1 /* CPP Library. (Directive handling.)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 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. */
29 /* Chained list of answers to an assertion. */
37 /* Stack of conditionals currently in progress
38 (including both successful and failing conditionals). */
42 struct if_stack
*next
;
43 unsigned int line
; /* Line where condition started. */
44 const cpp_hashnode
*mi_cmacro
;/* macro name for #ifndef around entire file */
45 bool skip_elses
; /* Can future #else / #elif be skipped? */
46 bool was_skipping
; /* If were skipping on entry. */
47 int type
; /* Most recent conditional, for diagnostics. */
50 /* Contains a registered pragma or pragma namespace. */
51 typedef void (*pragma_cb
) PARAMS ((cpp_reader
*));
54 struct pragma_entry
*next
;
55 const cpp_hashnode
*pragma
; /* Name and length. */
59 struct pragma_entry
*space
;
63 /* Values for the origin field of struct directive. KANDR directives
64 come from traditional (K&R) C. STDC89 directives come from the
65 1989 C standard. EXTENSION directives are extensions. */
70 /* Values for the flags field of struct directive. COND indicates a
71 conditional; IF_COND an opening conditional. INCL means to treat
72 "..." and <...> as q-char and h-char sequences respectively. IN_I
73 means this directive should be handled even if -fpreprocessed is in
74 effect (these are the directives with callback hooks). */
76 #define IF_COND (1 << 1)
80 /* Defines one #-directive, including how to handle it. */
81 typedef void (*directive_handler
) PARAMS ((cpp_reader
*));
82 typedef struct directive directive
;
85 directive_handler handler
; /* Function to handle directive. */
86 const U_CHAR
*name
; /* Name of directive. */
87 unsigned short length
; /* Length of name. */
88 unsigned char origin
; /* Origin of directive. */
89 unsigned char flags
; /* Flags describing this directive. */
92 /* Forward declarations. */
94 static void skip_rest_of_line
PARAMS ((cpp_reader
*));
95 static void check_eol
PARAMS ((cpp_reader
*));
96 static void start_directive
PARAMS ((cpp_reader
*));
97 static void end_directive
PARAMS ((cpp_reader
*, int));
98 static void directive_diagnostics
99 PARAMS ((cpp_reader
*, const directive
*, int));
100 static void run_directive
PARAMS ((cpp_reader
*, int,
101 const char *, size_t));
102 static const cpp_token
*glue_header_name
PARAMS ((cpp_reader
*));
103 static const cpp_token
*parse_include
PARAMS ((cpp_reader
*));
104 static void push_conditional
PARAMS ((cpp_reader
*, int, int,
105 const cpp_hashnode
*));
106 static unsigned int read_flag
PARAMS ((cpp_reader
*, unsigned int));
107 static int strtoul_for_line
PARAMS ((const U_CHAR
*, unsigned int,
109 static void do_diagnostic
PARAMS ((cpp_reader
*, enum error_type
, int));
110 static cpp_hashnode
*lex_macro_node
PARAMS ((cpp_reader
*));
111 static void do_include_common
PARAMS ((cpp_reader
*, enum include_type
));
112 static struct pragma_entry
*lookup_pragma_entry
113 PARAMS ((struct pragma_entry
*, const cpp_hashnode
*pragma
));
114 static struct pragma_entry
*insert_pragma_entry
115 PARAMS ((cpp_reader
*, struct pragma_entry
**, const cpp_hashnode
*,
117 static void do_pragma_once
PARAMS ((cpp_reader
*));
118 static void do_pragma_poison
PARAMS ((cpp_reader
*));
119 static void do_pragma_system_header
PARAMS ((cpp_reader
*));
120 static void do_pragma_dependency
PARAMS ((cpp_reader
*));
121 static const cpp_token
*get_token_no_padding
PARAMS ((cpp_reader
*));
122 static const cpp_token
*get__Pragma_string
PARAMS ((cpp_reader
*));
123 static void destringize_and_run
PARAMS ((cpp_reader
*, const cpp_string
*));
124 static int parse_answer
PARAMS ((cpp_reader
*, struct answer
**, int));
125 static cpp_hashnode
*parse_assertion
PARAMS ((cpp_reader
*, struct answer
**,
127 static struct answer
** find_answer
PARAMS ((cpp_hashnode
*,
128 const struct answer
*));
129 static void handle_assertion
PARAMS ((cpp_reader
*, const char *, int));
131 /* This is the table of directive handlers. It is ordered by
132 frequency of occurrence; the numbers at the end are directive
133 counts from all the source code I have lying around (egcs and libc
134 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
135 pcmcia-cs-3.0.9). This is no longer important as directive lookup
136 is now O(1). All extensions other than #warning and #include_next
137 are deprecated. The name is where the extension appears to have
140 #define DIRECTIVE_TABLE \
141 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
142 D(include, T_INCLUDE, KANDR, INCL) /* 52262 */ \
143 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
144 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
145 D(if, T_IF, KANDR, COND | IF_COND) /* 18162 */ \
146 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
147 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
148 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
149 D(line, T_LINE, KANDR, IN_I) /* 2465 */ \
150 D(elif, T_ELIF, STDC89, COND) /* 610 */ \
151 D(error, T_ERROR, STDC89, 0) /* 475 */ \
152 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
153 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
154 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL) /* 19 */ \
155 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
156 D(import, T_IMPORT, EXTENSION, INCL) /* 0 ObjC */ \
157 D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
158 D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
159 SCCS_ENTRY /* 0 SVR4? */
161 /* #sccs is not always recognized. */
162 #ifdef SCCS_DIRECTIVE
163 # define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION, 0)
165 # define SCCS_ENTRY /* nothing */
168 /* Use the table to generate a series of prototypes, an enum for the
169 directive names, and an array of directive handlers. */
171 /* The directive-processing functions are declared to return int
172 instead of void, because some old compilers have trouble with
173 pointers to functions returning void. */
175 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
176 #define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
180 #define D(n, tag, o, f) tag,
188 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
189 #define D(name, t, origin, flags) \
190 { CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
191 sizeof STRINGX(name) - 1, origin, flags },
192 static const directive dtable
[] =
197 #undef DIRECTIVE_TABLE
199 #define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
201 /* Skip any remaining tokens in a directive. */
203 skip_rest_of_line (pfile
)
206 /* Discard all stacked contexts. */
207 while (pfile
->context
!= &pfile
->base_context
)
208 _cpp_pop_context (pfile
);
210 /* Sweep up all tokens remaining on the line. */
212 while (_cpp_lex_token (pfile
)->type
!= CPP_EOF
)
216 /* Ensure there are no stray tokens at the end of a directive. */
221 if (! SEEN_EOL () && _cpp_lex_token (pfile
)->type
!= CPP_EOF
)
222 cpp_pedwarn (pfile
, "extra tokens at end of #%s directive",
223 pfile
->directive
->name
);
226 /* Called when entering a directive, _Pragma or command-line directive. */
228 start_directive (pfile
)
231 /* Setup in-directive state. */
232 pfile
->state
.in_directive
= 1;
233 pfile
->state
.save_comments
= 0;
235 /* Some handlers need the position of the # for diagnostics. */
236 pfile
->directive_line
= pfile
->line
;
239 /* Called when leaving a directive, _Pragma or command-line directive. */
241 end_directive (pfile
, skip_line
)
245 /* We don't skip for an assembler #. */
248 skip_rest_of_line (pfile
);
249 if (!pfile
->keep_tokens
)
251 pfile
->cur_run
= &pfile
->base_run
;
252 pfile
->cur_token
= pfile
->base_run
.base
;
257 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
258 pfile
->state
.in_directive
= 0;
259 pfile
->state
.angled_headers
= 0;
260 pfile
->state
.line_extension
= 0;
261 pfile
->directive
= 0;
264 /* Output diagnostics for a directive DIR. INDENTED is non-zero if
265 the '#' was indented. */
268 directive_diagnostics (pfile
, dir
, indented
)
270 const directive
*dir
;
273 if (pfile
->state
.line_extension
)
275 if (CPP_PEDANTIC (pfile
)
276 && ! pfile
->state
.skipping
)
277 cpp_pedwarn (pfile
, "style of line directive is a GCC extension");
281 /* Issue -pedantic warnings for extensions. */
282 if (CPP_PEDANTIC (pfile
)
283 && ! pfile
->state
.skipping
284 && dir
->origin
== EXTENSION
)
285 cpp_pedwarn (pfile
, "#%s is a GCC extension", dir
->name
);
287 /* Traditionally, a directive is ignored unless its # is in
288 column 1. Therefore in code intended to work with K+R
289 compilers, directives added by C89 must have their #
290 indented, and directives present in traditional C must not.
291 This is true even of directives in skipped conditional
293 if (CPP_WTRADITIONAL (pfile
))
295 if (dir
== &dtable
[T_ELIF
])
296 cpp_warning (pfile
, "suggest not using #elif in traditional C");
297 else if (indented
&& dir
->origin
== KANDR
)
299 "traditional C ignores #%s with the # indented",
301 else if (!indented
&& dir
->origin
!= KANDR
)
303 "suggest hiding #%s from traditional C with an indented #",
309 /* Check if we have a known directive. INDENTED is non-zero if the
310 '#' of the directive was indented. This function is in this file
311 to save unnecessarily exporting dtable etc. to cpplex.c. Returns
312 non-zero if the line of tokens has been handled, zero if we should
313 continue processing the line. */
316 _cpp_handle_directive (pfile
, indented
)
320 const directive
*dir
= 0;
321 const cpp_token
*dname
;
324 start_directive (pfile
);
325 dname
= _cpp_lex_token (pfile
);
327 if (dname
->type
== CPP_NAME
)
329 if (dname
->val
.node
->directive_index
)
330 dir
= &dtable
[dname
->val
.node
->directive_index
- 1];
332 /* We do not recognise the # followed by a number extension in
334 else if (dname
->type
== CPP_NUMBER
&& CPP_OPTION (pfile
, lang
) != CLK_ASM
)
336 dir
= &dtable
[T_LINE
];
337 pfile
->state
.line_extension
= 1;
342 /* If we have a directive that is not an opening conditional,
343 invalidate any control macro. */
344 if (! (dir
->flags
& IF_COND
))
345 pfile
->mi_valid
= false;
347 /* Kluge alert. In order to be sure that code like this
352 does not cause '#define foo bar' to get executed when
353 compiled with -save-temps, we recognize directives in
354 -fpreprocessed mode only if the # is in column 1. cppmacro.c
355 puts a space in fron of any '#' at the start of a macro. */
356 if (CPP_OPTION (pfile
, preprocessed
)
357 && (indented
|| !(dir
->flags
& IN_I
)))
364 /* In failed conditional groups, all non-conditional
365 directives are ignored. Before doing that, whether
366 skipping or not, we should lex angle-bracketed headers
367 correctly, and maybe output some diagnostics. */
368 pfile
->state
.angled_headers
= dir
->flags
& INCL
;
369 if (! CPP_OPTION (pfile
, preprocessed
))
370 directive_diagnostics (pfile
, dir
, indented
);
371 if (pfile
->state
.skipping
&& !(dir
->flags
& COND
))
375 else if (dname
->type
== CPP_EOF
)
376 ; /* CPP_EOF is the "null directive". */
379 /* An unknown directive. Don't complain about it in assembly
380 source: we don't know where the comments are, and # may
381 introduce assembler pseudo-ops. Don't complain about invalid
382 directives in skipped conditional groups (6.10 p4). */
383 if (CPP_OPTION (pfile
, lang
) == CLK_ASM
)
385 else if (!pfile
->state
.skipping
)
386 cpp_error (pfile
, "invalid preprocessing directive #%s",
387 cpp_token_as_text (pfile
, dname
));
392 pfile
->directive
= dir
;
393 (*pfile
->directive
->handler
) (pfile
);
396 _cpp_backup_tokens (pfile
, 1);
398 end_directive (pfile
, skip
);
402 /* Directive handler wrapper used by the command line option
405 run_directive (pfile
, dir_no
, buf
, count
)
411 cpp_push_buffer (pfile
, (const U_CHAR
*) buf
, count
,
412 /* from_stage3 */ true, 1);
413 start_directive (pfile
);
414 /* We don't want a leading # to be interpreted as a directive. */
415 pfile
->buffer
->saved_flags
= 0;
416 pfile
->directive
= &dtable
[dir_no
];
417 (void) (*pfile
->directive
->handler
) (pfile
);
418 end_directive (pfile
, 1);
419 _cpp_pop_buffer (pfile
);
422 /* Checks for validity the macro name in #define, #undef, #ifdef and
423 #ifndef directives. */
424 static cpp_hashnode
*
425 lex_macro_node (pfile
)
429 const cpp_token
*token
= _cpp_lex_token (pfile
);
431 /* The token immediately after #define must be an identifier. That
432 identifier may not be "defined", per C99 6.10.8p4.
433 In C++, it may not be any of the "named operators" either,
434 per C++98 [lex.digraph], [lex.key].
435 Finally, the identifier may not have been poisoned. (In that case
436 the lexer has issued the error message for us.) */
438 if (token
->type
!= CPP_NAME
)
440 if (token
->type
== CPP_EOF
)
441 cpp_error (pfile
, "no macro name given in #%s directive",
442 pfile
->directive
->name
);
443 else if (token
->flags
& NAMED_OP
)
445 "\"%s\" cannot be used as a macro name as it is an operator in C++",
446 NODE_NAME (token
->val
.node
));
448 cpp_error (pfile
, "macro names must be identifiers");
453 node
= token
->val
.node
;
454 if (node
->flags
& NODE_POISONED
)
457 if (node
== pfile
->spec_nodes
.n_defined
)
459 cpp_error (pfile
, "\"%s\" cannot be used as a macro name",
467 /* Process a #define directive. Most work is done in cppmacro.c. */
472 cpp_hashnode
*node
= lex_macro_node (pfile
);
476 if (_cpp_create_definition (pfile
, node
))
477 if (pfile
->cb
.define
)
478 (*pfile
->cb
.define
) (pfile
, pfile
->directive_line
, node
);
482 /* Handle #undef. Marks the identifier NT_VOID in the hash table. */
487 cpp_hashnode
*node
= lex_macro_node (pfile
);
489 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
490 is not currently defined as a macro name. */
491 if (node
&& node
->type
== NT_MACRO
)
494 (*pfile
->cb
.undef
) (pfile
, pfile
->directive_line
, node
);
496 if (node
->flags
& NODE_WARN
)
497 cpp_warning (pfile
, "undefining \"%s\"", NODE_NAME (node
));
499 _cpp_free_definition (node
);
504 /* Helper routine used by parse_include. Reinterpret the current line
505 as an h-char-sequence (< ... >); we are looking at the first token
506 after the <. Returns the header as a token, or NULL on failure. */
507 static const cpp_token
*
508 glue_header_name (pfile
)
511 cpp_token
*header
= NULL
;
512 const cpp_token
*token
;
516 /* To avoid lexed tokens overwriting our glued name, we can only
517 allocate from the string pool once we've lexed everything. */
519 dest
= BUFF_FRONT (pfile
->u_buff
);
522 token
= cpp_get_token (pfile
);
524 if (token
->type
== CPP_GREATER
|| token
->type
== CPP_EOF
)
527 /* + 1 for terminating NUL. */
528 len
= cpp_token_len (token
) + 1;
529 if ((size_t) (BUFF_LIMIT (pfile
->u_buff
) - dest
) < len
)
531 size_t len_so_far
= dest
- BUFF_FRONT (pfile
->u_buff
);
532 _cpp_extend_buff (pfile
, &pfile
->u_buff
, len
);
533 dest
= BUFF_FRONT (pfile
->u_buff
) + len_so_far
;
536 if (token
->flags
& PREV_WHITE
)
539 dest
= cpp_spell_token (pfile
, token
, dest
);
542 if (token
->type
== CPP_EOF
)
543 cpp_error (pfile
, "missing terminating > character");
546 header
= _cpp_temp_token (pfile
);
547 header
->type
= CPP_HEADER_NAME
;
549 header
->val
.str
.len
= dest
- BUFF_FRONT (pfile
->u_buff
);
550 header
->val
.str
.text
= BUFF_FRONT (pfile
->u_buff
);
552 BUFF_FRONT (pfile
->u_buff
) = dest
;
558 /* Returns the header string of #include, #include_next, #import and
559 #pragma dependency. Returns NULL on error. */
560 static const cpp_token
*
561 parse_include (pfile
)
564 const unsigned char *dir
;
565 const cpp_token
*header
;
567 if (pfile
->directive
== &dtable
[T_PRAGMA
])
568 dir
= U
"pragma dependency";
570 dir
= pfile
->directive
->name
;
572 /* Allow macro expansion. */
573 header
= cpp_get_token (pfile
);
574 if (header
->type
!= CPP_STRING
&& header
->type
!= CPP_HEADER_NAME
)
576 if (header
->type
!= CPP_LESS
)
578 cpp_error (pfile
, "#%s expects \"FILENAME\" or <FILENAME>", dir
);
582 header
= glue_header_name (pfile
);
587 if (header
->val
.str
.len
== 0)
589 cpp_error (pfile
, "empty file name in #%s", dir
);
596 /* Handle #include, #include_next and #import. */
598 do_include_common (pfile
, type
)
600 enum include_type type
;
602 const cpp_token
*header
;
604 /* For #include_next, if this is the primary source file, warn and
605 use the normal search logic. */
606 if (type
== IT_INCLUDE_NEXT
&& ! pfile
->buffer
->prev
)
608 cpp_warning (pfile
, "#include_next in primary source file");
611 else if (type
== IT_IMPORT
&& CPP_OPTION (pfile
, warn_import
))
613 CPP_OPTION (pfile
, warn_import
) = 0;
615 "#import is obsolete, use an #ifndef wrapper in the header file");
618 header
= parse_include (pfile
);
621 /* Prevent #include recursion. */
622 if (pfile
->line_maps
.depth
>= CPP_STACK_MAX
)
623 cpp_fatal (pfile
, "#include nested too deeply");
627 /* Get out of macro context, if we are. */
628 skip_rest_of_line (pfile
);
629 if (pfile
->cb
.include
)
630 (*pfile
->cb
.include
) (pfile
, pfile
->directive_line
,
631 pfile
->directive
->name
, header
);
633 _cpp_execute_include (pfile
, header
, type
);
642 do_include_common (pfile
, IT_INCLUDE
);
649 do_include_common (pfile
, IT_IMPORT
);
653 do_include_next (pfile
)
656 do_include_common (pfile
, IT_INCLUDE_NEXT
);
659 /* Subroutine of do_line. Read possible flags after file name. LAST
660 is the last flag seen; 0 if this is the first flag. Return the flag
661 if it is valid, 0 at the end of the directive. Otherwise complain. */
664 read_flag (pfile
, last
)
668 const cpp_token
*token
= _cpp_lex_token (pfile
);
670 if (token
->type
== CPP_NUMBER
&& token
->val
.str
.len
== 1)
672 unsigned int flag
= token
->val
.str
.text
[0] - '0';
674 if (flag
> last
&& flag
<= 4
675 && (flag
!= 4 || last
== 3)
676 && (flag
!= 2 || last
== 0))
680 if (token
->type
!= CPP_EOF
)
681 cpp_error (pfile
, "invalid flag \"%s\" in line directive",
682 cpp_token_as_text (pfile
, token
));
686 /* Another subroutine of do_line. Convert a number in STR, of length
687 LEN, to binary; store it in NUMP, and return 0 if the number was
688 well-formed, 1 if not. Temporary, hopefully. */
690 strtoul_for_line (str
, len
, nump
)
695 unsigned long reg
= 0;
709 /* Interpret #line command.
710 Note that the filename string (if any) is treated as if it were an
711 include filename. That means no escape handling. */
717 const cpp_token
*token
;
718 const char *new_file
= pfile
->map
->to_file
;
719 unsigned long new_lineno
;
720 unsigned int cap
, new_sysp
= pfile
->map
->sysp
;
721 enum lc_reason reason
= LC_RENAME
;
723 /* C99 raised the minimum limit on #line numbers. */
724 cap
= CPP_OPTION (pfile
, c99
) ? 2147483647 : 32767;
726 /* Putting this in _cpp_handle_directive risks two calls to
727 _cpp_backup_tokens in some circumstances, which can segfault. */
728 if (pfile
->state
.line_extension
)
729 _cpp_backup_tokens (pfile
, 1);
731 /* #line commands expand macros. */
732 token
= cpp_get_token (pfile
);
733 if (token
->type
!= CPP_NUMBER
734 || strtoul_for_line (token
->val
.str
.text
, token
->val
.str
.len
,
737 cpp_error (pfile
, "\"%s\" after #line is not a positive integer",
738 cpp_token_as_text (pfile
, token
));
742 if (CPP_PEDANTIC (pfile
) && ! pfile
->state
.line_extension
743 && (new_lineno
== 0 || new_lineno
> cap
))
744 cpp_pedwarn (pfile
, "line number out of range");
746 token
= cpp_get_token (pfile
);
747 if (token
->type
== CPP_STRING
)
749 new_file
= (const char *) token
->val
.str
.text
;
751 /* Only accept flags for the # 55 form. */
752 if (pfile
->state
.line_extension
)
757 flag
= read_flag (pfile
, 0);
761 /* Fake an include for cpp_included (). */
762 _cpp_fake_include (pfile
, new_file
);
763 flag
= read_flag (pfile
, flag
);
768 flag
= read_flag (pfile
, flag
);
773 flag
= read_flag (pfile
, flag
);
780 else if (token
->type
!= CPP_EOF
)
782 cpp_error (pfile
, "\"%s\" is not a valid filename",
783 cpp_token_as_text (pfile
, token
));
787 skip_rest_of_line (pfile
);
788 _cpp_do_file_change (pfile
, reason
, new_file
, new_lineno
, new_sysp
);
791 /* Arrange the file_change callback. pfile->line has changed to
792 FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system
793 header, 2 for a sytem header that needs to be extern "C" protected,
794 and zero otherwise. */
796 _cpp_do_file_change (pfile
, reason
, to_file
, file_line
, sysp
)
798 enum lc_reason reason
;
800 unsigned int file_line
;
803 pfile
->map
= add_line_map (&pfile
->line_maps
, reason
, sysp
,
804 pfile
->line
, to_file
, file_line
);
806 if (pfile
->cb
.file_change
)
807 (*pfile
->cb
.file_change
) (pfile
, pfile
->map
);
811 * Report a warning or error detected by the program we are
812 * processing. Use the directive's tokens in the error message.
816 do_diagnostic (pfile
, code
, print_dir
)
818 enum error_type code
;
821 if (_cpp_begin_message (pfile
, code
, 0, 0))
824 fprintf (stderr
, "#%s ", pfile
->directive
->name
);
825 pfile
->state
.prevent_expansion
++;
826 cpp_output_line (pfile
, stderr
);
827 pfile
->state
.prevent_expansion
--;
835 do_diagnostic (pfile
, ERROR
, 1);
842 /* We want #warning diagnostics to be emitted in system headers too. */
843 do_diagnostic (pfile
, WARNING_SYSHDR
, 1);
846 /* Report program identification. */
852 const cpp_token
*str
= cpp_get_token (pfile
);
854 if (str
->type
!= CPP_STRING
)
855 cpp_error (pfile
, "invalid #ident directive");
856 else if (pfile
->cb
.ident
)
857 (*pfile
->cb
.ident
) (pfile
, pfile
->directive_line
, &str
->val
.str
);
862 /* Lookup a PRAGMA name in a singly-linked CHAIN. Returns the
863 matching entry, or NULL if none is found. The returned entry could
864 be the start of a namespace chain, or a pragma. */
865 static struct pragma_entry
*
866 lookup_pragma_entry (chain
, pragma
)
867 struct pragma_entry
*chain
;
868 const cpp_hashnode
*pragma
;
870 while (chain
&& chain
->pragma
!= pragma
)
876 /* Create and insert a pragma entry for NAME at the beginning of a
877 singly-linked CHAIN. If handler is NULL, it is a namespace,
878 otherwise it is a pragma and its handler. */
879 static struct pragma_entry
*
880 insert_pragma_entry (pfile
, chain
, pragma
, handler
)
882 struct pragma_entry
**chain
;
883 const cpp_hashnode
*pragma
;
886 struct pragma_entry
*new;
888 new = (struct pragma_entry
*)
889 _cpp_aligned_alloc (pfile
, sizeof (struct pragma_entry
));
890 new->pragma
= pragma
;
894 new->u
.handler
= handler
;
907 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
908 goes in the global namespace. HANDLER is the handler it will call,
909 which must be non-NULL. */
911 cpp_register_pragma (pfile
, space
, name
, handler
)
917 struct pragma_entry
**chain
= &pfile
->pragmas
;
918 struct pragma_entry
*entry
;
919 const cpp_hashnode
*node
;
926 node
= cpp_lookup (pfile
, U space
, strlen (space
));
927 entry
= lookup_pragma_entry (*chain
, node
);
929 entry
= insert_pragma_entry (pfile
, chain
, node
, NULL
);
930 else if (!entry
->is_nspace
)
932 chain
= &entry
->u
.space
;
935 /* Check for duplicates. */
936 node
= cpp_lookup (pfile
, U name
, strlen (name
));
937 entry
= lookup_pragma_entry (*chain
, node
);
940 if (entry
->is_nspace
)
943 "registering \"%s\" as both a pragma and a pragma namespace",
946 cpp_ice (pfile
, "#pragma %s %s is already registered", space
, name
);
948 cpp_ice (pfile
, "#pragma %s is already registered", name
);
951 insert_pragma_entry (pfile
, chain
, node
, handler
);
954 /* Register the pragmas the preprocessor itself handles. */
956 _cpp_init_internal_pragmas (pfile
)
959 /* Pragmas in the global namespace. */
960 cpp_register_pragma (pfile
, 0, "poison", do_pragma_poison
);
961 cpp_register_pragma (pfile
, 0, "once", do_pragma_once
);
963 /* New GCC-specific pragmas should be put in the GCC namespace. */
964 cpp_register_pragma (pfile
, "GCC", "poison", do_pragma_poison
);
965 cpp_register_pragma (pfile
, "GCC", "system_header", do_pragma_system_header
);
966 cpp_register_pragma (pfile
, "GCC", "dependency", do_pragma_dependency
);
969 /* Pragmata handling. We handle some, and pass the rest on to the
970 front end. C99 defines three pragmas and says that no macro
971 expansion is to be performed on them; whether or not macro
972 expansion happens for other pragmas is implementation defined.
973 This implementation never macro-expands the text after #pragma. */
978 const struct pragma_entry
*p
= NULL
;
979 const cpp_token
*token
;
980 unsigned int count
= 1;
982 pfile
->state
.prevent_expansion
++;
984 token
= cpp_get_token (pfile
);
985 if (token
->type
== CPP_NAME
)
987 p
= lookup_pragma_entry (pfile
->pragmas
, token
->val
.node
);
988 if (p
&& p
->is_nspace
)
991 token
= cpp_get_token (pfile
);
992 if (token
->type
== CPP_NAME
)
993 p
= lookup_pragma_entry (p
->u
.space
, token
->val
.node
);
999 /* FIXME. This is an awful kludge to get the front ends to update
1000 their notion of line number for diagnostic purposes. The line
1001 number should be passed to the handler and they should do it
1002 themselves. Stand-alone CPP must ignore us, otherwise it will
1003 prefix the directive with spaces, hence the 1. Ugh. */
1004 if (pfile
->cb
.line_change
)
1005 (*pfile
->cb
.line_change
)(pfile
, token
, 1);
1008 (*p
->u
.handler
) (pfile
);
1009 else if (pfile
->cb
.def_pragma
)
1011 _cpp_backup_tokens (pfile
, count
);
1012 (*pfile
->cb
.def_pragma
) (pfile
, pfile
->directive_line
);
1015 pfile
->state
.prevent_expansion
--;
1019 do_pragma_once (pfile
)
1022 cpp_warning (pfile
, "#pragma once is obsolete");
1024 if (pfile
->buffer
->prev
== NULL
)
1025 cpp_warning (pfile
, "#pragma once in main file");
1027 _cpp_never_reread (pfile
->buffer
->inc
);
1033 do_pragma_poison (pfile
)
1036 /* Poison these symbols so that all subsequent usage produces an
1038 const cpp_token
*tok
;
1041 pfile
->state
.poisoned_ok
= 1;
1044 tok
= _cpp_lex_token (pfile
);
1045 if (tok
->type
== CPP_EOF
)
1047 if (tok
->type
!= CPP_NAME
)
1049 cpp_error (pfile
, "invalid #pragma GCC poison directive");
1054 if (hp
->flags
& NODE_POISONED
)
1057 if (hp
->type
== NT_MACRO
)
1058 cpp_warning (pfile
, "poisoning existing macro \"%s\"", NODE_NAME (hp
));
1059 _cpp_free_definition (hp
);
1060 hp
->flags
|= NODE_POISONED
| NODE_DIAGNOSTIC
;
1062 pfile
->state
.poisoned_ok
= 0;
1065 /* Mark the current header as a system header. This will suppress
1066 some categories of warnings (notably those from -pedantic). It is
1067 intended for use in system libraries that cannot be implemented in
1068 conforming C, but cannot be certain that their headers appear in a
1069 system include directory. To prevent abuse, it is rejected in the
1070 primary source file. */
1072 do_pragma_system_header (pfile
)
1075 cpp_buffer
*buffer
= pfile
->buffer
;
1077 if (buffer
->prev
== 0)
1078 cpp_warning (pfile
, "#pragma system_header ignored outside include file");
1082 skip_rest_of_line (pfile
);
1083 cpp_make_system_header (pfile
, 1, 0);
1087 /* Check the modified date of the current include file against a specified
1088 file. Issue a diagnostic, if the specified file is newer. We use this to
1089 determine if a fixed header should be refixed. */
1091 do_pragma_dependency (pfile
)
1094 const cpp_token
*header
;
1097 header
= parse_include (pfile
);
1101 ordering
= _cpp_compare_file_date (pfile
, header
);
1103 cpp_warning (pfile
, "cannot find source %s",
1104 cpp_token_as_text (pfile
, header
));
1105 else if (ordering
> 0)
1107 cpp_warning (pfile
, "current file is older than %s",
1108 cpp_token_as_text (pfile
, header
));
1109 if (cpp_get_token (pfile
)->type
!= CPP_EOF
)
1111 _cpp_backup_tokens (pfile
, 1);
1112 do_diagnostic (pfile
, WARNING
, 0);
1117 /* Get a token but skip padding. */
1118 static const cpp_token
*
1119 get_token_no_padding (pfile
)
1124 const cpp_token
*result
= cpp_get_token (pfile
);
1125 if (result
->type
!= CPP_PADDING
)
1130 /* Check syntax is "(string-literal)". Returns the string on success,
1131 or NULL on failure. */
1132 static const cpp_token
*
1133 get__Pragma_string (pfile
)
1136 const cpp_token
*string
;
1138 if (get_token_no_padding (pfile
)->type
!= CPP_OPEN_PAREN
)
1141 string
= get_token_no_padding (pfile
);
1142 if (string
->type
!= CPP_STRING
&& string
->type
!= CPP_WSTRING
)
1145 if (get_token_no_padding (pfile
)->type
!= CPP_CLOSE_PAREN
)
1151 /* Destringize IN into a temporary buffer, by removing the first \ of
1152 \" and \\ sequences, and process the result as a #pragma directive. */
1154 destringize_and_run (pfile
, in
)
1156 const cpp_string
*in
;
1158 const unsigned char *src
, *limit
;
1159 char *dest
, *result
;
1161 dest
= result
= alloca (in
->len
);
1162 for (src
= in
->text
, limit
= src
+ in
->len
; src
< limit
;)
1164 /* We know there is a character following the backslash. */
1165 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1170 run_directive (pfile
, T_PRAGMA
, result
, dest
- result
);
1173 /* Handle the _Pragma operator. */
1175 _cpp_do__Pragma (pfile
)
1178 const cpp_token
*string
= get__Pragma_string (pfile
);
1181 cpp_error (pfile
, "_Pragma takes a parenthesized string literal");
1184 /* Ideally, we'd like
1185 token1 _Pragma ("foo") token2
1192 Getting these correct line markers is a little tricky. */
1194 unsigned int orig_line
= pfile
->line
;
1195 destringize_and_run (pfile
, &string
->val
.str
);
1196 pfile
->line
= orig_line
;
1197 pfile
->buffer
->saved_flags
= BOL
;
1201 /* Just ignore #sccs, on systems where we define it at all. */
1202 #ifdef SCCS_DIRECTIVE
1205 cpp_reader
*pfile ATTRIBUTE_UNUSED
;
1216 if (! pfile
->state
.skipping
)
1218 const cpp_hashnode
*node
= lex_macro_node (pfile
);
1221 skip
= node
->type
!= NT_MACRO
;
1227 push_conditional (pfile
, skip
, T_IFDEF
, 0);
1235 const cpp_hashnode
*node
= 0;
1237 if (! pfile
->state
.skipping
)
1239 node
= lex_macro_node (pfile
);
1241 skip
= node
->type
== NT_MACRO
;
1247 push_conditional (pfile
, skip
, T_IFNDEF
, node
);
1250 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1251 pfile->mi_ind_cmacro so we can handle multiple-include
1252 optimisations. If macro expansion occurs in the expression, we
1253 cannot treat it as a controlling conditional, since the expansion
1254 could change in the future. That is handled by cpp_get_token. */
1262 if (! pfile
->state
.skipping
)
1263 skip
= _cpp_parse_expr (pfile
) == 0;
1265 push_conditional (pfile
, skip
, T_IF
, pfile
->mi_ind_cmacro
);
1268 /* Flip skipping state if appropriate and continue without changing
1269 if_stack; this is so that the error message for missing #endif's
1270 etc. will point to the original #if. */
1276 cpp_buffer
*buffer
= pfile
->buffer
;
1277 struct if_stack
*ifs
= buffer
->if_stack
;
1280 cpp_error (pfile
, "#else without #if");
1283 if (ifs
->type
== T_ELSE
)
1285 cpp_error (pfile
, "#else after #else");
1286 cpp_error_with_line (pfile
, ifs
->line
, 0,
1287 "the conditional began here");
1291 /* Skip any future (erroneous) #elses or #elifs. */
1292 pfile
->state
.skipping
= ifs
->skip_elses
;
1293 ifs
->skip_elses
= true;
1295 /* Invalidate any controlling macro. */
1298 /* Only check EOL if was not originally skipping. */
1299 if (!ifs
->was_skipping
)
1304 /* handle a #elif directive by not changing if_stack either. see the
1305 comment above do_else. */
1311 cpp_buffer
*buffer
= pfile
->buffer
;
1312 struct if_stack
*ifs
= buffer
->if_stack
;
1315 cpp_error (pfile
, "#elif without #if");
1318 if (ifs
->type
== T_ELSE
)
1320 cpp_error (pfile
, "#elif after #else");
1321 cpp_error_with_line (pfile
, ifs
->line
, 0,
1322 "the conditional began here");
1326 /* Only evaluate this if we aren't skipping elses. During
1327 evaluation, set skipping to false to get lexer warnings. */
1328 if (ifs
->skip_elses
)
1329 pfile
->state
.skipping
= 1;
1332 pfile
->state
.skipping
= 0;
1333 pfile
->state
.skipping
= ! _cpp_parse_expr (pfile
);
1334 ifs
->skip_elses
= ! pfile
->state
.skipping
;
1337 /* Invalidate any controlling macro. */
1342 /* #endif pops the if stack and resets pfile->state.skipping. */
1348 cpp_buffer
*buffer
= pfile
->buffer
;
1349 struct if_stack
*ifs
= buffer
->if_stack
;
1352 cpp_error (pfile
, "#endif without #if");
1355 /* Only check EOL if was not originally skipping. */
1356 if (!ifs
->was_skipping
)
1359 /* If potential control macro, we go back outside again. */
1360 if (ifs
->next
== 0 && ifs
->mi_cmacro
)
1362 pfile
->mi_valid
= true;
1363 pfile
->mi_cmacro
= ifs
->mi_cmacro
;
1366 buffer
->if_stack
= ifs
->next
;
1367 pfile
->state
.skipping
= ifs
->was_skipping
;
1368 obstack_free (&pfile
->buffer_ob
, ifs
);
1372 /* Push an if_stack entry and set pfile->state.skipping accordingly.
1373 If this is a #if or #ifndef, CMACRO is a potentially controlling
1374 macro - we need to check here that we are at the top of the file. */
1377 push_conditional (pfile
, skip
, type
, cmacro
)
1381 const cpp_hashnode
*cmacro
;
1383 struct if_stack
*ifs
;
1384 cpp_buffer
*buffer
= pfile
->buffer
;
1386 ifs
= xobnew (&pfile
->buffer_ob
, struct if_stack
);
1387 ifs
->line
= pfile
->directive_line
;
1388 ifs
->next
= buffer
->if_stack
;
1389 ifs
->skip_elses
= pfile
->state
.skipping
|| !skip
;
1390 ifs
->was_skipping
= pfile
->state
.skipping
;
1392 /* This condition is effectively a test for top-of-file. */
1393 if (pfile
->mi_valid
&& pfile
->mi_cmacro
== 0)
1394 ifs
->mi_cmacro
= cmacro
;
1398 pfile
->state
.skipping
= skip
;
1399 buffer
->if_stack
= ifs
;
1402 /* Read the tokens of the answer into the macro pool. Only commit the
1403 memory if we intend it as permanent storage, i.e. the #assert case.
1404 Returns 0 on success. */
1407 parse_answer (pfile
, answerp
, type
)
1409 struct answer
**answerp
;
1412 const cpp_token
*paren
;
1413 struct answer
*answer
;
1414 unsigned int acount
;
1416 /* In a conditional, it is legal to not have an open paren. We
1417 should save the following token in this case. */
1418 paren
= cpp_get_token (pfile
);
1420 /* If not a paren, see if we're OK. */
1421 if (paren
->type
!= CPP_OPEN_PAREN
)
1423 /* In a conditional no answer is a test for any answer. It
1424 could be followed by any token. */
1427 _cpp_backup_tokens (pfile
, 1);
1431 /* #unassert with no answer is valid - it removes all answers. */
1432 if (type
== T_UNASSERT
&& paren
->type
== CPP_EOF
)
1435 cpp_error (pfile
, "missing '(' after predicate");
1439 for (acount
= 0;; acount
++)
1442 const cpp_token
*token
= cpp_get_token (pfile
);
1445 if (token
->type
== CPP_CLOSE_PAREN
)
1448 if (token
->type
== CPP_EOF
)
1450 cpp_error (pfile
, "missing ')' to complete answer");
1454 /* struct answer includes the space for one token. */
1455 room_needed
= (sizeof (struct answer
) + acount
* sizeof (cpp_token
));
1457 if (BUFF_ROOM (pfile
->a_buff
) < room_needed
)
1458 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (struct answer
));
1460 dest
= &((struct answer
*) BUFF_FRONT (pfile
->a_buff
))->first
[acount
];
1463 /* Drop whitespace at start, for answer equivalence purposes. */
1465 dest
->flags
&= ~PREV_WHITE
;
1470 cpp_error (pfile
, "predicate's answer is empty");
1474 answer
= (struct answer
*) BUFF_FRONT (pfile
->a_buff
);
1475 answer
->count
= acount
;
1476 answer
->next
= NULL
;
1482 /* Parses an assertion, returning a pointer to the hash node of the
1483 predicate, or 0 on error. If an answer was supplied, it is placed
1484 in ANSWERP, otherwise it is set to 0. */
1485 static cpp_hashnode
*
1486 parse_assertion (pfile
, answerp
, type
)
1488 struct answer
**answerp
;
1491 cpp_hashnode
*result
= 0;
1492 const cpp_token
*predicate
;
1494 /* We don't expand predicates or answers. */
1495 pfile
->state
.prevent_expansion
++;
1498 predicate
= cpp_get_token (pfile
);
1499 if (predicate
->type
== CPP_EOF
)
1500 cpp_error (pfile
, "assertion without predicate");
1501 else if (predicate
->type
!= CPP_NAME
)
1502 cpp_error (pfile
, "predicate must be an identifier");
1503 else if (parse_answer (pfile
, answerp
, type
) == 0)
1505 unsigned int len
= NODE_LEN (predicate
->val
.node
);
1506 unsigned char *sym
= alloca (len
+ 1);
1508 /* Prefix '#' to get it out of macro namespace. */
1510 memcpy (sym
+ 1, NODE_NAME (predicate
->val
.node
), len
);
1511 result
= cpp_lookup (pfile
, sym
, len
+ 1);
1514 pfile
->state
.prevent_expansion
--;
1518 /* Returns a pointer to the pointer to the answer in the answer chain,
1519 or a pointer to NULL if the answer is not in the chain. */
1520 static struct answer
**
1521 find_answer (node
, candidate
)
1523 const struct answer
*candidate
;
1526 struct answer
**result
;
1528 for (result
= &node
->value
.answers
; *result
; result
= &(*result
)->next
)
1530 struct answer
*answer
= *result
;
1532 if (answer
->count
== candidate
->count
)
1534 for (i
= 0; i
< answer
->count
; i
++)
1535 if (! _cpp_equiv_tokens (&answer
->first
[i
], &candidate
->first
[i
]))
1538 if (i
== answer
->count
)
1546 /* Test an assertion within a preprocessor conditional. Returns
1547 non-zero on failure, zero on success. On success, the result of
1548 the test is written into VALUE. */
1550 _cpp_test_assertion (pfile
, value
)
1554 struct answer
*answer
;
1557 node
= parse_assertion (pfile
, &answer
, T_IF
);
1559 *value
= (node
->type
== NT_ASSERTION
&&
1560 (answer
== 0 || *find_answer (node
, answer
) != 0));
1562 /* We don't commit the memory for the answer - it's temporary only. */
1570 struct answer
*new_answer
;
1573 node
= parse_assertion (pfile
, &new_answer
, T_ASSERT
);
1576 /* Place the new answer in the answer list. First check there
1577 is not a duplicate. */
1578 new_answer
->next
= 0;
1579 if (node
->type
== NT_ASSERTION
)
1581 if (*find_answer (node
, new_answer
))
1583 cpp_warning (pfile
, "\"%s\" re-asserted", NODE_NAME (node
) + 1);
1586 new_answer
->next
= node
->value
.answers
;
1589 node
->type
= NT_ASSERTION
;
1590 node
->value
.answers
= new_answer
;
1591 BUFF_FRONT (pfile
->a_buff
) += (sizeof (struct answer
)
1592 + (new_answer
->count
- 1)
1593 * sizeof (cpp_token
));
1603 struct answer
*answer
;
1605 node
= parse_assertion (pfile
, &answer
, T_UNASSERT
);
1606 /* It isn't an error to #unassert something that isn't asserted. */
1607 if (node
&& node
->type
== NT_ASSERTION
)
1611 struct answer
**p
= find_answer (node
, answer
), *temp
;
1613 /* Remove the answer from the list. */
1618 /* Did we free the last answer? */
1619 if (node
->value
.answers
== 0)
1620 node
->type
= NT_VOID
;
1625 _cpp_free_definition (node
);
1628 /* We don't commit the memory for the answer - it's temporary only. */
1631 /* These are for -D, -U, -A. */
1633 /* Process the string STR as if it appeared as the body of a #define.
1634 If STR is just an identifier, define it with value 1.
1635 If STR has anything after the identifier, then it should
1636 be identifier=definition. */
1639 cpp_define (pfile
, str
)
1646 /* Copy the entire option so we can modify it.
1647 Change the first "=" in the string to a space. If there is none,
1648 tack " 1" on the end. */
1650 /* Length including the null. */
1651 count
= strlen (str
);
1652 buf
= (char *) alloca (count
+ 2);
1653 memcpy (buf
, str
, count
);
1655 p
= strchr (str
, '=');
1664 run_directive (pfile
, T_DEFINE
, buf
, count
);
1667 /* Slight variant of the above for use by initialize_builtins. */
1669 _cpp_define_builtin (pfile
, str
)
1673 run_directive (pfile
, T_DEFINE
, str
, strlen (str
));
1676 /* Process MACRO as if it appeared as the body of an #undef. */
1678 cpp_undef (pfile
, macro
)
1682 run_directive (pfile
, T_UNDEF
, macro
, strlen (macro
));
1685 /* Process the string STR as if it appeared as the body of a #assert. */
1687 cpp_assert (pfile
, str
)
1691 handle_assertion (pfile
, str
, T_ASSERT
);
1694 /* Process STR as if it appeared as the body of an #unassert. */
1696 cpp_unassert (pfile
, str
)
1700 handle_assertion (pfile
, str
, T_UNASSERT
);
1703 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1705 handle_assertion (pfile
, str
, type
)
1710 size_t count
= strlen (str
);
1711 const char *p
= strchr (str
, '=');
1715 /* Copy the entire option so we can modify it. Change the first
1716 "=" in the string to a '(', and tack a ')' on the end. */
1717 char *buf
= (char *) alloca (count
+ 1);
1719 memcpy (buf
, str
, count
);
1725 run_directive (pfile
, type
, str
, count
);
1728 /* The number of errors for a given reader. */
1733 return pfile
->errors
;
1736 /* The options structure. */
1738 cpp_get_options (pfile
)
1741 return &pfile
->opts
;
1744 /* The callbacks structure. */
1746 cpp_get_callbacks (pfile
)
1752 /* The line map set. */
1753 const struct line_maps
*
1754 cpp_get_line_maps (pfile
)
1757 return &pfile
->line_maps
;
1760 /* Copy the given callbacks structure to our own. */
1762 cpp_set_callbacks (pfile
, cb
)
1769 /* Push a new buffer on the buffer stack. Returns the new buffer; it
1770 doesn't fail. It does not generate a file change call back; that
1771 is the responsibility of the caller. */
1773 cpp_push_buffer (pfile
, buffer
, len
, from_stage3
, return_at_eof
)
1775 const U_CHAR
*buffer
;
1780 cpp_buffer
*new = xobnew (&pfile
->buffer_ob
, cpp_buffer
);
1782 /* Clears, amongst other things, if_stack and mi_cmacro. */
1783 memset (new, 0, sizeof (cpp_buffer
));
1785 new->line_base
= new->buf
= new->cur
= buffer
;
1786 new->rlimit
= buffer
+ len
;
1787 new->from_stage3
= from_stage3
;
1788 new->prev
= pfile
->buffer
;
1789 new->return_at_eof
= return_at_eof
;
1790 new->saved_flags
= BOL
;
1792 pfile
->buffer
= new;
1797 /* If called from do_line, pops a single buffer. Otherwise pops all
1798 buffers until a real file is reached. Generates appropriate
1801 _cpp_pop_buffer (pfile
)
1804 cpp_buffer
*buffer
= pfile
->buffer
;
1805 struct if_stack
*ifs
;
1807 /* Walk back up the conditional stack till we reach its level at
1808 entry to this file, issuing error messages. */
1809 for (ifs
= buffer
->if_stack
; ifs
; ifs
= ifs
->next
)
1810 cpp_error_with_line (pfile
, ifs
->line
, 0,
1811 "unterminated #%s", dtable
[ifs
->type
].name
);
1813 /* In case of a missing #endif. */
1814 pfile
->state
.skipping
= 0;
1816 /* Update the reader's buffer before _cpp_do_file_change. */
1817 pfile
->buffer
= buffer
->prev
;
1820 _cpp_pop_file_buffer (pfile
, buffer
->inc
);
1822 obstack_free (&pfile
->buffer_ob
, buffer
);
1826 _cpp_init_directives (pfile
)
1832 /* Register the directives. */
1833 for (i
= 0; i
< (unsigned int) N_DIRECTIVES
; i
++)
1835 node
= cpp_lookup (pfile
, dtable
[i
].name
, dtable
[i
].length
);
1836 node
->directive_index
= i
+ 1;