1 /* CPP Library. (Directive handling.)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 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. */
31 /* Chained list of answers to an assertion. */
39 /* Stack of conditionals currently in progress
40 (including both successful and failing conditionals). */
44 struct if_stack
*next
;
45 cpp_lexer_pos pos
; /* line and column where condition started */
46 const cpp_hashnode
*mi_cmacro
;/* macro name for #ifndef around entire file */
47 unsigned char was_skipping
; /* Value of pfile->skipping before this if. */
48 int type
; /* type of last directive seen in this group */
51 /* Values for the origin field of struct directive. KANDR directives
52 come from traditional (K&R) C. STDC89 directives come from the
53 1989 C standard. EXTENSION directives are extensions. */
58 /* Values for the flags field of struct directive. COND indicates a
59 conditional; IF_COND an opening conditional. INCL means to treat
60 "..." and <...> as q-char and h-char sequences respectively. IN_I
61 means this directive should be handled even if -fpreprocessed is in
62 effect (these are the directives with callback hooks). */
64 #define IF_COND (1 << 1)
68 /* Defines one #-directive, including how to handle it. */
69 typedef void (*directive_handler
) PARAMS ((cpp_reader
*));
70 typedef struct directive directive
;
73 directive_handler handler
; /* Function to handle directive. */
74 const U_CHAR
*name
; /* Name of directive. */
75 unsigned short length
; /* Length of name. */
76 unsigned char origin
; /* Origin of directive. */
77 unsigned char flags
; /* Flags describing this directive. */
80 /* Forward declarations. */
82 static void skip_rest_of_line
PARAMS ((cpp_reader
*));
83 static void check_eol
PARAMS ((cpp_reader
*));
84 static void start_directive
PARAMS ((cpp_reader
*));
85 static void end_directive
PARAMS ((cpp_reader
*, int));
86 static void run_directive
PARAMS ((cpp_reader
*, int,
88 const char *, size_t));
89 static int glue_header_name
PARAMS ((cpp_reader
*, cpp_token
*));
90 static int parse_include
PARAMS ((cpp_reader
*, cpp_token
*));
91 static void push_conditional
PARAMS ((cpp_reader
*, int, int,
92 const cpp_hashnode
*));
93 static unsigned int read_flag
PARAMS ((cpp_reader
*, unsigned int));
94 static int strtoul_for_line
PARAMS ((const U_CHAR
*, unsigned int,
96 static void do_diagnostic
PARAMS ((cpp_reader
*, enum error_type
, int));
97 static cpp_hashnode
*lex_macro_node
PARAMS ((cpp_reader
*));
98 static void do_pragma_once
PARAMS ((cpp_reader
*));
99 static void do_pragma_poison
PARAMS ((cpp_reader
*));
100 static void do_pragma_system_header
PARAMS ((cpp_reader
*));
101 static void do_pragma_dependency
PARAMS ((cpp_reader
*));
102 static int get__Pragma_string
PARAMS ((cpp_reader
*, cpp_token
*));
103 static unsigned char *destringize
PARAMS ((const cpp_string
*,
105 static int parse_answer
PARAMS ((cpp_reader
*, struct answer
**, int));
106 static cpp_hashnode
*parse_assertion
PARAMS ((cpp_reader
*, struct answer
**,
108 static struct answer
** find_answer
PARAMS ((cpp_hashnode
*,
109 const struct answer
*));
110 static void handle_assertion
PARAMS ((cpp_reader
*, const char *, int));
111 static void do_file_change
PARAMS ((cpp_reader
*, enum cpp_fc_reason
,
112 const char *, unsigned int));
114 /* This is the table of directive handlers. It is ordered by
115 frequency of occurrence; the numbers at the end are directive
116 counts from all the source code I have lying around (egcs and libc
117 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
118 pcmcia-cs-3.0.9). This is no longer important as directive lookup
119 is now O(1). All extensions other than #warning and #include_next
120 are deprecated. The name is where the extension appears to have
123 #define DIRECTIVE_TABLE \
124 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
125 D(include, T_INCLUDE, KANDR, INCL) /* 52262 */ \
126 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
127 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
128 D(if, T_IF, KANDR, COND | IF_COND) /* 18162 */ \
129 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
130 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
131 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
132 D(line, T_LINE, KANDR, IN_I) /* 2465 */ \
133 D(elif, T_ELIF, KANDR, COND) /* 610 */ \
134 D(error, T_ERROR, STDC89, 0) /* 475 */ \
135 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
136 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
137 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL) /* 19 */ \
138 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
139 D(import, T_IMPORT, EXTENSION, INCL) /* 0 ObjC */ \
140 D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
141 D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
142 SCCS_ENTRY /* 0 SVR4? */
144 /* #sccs is not always recognized. */
145 #ifdef SCCS_DIRECTIVE
146 # define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION, 0)
148 # define SCCS_ENTRY /* nothing */
151 /* Use the table to generate a series of prototypes, an enum for the
152 directive names, and an array of directive handlers. */
154 /* The directive-processing functions are declared to return int
155 instead of void, because some old compilers have trouble with
156 pointers to functions returning void. */
158 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
159 #define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
163 #define D(n, tag, o, f) tag,
172 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
173 #define D(name, t, origin, flags) \
174 { CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
175 sizeof STRINGX(name) - 1, origin, flags },
176 static const directive dtable
[] =
181 #undef DIRECTIVE_TABLE
183 /* Skip any remaining tokens in a directive. */
185 skip_rest_of_line (pfile
)
190 /* Discard all input lookaheads. */
191 while (pfile
->la_read
)
192 _cpp_release_lookahead (pfile
);
194 /* Discard all stacked contexts. */
195 while (pfile
->context
!= &pfile
->base_context
)
196 _cpp_pop_context (pfile
);
198 /* Sweep up all tokens remaining on the line. */
199 pfile
->state
.prevent_expansion
++;
200 while (!pfile
->state
.next_bol
)
201 _cpp_lex_token (pfile
, &token
);
202 pfile
->state
.prevent_expansion
--;
205 /* Ensure there are no stray tokens at the end of a directive. */
210 if (!pfile
->state
.next_bol
)
214 _cpp_lex_token (pfile
, &token
);
215 if (token
.type
!= CPP_EOF
)
216 cpp_pedwarn (pfile
, "extra tokens at end of #%s directive",
217 pfile
->directive
->name
);
221 /* Called when entering a directive, _Pragma or command-line directive. */
223 start_directive (pfile
)
226 cpp_buffer
*buffer
= pfile
->buffer
;
228 /* Setup in-directive state. */
229 pfile
->state
.in_directive
= 1;
230 pfile
->state
.save_comments
= 0;
232 /* Some handlers need the position of the # for diagnostics. */
233 pfile
->directive_pos
= pfile
->lexer_pos
;
235 /* Don't save directive tokens for external clients. */
236 pfile
->la_saved
= pfile
->la_write
;
239 /* Turn off skipping. */
240 buffer
->was_skipping
= pfile
->skipping
;
244 /* Called when leaving a directive, _Pragma or command-line directive. */
246 end_directive (pfile
, skip_line
)
250 cpp_buffer
*buffer
= pfile
->buffer
;
252 /* Restore pfile->skipping before skip_rest_of_line, so that e.g.
253 __VA_ARGS__ in the rest of the directive doesn't warn. */
254 pfile
->skipping
= buffer
->was_skipping
;
256 /* We don't skip for an assembler #. */
258 skip_rest_of_line (pfile
);
261 pfile
->la_write
= pfile
->la_saved
;
262 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
263 pfile
->state
.in_directive
= 0;
264 pfile
->state
.angled_headers
= 0;
265 pfile
->state
.line_extension
= 0;
266 pfile
->directive
= 0;
269 /* Check if a token's name matches that of a known directive. Put in
270 this file to save exporting dtable and other unneeded information. */
272 _cpp_handle_directive (pfile
, indented
)
276 cpp_buffer
*buffer
= pfile
->buffer
;
277 const directive
*dir
= 0;
281 start_directive (pfile
);
283 /* Lex the directive name directly. */
284 _cpp_lex_token (pfile
, &dname
);
286 if (dname
.type
== CPP_NAME
)
288 unsigned int index
= dname
.val
.node
->directive_index
;
290 dir
= &dtable
[index
- 1];
292 else if (dname
.type
== CPP_NUMBER
)
294 /* # followed by a number is equivalent to #line. Do not
295 recognize this form in assembly language source files or
296 skipped conditional groups. Complain about this form if
297 we're being pedantic, but not if this is regurgitated input
298 (preprocessed or fed back in by the C++ frontend). */
299 if (! buffer
->was_skipping
&& CPP_OPTION (pfile
, lang
) != CLK_ASM
)
301 dir
= &dtable
[T_LINE
];
302 pfile
->state
.line_extension
= 1;
303 _cpp_push_token (pfile
, &dname
, &pfile
->directive_pos
);
304 if (CPP_PEDANTIC (pfile
) && ! CPP_OPTION (pfile
, preprocessed
))
305 cpp_pedwarn (pfile
, "# followed by integer");
309 pfile
->directive
= dir
;
312 /* Make sure we lex headers correctly, whether skipping or not. */
313 pfile
->state
.angled_headers
= dir
->flags
& INCL
;
315 /* If we are rescanning preprocessed input, only directives tagged
316 with IN_I are honored, and the warnings below are suppressed. */
317 if (! CPP_OPTION (pfile
, preprocessed
) || dir
->flags
& IN_I
)
319 /* Traditionally, a directive is ignored unless its # is in
320 column 1. Therefore in code intended to work with K+R
321 compilers, directives added by C89 must have their #
322 indented, and directives present in traditional C must
323 not. This is true even of directives in skipped
324 conditional blocks. */
325 if (CPP_WTRADITIONAL (pfile
))
327 if (indented
&& dir
->origin
== KANDR
)
329 "traditional C ignores #%s with the # indented",
331 else if (!indented
&& dir
->origin
!= KANDR
)
333 "suggest hiding #%s from traditional C with an indented #",
337 /* If we are skipping a failed conditional group, all
338 non-conditional directives are ignored. */
339 if (! buffer
->was_skipping
|| (dir
->flags
& COND
))
341 /* Issue -pedantic warnings for extensions. */
342 if (CPP_PEDANTIC (pfile
) && dir
->origin
== EXTENSION
)
343 cpp_pedwarn (pfile
, "#%s is a GCC extension", dir
->name
);
345 /* If we have a directive that is not an opening
346 conditional, invalidate any control macro. */
347 if (! (dir
->flags
& IF_COND
))
348 pfile
->mi_state
= MI_FAILED
;
350 (*dir
->handler
) (pfile
);
354 else if (dname
.type
!= CPP_EOF
&& ! pfile
->skipping
)
356 /* An unknown directive. Don't complain about it in assembly
357 source: we don't know where the comments are, and # may
358 introduce assembler pseudo-ops. Don't complain about invalid
359 directives in skipped conditional groups (6.10 p4). */
360 if (CPP_OPTION (pfile
, lang
) == CLK_ASM
)
362 /* Output the # and lookahead token for the assembler. */
363 _cpp_push_token (pfile
, &dname
, &pfile
->directive_pos
);
367 cpp_error (pfile
, "invalid preprocessing directive #%s",
368 cpp_token_as_text (pfile
, &dname
));
371 end_directive (pfile
, skip
);
375 /* Directive handler wrapper used by the command line option
378 run_directive (pfile
, dir_no
, type
, buf
, count
)
381 enum cpp_buffer_type type
;
385 unsigned int output_line
= pfile
->lexer_pos
.output_line
;
388 buffer
= cpp_push_buffer (pfile
, (const U_CHAR
*) buf
, count
, type
, 0);
390 if (dir_no
== T_PRAGMA
)
392 /* A kludge to avoid line markers for _Pragma. */
393 pfile
->lexer_pos
.output_line
= output_line
;
394 /* Avoid interpretation of directives in a _Pragma string. */
395 pfile
->state
.next_bol
= 0;
398 start_directive (pfile
);
399 pfile
->state
.prevent_expansion
++;
400 (void) (*dtable
[dir_no
].handler
) (pfile
);
401 pfile
->state
.prevent_expansion
--;
403 end_directive (pfile
, 1);
405 cpp_pop_buffer (pfile
);
408 /* Checks for validity the macro name in #define, #undef, #ifdef and
409 #ifndef directives. */
410 static cpp_hashnode
*
411 lex_macro_node (pfile
)
416 /* Lex the macro name directly. */
417 _cpp_lex_token (pfile
, &token
);
419 /* The token immediately after #define must be an identifier. That
420 identifier is not allowed to be "defined". See predefined macro
421 names (6.10.8.4). In C++, it is not allowed to be any of the
422 <iso646.h> macro names (which are keywords in C++) either. */
424 if (token
.type
!= CPP_NAME
)
426 if (token
.type
== CPP_EOF
)
427 cpp_error (pfile
, "no macro name given in #%s directive",
428 pfile
->directive
->name
);
429 else if (token
.flags
& NAMED_OP
)
431 "\"%s\" cannot be used as a macro name as it is an operator in C++",
432 token
.val
.node
->name
);
434 cpp_error (pfile
, "macro names must be identifiers");
438 cpp_hashnode
*node
= token
.val
.node
;
440 /* In Objective C, some keywords begin with '@', but general
441 identifiers do not, and you're not allowed to #define them. */
442 if (node
== pfile
->spec_nodes
.n_defined
|| node
->name
[0] == '@')
443 cpp_error (pfile
, "\"%s\" cannot be used as a macro name", node
->name
);
444 else if (!(node
->flags
& NODE_POISONED
))
451 /* Process a #define directive. Most work is done in cppmacro.c. */
456 cpp_hashnode
*node
= lex_macro_node (pfile
);
460 if (_cpp_create_definition (pfile
, node
))
461 if (pfile
->cb
.define
)
462 (*pfile
->cb
.define
) (pfile
, node
);
466 /* Handle #undef. Marks the identifier NT_VOID in the hash table. */
471 cpp_hashnode
*node
= lex_macro_node (pfile
);
473 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
474 is not currently defined as a macro name. */
475 if (node
&& node
->type
== NT_MACRO
)
478 (*pfile
->cb
.undef
) (pfile
, node
);
480 if (node
->flags
& NODE_BUILTIN
)
481 cpp_warning (pfile
, "undefining \"%s\"", node
->name
);
483 _cpp_free_definition (node
);
488 /* Helper routine used by parse_include. Reinterpret the current line
489 as an h-char-sequence (< ... >); we are looking at the first token
490 after the <. Returns zero on success. */
492 glue_header_name (pfile
, header
)
497 unsigned char *buffer
, *token_mem
;
498 size_t len
, total_len
= 0, capacity
= 1024;
500 /* To avoid lexed tokens overwriting our glued name, we can only
501 allocate from the string pool once we've lexed everything. */
503 buffer
= (unsigned char *) xmalloc (capacity
);
506 cpp_get_token (pfile
, &token
);
508 if (token
.type
== CPP_GREATER
|| token
.type
== CPP_EOF
)
511 len
= cpp_token_len (&token
);
512 if (total_len
+ len
> capacity
)
514 capacity
= (capacity
+ len
) * 2;
515 buffer
= (unsigned char *) xrealloc (buffer
, capacity
);
518 if (token
.flags
& PREV_WHITE
)
519 buffer
[total_len
++] = ' ';
521 total_len
= cpp_spell_token (pfile
, &token
, &buffer
[total_len
]) - buffer
;
524 if (token
.type
== CPP_EOF
)
525 cpp_error (pfile
, "missing terminating > character");
528 token_mem
= _cpp_pool_alloc (&pfile
->ident_pool
, total_len
);
529 memcpy (token_mem
, buffer
, total_len
);
531 header
->type
= CPP_HEADER_NAME
;
532 header
->flags
&= ~PREV_WHITE
;
533 header
->val
.str
.len
= total_len
;
534 header
->val
.str
.text
= token_mem
;
538 return token
.type
== CPP_EOF
;
541 /* Parse the header name of #include, #include_next, #import and
542 #pragma dependency. Returns zero on success. */
544 parse_include (pfile
, header
)
548 int is_pragma
= pfile
->directive
== &dtable
[T_PRAGMA
];
549 const unsigned char *dir
;
552 dir
= U
"pragma dependency";
554 dir
= pfile
->directive
->name
;
556 /* Allow macro expansion. */
557 cpp_get_token (pfile
, header
);
558 if (header
->type
!= CPP_STRING
&& header
->type
!= CPP_HEADER_NAME
)
560 if (header
->type
!= CPP_LESS
)
562 cpp_error (pfile
, "#%s expects \"FILENAME\" or <FILENAME>", dir
);
565 if (glue_header_name (pfile
, header
))
569 if (header
->val
.str
.len
== 0)
571 cpp_error (pfile
, "empty file name in #%s", dir
);
578 /* Get out of macro context, if we are. */
579 skip_rest_of_line (pfile
);
580 if (pfile
->cb
.include
)
581 (*pfile
->cb
.include
) (pfile
, dir
, header
);
593 if (!parse_include (pfile
, &header
))
594 _cpp_execute_include (pfile
, &header
, 0, 0);
603 if (!pfile
->import_warning
&& CPP_OPTION (pfile
, warn_import
))
605 pfile
->import_warning
= 1;
607 "#import is obsolete, use an #ifndef wrapper in the header file");
610 if (!parse_include (pfile
, &header
))
611 _cpp_execute_include (pfile
, &header
, 1, 0);
615 do_include_next (pfile
)
620 if (!parse_include (pfile
, &header
))
621 _cpp_execute_include (pfile
, &header
, 0, 1);
624 /* Subroutine of do_line. Read possible flags after file name. LAST
625 is the last flag seen; 0 if this is the first flag. Return the flag
626 if it is valid, 0 at the end of the directive. Otherwise complain. */
629 read_flag (pfile
, last
)
635 _cpp_lex_token (pfile
, &token
);
636 if (token
.type
== CPP_NUMBER
&& token
.val
.str
.len
== 1)
638 unsigned int flag
= token
.val
.str
.text
[0] - '0';
640 if (flag
> last
&& flag
<= 4
641 && (flag
!= 4 || last
== 3)
642 && (flag
!= 2 || last
== 0))
646 if (token
.type
!= CPP_EOF
)
647 cpp_error (pfile
, "invalid flag \"%s\" in line directive",
648 cpp_token_as_text (pfile
, &token
));
652 /* Another subroutine of do_line. Convert a number in STR, of length
653 LEN, to binary; store it in NUMP, and return 0 if the number was
654 well-formed, 1 if not. Temporary, hopefully. */
656 strtoul_for_line (str
, len
, nump
)
661 unsigned long reg
= 0;
675 /* Interpret #line command.
676 Note that the filename string (if any) is treated as if it were an
677 include filename. That means no escape handling. */
683 cpp_buffer
*buffer
= pfile
->buffer
;
684 const char *filename
= buffer
->nominal_fname
;
685 unsigned int lineno
= buffer
->lineno
;
686 enum cpp_fc_reason reason
= FC_RENAME
;
687 unsigned long new_lineno
;
691 /* C99 raised the minimum limit on #line numbers. */
692 cap
= CPP_OPTION (pfile
, c99
) ? 2147483647 : 32767;
694 /* #line commands expand macros. */
695 cpp_get_token (pfile
, &token
);
696 if (token
.type
!= CPP_NUMBER
697 || strtoul_for_line (token
.val
.str
.text
, token
.val
.str
.len
, &new_lineno
))
699 cpp_error (pfile
, "\"%s\" after #line is not a positive integer",
700 cpp_token_as_text (pfile
, &token
));
704 if (CPP_PEDANTIC (pfile
) && (new_lineno
== 0 || new_lineno
> cap
))
705 cpp_pedwarn (pfile
, "line number out of range");
707 cpp_get_token (pfile
, &token
);
708 if (token
.type
== CPP_STRING
)
713 /* FIXME: memory leak. */
714 len
= token
.val
.str
.len
;
715 fname
= xmalloc (len
+ 1);
716 memcpy (fname
, token
.val
.str
.text
, len
);
719 _cpp_simplify_pathname (fname
);
721 if (! pfile
->state
.line_extension
)
725 int flag
= 0, sysp
= 0;
727 flag
= read_flag (pfile
, flag
);
731 flag
= read_flag (pfile
, flag
);
736 flag
= read_flag (pfile
, flag
);
741 flag
= read_flag (pfile
, flag
);
743 sysp
= 2, read_flag (pfile
, flag
);
746 if (reason
== FC_ENTER
)
748 cpp_push_buffer (pfile
, 0, 0, BUF_FAKE
, fname
);
749 buffer
= pfile
->buffer
;
751 else if (reason
== FC_LEAVE
)
753 if (buffer
->type
!= BUF_FAKE
)
754 cpp_warning (pfile
, "file \"%s\" left but not entered",
755 buffer
->nominal_fname
);
758 cpp_pop_buffer (pfile
);
759 buffer
= pfile
->buffer
;
760 if (strcmp (buffer
->nominal_fname
, fname
))
761 cpp_warning (pfile
, "expected to return to file \"%s\"",
762 buffer
->nominal_fname
);
763 if (buffer
->lineno
+ 1 != new_lineno
)
764 cpp_warning (pfile
, "expected to return to line number %u",
766 if (buffer
->sysp
!= sysp
)
767 cpp_warning (pfile
, "header flags for \"%s\" have changed",
768 buffer
->nominal_fname
);
772 cpp_make_system_header (pfile
, sysp
, sysp
== 2);
775 buffer
->nominal_fname
= fname
;
777 else if (token
.type
!= CPP_EOF
)
779 cpp_error (pfile
, "\"%s\" is not a valid filename",
780 cpp_token_as_text (pfile
, &token
));
784 /* Our line number is incremented after the directive is processed. */
785 buffer
->lineno
= new_lineno
- 1;
787 if (reason
== FC_RENAME
)
789 /* Special case for file "foo.i" with "# 1 foo.c" on first line. */
790 if (! buffer
->prev
&& pfile
->directive_pos
.line
== 1)
792 do_file_change (pfile
, reason
, filename
, lineno
);
796 /* Arrange the file_change callback. */
798 do_file_change (pfile
, reason
, from_file
, from_lineno
)
800 enum cpp_fc_reason reason
;
801 const char *from_file
;
802 unsigned int from_lineno
;
804 if (pfile
->cb
.change_file
)
807 cpp_buffer
*buffer
= pfile
->buffer
;
810 fc
.from
.filename
= from_file
;
811 fc
.from
.lineno
= from_lineno
;
812 fc
.to
.filename
= buffer
->nominal_fname
;
813 fc
.to
.lineno
= buffer
->lineno
+ 1;
814 fc
.sysp
= buffer
->sysp
;
815 fc
.externc
= CPP_OPTION (pfile
, cplusplus
) && buffer
->sysp
== 2;
816 pfile
->cb
.change_file (pfile
, &fc
);
821 * Report a warning or error detected by the program we are
822 * processing. Use the directive's tokens in the error message.
826 do_diagnostic (pfile
, code
, print_dir
)
828 enum error_type code
;
831 if (_cpp_begin_message (pfile
, code
, NULL
, 0))
834 fprintf (stderr
, "#%s ", pfile
->directive
->name
);
835 pfile
->state
.prevent_expansion
++;
836 cpp_output_line (pfile
, stderr
);
837 pfile
->state
.prevent_expansion
--;
845 do_diagnostic (pfile
, ERROR
, 1);
852 do_diagnostic (pfile
, WARNING
, 1);
855 /* Report program identification. */
863 cpp_get_token (pfile
, &str
);
864 if (str
.type
!= CPP_STRING
)
865 cpp_error (pfile
, "invalid #ident");
866 else if (pfile
->cb
.ident
)
867 (*pfile
->cb
.ident
) (pfile
, &str
.val
.str
);
872 /* Pragmata handling. We handle some of these, and pass the rest on
873 to the front end. C99 defines three pragmas and says that no macro
874 expansion is to be performed on them; whether or not macro
875 expansion happens for other pragmas is implementation defined.
876 This implementation never macro-expands the text after #pragma. */
878 /* Sub-handlers for the pragmas needing treatment here.
879 They return 1 if the token buffer is to be popped, 0 if not. */
882 struct pragma_entry
*next
;
887 void (*handler
) PARAMS ((cpp_reader
*));
888 struct pragma_entry
*space
;
893 cpp_register_pragma (pfile
, space
, name
, handler
)
897 void (*handler
) PARAMS ((cpp_reader
*));
899 struct pragma_entry
**x
, *new;
905 struct pragma_entry
*p
= pfile
->pragmas
;
906 len
= strlen (space
);
909 if (p
->isnspace
&& p
->len
== len
&& !memcmp (p
->name
, space
, len
))
916 cpp_ice (pfile
, "unknown #pragma namespace %s", space
);
921 new = xnew (struct pragma_entry
);
923 new->len
= strlen (name
);
925 new->u
.handler
= handler
;
932 cpp_register_pragma_space (pfile
, space
)
936 struct pragma_entry
*new;
937 const struct pragma_entry
*p
= pfile
->pragmas
;
938 size_t len
= strlen (space
);
942 if (p
->isnspace
&& p
->len
== len
&& !memcmp (p
->name
, space
, len
))
943 /* Multiple different callers are allowed to register the same
949 new = xnew (struct pragma_entry
);
955 new->next
= pfile
->pragmas
;
956 pfile
->pragmas
= new;
960 _cpp_init_internal_pragmas (pfile
)
964 cpp_register_pragma (pfile
, 0, "poison", do_pragma_poison
);
965 cpp_register_pragma (pfile
, 0, "once", do_pragma_once
);
968 cpp_register_pragma_space (pfile
, "GCC");
970 cpp_register_pragma (pfile
, "GCC", "poison", do_pragma_poison
);
971 cpp_register_pragma (pfile
, "GCC", "system_header", do_pragma_system_header
);
972 cpp_register_pragma (pfile
, "GCC", "dependency", do_pragma_dependency
);
979 const struct pragma_entry
*p
;
981 const cpp_hashnode
*node
;
987 pfile
->state
.prevent_expansion
++;
988 cpp_start_lookahead (pfile
);
991 cpp_get_token (pfile
, &tok
);
992 if (tok
.type
== CPP_NAME
)
999 if (strlen (p
->name
) == len
&& !memcmp (p
->name
, name
, len
))
1008 (*p
->u
.handler
) (pfile
);
1017 cpp_stop_lookahead (pfile
, drop
);
1018 pfile
->state
.prevent_expansion
--;
1020 if (!drop
&& pfile
->cb
.def_pragma
)
1021 (*pfile
->cb
.def_pragma
) (pfile
);
1025 do_pragma_once (pfile
)
1028 cpp_warning (pfile
, "#pragma once is obsolete");
1030 if (pfile
->buffer
->prev
== NULL
)
1031 cpp_warning (pfile
, "#pragma once in main file");
1033 _cpp_never_reread (pfile
->buffer
->inc
);
1039 do_pragma_poison (pfile
)
1042 /* Poison these symbols so that all subsequent usage produces an
1047 pfile
->state
.poisoned_ok
= 1;
1050 _cpp_lex_token (pfile
, &tok
);
1051 if (tok
.type
== CPP_EOF
)
1053 if (tok
.type
!= CPP_NAME
)
1055 cpp_error (pfile
, "invalid #pragma GCC poison directive");
1060 if (hp
->flags
& NODE_POISONED
)
1063 if (hp
->type
== NT_MACRO
)
1064 cpp_warning (pfile
, "poisoning existing macro \"%s\"", hp
->name
);
1065 _cpp_free_definition (hp
);
1066 hp
->flags
|= NODE_POISONED
| NODE_DIAGNOSTIC
;
1068 pfile
->state
.poisoned_ok
= 0;
1070 #if 0 /* Doesn't quite work yet. */
1071 if (tok
.type
== CPP_EOF
&& pfile
->cb
.poison
)
1072 (*pfile
->cb
.poison
) (pfile
);
1076 /* Mark the current header as a system header. This will suppress
1077 some categories of warnings (notably those from -pedantic). It is
1078 intended for use in system libraries that cannot be implemented in
1079 conforming C, but cannot be certain that their headers appear in a
1080 system include directory. To prevent abuse, it is rejected in the
1081 primary source file. */
1083 do_pragma_system_header (pfile
)
1086 cpp_buffer
*buffer
= pfile
->buffer
;
1088 if (buffer
->prev
== 0)
1089 cpp_warning (pfile
, "#pragma system_header ignored outside include file");
1091 cpp_make_system_header (pfile
, 1, 0);
1096 /* Check the modified date of the current include file against a specified
1097 file. Issue a diagnostic, if the specified file is newer. We use this to
1098 determine if a fixed header should be refixed. */
1100 do_pragma_dependency (pfile
)
1103 cpp_token header
, msg
;
1106 if (parse_include (pfile
, &header
))
1109 ordering
= _cpp_compare_file_date (pfile
, &header
);
1111 cpp_warning (pfile
, "cannot find source %s",
1112 cpp_token_as_text (pfile
, &header
));
1113 else if (ordering
> 0)
1115 cpp_warning (pfile
, "current file is older than %s",
1116 cpp_token_as_text (pfile
, &header
));
1117 cpp_start_lookahead (pfile
);
1118 cpp_get_token (pfile
, &msg
);
1119 cpp_stop_lookahead (pfile
, msg
.type
== CPP_EOF
);
1120 if (msg
.type
!= CPP_EOF
)
1121 do_diagnostic (pfile
, WARNING
, 0);
1125 /* Check syntax is "(string-literal)". Returns 0 on success. */
1127 get__Pragma_string (pfile
, string
)
1133 cpp_get_token (pfile
, &paren
);
1134 if (paren
.type
!= CPP_OPEN_PAREN
)
1137 cpp_get_token (pfile
, string
);
1138 if (string
->type
!= CPP_STRING
&& string
->type
!= CPP_WSTRING
)
1141 cpp_get_token (pfile
, &paren
);
1142 return paren
.type
!= CPP_CLOSE_PAREN
;
1145 /* Returns a malloced buffer containing a destringized cpp_string by
1146 removing the first \ of \" and \\ sequences. */
1147 static unsigned char *
1148 destringize (in
, len
)
1149 const cpp_string
*in
;
1152 const unsigned char *src
, *limit
;
1153 unsigned char *dest
, *result
;
1155 dest
= result
= (unsigned char *) xmalloc (in
->len
);
1156 for (src
= in
->text
, limit
= src
+ in
->len
; src
< limit
;)
1158 /* We know there is a character following the backslash. */
1159 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1164 *len
= dest
- result
;
1169 _cpp_do__Pragma (pfile
)
1173 unsigned char *buffer
;
1176 if (get__Pragma_string (pfile
, &string
))
1178 cpp_error (pfile
, "_Pragma takes a parenthesized string literal");
1182 buffer
= destringize (&string
.val
.str
, &len
);
1183 run_directive (pfile
, T_PRAGMA
, BUF_PRAGMA
, (char *) buffer
, len
);
1184 free ((PTR
) buffer
);
1187 /* Just ignore #sccs, on systems where we define it at all. */
1188 #ifdef SCCS_DIRECTIVE
1191 cpp_reader
*pfile ATTRIBUTE_UNUSED
;
1202 if (! pfile
->buffer
->was_skipping
)
1204 const cpp_hashnode
*node
= lex_macro_node (pfile
);
1207 skip
= node
->type
!= NT_MACRO
;
1213 push_conditional (pfile
, skip
, T_IFDEF
, 0);
1221 const cpp_hashnode
*node
= 0;
1223 if (! pfile
->buffer
->was_skipping
)
1225 node
= lex_macro_node (pfile
);
1227 skip
= node
->type
== NT_MACRO
;
1233 push_conditional (pfile
, skip
, T_IFNDEF
, node
);
1236 /* #if cooperates with parse_defined to handle multiple-include
1237 optimisations. If macro expansions or identifiers appear in the
1238 expression, we cannot treat it as a controlling conditional, since
1239 their values could change in the future. */
1246 const cpp_hashnode
*cmacro
= 0;
1248 if (! pfile
->buffer
->was_skipping
)
1250 /* Controlling macro of #if ! defined () */
1251 pfile
->mi_ind_cmacro
= 0;
1252 skip
= _cpp_parse_expr (pfile
) == 0;
1253 cmacro
= pfile
->mi_ind_cmacro
;
1256 push_conditional (pfile
, skip
, T_IF
, cmacro
);
1259 /* Flip skipping state if appropriate and continue without changing
1260 if_stack; this is so that the error message for missing #endif's
1261 etc. will point to the original #if. */
1267 cpp_buffer
*buffer
= pfile
->buffer
;
1268 struct if_stack
*ifs
= buffer
->if_stack
;
1271 cpp_error (pfile
, "#else without #if");
1274 if (ifs
->type
== T_ELSE
)
1276 cpp_error (pfile
, "#else after #else");
1277 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1278 "the conditional began here");
1282 /* Buffer->was_skipping is 1 if all conditionals in this chain
1283 have been false, 2 if a conditional has been true. */
1284 if (! ifs
->was_skipping
&& buffer
->was_skipping
!= 2)
1285 buffer
->was_skipping
= ! buffer
->was_skipping
;
1287 /* Invalidate any controlling macro. */
1294 /* handle a #elif directive by not changing if_stack either. see the
1295 comment above do_else. */
1301 cpp_buffer
*buffer
= pfile
->buffer
;
1302 struct if_stack
*ifs
= buffer
->if_stack
;
1305 cpp_error (pfile
, "#elif without #if");
1308 if (ifs
->type
== T_ELSE
)
1310 cpp_error (pfile
, "#elif after #else");
1311 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1312 "the conditional began here");
1316 /* Don't evaluate #elif if our higher level is skipping. */
1317 if (! ifs
->was_skipping
)
1319 /* Buffer->was_skipping is 1 if all conditionals in this
1320 chain have been false, 2 if a conditional has been true. */
1321 if (buffer
->was_skipping
== 1)
1322 buffer
->was_skipping
= ! _cpp_parse_expr (pfile
);
1324 buffer
->was_skipping
= 2;
1326 /* Invalidate any controlling macro. */
1332 /* #endif pops the if stack and resets pfile->skipping. */
1338 cpp_buffer
*buffer
= pfile
->buffer
;
1339 struct if_stack
*ifs
= buffer
->if_stack
;
1342 cpp_error (pfile
, "#endif without #if");
1345 /* If potential control macro, we go back outside again. */
1346 if (ifs
->next
== 0 && ifs
->mi_cmacro
)
1348 pfile
->mi_state
= MI_OUTSIDE
;
1349 pfile
->mi_cmacro
= ifs
->mi_cmacro
;
1352 buffer
->if_stack
= ifs
->next
;
1353 buffer
->was_skipping
= ifs
->was_skipping
;
1354 obstack_free (pfile
->buffer_ob
, ifs
);
1360 /* Push an if_stack entry and set pfile->skipping accordingly.
1361 If this is a #ifndef starting at the beginning of a file,
1362 CMACRO is the macro name tested by the #ifndef. */
1365 push_conditional (pfile
, skip
, type
, cmacro
)
1369 const cpp_hashnode
*cmacro
;
1371 struct if_stack
*ifs
;
1372 cpp_buffer
*buffer
= pfile
->buffer
;
1374 ifs
= xobnew (pfile
->buffer_ob
, struct if_stack
);
1375 ifs
->pos
= pfile
->directive_pos
;
1376 ifs
->next
= buffer
->if_stack
;
1377 ifs
->was_skipping
= buffer
->was_skipping
;
1379 if (pfile
->mi_state
== MI_OUTSIDE
&& pfile
->mi_cmacro
== 0)
1380 ifs
->mi_cmacro
= cmacro
;
1384 buffer
->was_skipping
= skip
;
1385 buffer
->if_stack
= ifs
;
1388 /* Read the tokens of the answer into the macro pool. Only commit the
1389 memory if we intend it as permanent storage, i.e. the #assert case.
1390 Returns 0 on success. */
1393 parse_answer (pfile
, answerp
, type
)
1395 struct answer
**answerp
;
1398 cpp_token paren
, *token
;
1399 struct answer
*answer
;
1401 if (POOL_FRONT (&pfile
->macro_pool
) + sizeof (struct answer
) >
1402 POOL_LIMIT (&pfile
->macro_pool
))
1403 _cpp_next_chunk (&pfile
->macro_pool
, sizeof (struct answer
), 0);
1404 answer
= (struct answer
*) POOL_FRONT (&pfile
->macro_pool
);
1407 /* In a conditional, it is legal to not have an open paren. We
1408 should save the following token in this case. */
1410 cpp_start_lookahead (pfile
);
1411 cpp_get_token (pfile
, &paren
);
1413 cpp_stop_lookahead (pfile
, paren
.type
== CPP_OPEN_PAREN
);
1415 /* If not a paren, see if we're OK. */
1416 if (paren
.type
!= CPP_OPEN_PAREN
)
1418 /* In a conditional no answer is a test for any answer. It
1419 could be followed by any token. */
1423 /* #unassert with no answer is valid - it removes all answers. */
1424 if (type
== T_UNASSERT
&& paren
.type
== CPP_EOF
)
1427 cpp_error (pfile
, "missing '(' after predicate");
1433 token
= &answer
->first
[answer
->count
];
1434 /* Check we have room for the token. */
1435 if ((unsigned char *) (token
+ 1) >= POOL_LIMIT (&pfile
->macro_pool
))
1437 _cpp_next_chunk (&pfile
->macro_pool
, sizeof (cpp_token
),
1438 (unsigned char **) &answer
);
1439 token
= &answer
->first
[answer
->count
];
1442 cpp_get_token (pfile
, token
);
1443 if (token
->type
== CPP_CLOSE_PAREN
)
1446 if (token
->type
== CPP_EOF
)
1448 cpp_error (pfile
, "missing ')' to complete answer");
1454 if (answer
->count
== 0)
1456 cpp_error (pfile
, "predicate's answer is empty");
1460 /* Drop whitespace at start. */
1461 answer
->first
->flags
&= ~PREV_WHITE
;
1464 if (type
== T_ASSERT
|| type
== T_UNASSERT
)
1469 /* Parses an assertion, returning a pointer to the hash node of the
1470 predicate, or 0 on error. If an answer was supplied, it is placed
1471 in ANSWERP, otherwise it is set to 0. */
1472 static cpp_hashnode
*
1473 parse_assertion (pfile
, answerp
, type
)
1475 struct answer
**answerp
;
1478 cpp_hashnode
*result
= 0;
1479 cpp_token predicate
;
1481 /* We don't expand predicates or answers. */
1482 pfile
->state
.prevent_expansion
++;
1485 cpp_get_token (pfile
, &predicate
);
1486 if (predicate
.type
== CPP_EOF
)
1487 cpp_error (pfile
, "assertion without predicate");
1488 else if (predicate
.type
!= CPP_NAME
)
1489 cpp_error (pfile
, "predicate must be an identifier");
1490 else if (parse_answer (pfile
, answerp
, type
) == 0)
1492 unsigned int len
= predicate
.val
.node
->length
;
1493 unsigned char *sym
= alloca (len
+ 1);
1495 /* Prefix '#' to get it out of macro namespace. */
1497 memcpy (sym
+ 1, predicate
.val
.node
->name
, len
);
1498 result
= cpp_lookup (pfile
, sym
, len
+ 1);
1501 pfile
->state
.prevent_expansion
--;
1505 /* Returns a pointer to the pointer to the answer in the answer chain,
1506 or a pointer to NULL if the answer is not in the chain. */
1507 static struct answer
**
1508 find_answer (node
, candidate
)
1510 const struct answer
*candidate
;
1513 struct answer
**result
;
1515 for (result
= &node
->value
.answers
; *result
; result
= &(*result
)->next
)
1517 struct answer
*answer
= *result
;
1519 if (answer
->count
== candidate
->count
)
1521 for (i
= 0; i
< answer
->count
; i
++)
1522 if (! _cpp_equiv_tokens (&answer
->first
[i
], &candidate
->first
[i
]))
1525 if (i
== answer
->count
)
1533 /* Test an assertion within a preprocessor conditional. Returns
1534 non-zero on failure, zero on success. On success, the result of
1535 the test is written into VALUE. */
1537 _cpp_test_assertion (pfile
, value
)
1541 struct answer
*answer
;
1544 node
= parse_assertion (pfile
, &answer
, T_IF
);
1546 *value
= (node
->type
== NT_ASSERTION
&&
1547 (answer
== 0 || *find_answer (node
, answer
) != 0));
1549 /* We don't commit the memory for the answer - it's temporary only. */
1557 struct answer
*new_answer
;
1560 node
= parse_assertion (pfile
, &new_answer
, T_ASSERT
);
1563 /* Place the new answer in the answer list. First check there
1564 is not a duplicate. */
1565 new_answer
->next
= 0;
1566 if (node
->type
== NT_ASSERTION
)
1568 if (*find_answer (node
, new_answer
))
1570 cpp_warning (pfile
, "\"%s\" re-asserted", node
->name
+ 1);
1573 new_answer
->next
= node
->value
.answers
;
1575 node
->type
= NT_ASSERTION
;
1576 node
->value
.answers
= new_answer
;
1577 POOL_COMMIT (&pfile
->macro_pool
, (sizeof (struct answer
)
1578 + (new_answer
->count
- 1)
1579 * sizeof (cpp_token
)));
1588 struct answer
*answer
;
1590 node
= parse_assertion (pfile
, &answer
, T_UNASSERT
);
1591 /* It isn't an error to #unassert something that isn't asserted. */
1592 if (node
&& node
->type
== NT_ASSERTION
)
1596 struct answer
**p
= find_answer (node
, answer
), *temp
;
1598 /* Remove the answer from the list. */
1603 /* Did we free the last answer? */
1604 if (node
->value
.answers
== 0)
1605 node
->type
= NT_VOID
;
1608 _cpp_free_definition (node
);
1611 /* We don't commit the memory for the answer - it's temporary only. */
1614 /* These are for -D, -U, -A. */
1616 /* Process the string STR as if it appeared as the body of a #define.
1617 If STR is just an identifier, define it with value 1.
1618 If STR has anything after the identifier, then it should
1619 be identifier=definition. */
1622 cpp_define (pfile
, str
)
1629 /* Copy the entire option so we can modify it.
1630 Change the first "=" in the string to a space. If there is none,
1631 tack " 1" on the end. */
1633 /* Length including the null. */
1634 count
= strlen (str
);
1635 buf
= (char *) alloca (count
+ 2);
1636 memcpy (buf
, str
, count
);
1638 p
= strchr (str
, '=');
1647 run_directive (pfile
, T_DEFINE
, BUF_CL_OPTION
, buf
, count
);
1650 /* Slight variant of the above for use by initialize_builtins. */
1652 _cpp_define_builtin (pfile
, str
)
1656 run_directive (pfile
, T_DEFINE
, BUF_BUILTIN
, str
, strlen (str
));
1659 /* Process MACRO as if it appeared as the body of an #undef. */
1661 cpp_undef (pfile
, macro
)
1665 run_directive (pfile
, T_UNDEF
, BUF_CL_OPTION
, macro
, strlen (macro
));
1668 /* Process the string STR as if it appeared as the body of a #assert. */
1670 cpp_assert (pfile
, str
)
1674 handle_assertion (pfile
, str
, T_ASSERT
);
1677 /* Process STR as if it appeared as the body of an #unassert. */
1679 cpp_unassert (pfile
, str
)
1683 handle_assertion (pfile
, str
, T_UNASSERT
);
1686 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1688 handle_assertion (pfile
, str
, type
)
1693 size_t count
= strlen (str
);
1694 const char *p
= strchr (str
, '=');
1698 /* Copy the entire option so we can modify it. Change the first
1699 "=" in the string to a '(', and tack a ')' on the end. */
1700 char *buf
= (char *) alloca (count
+ 1);
1702 memcpy (buf
, str
, count
);
1708 run_directive (pfile
, type
, BUF_CL_OPTION
, str
, count
);
1711 /* Push a new buffer on the buffer stack. Buffer can be NULL, but
1712 then LEN should be 0. Returns the new buffer; it doesn't fail. */
1715 cpp_push_buffer (pfile
, buffer
, len
, type
, filename
)
1717 const U_CHAR
*buffer
;
1719 enum cpp_buffer_type type
;
1720 const char *filename
;
1722 cpp_buffer
*new = xobnew (pfile
->buffer_ob
, cpp_buffer
);
1724 if (type
== BUF_FAKE
)
1726 /* A copy of the current buffer, just with a new name and type. */
1727 memcpy (new, pfile
->buffer
, sizeof (cpp_buffer
));
1728 new->type
= BUF_FAKE
;
1732 if (type
== BUF_BUILTIN
)
1733 filename
= _("<builtin>");
1734 else if (type
== BUF_CL_OPTION
)
1735 filename
= _("<command line>");
1736 else if (type
== BUF_PRAGMA
)
1737 filename
= "<_Pragma>";
1739 /* Clears, amongst other things, if_stack and mi_cmacro. */
1740 memset (new, 0, sizeof (cpp_buffer
));
1742 new->line_base
= new->buf
= new->cur
= buffer
;
1743 new->rlimit
= buffer
+ len
;
1745 /* No read ahead or extra char initially. */
1746 new->read_ahead
= EOF
;
1747 new->extra_char
= EOF
;
1749 /* Preprocessed files, builtins, _Pragma and command line
1750 options don't do trigraph and escaped newline processing. */
1751 new->from_stage3
= type
!= BUF_FILE
|| CPP_OPTION (pfile
, preprocessed
);
1753 pfile
->lexer_pos
.output_line
= 1;
1756 new->nominal_fname
= filename
;
1758 new->prev
= pfile
->buffer
;
1760 new->include_stack_listed
= 0;
1762 pfile
->state
.next_bol
= 1;
1763 pfile
->buffer_stack_depth
++;
1764 pfile
->buffer
= new;
1766 if (type
== BUF_FILE
|| type
== BUF_FAKE
)
1768 const char *filename
= 0;
1769 unsigned int lineno
= 0;
1773 filename
= new->prev
->nominal_fname
;
1774 lineno
= new->prev
->lineno
;
1777 do_file_change (pfile
, FC_ENTER
, filename
, lineno
);
1785 cpp_pop_buffer (pfile
)
1789 struct if_stack
*ifs
;
1790 int in_do_line
= pfile
->directive
== &dtable
[T_LINE
];
1794 buffer
= pfile
->buffer
;
1795 /* Walk back up the conditional stack till we reach its level at
1796 entry to this file, issuing error messages. */
1797 for (ifs
= buffer
->if_stack
; ifs
; ifs
= ifs
->next
)
1798 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1799 "unterminated #%s", dtable
[ifs
->type
].name
);
1801 if (buffer
->type
== BUF_FAKE
)
1804 cpp_warning (pfile
, "file \"%s\" entered but not left",
1805 buffer
->nominal_fname
);
1807 buffer
->prev
->cur
= buffer
->cur
;
1809 else if (buffer
->type
== BUF_FILE
)
1810 _cpp_pop_file_buffer (pfile
, buffer
);
1812 pfile
->buffer
= buffer
->prev
;
1813 pfile
->buffer_stack_depth
--;
1815 if ((buffer
->type
== BUF_FILE
|| buffer
->type
== BUF_FAKE
)
1818 do_file_change (pfile
, FC_LEAVE
, buffer
->nominal_fname
,
1820 pfile
->buffer
->include_stack_listed
= 0;
1823 while (pfile
->buffer
&& pfile
->buffer
->type
== BUF_FAKE
&& !in_do_line
);
1825 obstack_free (pfile
->buffer_ob
, buffer
);
1826 return pfile
->buffer
;
1829 #define obstack_chunk_alloc xmalloc
1830 #define obstack_chunk_free free
1832 _cpp_init_stacks (pfile
)
1838 pfile
->buffer_ob
= xnew (struct obstack
);
1839 obstack_init (pfile
->buffer_ob
);
1841 /* Register the directives. */
1842 for (i
= 1; i
< N_DIRECTIVES
; i
++)
1844 node
= cpp_lookup (pfile
, dtable
[i
- 1].name
, dtable
[i
- 1].length
);
1845 node
->directive_index
= i
;
1850 _cpp_cleanup_stacks (pfile
)
1853 obstack_free (pfile
->buffer_ob
, 0);
1854 free (pfile
->buffer_ob
);