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. */
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_include_common
PARAMS ((cpp_reader
*, enum include_type
));
99 static void do_pragma_once
PARAMS ((cpp_reader
*));
100 static void do_pragma_poison
PARAMS ((cpp_reader
*));
101 static void do_pragma_system_header
PARAMS ((cpp_reader
*));
102 static void do_pragma_dependency
PARAMS ((cpp_reader
*));
103 static int get__Pragma_string
PARAMS ((cpp_reader
*, cpp_token
*));
104 static unsigned char *destringize
PARAMS ((const cpp_string
*,
106 static int parse_answer
PARAMS ((cpp_reader
*, struct answer
**, int));
107 static cpp_hashnode
*parse_assertion
PARAMS ((cpp_reader
*, struct answer
**,
109 static struct answer
** find_answer
PARAMS ((cpp_hashnode
*,
110 const struct answer
*));
111 static void handle_assertion
PARAMS ((cpp_reader
*, const char *, int));
113 /* This is the table of directive handlers. It is ordered by
114 frequency of occurrence; the numbers at the end are directive
115 counts from all the source code I have lying around (egcs and libc
116 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
117 pcmcia-cs-3.0.9). This is no longer important as directive lookup
118 is now O(1). All extensions other than #warning and #include_next
119 are deprecated. The name is where the extension appears to have
122 #define DIRECTIVE_TABLE \
123 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
124 D(include, T_INCLUDE, KANDR, INCL) /* 52262 */ \
125 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
126 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
127 D(if, T_IF, KANDR, COND | IF_COND) /* 18162 */ \
128 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
129 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
130 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
131 D(line, T_LINE, KANDR, IN_I) /* 2465 */ \
132 D(elif, T_ELIF, STDC89, COND) /* 610 */ \
133 D(error, T_ERROR, STDC89, 0) /* 475 */ \
134 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
135 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
136 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL) /* 19 */ \
137 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
138 D(import, T_IMPORT, EXTENSION, INCL) /* 0 ObjC */ \
139 D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
140 D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
141 SCCS_ENTRY /* 0 SVR4? */
143 /* #sccs is not always recognized. */
144 #ifdef SCCS_DIRECTIVE
145 # define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION, 0)
147 # define SCCS_ENTRY /* nothing */
150 /* Use the table to generate a series of prototypes, an enum for the
151 directive names, and an array of directive handlers. */
153 /* The directive-processing functions are declared to return int
154 instead of void, because some old compilers have trouble with
155 pointers to functions returning void. */
157 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
158 #define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
162 #define D(n, tag, o, f) tag,
170 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
171 #define D(name, t, origin, flags) \
172 { CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
173 sizeof STRINGX(name) - 1, origin, flags },
174 static const directive dtable
[] =
179 #undef DIRECTIVE_TABLE
181 /* Skip any remaining tokens in a directive. */
183 skip_rest_of_line (pfile
)
188 /* Discard all input lookaheads. */
189 while (pfile
->la_read
)
190 _cpp_release_lookahead (pfile
);
192 /* Discard all stacked contexts. */
193 while (pfile
->context
!= &pfile
->base_context
)
194 _cpp_pop_context (pfile
);
196 /* Sweep up all tokens remaining on the line. */
197 pfile
->state
.prevent_expansion
++;
198 while (!pfile
->state
.next_bol
)
199 _cpp_lex_token (pfile
, &token
);
200 pfile
->state
.prevent_expansion
--;
203 /* Ensure there are no stray tokens at the end of a directive. */
208 if (!pfile
->state
.next_bol
)
212 _cpp_lex_token (pfile
, &token
);
213 if (token
.type
!= CPP_EOF
)
214 cpp_pedwarn (pfile
, "extra tokens at end of #%s directive",
215 pfile
->directive
->name
);
219 /* Called when entering a directive, _Pragma or command-line directive. */
221 start_directive (pfile
)
224 cpp_buffer
*buffer
= pfile
->buffer
;
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_pos
= pfile
->lexer_pos
;
233 /* Don't save directive tokens for external clients. */
234 pfile
->la_saved
= pfile
->la_write
;
237 /* Turn off skipping. */
238 buffer
->was_skipping
= pfile
->skipping
;
242 /* Called when leaving a directive, _Pragma or command-line directive. */
244 end_directive (pfile
, skip_line
)
248 cpp_buffer
*buffer
= pfile
->buffer
;
250 /* Restore pfile->skipping before skip_rest_of_line, so that e.g.
251 __VA_ARGS__ in the rest of the directive doesn't warn. */
252 pfile
->skipping
= buffer
->was_skipping
;
254 /* We don't skip for an assembler #. */
256 skip_rest_of_line (pfile
);
259 pfile
->la_write
= pfile
->la_saved
;
260 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
261 pfile
->state
.in_directive
= 0;
262 pfile
->state
.angled_headers
= 0;
263 pfile
->state
.line_extension
= 0;
264 pfile
->directive
= 0;
267 /* Check if a token's name matches that of a known directive. Put in
268 this file to save exporting dtable and other unneeded information. */
270 _cpp_handle_directive (pfile
, indented
)
274 cpp_buffer
*buffer
= pfile
->buffer
;
275 const directive
*dir
= 0;
279 start_directive (pfile
);
281 /* Lex the directive name directly. */
282 _cpp_lex_token (pfile
, &dname
);
284 if (dname
.type
== CPP_NAME
)
286 unsigned int index
= dname
.val
.node
->directive_index
;
288 dir
= &dtable
[index
- 1];
290 else if (dname
.type
== CPP_NUMBER
)
292 /* # followed by a number is equivalent to #line. Do not
293 recognize this form in assembly language source files or
294 skipped conditional groups. Complain about this form if
295 we're being pedantic, but not if this is regurgitated input
296 (preprocessed or fed back in by the C++ frontend). */
297 if (! buffer
->was_skipping
&& CPP_OPTION (pfile
, lang
) != CLK_ASM
)
299 dir
= &dtable
[T_LINE
];
300 pfile
->state
.line_extension
= 1;
301 _cpp_push_token (pfile
, &dname
, &pfile
->directive_pos
);
302 if (CPP_PEDANTIC (pfile
) && ! CPP_OPTION (pfile
, preprocessed
))
303 cpp_pedwarn (pfile
, "# followed by integer");
307 pfile
->directive
= dir
;
310 /* Make sure we lex headers correctly, whether skipping or not. */
311 pfile
->state
.angled_headers
= dir
->flags
& INCL
;
313 /* If we are rescanning preprocessed input, only directives tagged
314 with IN_I are honored, and the warnings below are suppressed. */
315 if (CPP_OPTION (pfile
, preprocessed
))
317 /* Kluge alert. In order to be sure that code like this
320 does not cause '#define foo bar' to get executed when
321 compiled with -save-temps, we recognize directives in
322 -fpreprocessed mode only if the # is in column 1 and the
323 directive name starts in column 2. This output can only
324 be generated by the directive callbacks in cppmain.c (see
325 also the special case in scan_buffer). */
326 if (dir
->flags
& IN_I
&& !indented
&& !(dname
.flags
& PREV_WHITE
))
327 (*dir
->handler
) (pfile
);
328 /* That check misses '# 123' linemarkers. Let them through too. */
329 else if (dname
.type
== CPP_NUMBER
)
330 (*dir
->handler
) (pfile
);
333 /* We don't want to process this directive. Put back the
334 tokens so caller will see them (and issue an error,
336 _cpp_push_token (pfile
, &dname
, &pfile
->directive_pos
);
342 /* Traditionally, a directive is ignored unless its # is in
343 column 1. Therefore in code intended to work with K+R
344 compilers, directives added by C89 must have their #
345 indented, and directives present in traditional C must
346 not. This is true even of directives in skipped
347 conditional blocks. */
348 if (CPP_WTRADITIONAL (pfile
))
350 if (dir
== &dtable
[T_ELIF
])
352 "suggest not using #elif in traditional C");
353 else if (indented
&& dir
->origin
== KANDR
)
355 "traditional C ignores #%s with the # indented",
357 else if (!indented
&& dir
->origin
!= KANDR
)
359 "suggest hiding #%s from traditional C with an indented #",
363 /* If we are skipping a failed conditional group, all
364 non-conditional directives are ignored. */
365 if (! buffer
->was_skipping
|| (dir
->flags
& COND
))
367 /* Issue -pedantic warnings for extensions. */
368 if (CPP_PEDANTIC (pfile
) && dir
->origin
== EXTENSION
)
369 cpp_pedwarn (pfile
, "#%s is a GCC extension", dir
->name
);
371 /* If we have a directive that is not an opening
372 conditional, invalidate any control macro. */
373 if (! (dir
->flags
& IF_COND
))
374 pfile
->mi_state
= MI_FAILED
;
376 (*dir
->handler
) (pfile
);
380 else if (dname
.type
!= CPP_EOF
&& ! buffer
->was_skipping
)
382 /* An unknown directive. Don't complain about it in assembly
383 source: we don't know where the comments are, and # may
384 introduce assembler pseudo-ops. Don't complain about invalid
385 directives in skipped conditional groups (6.10 p4). */
386 if (CPP_OPTION (pfile
, lang
) == CLK_ASM
)
388 /* Output the # and lookahead token for the assembler. */
389 _cpp_push_token (pfile
, &dname
, &pfile
->directive_pos
);
393 cpp_error (pfile
, "invalid preprocessing directive #%s",
394 cpp_token_as_text (pfile
, &dname
));
397 end_directive (pfile
, skip
);
401 /* Directive handler wrapper used by the command line option
404 run_directive (pfile
, dir_no
, type
, buf
, count
)
407 enum cpp_buffer_type type
;
411 unsigned int output_line
= pfile
->lexer_pos
.output_line
;
414 buffer
= cpp_push_buffer (pfile
, (const U_CHAR
*) buf
, count
, type
, 0);
416 if (dir_no
== T_PRAGMA
)
418 /* A kludge to avoid line markers for _Pragma. */
419 pfile
->lexer_pos
.output_line
= output_line
;
420 /* Avoid interpretation of directives in a _Pragma string. */
421 pfile
->state
.next_bol
= 0;
424 start_directive (pfile
);
425 pfile
->state
.prevent_expansion
++;
426 pfile
->directive
= &dtable
[dir_no
];
427 (void) (*pfile
->directive
->handler
) (pfile
);
428 pfile
->state
.prevent_expansion
--;
430 end_directive (pfile
, 1);
432 cpp_pop_buffer (pfile
);
435 /* Checks for validity the macro name in #define, #undef, #ifdef and
436 #ifndef directives. */
437 static cpp_hashnode
*
438 lex_macro_node (pfile
)
443 /* Lex the macro name directly. */
444 _cpp_lex_token (pfile
, &token
);
446 /* The token immediately after #define must be an identifier. That
447 identifier is not allowed to be "defined". See predefined macro
448 names (6.10.8.4). In C++, it is not allowed to be any of the
449 <iso646.h> macro names (which are keywords in C++) either. */
451 if (token
.type
!= CPP_NAME
)
453 if (token
.type
== CPP_EOF
)
454 cpp_error (pfile
, "no macro name given in #%s directive",
455 pfile
->directive
->name
);
456 else if (token
.flags
& NAMED_OP
)
458 "\"%s\" cannot be used as a macro name as it is an operator in C++",
459 token
.val
.node
->name
);
461 cpp_error (pfile
, "macro names must be identifiers");
465 cpp_hashnode
*node
= token
.val
.node
;
467 /* In Objective C, some keywords begin with '@', but general
468 identifiers do not, and you're not allowed to #define them. */
469 if (node
== pfile
->spec_nodes
.n_defined
|| node
->name
[0] == '@')
470 cpp_error (pfile
, "\"%s\" cannot be used as a macro name", node
->name
);
471 else if (!(node
->flags
& NODE_POISONED
))
478 /* Process a #define directive. Most work is done in cppmacro.c. */
483 cpp_hashnode
*node
= lex_macro_node (pfile
);
487 if (_cpp_create_definition (pfile
, node
))
488 if (pfile
->cb
.define
)
489 (*pfile
->cb
.define
) (pfile
, node
);
493 /* Handle #undef. Marks the identifier NT_VOID in the hash table. */
498 cpp_hashnode
*node
= lex_macro_node (pfile
);
500 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
501 is not currently defined as a macro name. */
502 if (node
&& node
->type
== NT_MACRO
)
505 (*pfile
->cb
.undef
) (pfile
, node
);
507 if (node
->flags
& NODE_WARN
)
508 cpp_warning (pfile
, "undefining \"%s\"", node
->name
);
510 _cpp_free_definition (node
);
515 /* Helper routine used by parse_include. Reinterpret the current line
516 as an h-char-sequence (< ... >); we are looking at the first token
517 after the <. Returns zero on success. */
519 glue_header_name (pfile
, header
)
524 unsigned char *buffer
, *token_mem
;
525 size_t len
, total_len
= 0, capacity
= 1024;
527 /* To avoid lexed tokens overwriting our glued name, we can only
528 allocate from the string pool once we've lexed everything. */
530 buffer
= (unsigned char *) xmalloc (capacity
);
533 cpp_get_token (pfile
, &token
);
535 if (token
.type
== CPP_GREATER
|| token
.type
== CPP_EOF
)
538 len
= cpp_token_len (&token
);
539 if (total_len
+ len
> capacity
)
541 capacity
= (capacity
+ len
) * 2;
542 buffer
= (unsigned char *) xrealloc (buffer
, capacity
);
545 if (token
.flags
& PREV_WHITE
)
546 buffer
[total_len
++] = ' ';
548 total_len
= cpp_spell_token (pfile
, &token
, &buffer
[total_len
]) - buffer
;
551 if (token
.type
== CPP_EOF
)
552 cpp_error (pfile
, "missing terminating > character");
555 token_mem
= _cpp_pool_alloc (&pfile
->ident_pool
, total_len
+ 1);
556 memcpy (token_mem
, buffer
, total_len
);
557 token_mem
[total_len
] = '\0';
559 header
->type
= CPP_HEADER_NAME
;
560 header
->flags
&= ~PREV_WHITE
;
561 header
->val
.str
.len
= total_len
;
562 header
->val
.str
.text
= token_mem
;
566 return token
.type
== CPP_EOF
;
569 /* Parse the header name of #include, #include_next, #import and
570 #pragma dependency. Returns zero on success. */
572 parse_include (pfile
, header
)
576 int is_pragma
= pfile
->directive
== &dtable
[T_PRAGMA
];
577 const unsigned char *dir
;
580 dir
= U
"pragma dependency";
582 dir
= pfile
->directive
->name
;
584 /* Allow macro expansion. */
585 cpp_get_token (pfile
, header
);
586 if (header
->type
!= CPP_STRING
&& header
->type
!= CPP_HEADER_NAME
)
588 if (header
->type
!= CPP_LESS
)
590 cpp_error (pfile
, "#%s expects \"FILENAME\" or <FILENAME>", dir
);
593 if (glue_header_name (pfile
, header
))
597 if (header
->val
.str
.len
== 0)
599 cpp_error (pfile
, "empty file name in #%s", dir
);
606 /* Get out of macro context, if we are. */
607 skip_rest_of_line (pfile
);
608 if (pfile
->cb
.include
)
609 (*pfile
->cb
.include
) (pfile
, dir
, header
);
615 /* Handle #include, #include_next and #import. */
617 do_include_common (pfile
, type
)
619 enum include_type type
;
623 if (!parse_include (pfile
, &header
))
625 /* Prevent #include recursion. */
626 if (pfile
->buffer_stack_depth
>= CPP_STACK_MAX
)
627 cpp_fatal (pfile
, "#include nested too deeply");
628 else if (pfile
->context
->prev
)
629 cpp_ice (pfile
, "attempt to push file buffer with contexts stacked");
632 /* For #include_next, if this is the primary source file,
633 warn and use the normal search logic. */
634 if (type
== IT_INCLUDE_NEXT
&& ! pfile
->buffer
->prev
)
636 cpp_warning (pfile
, "#include_next in primary source file");
640 _cpp_execute_include (pfile
, &header
, type
);
649 do_include_common (pfile
, IT_INCLUDE
);
656 if (!pfile
->import_warning
&& CPP_OPTION (pfile
, warn_import
))
658 pfile
->import_warning
= 1;
660 "#import is obsolete, use an #ifndef wrapper in the header file");
663 do_include_common (pfile
, IT_IMPORT
);
667 do_include_next (pfile
)
670 do_include_common (pfile
, IT_INCLUDE_NEXT
);
673 /* Subroutine of do_line. Read possible flags after file name. LAST
674 is the last flag seen; 0 if this is the first flag. Return the flag
675 if it is valid, 0 at the end of the directive. Otherwise complain. */
678 read_flag (pfile
, last
)
684 _cpp_lex_token (pfile
, &token
);
685 if (token
.type
== CPP_NUMBER
&& token
.val
.str
.len
== 1)
687 unsigned int flag
= token
.val
.str
.text
[0] - '0';
689 if (flag
> last
&& flag
<= 4
690 && (flag
!= 4 || last
== 3)
691 && (flag
!= 2 || last
== 0))
695 if (token
.type
!= CPP_EOF
)
696 cpp_error (pfile
, "invalid flag \"%s\" in line directive",
697 cpp_token_as_text (pfile
, &token
));
701 /* Another subroutine of do_line. Convert a number in STR, of length
702 LEN, to binary; store it in NUMP, and return 0 if the number was
703 well-formed, 1 if not. Temporary, hopefully. */
705 strtoul_for_line (str
, len
, nump
)
710 unsigned long reg
= 0;
724 /* Interpret #line command.
725 Note that the filename string (if any) is treated as if it were an
726 include filename. That means no escape handling. */
732 cpp_buffer
*buffer
= pfile
->buffer
;
733 const char *filename
= buffer
->nominal_fname
;
734 unsigned int lineno
= buffer
->lineno
;
735 enum cpp_fc_reason reason
= FC_RENAME
;
736 unsigned long new_lineno
;
740 /* C99 raised the minimum limit on #line numbers. */
741 cap
= CPP_OPTION (pfile
, c99
) ? 2147483647 : 32767;
743 /* #line commands expand macros. */
744 cpp_get_token (pfile
, &token
);
745 if (token
.type
!= CPP_NUMBER
746 || strtoul_for_line (token
.val
.str
.text
, token
.val
.str
.len
, &new_lineno
))
748 cpp_error (pfile
, "\"%s\" after #line is not a positive integer",
749 cpp_token_as_text (pfile
, &token
));
753 if (CPP_PEDANTIC (pfile
) && (new_lineno
== 0 || new_lineno
> cap
))
754 cpp_pedwarn (pfile
, "line number out of range");
756 cpp_get_token (pfile
, &token
);
757 if (token
.type
== CPP_STRING
)
759 const char *fname
= (const char *) token
.val
.str
.text
;
761 /* Only accept flags for the # 55 form. */
762 if (! pfile
->state
.line_extension
)
766 int flag
= 0, sysp
= 0;
768 flag
= read_flag (pfile
, flag
);
772 flag
= read_flag (pfile
, flag
);
777 flag
= read_flag (pfile
, flag
);
782 flag
= read_flag (pfile
, flag
);
784 sysp
= 2, read_flag (pfile
, flag
);
787 if (reason
== FC_ENTER
)
789 /* Fake a buffer stack for diagnostics. */
790 cpp_push_buffer (pfile
, 0, 0, BUF_FAKE
, fname
);
791 /* Fake an include for cpp_included. */
792 _cpp_fake_include (pfile
, fname
);
793 buffer
= pfile
->buffer
;
795 else if (reason
== FC_LEAVE
)
797 if (buffer
->type
!= BUF_FAKE
)
798 cpp_warning (pfile
, "file \"%s\" left but not entered",
799 buffer
->nominal_fname
);
802 cpp_pop_buffer (pfile
);
803 buffer
= pfile
->buffer
;
804 #ifdef ENABLE_CHECKING
805 if (strcmp (buffer
->nominal_fname
, fname
))
806 cpp_warning (pfile
, "expected to return to file \"%s\"",
807 buffer
->nominal_fname
);
808 if (buffer
->lineno
+ 1 != new_lineno
)
809 cpp_warning (pfile
, "expected to return to line number %u",
811 if (buffer
->sysp
!= sysp
)
812 cpp_warning (pfile
, "header flags for \"%s\" have changed",
813 buffer
->nominal_fname
);
819 buffer
->nominal_fname
= fname
;
821 else if (token
.type
!= CPP_EOF
)
823 cpp_error (pfile
, "\"%s\" is not a valid filename",
824 cpp_token_as_text (pfile
, &token
));
828 /* Our line number is incremented after the directive is processed. */
829 buffer
->lineno
= new_lineno
- 1;
830 _cpp_do_file_change (pfile
, reason
, filename
, lineno
);
833 /* Arrange the file_change callback. */
835 _cpp_do_file_change (pfile
, reason
, from_file
, from_lineno
)
837 enum cpp_fc_reason reason
;
838 const char *from_file
;
839 unsigned int from_lineno
;
841 if (pfile
->cb
.file_change
)
844 cpp_buffer
*buffer
= pfile
->buffer
;
847 fc
.to
.filename
= buffer
->nominal_fname
;
848 fc
.to
.lineno
= buffer
->lineno
+ 1;
849 fc
.sysp
= buffer
->sysp
;
850 fc
.externc
= CPP_OPTION (pfile
, cplusplus
) && buffer
->sysp
== 2;
852 /* Caller doesn't need to handle FC_ENTER. */
853 if (reason
== FC_ENTER
)
857 from_file
= buffer
->prev
->nominal_fname
;
858 from_lineno
= buffer
->prev
->lineno
;
863 /* Special case for file "foo.i" with "# 1 foo.c" on first line. */
864 else if (reason
== FC_RENAME
&& ! buffer
->prev
865 && pfile
->directive_pos
.line
== 1)
868 fc
.from
.filename
= from_file
;
869 fc
.from
.lineno
= from_lineno
;
870 (*pfile
->cb
.file_change
) (pfile
, &fc
);
875 * Report a warning or error detected by the program we are
876 * processing. Use the directive's tokens in the error message.
880 do_diagnostic (pfile
, code
, print_dir
)
882 enum error_type code
;
885 if (_cpp_begin_message (pfile
, code
, NULL
, 0))
888 fprintf (stderr
, "#%s ", pfile
->directive
->name
);
889 pfile
->state
.prevent_expansion
++;
890 cpp_output_line (pfile
, stderr
);
891 pfile
->state
.prevent_expansion
--;
899 do_diagnostic (pfile
, ERROR
, 1);
906 /* We want #warning diagnostics to be emitted in system headers too. */
907 do_diagnostic (pfile
, WARNING_SYSHDR
, 1);
910 /* Report program identification. */
918 cpp_get_token (pfile
, &str
);
919 if (str
.type
!= CPP_STRING
)
920 cpp_error (pfile
, "invalid #ident");
921 else if (pfile
->cb
.ident
)
922 (*pfile
->cb
.ident
) (pfile
, &str
.val
.str
);
927 /* Pragmata handling. We handle some of these, and pass the rest on
928 to the front end. C99 defines three pragmas and says that no macro
929 expansion is to be performed on them; whether or not macro
930 expansion happens for other pragmas is implementation defined.
931 This implementation never macro-expands the text after #pragma. */
933 /* Sub-handlers for the pragmas needing treatment here.
934 They return 1 if the token buffer is to be popped, 0 if not. */
937 struct pragma_entry
*next
;
942 void (*handler
) PARAMS ((cpp_reader
*));
943 struct pragma_entry
*space
;
948 cpp_register_pragma (pfile
, space
, name
, handler
)
952 void (*handler
) PARAMS ((cpp_reader
*));
954 struct pragma_entry
**x
, *new;
960 struct pragma_entry
*p
= pfile
->pragmas
;
961 len
= strlen (space
);
964 if (p
->isnspace
&& p
->len
== len
&& !memcmp (p
->name
, space
, len
))
971 cpp_ice (pfile
, "unknown #pragma namespace %s", space
);
976 new = xnew (struct pragma_entry
);
978 new->len
= strlen (name
);
980 new->u
.handler
= handler
;
987 cpp_register_pragma_space (pfile
, space
)
991 struct pragma_entry
*new;
992 const struct pragma_entry
*p
= pfile
->pragmas
;
993 size_t len
= strlen (space
);
997 if (p
->isnspace
&& p
->len
== len
&& !memcmp (p
->name
, space
, len
))
998 /* Multiple different callers are allowed to register the same
1004 new = xnew (struct pragma_entry
);
1010 new->next
= pfile
->pragmas
;
1011 pfile
->pragmas
= new;
1015 _cpp_init_internal_pragmas (pfile
)
1019 cpp_register_pragma (pfile
, 0, "poison", do_pragma_poison
);
1020 cpp_register_pragma (pfile
, 0, "once", do_pragma_once
);
1023 cpp_register_pragma_space (pfile
, "GCC");
1025 cpp_register_pragma (pfile
, "GCC", "poison", do_pragma_poison
);
1026 cpp_register_pragma (pfile
, "GCC", "system_header", do_pragma_system_header
);
1027 cpp_register_pragma (pfile
, "GCC", "dependency", do_pragma_dependency
);
1034 const struct pragma_entry
*p
;
1036 const cpp_hashnode
*node
;
1042 pfile
->state
.prevent_expansion
++;
1043 cpp_start_lookahead (pfile
);
1046 cpp_get_token (pfile
, &tok
);
1047 if (tok
.type
== CPP_NAME
)
1049 node
= tok
.val
.node
;
1054 if (strlen (p
->name
) == len
&& !memcmp (p
->name
, name
, len
))
1063 (*p
->u
.handler
) (pfile
);
1072 cpp_stop_lookahead (pfile
, drop
);
1073 if (!drop
&& pfile
->cb
.def_pragma
)
1074 (*pfile
->cb
.def_pragma
) (pfile
);
1075 pfile
->state
.prevent_expansion
--;
1079 do_pragma_once (pfile
)
1082 cpp_warning (pfile
, "#pragma once is obsolete");
1084 if (pfile
->buffer
->prev
== NULL
)
1085 cpp_warning (pfile
, "#pragma once in main file");
1087 _cpp_never_reread (pfile
->buffer
->inc
);
1093 do_pragma_poison (pfile
)
1096 /* Poison these symbols so that all subsequent usage produces an
1101 pfile
->state
.poisoned_ok
= 1;
1104 _cpp_lex_token (pfile
, &tok
);
1105 if (tok
.type
== CPP_EOF
)
1107 if (tok
.type
!= CPP_NAME
)
1109 cpp_error (pfile
, "invalid #pragma GCC poison directive");
1114 if (hp
->flags
& NODE_POISONED
)
1117 if (hp
->type
== NT_MACRO
)
1118 cpp_warning (pfile
, "poisoning existing macro \"%s\"", hp
->name
);
1119 _cpp_free_definition (hp
);
1120 hp
->flags
|= NODE_POISONED
| NODE_DIAGNOSTIC
;
1122 pfile
->state
.poisoned_ok
= 0;
1124 #if 0 /* Doesn't quite work yet. */
1125 if (tok
.type
== CPP_EOF
&& pfile
->cb
.poison
)
1126 (*pfile
->cb
.poison
) (pfile
);
1130 /* Mark the current header as a system header. This will suppress
1131 some categories of warnings (notably those from -pedantic). It is
1132 intended for use in system libraries that cannot be implemented in
1133 conforming C, but cannot be certain that their headers appear in a
1134 system include directory. To prevent abuse, it is rejected in the
1135 primary source file. */
1137 do_pragma_system_header (pfile
)
1140 cpp_buffer
*buffer
= pfile
->buffer
;
1142 if (buffer
->prev
== 0)
1143 cpp_warning (pfile
, "#pragma system_header ignored outside include file");
1145 cpp_make_system_header (pfile
, 1, 0);
1150 /* Check the modified date of the current include file against a specified
1151 file. Issue a diagnostic, if the specified file is newer. We use this to
1152 determine if a fixed header should be refixed. */
1154 do_pragma_dependency (pfile
)
1157 cpp_token header
, msg
;
1160 if (parse_include (pfile
, &header
))
1163 ordering
= _cpp_compare_file_date (pfile
, &header
);
1165 cpp_warning (pfile
, "cannot find source %s",
1166 cpp_token_as_text (pfile
, &header
));
1167 else if (ordering
> 0)
1169 cpp_warning (pfile
, "current file is older than %s",
1170 cpp_token_as_text (pfile
, &header
));
1171 cpp_start_lookahead (pfile
);
1172 cpp_get_token (pfile
, &msg
);
1173 cpp_stop_lookahead (pfile
, msg
.type
== CPP_EOF
);
1174 if (msg
.type
!= CPP_EOF
)
1175 do_diagnostic (pfile
, WARNING
, 0);
1179 /* Check syntax is "(string-literal)". Returns 0 on success. */
1181 get__Pragma_string (pfile
, string
)
1187 cpp_get_token (pfile
, &paren
);
1188 if (paren
.type
!= CPP_OPEN_PAREN
)
1191 cpp_get_token (pfile
, string
);
1192 if (string
->type
!= CPP_STRING
&& string
->type
!= CPP_WSTRING
)
1195 cpp_get_token (pfile
, &paren
);
1196 return paren
.type
!= CPP_CLOSE_PAREN
;
1199 /* Returns a malloced buffer containing a destringized cpp_string by
1200 removing the first \ of \" and \\ sequences. */
1201 static unsigned char *
1202 destringize (in
, len
)
1203 const cpp_string
*in
;
1206 const unsigned char *src
, *limit
;
1207 unsigned char *dest
, *result
;
1209 dest
= result
= (unsigned char *) xmalloc (in
->len
);
1210 for (src
= in
->text
, limit
= src
+ in
->len
; src
< limit
;)
1212 /* We know there is a character following the backslash. */
1213 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1218 *len
= dest
- result
;
1223 _cpp_do__Pragma (pfile
)
1227 unsigned char *buffer
;
1230 if (get__Pragma_string (pfile
, &string
))
1232 cpp_error (pfile
, "_Pragma takes a parenthesized string literal");
1236 buffer
= destringize (&string
.val
.str
, &len
);
1237 run_directive (pfile
, T_PRAGMA
, BUF_PRAGMA
, (char *) buffer
, len
);
1238 free ((PTR
) buffer
);
1241 /* Just ignore #sccs, on systems where we define it at all. */
1242 #ifdef SCCS_DIRECTIVE
1245 cpp_reader
*pfile ATTRIBUTE_UNUSED
;
1256 if (! pfile
->buffer
->was_skipping
)
1258 const cpp_hashnode
*node
= lex_macro_node (pfile
);
1261 skip
= node
->type
!= NT_MACRO
;
1267 push_conditional (pfile
, skip
, T_IFDEF
, 0);
1275 const cpp_hashnode
*node
= 0;
1277 if (! pfile
->buffer
->was_skipping
)
1279 node
= lex_macro_node (pfile
);
1281 skip
= node
->type
== NT_MACRO
;
1287 push_conditional (pfile
, skip
, T_IFNDEF
, node
);
1290 /* #if cooperates with parse_defined to handle multiple-include
1291 optimisations. If macro expansions or identifiers appear in the
1292 expression, we cannot treat it as a controlling conditional, since
1293 their values could change in the future. */
1300 const cpp_hashnode
*cmacro
= 0;
1302 if (! pfile
->buffer
->was_skipping
)
1304 /* Controlling macro of #if ! defined () */
1305 pfile
->mi_ind_cmacro
= 0;
1306 skip
= _cpp_parse_expr (pfile
) == 0;
1307 cmacro
= pfile
->mi_ind_cmacro
;
1310 push_conditional (pfile
, skip
, T_IF
, cmacro
);
1313 /* Flip skipping state if appropriate and continue without changing
1314 if_stack; this is so that the error message for missing #endif's
1315 etc. will point to the original #if. */
1321 cpp_buffer
*buffer
= pfile
->buffer
;
1322 struct if_stack
*ifs
= buffer
->if_stack
;
1325 cpp_error (pfile
, "#else without #if");
1328 if (ifs
->type
== T_ELSE
)
1330 cpp_error (pfile
, "#else after #else");
1331 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1332 "the conditional began here");
1336 /* Buffer->was_skipping is 1 if all conditionals in this chain
1337 have been false, 2 if a conditional has been true. */
1338 if (! ifs
->was_skipping
&& buffer
->was_skipping
!= 2)
1339 buffer
->was_skipping
= ! buffer
->was_skipping
;
1341 /* Invalidate any controlling macro. */
1348 /* handle a #elif directive by not changing if_stack either. see the
1349 comment above do_else. */
1355 cpp_buffer
*buffer
= pfile
->buffer
;
1356 struct if_stack
*ifs
= buffer
->if_stack
;
1359 cpp_error (pfile
, "#elif without #if");
1362 if (ifs
->type
== T_ELSE
)
1364 cpp_error (pfile
, "#elif after #else");
1365 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1366 "the conditional began here");
1370 /* Don't evaluate #elif if our higher level is skipping. */
1371 if (! ifs
->was_skipping
)
1373 /* Buffer->was_skipping is 1 if all conditionals in this
1374 chain have been false, 2 if a conditional has been true. */
1375 if (buffer
->was_skipping
== 1)
1376 buffer
->was_skipping
= ! _cpp_parse_expr (pfile
);
1378 buffer
->was_skipping
= 2;
1380 /* Invalidate any controlling macro. */
1386 /* #endif pops the if stack and resets pfile->skipping. */
1392 cpp_buffer
*buffer
= pfile
->buffer
;
1393 struct if_stack
*ifs
= buffer
->if_stack
;
1396 cpp_error (pfile
, "#endif without #if");
1399 /* If potential control macro, we go back outside again. */
1400 if (ifs
->next
== 0 && ifs
->mi_cmacro
)
1402 pfile
->mi_state
= MI_OUTSIDE
;
1403 pfile
->mi_cmacro
= ifs
->mi_cmacro
;
1406 buffer
->if_stack
= ifs
->next
;
1407 buffer
->was_skipping
= ifs
->was_skipping
;
1408 obstack_free (pfile
->buffer_ob
, ifs
);
1414 /* Push an if_stack entry and set pfile->skipping accordingly.
1415 If this is a #ifndef starting at the beginning of a file,
1416 CMACRO is the macro name tested by the #ifndef. */
1419 push_conditional (pfile
, skip
, type
, cmacro
)
1423 const cpp_hashnode
*cmacro
;
1425 struct if_stack
*ifs
;
1426 cpp_buffer
*buffer
= pfile
->buffer
;
1428 ifs
= xobnew (pfile
->buffer_ob
, struct if_stack
);
1429 ifs
->pos
= pfile
->directive_pos
;
1430 ifs
->next
= buffer
->if_stack
;
1431 ifs
->was_skipping
= buffer
->was_skipping
;
1433 if (pfile
->mi_state
== MI_OUTSIDE
&& pfile
->mi_cmacro
== 0)
1434 ifs
->mi_cmacro
= cmacro
;
1438 buffer
->was_skipping
= skip
;
1439 buffer
->if_stack
= ifs
;
1442 /* Read the tokens of the answer into the macro pool. Only commit the
1443 memory if we intend it as permanent storage, i.e. the #assert case.
1444 Returns 0 on success. */
1447 parse_answer (pfile
, answerp
, type
)
1449 struct answer
**answerp
;
1452 cpp_token paren
, *token
;
1453 struct answer
*answer
;
1455 if (POOL_FRONT (&pfile
->macro_pool
) + sizeof (struct answer
) >
1456 POOL_LIMIT (&pfile
->macro_pool
))
1457 _cpp_next_chunk (&pfile
->macro_pool
, sizeof (struct answer
), 0);
1458 answer
= (struct answer
*) POOL_FRONT (&pfile
->macro_pool
);
1461 /* In a conditional, it is legal to not have an open paren. We
1462 should save the following token in this case. */
1464 cpp_start_lookahead (pfile
);
1465 cpp_get_token (pfile
, &paren
);
1467 cpp_stop_lookahead (pfile
, paren
.type
== CPP_OPEN_PAREN
);
1469 /* If not a paren, see if we're OK. */
1470 if (paren
.type
!= CPP_OPEN_PAREN
)
1472 /* In a conditional no answer is a test for any answer. It
1473 could be followed by any token. */
1477 /* #unassert with no answer is valid - it removes all answers. */
1478 if (type
== T_UNASSERT
&& paren
.type
== CPP_EOF
)
1481 cpp_error (pfile
, "missing '(' after predicate");
1487 token
= &answer
->first
[answer
->count
];
1488 /* Check we have room for the token. */
1489 if ((unsigned char *) (token
+ 1) >= POOL_LIMIT (&pfile
->macro_pool
))
1491 _cpp_next_chunk (&pfile
->macro_pool
, sizeof (cpp_token
),
1492 (unsigned char **) &answer
);
1493 token
= &answer
->first
[answer
->count
];
1496 cpp_get_token (pfile
, token
);
1497 if (token
->type
== CPP_CLOSE_PAREN
)
1500 if (token
->type
== CPP_EOF
)
1502 cpp_error (pfile
, "missing ')' to complete answer");
1508 if (answer
->count
== 0)
1510 cpp_error (pfile
, "predicate's answer is empty");
1514 /* Drop whitespace at start. */
1515 answer
->first
->flags
&= ~PREV_WHITE
;
1518 if (type
== T_ASSERT
|| type
== T_UNASSERT
)
1523 /* Parses an assertion, returning a pointer to the hash node of the
1524 predicate, or 0 on error. If an answer was supplied, it is placed
1525 in ANSWERP, otherwise it is set to 0. */
1526 static cpp_hashnode
*
1527 parse_assertion (pfile
, answerp
, type
)
1529 struct answer
**answerp
;
1532 cpp_hashnode
*result
= 0;
1533 cpp_token predicate
;
1535 /* We don't expand predicates or answers. */
1536 pfile
->state
.prevent_expansion
++;
1539 cpp_get_token (pfile
, &predicate
);
1540 if (predicate
.type
== CPP_EOF
)
1541 cpp_error (pfile
, "assertion without predicate");
1542 else if (predicate
.type
!= CPP_NAME
)
1543 cpp_error (pfile
, "predicate must be an identifier");
1544 else if (parse_answer (pfile
, answerp
, type
) == 0)
1546 unsigned int len
= predicate
.val
.node
->length
;
1547 unsigned char *sym
= alloca (len
+ 1);
1549 /* Prefix '#' to get it out of macro namespace. */
1551 memcpy (sym
+ 1, predicate
.val
.node
->name
, len
);
1552 result
= cpp_lookup (pfile
, sym
, len
+ 1);
1555 pfile
->state
.prevent_expansion
--;
1559 /* Returns a pointer to the pointer to the answer in the answer chain,
1560 or a pointer to NULL if the answer is not in the chain. */
1561 static struct answer
**
1562 find_answer (node
, candidate
)
1564 const struct answer
*candidate
;
1567 struct answer
**result
;
1569 for (result
= &node
->value
.answers
; *result
; result
= &(*result
)->next
)
1571 struct answer
*answer
= *result
;
1573 if (answer
->count
== candidate
->count
)
1575 for (i
= 0; i
< answer
->count
; i
++)
1576 if (! _cpp_equiv_tokens (&answer
->first
[i
], &candidate
->first
[i
]))
1579 if (i
== answer
->count
)
1587 /* Test an assertion within a preprocessor conditional. Returns
1588 non-zero on failure, zero on success. On success, the result of
1589 the test is written into VALUE. */
1591 _cpp_test_assertion (pfile
, value
)
1595 struct answer
*answer
;
1598 node
= parse_assertion (pfile
, &answer
, T_IF
);
1600 *value
= (node
->type
== NT_ASSERTION
&&
1601 (answer
== 0 || *find_answer (node
, answer
) != 0));
1603 /* We don't commit the memory for the answer - it's temporary only. */
1611 struct answer
*new_answer
;
1614 node
= parse_assertion (pfile
, &new_answer
, T_ASSERT
);
1617 /* Place the new answer in the answer list. First check there
1618 is not a duplicate. */
1619 new_answer
->next
= 0;
1620 if (node
->type
== NT_ASSERTION
)
1622 if (*find_answer (node
, new_answer
))
1624 cpp_warning (pfile
, "\"%s\" re-asserted", node
->name
+ 1);
1627 new_answer
->next
= node
->value
.answers
;
1629 node
->type
= NT_ASSERTION
;
1630 node
->value
.answers
= new_answer
;
1631 POOL_COMMIT (&pfile
->macro_pool
, (sizeof (struct answer
)
1632 + (new_answer
->count
- 1)
1633 * sizeof (cpp_token
)));
1642 struct answer
*answer
;
1644 node
= parse_assertion (pfile
, &answer
, T_UNASSERT
);
1645 /* It isn't an error to #unassert something that isn't asserted. */
1646 if (node
&& node
->type
== NT_ASSERTION
)
1650 struct answer
**p
= find_answer (node
, answer
), *temp
;
1652 /* Remove the answer from the list. */
1657 /* Did we free the last answer? */
1658 if (node
->value
.answers
== 0)
1659 node
->type
= NT_VOID
;
1662 _cpp_free_definition (node
);
1665 /* We don't commit the memory for the answer - it's temporary only. */
1668 /* These are for -D, -U, -A. */
1670 /* Process the string STR as if it appeared as the body of a #define.
1671 If STR is just an identifier, define it with value 1.
1672 If STR has anything after the identifier, then it should
1673 be identifier=definition. */
1676 cpp_define (pfile
, str
)
1683 /* Copy the entire option so we can modify it.
1684 Change the first "=" in the string to a space. If there is none,
1685 tack " 1" on the end. */
1687 /* Length including the null. */
1688 count
= strlen (str
);
1689 buf
= (char *) alloca (count
+ 2);
1690 memcpy (buf
, str
, count
);
1692 p
= strchr (str
, '=');
1701 run_directive (pfile
, T_DEFINE
, BUF_CL_OPTION
, buf
, count
);
1704 /* Slight variant of the above for use by initialize_builtins. */
1706 _cpp_define_builtin (pfile
, str
)
1710 run_directive (pfile
, T_DEFINE
, BUF_BUILTIN
, str
, strlen (str
));
1713 /* Process MACRO as if it appeared as the body of an #undef. */
1715 cpp_undef (pfile
, macro
)
1719 run_directive (pfile
, T_UNDEF
, BUF_CL_OPTION
, macro
, strlen (macro
));
1722 /* Process the string STR as if it appeared as the body of a #assert. */
1724 cpp_assert (pfile
, str
)
1728 handle_assertion (pfile
, str
, T_ASSERT
);
1731 /* Process STR as if it appeared as the body of an #unassert. */
1733 cpp_unassert (pfile
, str
)
1737 handle_assertion (pfile
, str
, T_UNASSERT
);
1740 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1742 handle_assertion (pfile
, str
, type
)
1747 size_t count
= strlen (str
);
1748 const char *p
= strchr (str
, '=');
1752 /* Copy the entire option so we can modify it. Change the first
1753 "=" in the string to a '(', and tack a ')' on the end. */
1754 char *buf
= (char *) alloca (count
+ 1);
1756 memcpy (buf
, str
, count
);
1762 run_directive (pfile
, type
, BUF_CL_OPTION
, str
, count
);
1765 /* The number of errors for a given reader. */
1770 return pfile
->errors
;
1773 /* The options structure. */
1775 cpp_get_options (pfile
)
1778 return &pfile
->opts
;
1781 /* The callbacks structure. */
1783 cpp_get_callbacks (pfile
)
1789 /* Copy the given callbacks structure to our own. */
1791 cpp_set_callbacks (pfile
, cb
)
1798 /* Push a new buffer on the buffer stack. Returns the new buffer; it
1799 doesn't fail. It does not generate a file change call back; that
1800 is the responsibility of the caller. */
1802 cpp_push_buffer (pfile
, buffer
, len
, type
, filename
)
1804 const U_CHAR
*buffer
;
1806 enum cpp_buffer_type type
;
1807 const char *filename
;
1809 cpp_buffer
*new = xobnew (pfile
->buffer_ob
, cpp_buffer
);
1811 if (type
== BUF_FAKE
)
1813 /* A copy of the current buffer, just with a new name and type. */
1814 memcpy (new, pfile
->buffer
, sizeof (cpp_buffer
));
1815 new->type
= BUF_FAKE
;
1819 if (type
== BUF_BUILTIN
)
1820 filename
= _("<builtin>");
1821 else if (type
== BUF_CL_OPTION
)
1822 filename
= _("<command line>");
1823 else if (type
== BUF_PRAGMA
)
1824 filename
= "<_Pragma>";
1826 /* Clears, amongst other things, if_stack and mi_cmacro. */
1827 memset (new, 0, sizeof (cpp_buffer
));
1829 new->line_base
= new->buf
= new->cur
= buffer
;
1830 new->rlimit
= buffer
+ len
;
1833 /* No read ahead or extra char initially. */
1834 new->read_ahead
= EOF
;
1835 new->extra_char
= EOF
;
1837 /* Preprocessed files, builtins, _Pragma and command line
1838 options don't do trigraph and escaped newline processing. */
1839 new->from_stage3
= type
!= BUF_FILE
|| CPP_OPTION (pfile
, preprocessed
);
1841 pfile
->lexer_pos
.output_line
= 1;
1844 if (*filename
== '\0')
1845 new->nominal_fname
= _("<stdin>");
1847 new->nominal_fname
= filename
;
1849 new->prev
= pfile
->buffer
;
1851 new->include_stack_listed
= 0;
1854 pfile
->state
.next_bol
= 1;
1855 pfile
->buffer_stack_depth
++;
1856 pfile
->buffer
= new;
1861 /* If called from do_line, pops a single buffer. Otherwise pops all
1862 buffers until a real file is reached. Generates appropriate
1865 cpp_pop_buffer (pfile
)
1869 struct if_stack
*ifs
;
1873 buffer
= pfile
->buffer
;
1874 /* Walk back up the conditional stack till we reach its level at
1875 entry to this file, issuing error messages. */
1876 for (ifs
= buffer
->if_stack
; ifs
; ifs
= ifs
->next
)
1877 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1878 "unterminated #%s", dtable
[ifs
->type
].name
);
1880 if (buffer
->type
== BUF_FAKE
)
1881 buffer
->prev
->cur
= buffer
->cur
;
1882 else if (buffer
->type
== BUF_FILE
)
1883 _cpp_pop_file_buffer (pfile
, buffer
);
1885 pfile
->buffer
= buffer
->prev
;
1886 pfile
->buffer_stack_depth
--;
1888 /* Callbacks only generated for faked or real files. */
1889 if (buffer
->type
!= BUF_FILE
&& buffer
->type
!= BUF_FAKE
)
1892 /* No callback for EOF of last file. */
1896 /* do_line does its own call backs. */
1897 pfile
->buffer
->include_stack_listed
= 0;
1898 if (pfile
->directive
== &dtable
[T_LINE
])
1901 _cpp_do_file_change (pfile
, FC_LEAVE
, buffer
->nominal_fname
,
1903 if (pfile
->buffer
->type
== BUF_FILE
)
1906 cpp_warning (pfile
, "file \"%s\" entered but not left",
1907 buffer
->nominal_fname
);
1910 obstack_free (pfile
->buffer_ob
, buffer
);
1911 return pfile
->buffer
;
1914 #define obstack_chunk_alloc xmalloc
1915 #define obstack_chunk_free free
1917 _cpp_init_stacks (pfile
)
1923 pfile
->buffer_ob
= xnew (struct obstack
);
1924 obstack_init (pfile
->buffer_ob
);
1926 /* Register the directives. */
1927 for (i
= 0; i
< (unsigned int) N_DIRECTIVES
; i
++)
1929 node
= cpp_lookup (pfile
, dtable
[i
].name
, dtable
[i
].length
);
1930 node
->directive_index
= i
+ 1;
1935 _cpp_cleanup_stacks (pfile
)
1938 obstack_free (pfile
->buffer_ob
, 0);
1939 free (pfile
->buffer_ob
);