1 /* CPP Library. (Directive handling.)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
4 Contributed by Per Bothner, 1994-95.
5 Based on CCCP program by Paul Rubin, June 1986
6 Adapted to ANSI C, Richard Stallman, Jan 1987
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 /* Chained list of answers to an assertion. */
36 /* Stack of conditionals currently in progress
37 (including both successful and failing conditionals). */
40 struct if_stack
*next
;
41 unsigned int line
; /* Line where condition started. */
42 const cpp_hashnode
*mi_cmacro
;/* macro name for #ifndef around entire file */
43 bool skip_elses
; /* Can future #else / #elif be skipped? */
44 bool was_skipping
; /* If were skipping on entry. */
45 int type
; /* Most recent conditional for diagnostics. */
48 /* Contains a registered pragma or pragma namespace. */
49 typedef void (*pragma_cb
) (cpp_reader
*);
52 struct pragma_entry
*next
;
53 const cpp_hashnode
*pragma
; /* Name and length. */
57 struct pragma_entry
*space
;
61 /* Values for the origin field of struct directive. KANDR directives
62 come from traditional (K&R) C. STDC89 directives come from the
63 1989 C standard. EXTENSION directives are extensions. */
68 /* Values for the flags field of struct directive. COND indicates a
69 conditional; IF_COND an opening conditional. INCL means to treat
70 "..." and <...> as q-char and h-char sequences respectively. IN_I
71 means this directive should be handled even if -fpreprocessed is in
72 effect (these are the directives with callback hooks).
74 EXPAND is set on directives that are always macro-expanded. */
76 #define IF_COND (1 << 1)
79 #define EXPAND (1 << 4)
81 /* Defines one #-directive, including how to handle it. */
82 typedef void (*directive_handler
) (cpp_reader
*);
83 typedef struct directive directive
;
86 directive_handler handler
; /* Function to handle directive. */
87 const uchar
*name
; /* Name of directive. */
88 unsigned short length
; /* Length of name. */
89 unsigned char origin
; /* Origin of directive. */
90 unsigned char flags
; /* Flags describing this directive. */
93 /* Forward declarations. */
95 static void skip_rest_of_line (cpp_reader
*);
96 static void check_eol (cpp_reader
*);
97 static void start_directive (cpp_reader
*);
98 static void prepare_directive_trad (cpp_reader
*);
99 static void end_directive (cpp_reader
*, int);
100 static void directive_diagnostics (cpp_reader
*, const directive
*, int);
101 static void run_directive (cpp_reader
*, int, const char *, size_t);
102 static char *glue_header_name (cpp_reader
*);
103 static const char *parse_include (cpp_reader
*, int *);
104 static void push_conditional (cpp_reader
*, int, int, const cpp_hashnode
*);
105 static unsigned int read_flag (cpp_reader
*, unsigned int);
106 static int strtoul_for_line (const uchar
*, unsigned int, unsigned long *);
107 static void do_diagnostic (cpp_reader
*, int, int);
108 static cpp_hashnode
*lex_macro_node (cpp_reader
*);
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 struct pragma_entry
*insert_pragma_entry (cpp_reader
*,
114 struct pragma_entry
**,
115 const cpp_hashnode
*,
117 static int count_registered_pragmas (struct pragma_entry
*);
118 static char ** save_registered_pragmas (struct pragma_entry
*, char **);
119 static char ** restore_registered_pragmas (cpp_reader
*, struct pragma_entry
*,
121 static void do_pragma_once (cpp_reader
*);
122 static void do_pragma_poison (cpp_reader
*);
123 static void do_pragma_system_header (cpp_reader
*);
124 static void do_pragma_dependency (cpp_reader
*);
125 static void do_linemarker (cpp_reader
*);
126 static const cpp_token
*get_token_no_padding (cpp_reader
*);
127 static const cpp_token
*get__Pragma_string (cpp_reader
*);
128 static void destringize_and_run (cpp_reader
*, const cpp_string
*);
129 static int parse_answer (cpp_reader
*, struct answer
**, int);
130 static cpp_hashnode
*parse_assertion (cpp_reader
*, struct answer
**, int);
131 static struct answer
** find_answer (cpp_hashnode
*, const struct answer
*);
132 static void handle_assertion (cpp_reader
*, const char *, int);
134 /* This is the table of directive handlers. It is ordered by
135 frequency of occurrence; the numbers at the end are directive
136 counts from all the source code I have lying around (egcs and libc
137 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
138 pcmcia-cs-3.0.9). This is no longer important as directive lookup
139 is now O(1). All extensions other than #warning and #include_next
140 are deprecated. The name is where the extension appears to have
143 #define DIRECTIVE_TABLE \
144 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
145 D(include, T_INCLUDE, KANDR, INCL | EXPAND) /* 52262 */ \
146 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
147 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
148 D(if, T_IF, KANDR, COND | IF_COND | EXPAND) /* 18162 */ \
149 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
150 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
151 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
152 D(line, T_LINE, KANDR, EXPAND) /* 2465 */ \
153 D(elif, T_ELIF, STDC89, COND | EXPAND) /* 610 */ \
154 D(error, T_ERROR, STDC89, 0) /* 475 */ \
155 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
156 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
157 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL | EXPAND) /* 19 */ \
158 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
159 D(import, T_IMPORT, EXTENSION, INCL | EXPAND) /* 0 ObjC */ \
160 D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
161 D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
162 D(sccs, T_SCCS, EXTENSION, 0) /* 0 SVR4? */
164 /* Use the table to generate a series of prototypes, an enum for the
165 directive names, and an array of directive handlers. */
167 #define D(name, t, o, f) static void do_##name (cpp_reader *);
171 #define D(n, tag, o, f) tag,
179 #define D(name, t, origin, flags) \
180 { do_##name, (const uchar *) #name, \
181 sizeof #name - 1, origin, flags },
182 static const directive dtable
[] =
187 #undef DIRECTIVE_TABLE
189 /* Wrapper struct directive for linemarkers.
190 The origin is more or less true - the original K+R cpp
191 did use this notation in its preprocessed output. */
192 static const directive linemarker_dir
=
194 do_linemarker
, U
"#", 1, KANDR
, IN_I
197 #define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
199 /* Skip any remaining tokens in a directive. */
201 skip_rest_of_line (cpp_reader
*pfile
)
203 /* Discard all stacked contexts. */
204 while (pfile
->context
->prev
)
205 _cpp_pop_context (pfile
);
207 /* Sweep up all tokens remaining on the line. */
209 while (_cpp_lex_token (pfile
)->type
!= CPP_EOF
)
213 /* Ensure there are no stray tokens at the end of a directive. */
215 check_eol (cpp_reader
*pfile
)
217 if (! SEEN_EOL () && _cpp_lex_token (pfile
)->type
!= CPP_EOF
)
218 cpp_error (pfile
, CPP_DL_PEDWARN
, "extra tokens at end of #%s directive",
219 pfile
->directive
->name
);
222 /* Called when entering a directive, _Pragma or command-line directive. */
224 start_directive (cpp_reader
*pfile
)
226 /* Setup in-directive state. */
227 pfile
->state
.in_directive
= 1;
228 pfile
->state
.save_comments
= 0;
230 /* Some handlers need the position of the # for diagnostics. */
231 pfile
->directive_line
= pfile
->line
;
234 /* Called when leaving a directive, _Pragma or command-line directive. */
236 end_directive (cpp_reader
*pfile
, int skip_line
)
238 if (CPP_OPTION (pfile
, traditional
))
240 /* Revert change of prepare_directive_trad. */
241 pfile
->state
.prevent_expansion
--;
243 if (pfile
->directive
!= &dtable
[T_DEFINE
])
244 _cpp_remove_overlay (pfile
);
246 /* We don't skip for an assembler #. */
249 skip_rest_of_line (pfile
);
250 if (!pfile
->keep_tokens
)
252 pfile
->cur_run
= &pfile
->base_run
;
253 pfile
->cur_token
= pfile
->base_run
.base
;
258 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
259 pfile
->state
.in_directive
= 0;
260 pfile
->state
.in_expression
= 0;
261 pfile
->state
.angled_headers
= 0;
262 pfile
->directive
= 0;
265 /* Prepare to handle the directive in pfile->directive. */
267 prepare_directive_trad (cpp_reader
*pfile
)
269 if (pfile
->directive
!= &dtable
[T_DEFINE
])
271 bool no_expand
= (pfile
->directive
272 && ! (pfile
->directive
->flags
& EXPAND
));
273 bool was_skipping
= pfile
->state
.skipping
;
275 pfile
->state
.skipping
= false;
276 pfile
->state
.in_expression
= (pfile
->directive
== &dtable
[T_IF
]
277 || pfile
->directive
== &dtable
[T_ELIF
]);
279 pfile
->state
.prevent_expansion
++;
280 _cpp_scan_out_logical_line (pfile
, NULL
);
282 pfile
->state
.prevent_expansion
--;
283 pfile
->state
.skipping
= was_skipping
;
284 _cpp_overlay_buffer (pfile
, pfile
->out
.base
,
285 pfile
->out
.cur
- pfile
->out
.base
);
288 /* Stop ISO C from expanding anything. */
289 pfile
->state
.prevent_expansion
++;
292 /* Output diagnostics for a directive DIR. INDENTED is nonzero if
293 the '#' was indented. */
295 directive_diagnostics (cpp_reader
*pfile
, const directive
*dir
, int indented
)
297 /* Issue -pedantic warnings for extensions. */
298 if (CPP_PEDANTIC (pfile
)
299 && ! pfile
->state
.skipping
300 && dir
->origin
== EXTENSION
)
301 cpp_error (pfile
, CPP_DL_PEDWARN
, "#%s is a GCC extension", dir
->name
);
303 /* Traditionally, a directive is ignored unless its # is in
304 column 1. Therefore in code intended to work with K+R
305 compilers, directives added by C89 must have their #
306 indented, and directives present in traditional C must not.
307 This is true even of directives in skipped conditional
308 blocks. #elif cannot be used at all. */
309 if (CPP_WTRADITIONAL (pfile
))
311 if (dir
== &dtable
[T_ELIF
])
312 cpp_error (pfile
, CPP_DL_WARNING
,
313 "suggest not using #elif in traditional C");
314 else if (indented
&& dir
->origin
== KANDR
)
315 cpp_error (pfile
, CPP_DL_WARNING
,
316 "traditional C ignores #%s with the # indented",
318 else if (!indented
&& dir
->origin
!= KANDR
)
319 cpp_error (pfile
, CPP_DL_WARNING
,
320 "suggest hiding #%s from traditional C with an indented #",
325 /* Check if we have a known directive. INDENTED is nonzero if the
326 '#' of the directive was indented. This function is in this file
327 to save unnecessarily exporting dtable etc. to cpplex.c. Returns
328 nonzero if the line of tokens has been handled, zero if we should
329 continue processing the line. */
331 _cpp_handle_directive (cpp_reader
*pfile
, int indented
)
333 const directive
*dir
= 0;
334 const cpp_token
*dname
;
335 bool was_parsing_args
= pfile
->state
.parsing_args
;
338 if (was_parsing_args
)
340 if (CPP_OPTION (pfile
, pedantic
))
341 cpp_error (pfile
, CPP_DL_PEDWARN
,
342 "embedding a directive within macro arguments is not portable");
343 pfile
->state
.parsing_args
= 0;
344 pfile
->state
.prevent_expansion
= 0;
346 start_directive (pfile
);
347 dname
= _cpp_lex_token (pfile
);
349 if (dname
->type
== CPP_NAME
)
351 if (dname
->val
.node
->is_directive
)
352 dir
= &dtable
[dname
->val
.node
->directive_index
];
354 /* We do not recognize the # followed by a number extension in
356 else if (dname
->type
== CPP_NUMBER
&& CPP_OPTION (pfile
, lang
) != CLK_ASM
)
358 dir
= &linemarker_dir
;
359 if (CPP_PEDANTIC (pfile
) && ! CPP_OPTION (pfile
, preprocessed
)
360 && ! pfile
->state
.skipping
)
361 cpp_error (pfile
, CPP_DL_PEDWARN
,
362 "style of line directive is a GCC extension");
367 /* If we have a directive that is not an opening conditional,
368 invalidate any control macro. */
369 if (! (dir
->flags
& IF_COND
))
370 pfile
->mi_valid
= false;
372 /* Kluge alert. In order to be sure that code like this
377 does not cause '#define foo bar' to get executed when
378 compiled with -save-temps, we recognize directives in
379 -fpreprocessed mode only if the # is in column 1. cppmacro.c
380 puts a space in front of any '#' at the start of a macro. */
381 if (CPP_OPTION (pfile
, preprocessed
)
382 && (indented
|| !(dir
->flags
& IN_I
)))
389 /* In failed conditional groups, all non-conditional
390 directives are ignored. Before doing that, whether
391 skipping or not, we should lex angle-bracketed headers
392 correctly, and maybe output some diagnostics. */
393 pfile
->state
.angled_headers
= dir
->flags
& INCL
;
394 pfile
->state
.directive_wants_padding
= dir
->flags
& INCL
;
395 if (! CPP_OPTION (pfile
, preprocessed
))
396 directive_diagnostics (pfile
, dir
, indented
);
397 if (pfile
->state
.skipping
&& !(dir
->flags
& COND
))
401 else if (dname
->type
== CPP_EOF
)
402 ; /* CPP_EOF is the "null directive". */
405 /* An unknown directive. Don't complain about it in assembly
406 source: we don't know where the comments are, and # may
407 introduce assembler pseudo-ops. Don't complain about invalid
408 directives in skipped conditional groups (6.10 p4). */
409 if (CPP_OPTION (pfile
, lang
) == CLK_ASM
)
411 else if (!pfile
->state
.skipping
)
412 cpp_error (pfile
, CPP_DL_ERROR
, "invalid preprocessing directive #%s",
413 cpp_token_as_text (pfile
, dname
));
416 pfile
->directive
= dir
;
417 if (CPP_OPTION (pfile
, traditional
))
418 prepare_directive_trad (pfile
);
421 pfile
->directive
->handler (pfile
);
423 _cpp_backup_tokens (pfile
, 1);
425 end_directive (pfile
, skip
);
426 if (was_parsing_args
)
428 /* Restore state when within macro args. */
429 pfile
->state
.parsing_args
= 2;
430 pfile
->state
.prevent_expansion
= 1;
435 /* Directive handler wrapper used by the command line option
436 processor. BUF is \n terminated. */
438 run_directive (cpp_reader
*pfile
, int dir_no
, const char *buf
, size_t count
)
440 cpp_push_buffer (pfile
, (const uchar
*) buf
, count
,
441 /* from_stage3 */ true);
442 /* Disgusting hack. */
443 if (dir_no
== T_PRAGMA
)
444 pfile
->buffer
->file
= pfile
->buffer
->prev
->file
;
445 start_directive (pfile
);
447 /* This is a short-term fix to prevent a leading '#' being
448 interpreted as a directive. */
449 _cpp_clean_line (pfile
);
451 pfile
->directive
= &dtable
[dir_no
];
452 if (CPP_OPTION (pfile
, traditional
))
453 prepare_directive_trad (pfile
);
454 pfile
->directive
->handler (pfile
);
455 end_directive (pfile
, 1);
456 if (dir_no
== T_PRAGMA
)
457 pfile
->buffer
->file
= NULL
;
458 _cpp_pop_buffer (pfile
);
461 /* Checks for validity the macro name in #define, #undef, #ifdef and
462 #ifndef directives. */
463 static cpp_hashnode
*
464 lex_macro_node (cpp_reader
*pfile
)
466 const cpp_token
*token
= _cpp_lex_token (pfile
);
468 /* The token immediately after #define must be an identifier. That
469 identifier may not be "defined", per C99 6.10.8p4.
470 In C++, it may not be any of the "named operators" either,
471 per C++98 [lex.digraph], [lex.key].
472 Finally, the identifier may not have been poisoned. (In that case
473 the lexer has issued the error message for us.) */
475 if (token
->type
== CPP_NAME
)
477 cpp_hashnode
*node
= token
->val
.node
;
479 if (node
== pfile
->spec_nodes
.n_defined
)
480 cpp_error (pfile
, CPP_DL_ERROR
,
481 "\"defined\" cannot be used as a macro name");
482 else if (! (node
->flags
& NODE_POISONED
))
485 else if (token
->flags
& NAMED_OP
)
486 cpp_error (pfile
, CPP_DL_ERROR
,
487 "\"%s\" cannot be used as a macro name as it is an operator in C++",
488 NODE_NAME (token
->val
.node
));
489 else if (token
->type
== CPP_EOF
)
490 cpp_error (pfile
, CPP_DL_ERROR
, "no macro name given in #%s directive",
491 pfile
->directive
->name
);
493 cpp_error (pfile
, CPP_DL_ERROR
, "macro names must be identifiers");
498 /* Process a #define directive. Most work is done in cppmacro.c. */
500 do_define (cpp_reader
*pfile
)
502 cpp_hashnode
*node
= lex_macro_node (pfile
);
506 /* If we have been requested to expand comments into macros,
507 then re-enable saving of comments. */
508 pfile
->state
.save_comments
=
509 ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
);
511 if (_cpp_create_definition (pfile
, node
))
512 if (pfile
->cb
.define
)
513 pfile
->cb
.define (pfile
, pfile
->directive_line
, node
);
517 /* Handle #undef. Mark the identifier NT_VOID in the hash table. */
519 do_undef (cpp_reader
*pfile
)
521 cpp_hashnode
*node
= lex_macro_node (pfile
);
523 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
524 is not currently defined as a macro name. */
525 if (node
&& node
->type
== NT_MACRO
)
528 pfile
->cb
.undef (pfile
, pfile
->directive_line
, node
);
530 if (node
->flags
& NODE_WARN
)
531 cpp_error (pfile
, CPP_DL_WARNING
,
532 "undefining \"%s\"", NODE_NAME (node
));
534 if (CPP_OPTION (pfile
, warn_unused_macros
))
535 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
537 _cpp_free_definition (node
);
542 /* Undefine a single macro/assertion/whatever. */
545 undefine_macros (cpp_reader
*pfile
, cpp_hashnode
*h
,
546 void *data_p ATTRIBUTE_UNUSED
)
555 (*pfile
->cb
.undef
) (pfile
, pfile
->directive_line
, h
);
557 if (CPP_OPTION (pfile
, warn_unused_macros
))
558 _cpp_warn_if_unused_macro (pfile
, h
, NULL
);
560 /* And fall through.... */
562 _cpp_free_definition (h
);
568 h
->flags
&= ~NODE_POISONED
;
572 /* Undefine all macros and assertions. */
575 cpp_undef_all (cpp_reader
*pfile
)
577 cpp_forall_identifiers (pfile
, undefine_macros
, NULL
);
581 /* Helper routine used by parse_include. Reinterpret the current line
582 as an h-char-sequence (< ... >); we are looking at the first token
583 after the <. Returns a malloced filename. */
585 glue_header_name (cpp_reader
*pfile
)
587 const cpp_token
*token
;
589 size_t len
, total_len
= 0, capacity
= 1024;
591 /* To avoid lexed tokens overwriting our glued name, we can only
592 allocate from the string pool once we've lexed everything. */
593 buffer
= xmalloc (capacity
);
596 token
= get_token_no_padding (pfile
);
598 if (token
->type
== CPP_GREATER
)
600 if (token
->type
== CPP_EOF
)
602 cpp_error (pfile
, CPP_DL_ERROR
, "missing terminating > character");
606 len
= cpp_token_len (token
) + 2; /* Leading space, terminating \0. */
607 if (total_len
+ len
> capacity
)
609 capacity
= (capacity
+ len
) * 2;
610 buffer
= xrealloc (buffer
, capacity
);
613 if (token
->flags
& PREV_WHITE
)
614 buffer
[total_len
++] = ' ';
616 total_len
= (cpp_spell_token (pfile
, token
, (uchar
*) &buffer
[total_len
])
620 buffer
[total_len
] = '\0';
624 /* Returns the file name of #include, #include_next, #import and
625 #pragma dependency. The string is malloced and the caller should
626 free it. Returns NULL on error. */
628 parse_include (cpp_reader
*pfile
, int *pangle_brackets
)
631 const cpp_token
*header
;
633 /* Allow macro expansion. */
634 header
= get_token_no_padding (pfile
);
635 if (header
->type
== CPP_STRING
|| header
->type
== CPP_HEADER_NAME
)
637 fname
= xmalloc (header
->val
.str
.len
- 1);
638 memcpy (fname
, header
->val
.str
.text
+ 1, header
->val
.str
.len
- 2);
639 fname
[header
->val
.str
.len
- 2] = '\0';
640 *pangle_brackets
= header
->type
== CPP_HEADER_NAME
;
642 else if (header
->type
== CPP_LESS
)
644 fname
= glue_header_name (pfile
);
645 *pangle_brackets
= 1;
649 const unsigned char *dir
;
651 if (pfile
->directive
== &dtable
[T_PRAGMA
])
652 dir
= U
"pragma dependency";
654 dir
= pfile
->directive
->name
;
655 cpp_error (pfile
, CPP_DL_ERROR
, "#%s expects \"FILENAME\" or <FILENAME>",
665 /* Handle #include, #include_next and #import. */
667 do_include_common (cpp_reader
*pfile
, enum include_type type
)
672 fname
= parse_include (pfile
, &angle_brackets
);
676 /* Prevent #include recursion. */
677 if (pfile
->line_maps
.depth
>= CPP_STACK_MAX
)
678 cpp_error (pfile
, CPP_DL_ERROR
, "#include nested too deeply");
681 /* Get out of macro context, if we are. */
682 skip_rest_of_line (pfile
);
684 if (pfile
->cb
.include
)
685 pfile
->cb
.include (pfile
, pfile
->directive_line
,
686 pfile
->directive
->name
, fname
, angle_brackets
);
688 _cpp_stack_include (pfile
, fname
, angle_brackets
, type
);
691 free ((void *) fname
);
695 do_include (cpp_reader
*pfile
)
697 do_include_common (pfile
, IT_INCLUDE
);
701 do_import (cpp_reader
*pfile
)
703 do_include_common (pfile
, IT_IMPORT
);
707 do_include_next (cpp_reader
*pfile
)
709 enum include_type type
= IT_INCLUDE_NEXT
;
711 /* If this is the primary source file, warn and use the normal
713 if (! pfile
->buffer
->prev
)
715 cpp_error (pfile
, CPP_DL_WARNING
,
716 "#include_next in primary source file");
719 do_include_common (pfile
, type
);
722 /* Subroutine of do_linemarker. Read possible flags after file name.
723 LAST is the last flag seen; 0 if this is the first flag. Return the
724 flag if it is valid, 0 at the end of the directive. Otherwise
727 read_flag (cpp_reader
*pfile
, unsigned int last
)
729 const cpp_token
*token
= _cpp_lex_token (pfile
);
731 if (token
->type
== CPP_NUMBER
&& token
->val
.str
.len
== 1)
733 unsigned int flag
= token
->val
.str
.text
[0] - '0';
735 if (flag
> last
&& flag
<= 4
736 && (flag
!= 4 || last
== 3)
737 && (flag
!= 2 || last
== 0))
741 if (token
->type
!= CPP_EOF
)
742 cpp_error (pfile
, CPP_DL_ERROR
, "invalid flag \"%s\" in line directive",
743 cpp_token_as_text (pfile
, token
));
747 /* Subroutine of do_line and do_linemarker. Convert a number in STR,
748 of length LEN, to binary; store it in NUMP, and return 0 if the
749 number was well-formed, 1 if not. Temporary, hopefully. */
751 strtoul_for_line (const uchar
*str
, unsigned int len
, long unsigned int *nump
)
753 unsigned long reg
= 0;
767 /* Interpret #line command.
768 Note that the filename string (if any) is a true string constant
769 (escapes are interpreted), unlike in #line. */
771 do_line (cpp_reader
*pfile
)
773 const cpp_token
*token
;
774 const char *new_file
= pfile
->map
->to_file
;
775 unsigned long new_lineno
;
777 /* C99 raised the minimum limit on #line numbers. */
778 unsigned int cap
= CPP_OPTION (pfile
, c99
) ? 2147483647 : 32767;
780 /* #line commands expand macros. */
781 token
= cpp_get_token (pfile
);
782 if (token
->type
!= CPP_NUMBER
783 || strtoul_for_line (token
->val
.str
.text
, token
->val
.str
.len
,
786 cpp_error (pfile
, CPP_DL_ERROR
,
787 "\"%s\" after #line is not a positive integer",
788 cpp_token_as_text (pfile
, token
));
792 if (CPP_PEDANTIC (pfile
) && (new_lineno
== 0 || new_lineno
> cap
))
793 cpp_error (pfile
, CPP_DL_PEDWARN
, "line number out of range");
795 token
= cpp_get_token (pfile
);
796 if (token
->type
== CPP_STRING
)
798 cpp_string s
= { 0, 0 };
799 if (_cpp_interpret_string_notranslate (pfile
, &token
->val
.str
, &s
))
800 new_file
= (const char *)s
.text
;
803 else if (token
->type
!= CPP_EOF
)
805 cpp_error (pfile
, CPP_DL_ERROR
, "\"%s\" is not a valid filename",
806 cpp_token_as_text (pfile
, token
));
810 skip_rest_of_line (pfile
);
811 _cpp_do_file_change (pfile
, LC_RENAME
, new_file
, new_lineno
,
815 /* Interpret the # 44 "file" [flags] notation, which has slightly
816 different syntax and semantics from #line: Flags are allowed,
817 and we never complain about the line number being too big. */
819 do_linemarker (cpp_reader
*pfile
)
821 const cpp_token
*token
;
822 const char *new_file
= pfile
->map
->to_file
;
823 unsigned long new_lineno
;
824 unsigned int new_sysp
= pfile
->map
->sysp
;
825 enum lc_reason reason
= LC_RENAME
;
828 /* Back up so we can get the number again. Putting this in
829 _cpp_handle_directive risks two calls to _cpp_backup_tokens in
830 some circumstances, which can segfault. */
831 _cpp_backup_tokens (pfile
, 1);
833 /* #line commands expand macros. */
834 token
= cpp_get_token (pfile
);
835 if (token
->type
!= CPP_NUMBER
836 || strtoul_for_line (token
->val
.str
.text
, token
->val
.str
.len
,
839 cpp_error (pfile
, CPP_DL_ERROR
,
840 "\"%s\" after # is not a positive integer",
841 cpp_token_as_text (pfile
, token
));
845 token
= cpp_get_token (pfile
);
846 if (token
->type
== CPP_STRING
)
848 cpp_string s
= { 0, 0 };
849 if (_cpp_interpret_string_notranslate (pfile
, &token
->val
.str
, &s
))
850 new_file
= (const char *)s
.text
;
853 flag
= read_flag (pfile
, 0);
857 /* Fake an include for cpp_included (). */
858 _cpp_fake_include (pfile
, new_file
);
859 flag
= read_flag (pfile
, flag
);
864 flag
= read_flag (pfile
, flag
);
869 flag
= read_flag (pfile
, flag
);
876 else if (token
->type
!= CPP_EOF
)
878 cpp_error (pfile
, CPP_DL_ERROR
, "\"%s\" is not a valid filename",
879 cpp_token_as_text (pfile
, token
));
883 skip_rest_of_line (pfile
);
884 _cpp_do_file_change (pfile
, reason
, new_file
, new_lineno
, new_sysp
);
887 /* Arrange the file_change callback. pfile->line has changed to
888 FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system
889 header, 2 for a system header that needs to be extern "C" protected,
890 and zero otherwise. */
892 _cpp_do_file_change (cpp_reader
*pfile
, enum lc_reason reason
,
893 const char *to_file
, unsigned int file_line
,
896 pfile
->map
= linemap_add (&pfile
->line_maps
, reason
, sysp
,
897 pfile
->line
, to_file
, file_line
);
899 if (pfile
->cb
.file_change
)
900 pfile
->cb
.file_change (pfile
, pfile
->map
);
903 /* Report a warning or error detected by the program we are
904 processing. Use the directive's tokens in the error message. */
906 do_diagnostic (cpp_reader
*pfile
, int code
, int print_dir
)
908 if (_cpp_begin_message (pfile
, code
,
909 pfile
->cur_token
[-1].line
,
910 pfile
->cur_token
[-1].col
))
913 fprintf (stderr
, "#%s ", pfile
->directive
->name
);
914 pfile
->state
.prevent_expansion
++;
915 cpp_output_line (pfile
, stderr
);
916 pfile
->state
.prevent_expansion
--;
921 do_error (cpp_reader
*pfile
)
923 do_diagnostic (pfile
, CPP_DL_ERROR
, 1);
927 do_warning (cpp_reader
*pfile
)
929 /* We want #warning diagnostics to be emitted in system headers too. */
930 do_diagnostic (pfile
, CPP_DL_WARNING_SYSHDR
, 1);
933 /* Report program identification. */
935 do_ident (cpp_reader
*pfile
)
937 const cpp_token
*str
= cpp_get_token (pfile
);
939 if (str
->type
!= CPP_STRING
)
940 cpp_error (pfile
, CPP_DL_ERROR
, "invalid #ident directive");
941 else if (pfile
->cb
.ident
)
942 pfile
->cb
.ident (pfile
, pfile
->directive_line
, &str
->val
.str
);
947 /* Lookup a PRAGMA name in a singly-linked CHAIN. Returns the
948 matching entry, or NULL if none is found. The returned entry could
949 be the start of a namespace chain, or a pragma. */
950 static struct pragma_entry
*
951 lookup_pragma_entry (struct pragma_entry
*chain
, const cpp_hashnode
*pragma
)
953 while (chain
&& chain
->pragma
!= pragma
)
959 /* Create and insert a pragma entry for NAME at the beginning of a
960 singly-linked CHAIN. If handler is NULL, it is a namespace,
961 otherwise it is a pragma and its handler. */
962 static struct pragma_entry
*
963 insert_pragma_entry (cpp_reader
*pfile
, struct pragma_entry
**chain
,
964 const cpp_hashnode
*pragma
, pragma_cb handler
)
966 struct pragma_entry
*new;
968 new = (struct pragma_entry
*)
969 _cpp_aligned_alloc (pfile
, sizeof (struct pragma_entry
));
970 new->pragma
= pragma
;
974 new->u
.handler
= handler
;
987 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
988 goes in the global namespace. HANDLER is the handler it will call,
989 which must be non-NULL. */
991 cpp_register_pragma (cpp_reader
*pfile
, const char *space
, const char *name
,
994 struct pragma_entry
**chain
= &pfile
->pragmas
;
995 struct pragma_entry
*entry
;
996 const cpp_hashnode
*node
;
1003 node
= cpp_lookup (pfile
, U space
, strlen (space
));
1004 entry
= lookup_pragma_entry (*chain
, node
);
1006 entry
= insert_pragma_entry (pfile
, chain
, node
, NULL
);
1007 else if (!entry
->is_nspace
)
1009 chain
= &entry
->u
.space
;
1012 /* Check for duplicates. */
1013 node
= cpp_lookup (pfile
, U name
, strlen (name
));
1014 entry
= lookup_pragma_entry (*chain
, node
);
1017 if (entry
->is_nspace
)
1019 cpp_error (pfile
, CPP_DL_ICE
,
1020 "registering \"%s\" as both a pragma and a pragma namespace",
1023 cpp_error (pfile
, CPP_DL_ICE
, "#pragma %s %s is already registered",
1026 cpp_error (pfile
, CPP_DL_ICE
, "#pragma %s is already registered", name
);
1029 insert_pragma_entry (pfile
, chain
, node
, handler
);
1032 /* Register the pragmas the preprocessor itself handles. */
1034 _cpp_init_internal_pragmas (cpp_reader
*pfile
)
1036 /* Pragmas in the global namespace. */
1037 cpp_register_pragma (pfile
, 0, "once", do_pragma_once
);
1039 /* New GCC-specific pragmas should be put in the GCC namespace. */
1040 cpp_register_pragma (pfile
, "GCC", "poison", do_pragma_poison
);
1041 cpp_register_pragma (pfile
, "GCC", "system_header", do_pragma_system_header
);
1042 cpp_register_pragma (pfile
, "GCC", "dependency", do_pragma_dependency
);
1045 /* Return the number of registered pragmas in PE. */
1048 count_registered_pragmas (struct pragma_entry
*pe
)
1051 for (; pe
!= NULL
; pe
= pe
->next
)
1054 ct
+= count_registered_pragmas (pe
->u
.space
);
1060 /* Save into SD the names of the registered pragmas referenced by PE,
1061 and return a pointer to the next free space in SD. */
1064 save_registered_pragmas (struct pragma_entry
*pe
, char **sd
)
1066 for (; pe
!= NULL
; pe
= pe
->next
)
1069 sd
= save_registered_pragmas (pe
->u
.space
, sd
);
1070 *sd
++ = xmemdup (HT_STR (&pe
->pragma
->ident
),
1071 HT_LEN (&pe
->pragma
->ident
),
1072 HT_LEN (&pe
->pragma
->ident
) + 1);
1077 /* Return a newly-allocated array which saves the names of the
1078 registered pragmas. */
1081 _cpp_save_pragma_names (cpp_reader
*pfile
)
1083 int ct
= count_registered_pragmas (pfile
->pragmas
);
1084 char **result
= xnewvec (char *, ct
);
1085 (void) save_registered_pragmas (pfile
->pragmas
, result
);
1089 /* Restore from SD the names of the registered pragmas referenced by PE,
1090 and return a pointer to the next unused name in SD. */
1093 restore_registered_pragmas (cpp_reader
*pfile
, struct pragma_entry
*pe
,
1096 for (; pe
!= NULL
; pe
= pe
->next
)
1099 sd
= restore_registered_pragmas (pfile
, pe
->u
.space
, sd
);
1100 pe
->pragma
= cpp_lookup (pfile
, U
*sd
, strlen (*sd
));
1107 /* Restore the names of the registered pragmas from SAVED. */
1110 _cpp_restore_pragma_names (cpp_reader
*pfile
, char **saved
)
1112 (void) restore_registered_pragmas (pfile
, pfile
->pragmas
, saved
);
1116 /* Pragmata handling. We handle some, and pass the rest on to the
1117 front end. C99 defines three pragmas and says that no macro
1118 expansion is to be performed on them; whether or not macro
1119 expansion happens for other pragmas is implementation defined.
1120 This implementation never macro-expands the text after #pragma. */
1122 do_pragma (cpp_reader
*pfile
)
1124 const struct pragma_entry
*p
= NULL
;
1125 const cpp_token
*token
, *pragma_token
= pfile
->cur_token
;
1126 unsigned int count
= 1;
1128 pfile
->state
.prevent_expansion
++;
1130 token
= cpp_get_token (pfile
);
1131 if (token
->type
== CPP_NAME
)
1133 p
= lookup_pragma_entry (pfile
->pragmas
, token
->val
.node
);
1134 if (p
&& p
->is_nspace
)
1137 token
= cpp_get_token (pfile
);
1138 if (token
->type
== CPP_NAME
)
1139 p
= lookup_pragma_entry (p
->u
.space
, token
->val
.node
);
1147 /* Since the handler below doesn't get the line number, that it
1148 might need for diagnostics, make sure it has the right
1149 numbers in place. */
1150 if (pfile
->cb
.line_change
)
1151 (*pfile
->cb
.line_change
) (pfile
, pragma_token
, false);
1152 (*p
->u
.handler
) (pfile
);
1153 if (pfile
->cb
.line_change
)
1154 (*pfile
->cb
.line_change
) (pfile
, pfile
->cur_token
, false);
1157 else if (pfile
->cb
.def_pragma
)
1159 _cpp_backup_tokens (pfile
, count
);
1160 pfile
->cb
.def_pragma (pfile
, pfile
->directive_line
);
1163 pfile
->state
.prevent_expansion
--;
1166 /* Handle #pragma once. */
1168 do_pragma_once (cpp_reader
*pfile
)
1170 if (pfile
->buffer
->prev
== NULL
)
1171 cpp_error (pfile
, CPP_DL_WARNING
, "#pragma once in main file");
1174 _cpp_mark_file_once_only (pfile
, pfile
->buffer
->file
);
1177 /* Handle #pragma GCC poison, to poison one or more identifiers so
1178 that the lexer produces a hard error for each subsequent usage. */
1180 do_pragma_poison (cpp_reader
*pfile
)
1182 const cpp_token
*tok
;
1185 pfile
->state
.poisoned_ok
= 1;
1188 tok
= _cpp_lex_token (pfile
);
1189 if (tok
->type
== CPP_EOF
)
1191 if (tok
->type
!= CPP_NAME
)
1193 cpp_error (pfile
, CPP_DL_ERROR
,
1194 "invalid #pragma GCC poison directive");
1199 if (hp
->flags
& NODE_POISONED
)
1202 if (hp
->type
== NT_MACRO
)
1203 cpp_error (pfile
, CPP_DL_WARNING
, "poisoning existing macro \"%s\"",
1205 _cpp_free_definition (hp
);
1206 hp
->flags
|= NODE_POISONED
| NODE_DIAGNOSTIC
;
1208 pfile
->state
.poisoned_ok
= 0;
1211 /* Mark the current header as a system header. This will suppress
1212 some categories of warnings (notably those from -pedantic). It is
1213 intended for use in system libraries that cannot be implemented in
1214 conforming C, but cannot be certain that their headers appear in a
1215 system include directory. To prevent abuse, it is rejected in the
1216 primary source file. */
1218 do_pragma_system_header (cpp_reader
*pfile
)
1220 cpp_buffer
*buffer
= pfile
->buffer
;
1222 if (buffer
->prev
== 0)
1223 cpp_error (pfile
, CPP_DL_WARNING
,
1224 "#pragma system_header ignored outside include file");
1228 skip_rest_of_line (pfile
);
1229 cpp_make_system_header (pfile
, 1, 0);
1233 /* Check the modified date of the current include file against a specified
1234 file. Issue a diagnostic, if the specified file is newer. We use this to
1235 determine if a fixed header should be refixed. */
1237 do_pragma_dependency (cpp_reader
*pfile
)
1240 int angle_brackets
, ordering
;
1242 fname
= parse_include (pfile
, &angle_brackets
);
1246 ordering
= _cpp_compare_file_date (pfile
, fname
, angle_brackets
);
1248 cpp_error (pfile
, CPP_DL_WARNING
, "cannot find source file %s", fname
);
1249 else if (ordering
> 0)
1251 cpp_error (pfile
, CPP_DL_WARNING
,
1252 "current file is older than %s", fname
);
1253 if (cpp_get_token (pfile
)->type
!= CPP_EOF
)
1255 _cpp_backup_tokens (pfile
, 1);
1256 do_diagnostic (pfile
, CPP_DL_WARNING
, 0);
1260 free ((void *) fname
);
1263 /* Get a token but skip padding. */
1264 static const cpp_token
*
1265 get_token_no_padding (cpp_reader
*pfile
)
1269 const cpp_token
*result
= cpp_get_token (pfile
);
1270 if (result
->type
!= CPP_PADDING
)
1275 /* Check syntax is "(string-literal)". Returns the string on success,
1276 or NULL on failure. */
1277 static const cpp_token
*
1278 get__Pragma_string (cpp_reader
*pfile
)
1280 const cpp_token
*string
;
1282 if (get_token_no_padding (pfile
)->type
!= CPP_OPEN_PAREN
)
1285 string
= get_token_no_padding (pfile
);
1286 if (string
->type
!= CPP_STRING
&& string
->type
!= CPP_WSTRING
)
1289 if (get_token_no_padding (pfile
)->type
!= CPP_CLOSE_PAREN
)
1295 /* Destringize IN into a temporary buffer, by removing the first \ of
1296 \" and \\ sequences, and process the result as a #pragma directive. */
1298 destringize_and_run (cpp_reader
*pfile
, const cpp_string
*in
)
1300 const unsigned char *src
, *limit
;
1301 char *dest
, *result
;
1303 dest
= result
= alloca (in
->len
- 1);
1304 src
= in
->text
+ 1 + (in
->text
[0] == 'L');
1305 limit
= in
->text
+ in
->len
- 1;
1308 /* We know there is a character following the backslash. */
1309 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1315 /* Ugh; an awful kludge. We are really not set up to be lexing
1316 tokens when in the middle of a macro expansion. Use a new
1317 context to force cpp_get_token to lex, and so skip_rest_of_line
1318 doesn't go beyond the end of the text. Also, remember the
1319 current lexing position so we can return to it later.
1321 Something like line-at-a-time lexing should remove the need for
1324 cpp_context
*saved_context
= pfile
->context
;
1325 cpp_token
*saved_cur_token
= pfile
->cur_token
;
1326 tokenrun
*saved_cur_run
= pfile
->cur_run
;
1328 pfile
->context
= xnew (cpp_context
);
1329 pfile
->context
->macro
= 0;
1330 pfile
->context
->prev
= 0;
1331 run_directive (pfile
, T_PRAGMA
, result
, dest
- result
);
1332 free (pfile
->context
);
1333 pfile
->context
= saved_context
;
1334 pfile
->cur_token
= saved_cur_token
;
1335 pfile
->cur_run
= saved_cur_run
;
1339 /* See above comment. For the moment, we'd like
1341 token1 _Pragma ("foo") token2
1351 Getting the line markers is a little tricky. */
1352 if (pfile
->cb
.line_change
)
1353 pfile
->cb
.line_change (pfile
, pfile
->cur_token
, false);
1356 /* Handle the _Pragma operator. */
1358 _cpp_do__Pragma (cpp_reader
*pfile
)
1360 const cpp_token
*string
= get__Pragma_string (pfile
);
1363 destringize_and_run (pfile
, &string
->val
.str
);
1365 cpp_error (pfile
, CPP_DL_ERROR
,
1366 "_Pragma takes a parenthesized string literal");
1369 /* Ignore #sccs on all systems. */
1371 do_sccs (cpp_reader
*pfile ATTRIBUTE_UNUSED
)
1375 /* Handle #ifdef. */
1377 do_ifdef (cpp_reader
*pfile
)
1381 if (! pfile
->state
.skipping
)
1383 const cpp_hashnode
*node
= lex_macro_node (pfile
);
1387 skip
= node
->type
!= NT_MACRO
;
1388 _cpp_mark_macro_used (node
);
1393 push_conditional (pfile
, skip
, T_IFDEF
, 0);
1396 /* Handle #ifndef. */
1398 do_ifndef (cpp_reader
*pfile
)
1401 const cpp_hashnode
*node
= 0;
1403 if (! pfile
->state
.skipping
)
1405 node
= lex_macro_node (pfile
);
1409 skip
= node
->type
== NT_MACRO
;
1410 _cpp_mark_macro_used (node
);
1415 push_conditional (pfile
, skip
, T_IFNDEF
, node
);
1418 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1419 pfile->mi_ind_cmacro so we can handle multiple-include
1420 optimizations. If macro expansion occurs in the expression, we
1421 cannot treat it as a controlling conditional, since the expansion
1422 could change in the future. That is handled by cpp_get_token. */
1424 do_if (cpp_reader
*pfile
)
1428 if (! pfile
->state
.skipping
)
1429 skip
= _cpp_parse_expr (pfile
) == false;
1431 push_conditional (pfile
, skip
, T_IF
, pfile
->mi_ind_cmacro
);
1434 /* Flip skipping state if appropriate and continue without changing
1435 if_stack; this is so that the error message for missing #endif's
1436 etc. will point to the original #if. */
1438 do_else (cpp_reader
*pfile
)
1440 cpp_buffer
*buffer
= pfile
->buffer
;
1441 struct if_stack
*ifs
= buffer
->if_stack
;
1444 cpp_error (pfile
, CPP_DL_ERROR
, "#else without #if");
1447 if (ifs
->type
== T_ELSE
)
1449 cpp_error (pfile
, CPP_DL_ERROR
, "#else after #else");
1450 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
1451 "the conditional began here");
1455 /* Skip any future (erroneous) #elses or #elifs. */
1456 pfile
->state
.skipping
= ifs
->skip_elses
;
1457 ifs
->skip_elses
= true;
1459 /* Invalidate any controlling macro. */
1462 /* Only check EOL if was not originally skipping. */
1463 if (!ifs
->was_skipping
&& CPP_OPTION (pfile
, warn_endif_labels
))
1468 /* Handle a #elif directive by not changing if_stack either. See the
1469 comment above do_else. */
1471 do_elif (cpp_reader
*pfile
)
1473 cpp_buffer
*buffer
= pfile
->buffer
;
1474 struct if_stack
*ifs
= buffer
->if_stack
;
1477 cpp_error (pfile
, CPP_DL_ERROR
, "#elif without #if");
1480 if (ifs
->type
== T_ELSE
)
1482 cpp_error (pfile
, CPP_DL_ERROR
, "#elif after #else");
1483 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
1484 "the conditional began here");
1488 /* Only evaluate this if we aren't skipping elses. During
1489 evaluation, set skipping to false to get lexer warnings. */
1490 if (ifs
->skip_elses
)
1491 pfile
->state
.skipping
= 1;
1494 pfile
->state
.skipping
= 0;
1495 pfile
->state
.skipping
= ! _cpp_parse_expr (pfile
);
1496 ifs
->skip_elses
= ! pfile
->state
.skipping
;
1499 /* Invalidate any controlling macro. */
1504 /* #endif pops the if stack and resets pfile->state.skipping. */
1506 do_endif (cpp_reader
*pfile
)
1508 cpp_buffer
*buffer
= pfile
->buffer
;
1509 struct if_stack
*ifs
= buffer
->if_stack
;
1512 cpp_error (pfile
, CPP_DL_ERROR
, "#endif without #if");
1515 /* Only check EOL if was not originally skipping. */
1516 if (!ifs
->was_skipping
&& CPP_OPTION (pfile
, warn_endif_labels
))
1519 /* If potential control macro, we go back outside again. */
1520 if (ifs
->next
== 0 && ifs
->mi_cmacro
)
1522 pfile
->mi_valid
= true;
1523 pfile
->mi_cmacro
= ifs
->mi_cmacro
;
1526 buffer
->if_stack
= ifs
->next
;
1527 pfile
->state
.skipping
= ifs
->was_skipping
;
1528 obstack_free (&pfile
->buffer_ob
, ifs
);
1532 /* Push an if_stack entry for a preprocessor conditional, and set
1533 pfile->state.skipping to SKIP. If TYPE indicates the conditional
1534 is #if or #ifndef, CMACRO is a potentially controlling macro, and
1535 we need to check here that we are at the top of the file. */
1537 push_conditional (cpp_reader
*pfile
, int skip
, int type
,
1538 const cpp_hashnode
*cmacro
)
1540 struct if_stack
*ifs
;
1541 cpp_buffer
*buffer
= pfile
->buffer
;
1543 ifs
= xobnew (&pfile
->buffer_ob
, struct if_stack
);
1544 ifs
->line
= pfile
->directive_line
;
1545 ifs
->next
= buffer
->if_stack
;
1546 ifs
->skip_elses
= pfile
->state
.skipping
|| !skip
;
1547 ifs
->was_skipping
= pfile
->state
.skipping
;
1549 /* This condition is effectively a test for top-of-file. */
1550 if (pfile
->mi_valid
&& pfile
->mi_cmacro
== 0)
1551 ifs
->mi_cmacro
= cmacro
;
1555 pfile
->state
.skipping
= skip
;
1556 buffer
->if_stack
= ifs
;
1559 /* Read the tokens of the answer into the macro pool, in a directive
1560 of type TYPE. Only commit the memory if we intend it as permanent
1561 storage, i.e. the #assert case. Returns 0 on success, and sets
1562 ANSWERP to point to the answer. */
1564 parse_answer (cpp_reader
*pfile
, struct answer
**answerp
, int type
)
1566 const cpp_token
*paren
;
1567 struct answer
*answer
;
1568 unsigned int acount
;
1570 /* In a conditional, it is legal to not have an open paren. We
1571 should save the following token in this case. */
1572 paren
= cpp_get_token (pfile
);
1574 /* If not a paren, see if we're OK. */
1575 if (paren
->type
!= CPP_OPEN_PAREN
)
1577 /* In a conditional no answer is a test for any answer. It
1578 could be followed by any token. */
1581 _cpp_backup_tokens (pfile
, 1);
1585 /* #unassert with no answer is valid - it removes all answers. */
1586 if (type
== T_UNASSERT
&& paren
->type
== CPP_EOF
)
1589 cpp_error (pfile
, CPP_DL_ERROR
, "missing '(' after predicate");
1593 for (acount
= 0;; acount
++)
1596 const cpp_token
*token
= cpp_get_token (pfile
);
1599 if (token
->type
== CPP_CLOSE_PAREN
)
1602 if (token
->type
== CPP_EOF
)
1604 cpp_error (pfile
, CPP_DL_ERROR
, "missing ')' to complete answer");
1608 /* struct answer includes the space for one token. */
1609 room_needed
= (sizeof (struct answer
) + acount
* sizeof (cpp_token
));
1611 if (BUFF_ROOM (pfile
->a_buff
) < room_needed
)
1612 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (struct answer
));
1614 dest
= &((struct answer
*) BUFF_FRONT (pfile
->a_buff
))->first
[acount
];
1617 /* Drop whitespace at start, for answer equivalence purposes. */
1619 dest
->flags
&= ~PREV_WHITE
;
1624 cpp_error (pfile
, CPP_DL_ERROR
, "predicate's answer is empty");
1628 answer
= (struct answer
*) BUFF_FRONT (pfile
->a_buff
);
1629 answer
->count
= acount
;
1630 answer
->next
= NULL
;
1636 /* Parses an assertion directive of type TYPE, returning a pointer to
1637 the hash node of the predicate, or 0 on error. If an answer was
1638 supplied, it is placed in ANSWERP, otherwise it is set to 0. */
1639 static cpp_hashnode
*
1640 parse_assertion (cpp_reader
*pfile
, struct answer
**answerp
, int type
)
1642 cpp_hashnode
*result
= 0;
1643 const cpp_token
*predicate
;
1645 /* We don't expand predicates or answers. */
1646 pfile
->state
.prevent_expansion
++;
1649 predicate
= cpp_get_token (pfile
);
1650 if (predicate
->type
== CPP_EOF
)
1651 cpp_error (pfile
, CPP_DL_ERROR
, "assertion without predicate");
1652 else if (predicate
->type
!= CPP_NAME
)
1653 cpp_error (pfile
, CPP_DL_ERROR
, "predicate must be an identifier");
1654 else if (parse_answer (pfile
, answerp
, type
) == 0)
1656 unsigned int len
= NODE_LEN (predicate
->val
.node
);
1657 unsigned char *sym
= alloca (len
+ 1);
1659 /* Prefix '#' to get it out of macro namespace. */
1661 memcpy (sym
+ 1, NODE_NAME (predicate
->val
.node
), len
);
1662 result
= cpp_lookup (pfile
, sym
, len
+ 1);
1665 pfile
->state
.prevent_expansion
--;
1669 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
1670 or a pointer to NULL if the answer is not in the chain. */
1671 static struct answer
**
1672 find_answer (cpp_hashnode
*node
, const struct answer
*candidate
)
1675 struct answer
**result
;
1677 for (result
= &node
->value
.answers
; *result
; result
= &(*result
)->next
)
1679 struct answer
*answer
= *result
;
1681 if (answer
->count
== candidate
->count
)
1683 for (i
= 0; i
< answer
->count
; i
++)
1684 if (! _cpp_equiv_tokens (&answer
->first
[i
], &candidate
->first
[i
]))
1687 if (i
== answer
->count
)
1695 /* Test an assertion within a preprocessor conditional. Returns
1696 nonzero on failure, zero on success. On success, the result of
1697 the test is written into VALUE, otherwise the value 0. */
1699 _cpp_test_assertion (cpp_reader
*pfile
, unsigned int *value
)
1701 struct answer
*answer
;
1704 node
= parse_assertion (pfile
, &answer
, T_IF
);
1706 /* For recovery, an erroneous assertion expression is handled as a
1707 failing assertion. */
1711 *value
= (node
->type
== NT_ASSERTION
&&
1712 (answer
== 0 || *find_answer (node
, answer
) != 0));
1713 else if (pfile
->cur_token
[-1].type
== CPP_EOF
)
1714 _cpp_backup_tokens (pfile
, 1);
1716 /* We don't commit the memory for the answer - it's temporary only. */
1720 /* Handle #assert. */
1722 do_assert (cpp_reader
*pfile
)
1724 struct answer
*new_answer
;
1727 node
= parse_assertion (pfile
, &new_answer
, T_ASSERT
);
1730 /* Place the new answer in the answer list. First check there
1731 is not a duplicate. */
1732 new_answer
->next
= 0;
1733 if (node
->type
== NT_ASSERTION
)
1735 if (*find_answer (node
, new_answer
))
1737 cpp_error (pfile
, CPP_DL_WARNING
, "\"%s\" re-asserted",
1738 NODE_NAME (node
) + 1);
1741 new_answer
->next
= node
->value
.answers
;
1744 node
->type
= NT_ASSERTION
;
1745 node
->value
.answers
= new_answer
;
1746 BUFF_FRONT (pfile
->a_buff
) += (sizeof (struct answer
)
1747 + (new_answer
->count
- 1)
1748 * sizeof (cpp_token
));
1753 /* Handle #unassert. */
1755 do_unassert (cpp_reader
*pfile
)
1758 struct answer
*answer
;
1760 node
= parse_assertion (pfile
, &answer
, T_UNASSERT
);
1761 /* It isn't an error to #unassert something that isn't asserted. */
1762 if (node
&& node
->type
== NT_ASSERTION
)
1766 struct answer
**p
= find_answer (node
, answer
), *temp
;
1768 /* Remove the answer from the list. */
1773 /* Did we free the last answer? */
1774 if (node
->value
.answers
== 0)
1775 node
->type
= NT_VOID
;
1780 _cpp_free_definition (node
);
1783 /* We don't commit the memory for the answer - it's temporary only. */
1786 /* These are for -D, -U, -A. */
1788 /* Process the string STR as if it appeared as the body of a #define.
1789 If STR is just an identifier, define it with value 1.
1790 If STR has anything after the identifier, then it should
1791 be identifier=definition. */
1793 cpp_define (cpp_reader
*pfile
, const char *str
)
1798 /* Copy the entire option so we can modify it.
1799 Change the first "=" in the string to a space. If there is none,
1800 tack " 1" on the end. */
1802 count
= strlen (str
);
1803 buf
= alloca (count
+ 3);
1804 memcpy (buf
, str
, count
);
1806 p
= strchr (str
, '=');
1816 run_directive (pfile
, T_DEFINE
, buf
, count
);
1819 /* Slight variant of the above for use by initialize_builtins. */
1821 _cpp_define_builtin (cpp_reader
*pfile
, const char *str
)
1823 size_t len
= strlen (str
);
1824 char *buf
= alloca (len
+ 1);
1825 memcpy (buf
, str
, len
);
1827 run_directive (pfile
, T_DEFINE
, buf
, len
);
1830 /* Process MACRO as if it appeared as the body of an #undef. */
1832 cpp_undef (cpp_reader
*pfile
, const char *macro
)
1834 size_t len
= strlen (macro
);
1835 char *buf
= alloca (len
+ 1);
1836 memcpy (buf
, macro
, len
);
1838 run_directive (pfile
, T_UNDEF
, buf
, len
);
1841 /* Process the string STR as if it appeared as the body of a #assert. */
1843 cpp_assert (cpp_reader
*pfile
, const char *str
)
1845 handle_assertion (pfile
, str
, T_ASSERT
);
1848 /* Process STR as if it appeared as the body of an #unassert. */
1850 cpp_unassert (cpp_reader
*pfile
, const char *str
)
1852 handle_assertion (pfile
, str
, T_UNASSERT
);
1855 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1857 handle_assertion (cpp_reader
*pfile
, const char *str
, int type
)
1859 size_t count
= strlen (str
);
1860 const char *p
= strchr (str
, '=');
1862 /* Copy the entire option so we can modify it. Change the first
1863 "=" in the string to a '(', and tack a ')' on the end. */
1864 char *buf
= alloca (count
+ 2);
1866 memcpy (buf
, str
, count
);
1875 run_directive (pfile
, type
, str
, count
);
1878 /* The number of errors for a given reader. */
1880 cpp_errors (cpp_reader
*pfile
)
1882 return pfile
->errors
;
1885 /* The options structure. */
1887 cpp_get_options (cpp_reader
*pfile
)
1889 return &pfile
->opts
;
1892 /* The callbacks structure. */
1894 cpp_get_callbacks (cpp_reader
*pfile
)
1899 /* The line map set. */
1900 const struct line_maps
*
1901 cpp_get_line_maps (cpp_reader
*pfile
)
1903 return &pfile
->line_maps
;
1906 /* Copy the given callbacks structure to our own. */
1908 cpp_set_callbacks (cpp_reader
*pfile
, cpp_callbacks
*cb
)
1913 /* Push a new buffer on the buffer stack. Returns the new buffer; it
1914 doesn't fail. It does not generate a file change call back; that
1915 is the responsibility of the caller. */
1917 cpp_push_buffer (cpp_reader
*pfile
, const uchar
*buffer
, size_t len
,
1920 cpp_buffer
*new = xobnew (&pfile
->buffer_ob
, cpp_buffer
);
1922 /* Clears, amongst other things, if_stack and mi_cmacro. */
1923 memset (new, 0, sizeof (cpp_buffer
));
1925 new->next_line
= new->buf
= buffer
;
1926 new->rlimit
= buffer
+ len
;
1927 new->from_stage3
= from_stage3
;
1928 new->prev
= pfile
->buffer
;
1929 new->need_line
= true;
1931 pfile
->buffer
= new;
1935 /* Pops a single buffer, with a file change call-back if appropriate.
1936 Then pushes the next -include file, if any remain. */
1938 _cpp_pop_buffer (cpp_reader
*pfile
)
1940 cpp_buffer
*buffer
= pfile
->buffer
;
1941 struct _cpp_file
*inc
= buffer
->file
;
1942 struct if_stack
*ifs
;
1944 /* Walk back up the conditional stack till we reach its level at
1945 entry to this file, issuing error messages. */
1946 for (ifs
= buffer
->if_stack
; ifs
; ifs
= ifs
->next
)
1947 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
1948 "unterminated #%s", dtable
[ifs
->type
].name
);
1950 /* In case of a missing #endif. */
1951 pfile
->state
.skipping
= 0;
1953 /* _cpp_do_file_change expects pfile->buffer to be the new one. */
1954 pfile
->buffer
= buffer
->prev
;
1956 free (buffer
->notes
);
1958 /* Free the buffer object now; we may want to push a new buffer
1959 in _cpp_push_next_include_file. */
1960 obstack_free (&pfile
->buffer_ob
, buffer
);
1964 _cpp_pop_file_buffer (pfile
, inc
);
1966 _cpp_do_file_change (pfile
, LC_LEAVE
, 0, 0, 0);
1970 /* Enter all recognized directives in the hash table. */
1972 _cpp_init_directives (cpp_reader
*pfile
)
1977 for (i
= 0; i
< (unsigned int) N_DIRECTIVES
; i
++)
1979 node
= cpp_lookup (pfile
, dtable
[i
].name
, dtable
[i
].length
);
1980 node
->is_directive
= 1;
1981 node
->directive_index
= i
;