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 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
.in_expression
= (pfile
->directive
== &dtable
[T_IF
]
276 || pfile
->directive
== &dtable
[T_ELIF
]);
277 if (pfile
->state
.in_expression
)
278 pfile
->state
.skipping
= false;
281 pfile
->state
.prevent_expansion
++;
282 _cpp_scan_out_logical_line (pfile
, NULL
);
284 pfile
->state
.prevent_expansion
--;
286 pfile
->state
.skipping
= was_skipping
;
287 _cpp_overlay_buffer (pfile
, pfile
->out
.base
,
288 pfile
->out
.cur
- pfile
->out
.base
);
291 /* Stop ISO C from expanding anything. */
292 pfile
->state
.prevent_expansion
++;
295 /* Output diagnostics for a directive DIR. INDENTED is nonzero if
296 the '#' was indented. */
298 directive_diagnostics (cpp_reader
*pfile
, const directive
*dir
, int indented
)
300 /* Issue -pedantic warnings for extensions. */
301 if (CPP_PEDANTIC (pfile
)
302 && ! pfile
->state
.skipping
303 && dir
->origin
== EXTENSION
)
304 cpp_error (pfile
, CPP_DL_PEDWARN
, "#%s is a GCC extension", dir
->name
);
306 /* Traditionally, a directive is ignored unless its # is in
307 column 1. Therefore in code intended to work with K+R
308 compilers, directives added by C89 must have their #
309 indented, and directives present in traditional C must not.
310 This is true even of directives in skipped conditional
311 blocks. #elif cannot be used at all. */
312 if (CPP_WTRADITIONAL (pfile
))
314 if (dir
== &dtable
[T_ELIF
])
315 cpp_error (pfile
, CPP_DL_WARNING
,
316 "suggest not using #elif in traditional C");
317 else if (indented
&& dir
->origin
== KANDR
)
318 cpp_error (pfile
, CPP_DL_WARNING
,
319 "traditional C ignores #%s with the # indented",
321 else if (!indented
&& dir
->origin
!= KANDR
)
322 cpp_error (pfile
, CPP_DL_WARNING
,
323 "suggest hiding #%s from traditional C with an indented #",
328 /* Check if we have a known directive. INDENTED is nonzero if the
329 '#' of the directive was indented. This function is in this file
330 to save unnecessarily exporting dtable etc. to cpplex.c. Returns
331 nonzero if the line of tokens has been handled, zero if we should
332 continue processing the line. */
334 _cpp_handle_directive (cpp_reader
*pfile
, int indented
)
336 const directive
*dir
= 0;
337 const cpp_token
*dname
;
338 bool was_parsing_args
= pfile
->state
.parsing_args
;
341 if (was_parsing_args
)
343 if (CPP_OPTION (pfile
, pedantic
))
344 cpp_error (pfile
, CPP_DL_PEDWARN
,
345 "embedding a directive within macro arguments is not portable");
346 pfile
->state
.parsing_args
= 0;
347 pfile
->state
.prevent_expansion
= 0;
349 start_directive (pfile
);
350 dname
= _cpp_lex_token (pfile
);
352 if (dname
->type
== CPP_NAME
)
354 if (dname
->val
.node
->is_directive
)
355 dir
= &dtable
[dname
->val
.node
->directive_index
];
357 /* We do not recognize the # followed by a number extension in
359 else if (dname
->type
== CPP_NUMBER
&& CPP_OPTION (pfile
, lang
) != CLK_ASM
)
361 dir
= &linemarker_dir
;
362 if (CPP_PEDANTIC (pfile
) && ! CPP_OPTION (pfile
, preprocessed
)
363 && ! pfile
->state
.skipping
)
364 cpp_error (pfile
, CPP_DL_PEDWARN
,
365 "style of line directive is a GCC extension");
370 /* If we have a directive that is not an opening conditional,
371 invalidate any control macro. */
372 if (! (dir
->flags
& IF_COND
))
373 pfile
->mi_valid
= false;
375 /* Kluge alert. In order to be sure that code like this
380 does not cause '#define foo bar' to get executed when
381 compiled with -save-temps, we recognize directives in
382 -fpreprocessed mode only if the # is in column 1. cppmacro.c
383 puts a space in front of any '#' at the start of a macro. */
384 if (CPP_OPTION (pfile
, preprocessed
)
385 && (indented
|| !(dir
->flags
& IN_I
)))
392 /* In failed conditional groups, all non-conditional
393 directives are ignored. Before doing that, whether
394 skipping or not, we should lex angle-bracketed headers
395 correctly, and maybe output some diagnostics. */
396 pfile
->state
.angled_headers
= dir
->flags
& INCL
;
397 pfile
->state
.directive_wants_padding
= dir
->flags
& INCL
;
398 if (! CPP_OPTION (pfile
, preprocessed
))
399 directive_diagnostics (pfile
, dir
, indented
);
400 if (pfile
->state
.skipping
&& !(dir
->flags
& COND
))
404 else if (dname
->type
== CPP_EOF
)
405 ; /* CPP_EOF is the "null directive". */
408 /* An unknown directive. Don't complain about it in assembly
409 source: we don't know where the comments are, and # may
410 introduce assembler pseudo-ops. Don't complain about invalid
411 directives in skipped conditional groups (6.10 p4). */
412 if (CPP_OPTION (pfile
, lang
) == CLK_ASM
)
414 else if (!pfile
->state
.skipping
)
415 cpp_error (pfile
, CPP_DL_ERROR
, "invalid preprocessing directive #%s",
416 cpp_token_as_text (pfile
, dname
));
419 pfile
->directive
= dir
;
420 if (CPP_OPTION (pfile
, traditional
))
421 prepare_directive_trad (pfile
);
424 pfile
->directive
->handler (pfile
);
426 _cpp_backup_tokens (pfile
, 1);
428 end_directive (pfile
, skip
);
429 if (was_parsing_args
)
431 /* Restore state when within macro args. */
432 pfile
->state
.parsing_args
= 2;
433 pfile
->state
.prevent_expansion
= 1;
438 /* Directive handler wrapper used by the command line option
439 processor. BUF is \n terminated. */
441 run_directive (cpp_reader
*pfile
, int dir_no
, const char *buf
, size_t count
)
443 cpp_push_buffer (pfile
, (const uchar
*) buf
, count
,
444 /* from_stage3 */ true);
445 /* Disgusting hack. */
446 if (dir_no
== T_PRAGMA
)
447 pfile
->buffer
->file
= pfile
->buffer
->prev
->file
;
448 start_directive (pfile
);
450 /* This is a short-term fix to prevent a leading '#' being
451 interpreted as a directive. */
452 _cpp_clean_line (pfile
);
454 pfile
->directive
= &dtable
[dir_no
];
455 if (CPP_OPTION (pfile
, traditional
))
456 prepare_directive_trad (pfile
);
457 pfile
->directive
->handler (pfile
);
458 end_directive (pfile
, 1);
459 if (dir_no
== T_PRAGMA
)
460 pfile
->buffer
->file
= NULL
;
461 _cpp_pop_buffer (pfile
);
464 /* Checks for validity the macro name in #define, #undef, #ifdef and
465 #ifndef directives. */
466 static cpp_hashnode
*
467 lex_macro_node (cpp_reader
*pfile
)
469 const cpp_token
*token
= _cpp_lex_token (pfile
);
471 /* The token immediately after #define must be an identifier. That
472 identifier may not be "defined", per C99 6.10.8p4.
473 In C++, it may not be any of the "named operators" either,
474 per C++98 [lex.digraph], [lex.key].
475 Finally, the identifier may not have been poisoned. (In that case
476 the lexer has issued the error message for us.) */
478 if (token
->type
== CPP_NAME
)
480 cpp_hashnode
*node
= token
->val
.node
;
482 if (node
== pfile
->spec_nodes
.n_defined
)
483 cpp_error (pfile
, CPP_DL_ERROR
,
484 "\"defined\" cannot be used as a macro name");
485 else if (! (node
->flags
& NODE_POISONED
))
488 else if (token
->flags
& NAMED_OP
)
489 cpp_error (pfile
, CPP_DL_ERROR
,
490 "\"%s\" cannot be used as a macro name as it is an operator in C++",
491 NODE_NAME (token
->val
.node
));
492 else if (token
->type
== CPP_EOF
)
493 cpp_error (pfile
, CPP_DL_ERROR
, "no macro name given in #%s directive",
494 pfile
->directive
->name
);
496 cpp_error (pfile
, CPP_DL_ERROR
, "macro names must be identifiers");
501 /* Process a #define directive. Most work is done in cppmacro.c. */
503 do_define (cpp_reader
*pfile
)
505 cpp_hashnode
*node
= lex_macro_node (pfile
);
509 /* If we have been requested to expand comments into macros,
510 then re-enable saving of comments. */
511 pfile
->state
.save_comments
=
512 ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
);
514 if (_cpp_create_definition (pfile
, node
))
515 if (pfile
->cb
.define
)
516 pfile
->cb
.define (pfile
, pfile
->directive_line
, node
);
520 /* Handle #undef. Mark the identifier NT_VOID in the hash table. */
522 do_undef (cpp_reader
*pfile
)
524 cpp_hashnode
*node
= lex_macro_node (pfile
);
529 pfile
->cb
.undef (pfile
, pfile
->directive_line
, node
);
531 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified
532 identifier is not currently defined as a macro name. */
533 if (node
->type
== NT_MACRO
)
535 if (node
->flags
& NODE_WARN
)
536 cpp_error (pfile
, CPP_DL_WARNING
,
537 "undefining \"%s\"", NODE_NAME (node
));
539 if (CPP_OPTION (pfile
, warn_unused_macros
))
540 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
542 _cpp_free_definition (node
);
549 /* Undefine a single macro/assertion/whatever. */
552 undefine_macros (cpp_reader
*pfile
, cpp_hashnode
*h
,
553 void *data_p ATTRIBUTE_UNUSED
)
562 (*pfile
->cb
.undef
) (pfile
, pfile
->directive_line
, h
);
564 if (CPP_OPTION (pfile
, warn_unused_macros
))
565 _cpp_warn_if_unused_macro (pfile
, h
, NULL
);
567 /* And fall through.... */
569 _cpp_free_definition (h
);
575 h
->flags
&= ~NODE_POISONED
;
579 /* Undefine all macros and assertions. */
582 cpp_undef_all (cpp_reader
*pfile
)
584 cpp_forall_identifiers (pfile
, undefine_macros
, NULL
);
588 /* Helper routine used by parse_include. Reinterpret the current line
589 as an h-char-sequence (< ... >); we are looking at the first token
590 after the <. Returns a malloced filename. */
592 glue_header_name (cpp_reader
*pfile
)
594 const cpp_token
*token
;
596 size_t len
, total_len
= 0, capacity
= 1024;
598 /* To avoid lexed tokens overwriting our glued name, we can only
599 allocate from the string pool once we've lexed everything. */
600 buffer
= xmalloc (capacity
);
603 token
= get_token_no_padding (pfile
);
605 if (token
->type
== CPP_GREATER
)
607 if (token
->type
== CPP_EOF
)
609 cpp_error (pfile
, CPP_DL_ERROR
, "missing terminating > character");
613 len
= cpp_token_len (token
) + 2; /* Leading space, terminating \0. */
614 if (total_len
+ len
> capacity
)
616 capacity
= (capacity
+ len
) * 2;
617 buffer
= xrealloc (buffer
, capacity
);
620 if (token
->flags
& PREV_WHITE
)
621 buffer
[total_len
++] = ' ';
623 total_len
= (cpp_spell_token (pfile
, token
, (uchar
*) &buffer
[total_len
])
627 buffer
[total_len
] = '\0';
631 /* Returns the file name of #include, #include_next, #import and
632 #pragma dependency. The string is malloced and the caller should
633 free it. Returns NULL on error. */
635 parse_include (cpp_reader
*pfile
, int *pangle_brackets
)
638 const cpp_token
*header
;
640 /* Allow macro expansion. */
641 header
= get_token_no_padding (pfile
);
642 if (header
->type
== CPP_STRING
|| header
->type
== CPP_HEADER_NAME
)
644 fname
= xmalloc (header
->val
.str
.len
- 1);
645 memcpy (fname
, header
->val
.str
.text
+ 1, header
->val
.str
.len
- 2);
646 fname
[header
->val
.str
.len
- 2] = '\0';
647 *pangle_brackets
= header
->type
== CPP_HEADER_NAME
;
649 else if (header
->type
== CPP_LESS
)
651 fname
= glue_header_name (pfile
);
652 *pangle_brackets
= 1;
656 const unsigned char *dir
;
658 if (pfile
->directive
== &dtable
[T_PRAGMA
])
659 dir
= U
"pragma dependency";
661 dir
= pfile
->directive
->name
;
662 cpp_error (pfile
, CPP_DL_ERROR
, "#%s expects \"FILENAME\" or <FILENAME>",
672 /* Handle #include, #include_next and #import. */
674 do_include_common (cpp_reader
*pfile
, enum include_type type
)
679 fname
= parse_include (pfile
, &angle_brackets
);
683 /* Prevent #include recursion. */
684 if (pfile
->line_table
->depth
>= CPP_STACK_MAX
)
685 cpp_error (pfile
, CPP_DL_ERROR
, "#include nested too deeply");
688 /* Get out of macro context, if we are. */
689 skip_rest_of_line (pfile
);
691 if (pfile
->cb
.include
)
692 pfile
->cb
.include (pfile
, pfile
->directive_line
,
693 pfile
->directive
->name
, fname
, angle_brackets
);
695 _cpp_stack_include (pfile
, fname
, angle_brackets
, type
);
698 free ((void *) fname
);
702 do_include (cpp_reader
*pfile
)
704 do_include_common (pfile
, IT_INCLUDE
);
708 do_import (cpp_reader
*pfile
)
710 do_include_common (pfile
, IT_IMPORT
);
714 do_include_next (cpp_reader
*pfile
)
716 enum include_type type
= IT_INCLUDE_NEXT
;
718 /* If this is the primary source file, warn and use the normal
720 if (! pfile
->buffer
->prev
)
722 cpp_error (pfile
, CPP_DL_WARNING
,
723 "#include_next in primary source file");
726 do_include_common (pfile
, type
);
729 /* Subroutine of do_linemarker. Read possible flags after file name.
730 LAST is the last flag seen; 0 if this is the first flag. Return the
731 flag if it is valid, 0 at the end of the directive. Otherwise
734 read_flag (cpp_reader
*pfile
, unsigned int last
)
736 const cpp_token
*token
= _cpp_lex_token (pfile
);
738 if (token
->type
== CPP_NUMBER
&& token
->val
.str
.len
== 1)
740 unsigned int flag
= token
->val
.str
.text
[0] - '0';
742 if (flag
> last
&& flag
<= 4
743 && (flag
!= 4 || last
== 3)
744 && (flag
!= 2 || last
== 0))
748 if (token
->type
!= CPP_EOF
)
749 cpp_error (pfile
, CPP_DL_ERROR
, "invalid flag \"%s\" in line directive",
750 cpp_token_as_text (pfile
, token
));
754 /* Subroutine of do_line and do_linemarker. Convert a number in STR,
755 of length LEN, to binary; store it in NUMP, and return 0 if the
756 number was well-formed, 1 if not. Temporary, hopefully. */
758 strtoul_for_line (const uchar
*str
, unsigned int len
, long unsigned int *nump
)
760 unsigned long reg
= 0;
774 /* Interpret #line command.
775 Note that the filename string (if any) is a true string constant
776 (escapes are interpreted), unlike in #line. */
778 do_line (cpp_reader
*pfile
)
780 const cpp_token
*token
;
781 const char *new_file
= pfile
->map
->to_file
;
782 unsigned long new_lineno
;
784 /* C99 raised the minimum limit on #line numbers. */
785 unsigned int cap
= CPP_OPTION (pfile
, c99
) ? 2147483647 : 32767;
787 /* #line commands expand macros. */
788 token
= cpp_get_token (pfile
);
789 if (token
->type
!= CPP_NUMBER
790 || strtoul_for_line (token
->val
.str
.text
, token
->val
.str
.len
,
793 cpp_error (pfile
, CPP_DL_ERROR
,
794 "\"%s\" after #line is not a positive integer",
795 cpp_token_as_text (pfile
, token
));
799 if (CPP_PEDANTIC (pfile
) && (new_lineno
== 0 || new_lineno
> cap
))
800 cpp_error (pfile
, CPP_DL_PEDWARN
, "line number out of range");
802 token
= cpp_get_token (pfile
);
803 if (token
->type
== CPP_STRING
)
805 cpp_string s
= { 0, 0 };
806 if (_cpp_interpret_string_notranslate (pfile
, &token
->val
.str
, &s
))
807 new_file
= (const char *)s
.text
;
810 else if (token
->type
!= CPP_EOF
)
812 cpp_error (pfile
, CPP_DL_ERROR
, "\"%s\" is not a valid filename",
813 cpp_token_as_text (pfile
, token
));
817 skip_rest_of_line (pfile
);
818 _cpp_do_file_change (pfile
, LC_RENAME
, new_file
, new_lineno
,
822 /* Interpret the # 44 "file" [flags] notation, which has slightly
823 different syntax and semantics from #line: Flags are allowed,
824 and we never complain about the line number being too big. */
826 do_linemarker (cpp_reader
*pfile
)
828 const cpp_token
*token
;
829 const char *new_file
= pfile
->map
->to_file
;
830 unsigned long new_lineno
;
831 unsigned int new_sysp
= pfile
->map
->sysp
;
832 enum lc_reason reason
= LC_RENAME
;
835 /* Back up so we can get the number again. Putting this in
836 _cpp_handle_directive risks two calls to _cpp_backup_tokens in
837 some circumstances, which can segfault. */
838 _cpp_backup_tokens (pfile
, 1);
840 /* #line commands expand macros. */
841 token
= cpp_get_token (pfile
);
842 if (token
->type
!= CPP_NUMBER
843 || strtoul_for_line (token
->val
.str
.text
, token
->val
.str
.len
,
846 cpp_error (pfile
, CPP_DL_ERROR
,
847 "\"%s\" after # is not a positive integer",
848 cpp_token_as_text (pfile
, token
));
852 token
= cpp_get_token (pfile
);
853 if (token
->type
== CPP_STRING
)
855 cpp_string s
= { 0, 0 };
856 if (_cpp_interpret_string_notranslate (pfile
, &token
->val
.str
, &s
))
857 new_file
= (const char *)s
.text
;
860 flag
= read_flag (pfile
, 0);
864 /* Fake an include for cpp_included (). */
865 _cpp_fake_include (pfile
, new_file
);
866 flag
= read_flag (pfile
, flag
);
871 flag
= read_flag (pfile
, flag
);
876 flag
= read_flag (pfile
, flag
);
883 else if (token
->type
!= CPP_EOF
)
885 cpp_error (pfile
, CPP_DL_ERROR
, "\"%s\" is not a valid filename",
886 cpp_token_as_text (pfile
, token
));
890 skip_rest_of_line (pfile
);
891 _cpp_do_file_change (pfile
, reason
, new_file
, new_lineno
, new_sysp
);
894 /* Arrange the file_change callback. pfile->line has changed to
895 FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system
896 header, 2 for a system header that needs to be extern "C" protected,
897 and zero otherwise. */
899 _cpp_do_file_change (cpp_reader
*pfile
, enum lc_reason reason
,
900 const char *to_file
, unsigned int file_line
,
903 pfile
->map
= linemap_add (pfile
->line_table
, reason
, sysp
,
904 pfile
->line
, to_file
, file_line
);
906 if (pfile
->cb
.file_change
)
907 pfile
->cb
.file_change (pfile
, pfile
->map
);
910 /* Report a warning or error detected by the program we are
911 processing. Use the directive's tokens in the error message. */
913 do_diagnostic (cpp_reader
*pfile
, int code
, int print_dir
)
915 if (_cpp_begin_message (pfile
, code
,
916 pfile
->cur_token
[-1].line
,
917 pfile
->cur_token
[-1].col
))
920 fprintf (stderr
, "#%s ", pfile
->directive
->name
);
921 pfile
->state
.prevent_expansion
++;
922 cpp_output_line (pfile
, stderr
);
923 pfile
->state
.prevent_expansion
--;
928 do_error (cpp_reader
*pfile
)
930 do_diagnostic (pfile
, CPP_DL_ERROR
, 1);
934 do_warning (cpp_reader
*pfile
)
936 /* We want #warning diagnostics to be emitted in system headers too. */
937 do_diagnostic (pfile
, CPP_DL_WARNING_SYSHDR
, 1);
940 /* Report program identification. */
942 do_ident (cpp_reader
*pfile
)
944 const cpp_token
*str
= cpp_get_token (pfile
);
946 if (str
->type
!= CPP_STRING
)
947 cpp_error (pfile
, CPP_DL_ERROR
, "invalid #ident directive");
948 else if (pfile
->cb
.ident
)
949 pfile
->cb
.ident (pfile
, pfile
->directive_line
, &str
->val
.str
);
954 /* Lookup a PRAGMA name in a singly-linked CHAIN. Returns the
955 matching entry, or NULL if none is found. The returned entry could
956 be the start of a namespace chain, or a pragma. */
957 static struct pragma_entry
*
958 lookup_pragma_entry (struct pragma_entry
*chain
, const cpp_hashnode
*pragma
)
960 while (chain
&& chain
->pragma
!= pragma
)
966 /* Create and insert a pragma entry for NAME at the beginning of a
967 singly-linked CHAIN. If handler is NULL, it is a namespace,
968 otherwise it is a pragma and its handler. */
969 static struct pragma_entry
*
970 insert_pragma_entry (cpp_reader
*pfile
, struct pragma_entry
**chain
,
971 const cpp_hashnode
*pragma
, pragma_cb handler
)
973 struct pragma_entry
*new;
975 new = (struct pragma_entry
*)
976 _cpp_aligned_alloc (pfile
, sizeof (struct pragma_entry
));
977 new->pragma
= pragma
;
981 new->u
.handler
= handler
;
994 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
995 goes in the global namespace. HANDLER is the handler it will call,
996 which must be non-NULL. */
998 cpp_register_pragma (cpp_reader
*pfile
, const char *space
, const char *name
,
1001 struct pragma_entry
**chain
= &pfile
->pragmas
;
1002 struct pragma_entry
*entry
;
1003 const cpp_hashnode
*node
;
1010 node
= cpp_lookup (pfile
, U space
, strlen (space
));
1011 entry
= lookup_pragma_entry (*chain
, node
);
1013 entry
= insert_pragma_entry (pfile
, chain
, node
, NULL
);
1014 else if (!entry
->is_nspace
)
1016 chain
= &entry
->u
.space
;
1019 /* Check for duplicates. */
1020 node
= cpp_lookup (pfile
, U name
, strlen (name
));
1021 entry
= lookup_pragma_entry (*chain
, node
);
1024 if (entry
->is_nspace
)
1026 cpp_error (pfile
, CPP_DL_ICE
,
1027 "registering \"%s\" as both a pragma and a pragma namespace",
1030 cpp_error (pfile
, CPP_DL_ICE
, "#pragma %s %s is already registered",
1033 cpp_error (pfile
, CPP_DL_ICE
, "#pragma %s is already registered", name
);
1036 insert_pragma_entry (pfile
, chain
, node
, handler
);
1039 /* Register the pragmas the preprocessor itself handles. */
1041 _cpp_init_internal_pragmas (cpp_reader
*pfile
)
1043 /* Pragmas in the global namespace. */
1044 cpp_register_pragma (pfile
, 0, "once", do_pragma_once
);
1046 /* New GCC-specific pragmas should be put in the GCC namespace. */
1047 cpp_register_pragma (pfile
, "GCC", "poison", do_pragma_poison
);
1048 cpp_register_pragma (pfile
, "GCC", "system_header", do_pragma_system_header
);
1049 cpp_register_pragma (pfile
, "GCC", "dependency", do_pragma_dependency
);
1052 /* Return the number of registered pragmas in PE. */
1055 count_registered_pragmas (struct pragma_entry
*pe
)
1058 for (; pe
!= NULL
; pe
= pe
->next
)
1061 ct
+= count_registered_pragmas (pe
->u
.space
);
1067 /* Save into SD the names of the registered pragmas referenced by PE,
1068 and return a pointer to the next free space in SD. */
1071 save_registered_pragmas (struct pragma_entry
*pe
, char **sd
)
1073 for (; pe
!= NULL
; pe
= pe
->next
)
1076 sd
= save_registered_pragmas (pe
->u
.space
, sd
);
1077 *sd
++ = xmemdup (HT_STR (&pe
->pragma
->ident
),
1078 HT_LEN (&pe
->pragma
->ident
),
1079 HT_LEN (&pe
->pragma
->ident
) + 1);
1084 /* Return a newly-allocated array which saves the names of the
1085 registered pragmas. */
1088 _cpp_save_pragma_names (cpp_reader
*pfile
)
1090 int ct
= count_registered_pragmas (pfile
->pragmas
);
1091 char **result
= xnewvec (char *, ct
);
1092 (void) save_registered_pragmas (pfile
->pragmas
, result
);
1096 /* Restore from SD the names of the registered pragmas referenced by PE,
1097 and return a pointer to the next unused name in SD. */
1100 restore_registered_pragmas (cpp_reader
*pfile
, struct pragma_entry
*pe
,
1103 for (; pe
!= NULL
; pe
= pe
->next
)
1106 sd
= restore_registered_pragmas (pfile
, pe
->u
.space
, sd
);
1107 pe
->pragma
= cpp_lookup (pfile
, U
*sd
, strlen (*sd
));
1114 /* Restore the names of the registered pragmas from SAVED. */
1117 _cpp_restore_pragma_names (cpp_reader
*pfile
, char **saved
)
1119 (void) restore_registered_pragmas (pfile
, pfile
->pragmas
, saved
);
1123 /* Pragmata handling. We handle some, and pass the rest on to the
1124 front end. C99 defines three pragmas and says that no macro
1125 expansion is to be performed on them; whether or not macro
1126 expansion happens for other pragmas is implementation defined.
1127 This implementation never macro-expands the text after #pragma. */
1129 do_pragma (cpp_reader
*pfile
)
1131 const struct pragma_entry
*p
= NULL
;
1132 const cpp_token
*token
, *pragma_token
= pfile
->cur_token
;
1133 unsigned int count
= 1;
1135 pfile
->state
.prevent_expansion
++;
1137 token
= cpp_get_token (pfile
);
1138 if (token
->type
== CPP_NAME
)
1140 p
= lookup_pragma_entry (pfile
->pragmas
, token
->val
.node
);
1141 if (p
&& p
->is_nspace
)
1144 token
= cpp_get_token (pfile
);
1145 if (token
->type
== CPP_NAME
)
1146 p
= lookup_pragma_entry (p
->u
.space
, token
->val
.node
);
1154 /* Since the handler below doesn't get the line number, that it
1155 might need for diagnostics, make sure it has the right
1156 numbers in place. */
1157 if (pfile
->cb
.line_change
)
1158 (*pfile
->cb
.line_change
) (pfile
, pragma_token
, false);
1159 (*p
->u
.handler
) (pfile
);
1160 if (pfile
->cb
.line_change
)
1161 (*pfile
->cb
.line_change
) (pfile
, pfile
->cur_token
, false);
1164 else if (pfile
->cb
.def_pragma
)
1166 _cpp_backup_tokens (pfile
, count
);
1167 pfile
->cb
.def_pragma (pfile
, pfile
->directive_line
);
1170 pfile
->state
.prevent_expansion
--;
1173 /* Handle #pragma once. */
1175 do_pragma_once (cpp_reader
*pfile
)
1177 if (pfile
->buffer
->prev
== NULL
)
1178 cpp_error (pfile
, CPP_DL_WARNING
, "#pragma once in main file");
1181 _cpp_mark_file_once_only (pfile
, pfile
->buffer
->file
);
1184 /* Handle #pragma GCC poison, to poison one or more identifiers so
1185 that the lexer produces a hard error for each subsequent usage. */
1187 do_pragma_poison (cpp_reader
*pfile
)
1189 const cpp_token
*tok
;
1192 pfile
->state
.poisoned_ok
= 1;
1195 tok
= _cpp_lex_token (pfile
);
1196 if (tok
->type
== CPP_EOF
)
1198 if (tok
->type
!= CPP_NAME
)
1200 cpp_error (pfile
, CPP_DL_ERROR
,
1201 "invalid #pragma GCC poison directive");
1206 if (hp
->flags
& NODE_POISONED
)
1209 if (hp
->type
== NT_MACRO
)
1210 cpp_error (pfile
, CPP_DL_WARNING
, "poisoning existing macro \"%s\"",
1212 _cpp_free_definition (hp
);
1213 hp
->flags
|= NODE_POISONED
| NODE_DIAGNOSTIC
;
1215 pfile
->state
.poisoned_ok
= 0;
1218 /* Mark the current header as a system header. This will suppress
1219 some categories of warnings (notably those from -pedantic). It is
1220 intended for use in system libraries that cannot be implemented in
1221 conforming C, but cannot be certain that their headers appear in a
1222 system include directory. To prevent abuse, it is rejected in the
1223 primary source file. */
1225 do_pragma_system_header (cpp_reader
*pfile
)
1227 cpp_buffer
*buffer
= pfile
->buffer
;
1229 if (buffer
->prev
== 0)
1230 cpp_error (pfile
, CPP_DL_WARNING
,
1231 "#pragma system_header ignored outside include file");
1235 skip_rest_of_line (pfile
);
1236 cpp_make_system_header (pfile
, 1, 0);
1240 /* Check the modified date of the current include file against a specified
1241 file. Issue a diagnostic, if the specified file is newer. We use this to
1242 determine if a fixed header should be refixed. */
1244 do_pragma_dependency (cpp_reader
*pfile
)
1247 int angle_brackets
, ordering
;
1249 fname
= parse_include (pfile
, &angle_brackets
);
1253 ordering
= _cpp_compare_file_date (pfile
, fname
, angle_brackets
);
1255 cpp_error (pfile
, CPP_DL_WARNING
, "cannot find source file %s", fname
);
1256 else if (ordering
> 0)
1258 cpp_error (pfile
, CPP_DL_WARNING
,
1259 "current file is older than %s", fname
);
1260 if (cpp_get_token (pfile
)->type
!= CPP_EOF
)
1262 _cpp_backup_tokens (pfile
, 1);
1263 do_diagnostic (pfile
, CPP_DL_WARNING
, 0);
1267 free ((void *) fname
);
1270 /* Get a token but skip padding. */
1271 static const cpp_token
*
1272 get_token_no_padding (cpp_reader
*pfile
)
1276 const cpp_token
*result
= cpp_get_token (pfile
);
1277 if (result
->type
!= CPP_PADDING
)
1282 /* Check syntax is "(string-literal)". Returns the string on success,
1283 or NULL on failure. */
1284 static const cpp_token
*
1285 get__Pragma_string (cpp_reader
*pfile
)
1287 const cpp_token
*string
;
1289 if (get_token_no_padding (pfile
)->type
!= CPP_OPEN_PAREN
)
1292 string
= get_token_no_padding (pfile
);
1293 if (string
->type
!= CPP_STRING
&& string
->type
!= CPP_WSTRING
)
1296 if (get_token_no_padding (pfile
)->type
!= CPP_CLOSE_PAREN
)
1302 /* Destringize IN into a temporary buffer, by removing the first \ of
1303 \" and \\ sequences, and process the result as a #pragma directive. */
1305 destringize_and_run (cpp_reader
*pfile
, const cpp_string
*in
)
1307 const unsigned char *src
, *limit
;
1308 char *dest
, *result
;
1310 dest
= result
= alloca (in
->len
- 1);
1311 src
= in
->text
+ 1 + (in
->text
[0] == 'L');
1312 limit
= in
->text
+ in
->len
- 1;
1315 /* We know there is a character following the backslash. */
1316 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1322 /* Ugh; an awful kludge. We are really not set up to be lexing
1323 tokens when in the middle of a macro expansion. Use a new
1324 context to force cpp_get_token to lex, and so skip_rest_of_line
1325 doesn't go beyond the end of the text. Also, remember the
1326 current lexing position so we can return to it later.
1328 Something like line-at-a-time lexing should remove the need for
1331 cpp_context
*saved_context
= pfile
->context
;
1332 cpp_token
*saved_cur_token
= pfile
->cur_token
;
1333 tokenrun
*saved_cur_run
= pfile
->cur_run
;
1335 pfile
->context
= xnew (cpp_context
);
1336 pfile
->context
->macro
= 0;
1337 pfile
->context
->prev
= 0;
1338 run_directive (pfile
, T_PRAGMA
, result
, dest
- result
);
1339 free (pfile
->context
);
1340 pfile
->context
= saved_context
;
1341 pfile
->cur_token
= saved_cur_token
;
1342 pfile
->cur_run
= saved_cur_run
;
1346 /* See above comment. For the moment, we'd like
1348 token1 _Pragma ("foo") token2
1358 Getting the line markers is a little tricky. */
1359 if (pfile
->cb
.line_change
)
1360 pfile
->cb
.line_change (pfile
, pfile
->cur_token
, false);
1363 /* Handle the _Pragma operator. */
1365 _cpp_do__Pragma (cpp_reader
*pfile
)
1367 const cpp_token
*string
= get__Pragma_string (pfile
);
1370 destringize_and_run (pfile
, &string
->val
.str
);
1372 cpp_error (pfile
, CPP_DL_ERROR
,
1373 "_Pragma takes a parenthesized string literal");
1376 /* Ignore #sccs on all systems. */
1378 do_sccs (cpp_reader
*pfile ATTRIBUTE_UNUSED
)
1382 /* Handle #ifdef. */
1384 do_ifdef (cpp_reader
*pfile
)
1388 if (! pfile
->state
.skipping
)
1390 const cpp_hashnode
*node
= lex_macro_node (pfile
);
1394 skip
= node
->type
!= NT_MACRO
;
1395 _cpp_mark_macro_used (node
);
1400 push_conditional (pfile
, skip
, T_IFDEF
, 0);
1403 /* Handle #ifndef. */
1405 do_ifndef (cpp_reader
*pfile
)
1408 const cpp_hashnode
*node
= 0;
1410 if (! pfile
->state
.skipping
)
1412 node
= lex_macro_node (pfile
);
1416 skip
= node
->type
== NT_MACRO
;
1417 _cpp_mark_macro_used (node
);
1422 push_conditional (pfile
, skip
, T_IFNDEF
, node
);
1425 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1426 pfile->mi_ind_cmacro so we can handle multiple-include
1427 optimizations. If macro expansion occurs in the expression, we
1428 cannot treat it as a controlling conditional, since the expansion
1429 could change in the future. That is handled by cpp_get_token. */
1431 do_if (cpp_reader
*pfile
)
1435 if (! pfile
->state
.skipping
)
1436 skip
= _cpp_parse_expr (pfile
) == false;
1438 push_conditional (pfile
, skip
, T_IF
, pfile
->mi_ind_cmacro
);
1441 /* Flip skipping state if appropriate and continue without changing
1442 if_stack; this is so that the error message for missing #endif's
1443 etc. will point to the original #if. */
1445 do_else (cpp_reader
*pfile
)
1447 cpp_buffer
*buffer
= pfile
->buffer
;
1448 struct if_stack
*ifs
= buffer
->if_stack
;
1451 cpp_error (pfile
, CPP_DL_ERROR
, "#else without #if");
1454 if (ifs
->type
== T_ELSE
)
1456 cpp_error (pfile
, CPP_DL_ERROR
, "#else after #else");
1457 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
1458 "the conditional began here");
1462 /* Skip any future (erroneous) #elses or #elifs. */
1463 pfile
->state
.skipping
= ifs
->skip_elses
;
1464 ifs
->skip_elses
= true;
1466 /* Invalidate any controlling macro. */
1469 /* Only check EOL if was not originally skipping. */
1470 if (!ifs
->was_skipping
&& CPP_OPTION (pfile
, warn_endif_labels
))
1475 /* Handle a #elif directive by not changing if_stack either. See the
1476 comment above do_else. */
1478 do_elif (cpp_reader
*pfile
)
1480 cpp_buffer
*buffer
= pfile
->buffer
;
1481 struct if_stack
*ifs
= buffer
->if_stack
;
1484 cpp_error (pfile
, CPP_DL_ERROR
, "#elif without #if");
1487 if (ifs
->type
== T_ELSE
)
1489 cpp_error (pfile
, CPP_DL_ERROR
, "#elif after #else");
1490 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
1491 "the conditional began here");
1495 /* Only evaluate this if we aren't skipping elses. During
1496 evaluation, set skipping to false to get lexer warnings. */
1497 if (ifs
->skip_elses
)
1498 pfile
->state
.skipping
= 1;
1501 pfile
->state
.skipping
= 0;
1502 pfile
->state
.skipping
= ! _cpp_parse_expr (pfile
);
1503 ifs
->skip_elses
= ! pfile
->state
.skipping
;
1506 /* Invalidate any controlling macro. */
1511 /* #endif pops the if stack and resets pfile->state.skipping. */
1513 do_endif (cpp_reader
*pfile
)
1515 cpp_buffer
*buffer
= pfile
->buffer
;
1516 struct if_stack
*ifs
= buffer
->if_stack
;
1519 cpp_error (pfile
, CPP_DL_ERROR
, "#endif without #if");
1522 /* Only check EOL if was not originally skipping. */
1523 if (!ifs
->was_skipping
&& CPP_OPTION (pfile
, warn_endif_labels
))
1526 /* If potential control macro, we go back outside again. */
1527 if (ifs
->next
== 0 && ifs
->mi_cmacro
)
1529 pfile
->mi_valid
= true;
1530 pfile
->mi_cmacro
= ifs
->mi_cmacro
;
1533 buffer
->if_stack
= ifs
->next
;
1534 pfile
->state
.skipping
= ifs
->was_skipping
;
1535 obstack_free (&pfile
->buffer_ob
, ifs
);
1539 /* Push an if_stack entry for a preprocessor conditional, and set
1540 pfile->state.skipping to SKIP. If TYPE indicates the conditional
1541 is #if or #ifndef, CMACRO is a potentially controlling macro, and
1542 we need to check here that we are at the top of the file. */
1544 push_conditional (cpp_reader
*pfile
, int skip
, int type
,
1545 const cpp_hashnode
*cmacro
)
1547 struct if_stack
*ifs
;
1548 cpp_buffer
*buffer
= pfile
->buffer
;
1550 ifs
= xobnew (&pfile
->buffer_ob
, struct if_stack
);
1551 ifs
->line
= pfile
->directive_line
;
1552 ifs
->next
= buffer
->if_stack
;
1553 ifs
->skip_elses
= pfile
->state
.skipping
|| !skip
;
1554 ifs
->was_skipping
= pfile
->state
.skipping
;
1556 /* This condition is effectively a test for top-of-file. */
1557 if (pfile
->mi_valid
&& pfile
->mi_cmacro
== 0)
1558 ifs
->mi_cmacro
= cmacro
;
1562 pfile
->state
.skipping
= skip
;
1563 buffer
->if_stack
= ifs
;
1566 /* Read the tokens of the answer into the macro pool, in a directive
1567 of type TYPE. Only commit the memory if we intend it as permanent
1568 storage, i.e. the #assert case. Returns 0 on success, and sets
1569 ANSWERP to point to the answer. */
1571 parse_answer (cpp_reader
*pfile
, struct answer
**answerp
, int type
)
1573 const cpp_token
*paren
;
1574 struct answer
*answer
;
1575 unsigned int acount
;
1577 /* In a conditional, it is legal to not have an open paren. We
1578 should save the following token in this case. */
1579 paren
= cpp_get_token (pfile
);
1581 /* If not a paren, see if we're OK. */
1582 if (paren
->type
!= CPP_OPEN_PAREN
)
1584 /* In a conditional no answer is a test for any answer. It
1585 could be followed by any token. */
1588 _cpp_backup_tokens (pfile
, 1);
1592 /* #unassert with no answer is valid - it removes all answers. */
1593 if (type
== T_UNASSERT
&& paren
->type
== CPP_EOF
)
1596 cpp_error (pfile
, CPP_DL_ERROR
, "missing '(' after predicate");
1600 for (acount
= 0;; acount
++)
1603 const cpp_token
*token
= cpp_get_token (pfile
);
1606 if (token
->type
== CPP_CLOSE_PAREN
)
1609 if (token
->type
== CPP_EOF
)
1611 cpp_error (pfile
, CPP_DL_ERROR
, "missing ')' to complete answer");
1615 /* struct answer includes the space for one token. */
1616 room_needed
= (sizeof (struct answer
) + acount
* sizeof (cpp_token
));
1618 if (BUFF_ROOM (pfile
->a_buff
) < room_needed
)
1619 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (struct answer
));
1621 dest
= &((struct answer
*) BUFF_FRONT (pfile
->a_buff
))->first
[acount
];
1624 /* Drop whitespace at start, for answer equivalence purposes. */
1626 dest
->flags
&= ~PREV_WHITE
;
1631 cpp_error (pfile
, CPP_DL_ERROR
, "predicate's answer is empty");
1635 answer
= (struct answer
*) BUFF_FRONT (pfile
->a_buff
);
1636 answer
->count
= acount
;
1637 answer
->next
= NULL
;
1643 /* Parses an assertion directive of type TYPE, returning a pointer to
1644 the hash node of the predicate, or 0 on error. If an answer was
1645 supplied, it is placed in ANSWERP, otherwise it is set to 0. */
1646 static cpp_hashnode
*
1647 parse_assertion (cpp_reader
*pfile
, struct answer
**answerp
, int type
)
1649 cpp_hashnode
*result
= 0;
1650 const cpp_token
*predicate
;
1652 /* We don't expand predicates or answers. */
1653 pfile
->state
.prevent_expansion
++;
1656 predicate
= cpp_get_token (pfile
);
1657 if (predicate
->type
== CPP_EOF
)
1658 cpp_error (pfile
, CPP_DL_ERROR
, "assertion without predicate");
1659 else if (predicate
->type
!= CPP_NAME
)
1660 cpp_error (pfile
, CPP_DL_ERROR
, "predicate must be an identifier");
1661 else if (parse_answer (pfile
, answerp
, type
) == 0)
1663 unsigned int len
= NODE_LEN (predicate
->val
.node
);
1664 unsigned char *sym
= alloca (len
+ 1);
1666 /* Prefix '#' to get it out of macro namespace. */
1668 memcpy (sym
+ 1, NODE_NAME (predicate
->val
.node
), len
);
1669 result
= cpp_lookup (pfile
, sym
, len
+ 1);
1672 pfile
->state
.prevent_expansion
--;
1676 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
1677 or a pointer to NULL if the answer is not in the chain. */
1678 static struct answer
**
1679 find_answer (cpp_hashnode
*node
, const struct answer
*candidate
)
1682 struct answer
**result
;
1684 for (result
= &node
->value
.answers
; *result
; result
= &(*result
)->next
)
1686 struct answer
*answer
= *result
;
1688 if (answer
->count
== candidate
->count
)
1690 for (i
= 0; i
< answer
->count
; i
++)
1691 if (! _cpp_equiv_tokens (&answer
->first
[i
], &candidate
->first
[i
]))
1694 if (i
== answer
->count
)
1702 /* Test an assertion within a preprocessor conditional. Returns
1703 nonzero on failure, zero on success. On success, the result of
1704 the test is written into VALUE, otherwise the value 0. */
1706 _cpp_test_assertion (cpp_reader
*pfile
, unsigned int *value
)
1708 struct answer
*answer
;
1711 node
= parse_assertion (pfile
, &answer
, T_IF
);
1713 /* For recovery, an erroneous assertion expression is handled as a
1714 failing assertion. */
1718 *value
= (node
->type
== NT_ASSERTION
&&
1719 (answer
== 0 || *find_answer (node
, answer
) != 0));
1720 else if (pfile
->cur_token
[-1].type
== CPP_EOF
)
1721 _cpp_backup_tokens (pfile
, 1);
1723 /* We don't commit the memory for the answer - it's temporary only. */
1727 /* Handle #assert. */
1729 do_assert (cpp_reader
*pfile
)
1731 struct answer
*new_answer
;
1734 node
= parse_assertion (pfile
, &new_answer
, T_ASSERT
);
1737 /* Place the new answer in the answer list. First check there
1738 is not a duplicate. */
1739 new_answer
->next
= 0;
1740 if (node
->type
== NT_ASSERTION
)
1742 if (*find_answer (node
, new_answer
))
1744 cpp_error (pfile
, CPP_DL_WARNING
, "\"%s\" re-asserted",
1745 NODE_NAME (node
) + 1);
1748 new_answer
->next
= node
->value
.answers
;
1751 node
->type
= NT_ASSERTION
;
1752 node
->value
.answers
= new_answer
;
1753 BUFF_FRONT (pfile
->a_buff
) += (sizeof (struct answer
)
1754 + (new_answer
->count
- 1)
1755 * sizeof (cpp_token
));
1760 /* Handle #unassert. */
1762 do_unassert (cpp_reader
*pfile
)
1765 struct answer
*answer
;
1767 node
= parse_assertion (pfile
, &answer
, T_UNASSERT
);
1768 /* It isn't an error to #unassert something that isn't asserted. */
1769 if (node
&& node
->type
== NT_ASSERTION
)
1773 struct answer
**p
= find_answer (node
, answer
), *temp
;
1775 /* Remove the answer from the list. */
1780 /* Did we free the last answer? */
1781 if (node
->value
.answers
== 0)
1782 node
->type
= NT_VOID
;
1787 _cpp_free_definition (node
);
1790 /* We don't commit the memory for the answer - it's temporary only. */
1793 /* These are for -D, -U, -A. */
1795 /* Process the string STR as if it appeared as the body of a #define.
1796 If STR is just an identifier, define it with value 1.
1797 If STR has anything after the identifier, then it should
1798 be identifier=definition. */
1800 cpp_define (cpp_reader
*pfile
, const char *str
)
1805 /* Copy the entire option so we can modify it.
1806 Change the first "=" in the string to a space. If there is none,
1807 tack " 1" on the end. */
1809 count
= strlen (str
);
1810 buf
= alloca (count
+ 3);
1811 memcpy (buf
, str
, count
);
1813 p
= strchr (str
, '=');
1823 run_directive (pfile
, T_DEFINE
, buf
, count
);
1826 /* Slight variant of the above for use by initialize_builtins. */
1828 _cpp_define_builtin (cpp_reader
*pfile
, const char *str
)
1830 size_t len
= strlen (str
);
1831 char *buf
= alloca (len
+ 1);
1832 memcpy (buf
, str
, len
);
1834 run_directive (pfile
, T_DEFINE
, buf
, len
);
1837 /* Process MACRO as if it appeared as the body of an #undef. */
1839 cpp_undef (cpp_reader
*pfile
, const char *macro
)
1841 size_t len
= strlen (macro
);
1842 char *buf
= alloca (len
+ 1);
1843 memcpy (buf
, macro
, len
);
1845 run_directive (pfile
, T_UNDEF
, buf
, len
);
1848 /* Process the string STR as if it appeared as the body of a #assert. */
1850 cpp_assert (cpp_reader
*pfile
, const char *str
)
1852 handle_assertion (pfile
, str
, T_ASSERT
);
1855 /* Process STR as if it appeared as the body of an #unassert. */
1857 cpp_unassert (cpp_reader
*pfile
, const char *str
)
1859 handle_assertion (pfile
, str
, T_UNASSERT
);
1862 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1864 handle_assertion (cpp_reader
*pfile
, const char *str
, int type
)
1866 size_t count
= strlen (str
);
1867 const char *p
= strchr (str
, '=');
1869 /* Copy the entire option so we can modify it. Change the first
1870 "=" in the string to a '(', and tack a ')' on the end. */
1871 char *buf
= alloca (count
+ 2);
1873 memcpy (buf
, str
, count
);
1882 run_directive (pfile
, type
, str
, count
);
1885 /* The number of errors for a given reader. */
1887 cpp_errors (cpp_reader
*pfile
)
1889 return pfile
->errors
;
1892 /* The options structure. */
1894 cpp_get_options (cpp_reader
*pfile
)
1896 return &pfile
->opts
;
1899 /* The callbacks structure. */
1901 cpp_get_callbacks (cpp_reader
*pfile
)
1906 /* The line map set. */
1907 const struct line_maps
*
1908 cpp_get_line_maps (cpp_reader
*pfile
)
1910 return pfile
->line_table
;
1913 /* Copy the given callbacks structure to our own. */
1915 cpp_set_callbacks (cpp_reader
*pfile
, cpp_callbacks
*cb
)
1920 /* Push a new buffer on the buffer stack. Returns the new buffer; it
1921 doesn't fail. It does not generate a file change call back; that
1922 is the responsibility of the caller. */
1924 cpp_push_buffer (cpp_reader
*pfile
, const uchar
*buffer
, size_t len
,
1927 cpp_buffer
*new = xobnew (&pfile
->buffer_ob
, cpp_buffer
);
1928 const char *input
= CPP_OPTION (pfile
, input_charset
);
1930 /* Clears, amongst other things, if_stack and mi_cmacro. */
1931 memset (new, 0, sizeof (cpp_buffer
));
1933 new->next_line
= new->buf
= buffer
;
1934 new->rlimit
= buffer
+ len
;
1935 new->from_stage3
= from_stage3
;
1936 new->prev
= pfile
->buffer
;
1937 new->need_line
= true;
1939 pfile
->buffer
= new;
1940 _cpp_init_iconv_buffer (pfile
, input
);
1945 /* Pops a single buffer, with a file change call-back if appropriate.
1946 Then pushes the next -include file, if any remain. */
1948 _cpp_pop_buffer (cpp_reader
*pfile
)
1950 cpp_buffer
*buffer
= pfile
->buffer
;
1951 struct _cpp_file
*inc
= buffer
->file
;
1952 struct if_stack
*ifs
;
1954 /* Walk back up the conditional stack till we reach its level at
1955 entry to this file, issuing error messages. */
1956 for (ifs
= buffer
->if_stack
; ifs
; ifs
= ifs
->next
)
1957 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
1958 "unterminated #%s", dtable
[ifs
->type
].name
);
1960 /* In case of a missing #endif. */
1961 pfile
->state
.skipping
= 0;
1963 _cpp_close_iconv_buffer (pfile
);
1965 /* _cpp_do_file_change expects pfile->buffer to be the new one. */
1966 pfile
->buffer
= buffer
->prev
;
1968 free (buffer
->notes
);
1970 /* Free the buffer object now; we may want to push a new buffer
1971 in _cpp_push_next_include_file. */
1972 obstack_free (&pfile
->buffer_ob
, buffer
);
1976 _cpp_pop_file_buffer (pfile
, inc
);
1978 _cpp_do_file_change (pfile
, LC_LEAVE
, 0, 0, 0);
1982 /* Enter all recognized directives in the hash table. */
1984 _cpp_init_directives (cpp_reader
*pfile
)
1989 for (i
= 0; i
< (unsigned int) N_DIRECTIVES
; i
++)
1991 node
= cpp_lookup (pfile
, dtable
[i
].name
, dtable
[i
].length
);
1992 node
->is_directive
= 1;
1993 node
->directive_index
= i
;