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. */
30 /* Chained list of answers to an assertion. */
38 /* Stack of conditionals currently in progress
39 (including both successful and failing conditionals). */
43 struct if_stack
*next
;
44 cpp_lexer_pos pos
; /* line and column where condition started */
45 const cpp_hashnode
*mi_cmacro
;/* macro name for #ifndef around entire file */
46 unsigned char was_skipping
; /* Value of pfile->skipping before this if. */
47 int type
; /* type of last directive seen in this group */
50 /* Values for the origin field of struct directive. KANDR directives
51 come from traditional (K&R) C. STDC89 directives come from the
52 1989 C standard. EXTENSION directives are extensions. */
57 /* Values for the flags field of struct directive. COND indicates a
58 conditional; IF_COND an opening conditional. INCL means to treat
59 "..." and <...> as q-char and h-char sequences respectively. IN_I
60 means this directive should be handled even if -fpreprocessed is in
61 effect (these are the directives with callback hooks). */
63 #define IF_COND (1 << 1)
67 /* Defines one #-directive, including how to handle it. */
68 typedef void (*directive_handler
) PARAMS ((cpp_reader
*));
69 typedef struct directive directive
;
72 directive_handler handler
; /* Function to handle directive. */
73 const U_CHAR
*name
; /* Name of directive. */
74 unsigned short length
; /* Length of name. */
75 unsigned char origin
; /* Origin of directive. */
76 unsigned char flags
; /* Flags describing this directive. */
79 /* Forward declarations. */
81 static void skip_rest_of_line
PARAMS ((cpp_reader
*));
82 static void check_eol
PARAMS ((cpp_reader
*));
83 static void start_directive
PARAMS ((cpp_reader
*));
84 static void end_directive
PARAMS ((cpp_reader
*, int));
85 static void run_directive
PARAMS ((cpp_reader
*, int,
87 const char *, size_t));
88 static int glue_header_name
PARAMS ((cpp_reader
*, cpp_token
*));
89 static int parse_include
PARAMS ((cpp_reader
*, cpp_token
*));
90 static void push_conditional
PARAMS ((cpp_reader
*, int, int,
91 const cpp_hashnode
*));
92 static unsigned int read_flag
PARAMS ((cpp_reader
*, unsigned int));
93 static int strtoul_for_line
PARAMS ((const U_CHAR
*, unsigned int,
95 static void do_diagnostic
PARAMS ((cpp_reader
*, enum error_type
, int));
96 static cpp_hashnode
*lex_macro_node
PARAMS ((cpp_reader
*));
97 static void do_include_common
PARAMS ((cpp_reader
*, enum include_type
));
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));
112 /* This is the table of directive handlers. It is ordered by
113 frequency of occurrence; the numbers at the end are directive
114 counts from all the source code I have lying around (egcs and libc
115 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
116 pcmcia-cs-3.0.9). This is no longer important as directive lookup
117 is now O(1). All extensions other than #warning and #include_next
118 are deprecated. The name is where the extension appears to have
121 #define DIRECTIVE_TABLE \
122 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
123 D(include, T_INCLUDE, KANDR, INCL) /* 52262 */ \
124 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
125 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
126 D(if, T_IF, KANDR, COND | IF_COND) /* 18162 */ \
127 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
128 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
129 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
130 D(line, T_LINE, KANDR, IN_I) /* 2465 */ \
131 D(elif, T_ELIF, STDC89, COND) /* 610 */ \
132 D(error, T_ERROR, STDC89, 0) /* 475 */ \
133 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
134 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
135 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL) /* 19 */ \
136 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
137 D(import, T_IMPORT, EXTENSION, INCL) /* 0 ObjC */ \
138 D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
139 D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
140 SCCS_ENTRY /* 0 SVR4? */
142 /* #sccs is not always recognized. */
143 #ifdef SCCS_DIRECTIVE
144 # define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION, 0)
146 # define SCCS_ENTRY /* nothing */
149 /* Use the table to generate a series of prototypes, an enum for the
150 directive names, and an array of directive handlers. */
152 /* The directive-processing functions are declared to return int
153 instead of void, because some old compilers have trouble with
154 pointers to functions returning void. */
156 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
157 #define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
161 #define D(n, tag, o, f) tag,
169 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
170 #define D(name, t, origin, flags) \
171 { CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
172 sizeof STRINGX(name) - 1, origin, flags },
173 static const directive dtable
[] =
178 #undef DIRECTIVE_TABLE
180 /* Skip any remaining tokens in a directive. */
182 skip_rest_of_line (pfile
)
187 /* Discard all input lookaheads. */
188 while (pfile
->la_read
)
189 _cpp_release_lookahead (pfile
);
191 /* Discard all stacked contexts. */
192 while (pfile
->context
!= &pfile
->base_context
)
193 _cpp_pop_context (pfile
);
195 /* Sweep up all tokens remaining on the line. */
196 pfile
->state
.prevent_expansion
++;
197 while (!pfile
->state
.next_bol
)
198 _cpp_lex_token (pfile
, &token
);
199 pfile
->state
.prevent_expansion
--;
202 /* Ensure there are no stray tokens at the end of a directive. */
207 if (!pfile
->state
.next_bol
)
211 _cpp_lex_token (pfile
, &token
);
212 if (token
.type
!= CPP_EOF
)
213 cpp_pedwarn (pfile
, "extra tokens at end of #%s directive",
214 pfile
->directive
->name
);
218 /* Called when entering a directive, _Pragma or command-line directive. */
220 start_directive (pfile
)
223 cpp_buffer
*buffer
= pfile
->buffer
;
225 /* Setup in-directive state. */
226 pfile
->state
.in_directive
= 1;
227 pfile
->state
.save_comments
= 0;
229 /* Some handlers need the position of the # for diagnostics. */
230 pfile
->directive_pos
= pfile
->lexer_pos
;
232 /* Don't save directive tokens for external clients. */
233 pfile
->la_saved
= pfile
->la_write
;
236 /* Turn off skipping. */
237 buffer
->was_skipping
= pfile
->skipping
;
241 /* Called when leaving a directive, _Pragma or command-line directive. */
243 end_directive (pfile
, skip_line
)
247 cpp_buffer
*buffer
= pfile
->buffer
;
249 /* Restore pfile->skipping before skip_rest_of_line, so that e.g.
250 __VA_ARGS__ in the rest of the directive doesn't warn. */
251 pfile
->skipping
= buffer
->was_skipping
;
253 /* We don't skip for an assembler #. */
255 skip_rest_of_line (pfile
);
258 pfile
->la_write
= pfile
->la_saved
;
259 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
260 pfile
->state
.in_directive
= 0;
261 pfile
->state
.angled_headers
= 0;
262 pfile
->state
.line_extension
= 0;
263 pfile
->directive
= 0;
266 /* Check if a token's name matches that of a known directive. Put in
267 this file to save exporting dtable and other unneeded information. */
269 _cpp_handle_directive (pfile
, indented
)
273 cpp_buffer
*buffer
= pfile
->buffer
;
274 const directive
*dir
= 0;
278 start_directive (pfile
);
280 /* Lex the directive name directly. */
281 _cpp_lex_token (pfile
, &dname
);
283 if (dname
.type
== CPP_NAME
)
285 unsigned int index
= dname
.val
.node
->directive_index
;
287 dir
= &dtable
[index
- 1];
289 else if (dname
.type
== CPP_NUMBER
)
291 /* # followed by a number is equivalent to #line. Do not
292 recognize this form in assembly language source files or
293 skipped conditional groups. Complain about this form if
294 we're being pedantic, but not if this is regurgitated input
295 (preprocessed or fed back in by the C++ frontend). */
296 if (! buffer
->was_skipping
&& CPP_OPTION (pfile
, lang
) != CLK_ASM
)
298 dir
= &dtable
[T_LINE
];
299 pfile
->state
.line_extension
= 1;
300 _cpp_push_token (pfile
, &dname
, &pfile
->directive_pos
);
301 if (CPP_PEDANTIC (pfile
) && ! CPP_OPTION (pfile
, preprocessed
))
302 cpp_pedwarn (pfile
, "# followed by integer");
306 pfile
->directive
= dir
;
309 /* Make sure we lex headers correctly, whether skipping or not. */
310 pfile
->state
.angled_headers
= dir
->flags
& INCL
;
312 /* If we are rescanning preprocessed input, only directives tagged
313 with IN_I are honored, and the warnings below are suppressed. */
314 if (! CPP_OPTION (pfile
, preprocessed
) || dir
->flags
& IN_I
)
316 /* Traditionally, a directive is ignored unless its # is in
317 column 1. Therefore in code intended to work with K+R
318 compilers, directives added by C89 must have their #
319 indented, and directives present in traditional C must
320 not. This is true even of directives in skipped
321 conditional blocks. */
322 if (CPP_WTRADITIONAL (pfile
))
324 if (dir
== &dtable
[T_ELIF
])
326 "suggest not using #elif in traditional C");
327 else 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
&& ! buffer
->was_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_WARN
)
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
+ 1);
529 memcpy (token_mem
, buffer
, total_len
);
530 token_mem
[total_len
] = '\0';
532 header
->type
= CPP_HEADER_NAME
;
533 header
->flags
&= ~PREV_WHITE
;
534 header
->val
.str
.len
= total_len
;
535 header
->val
.str
.text
= token_mem
;
539 return token
.type
== CPP_EOF
;
542 /* Parse the header name of #include, #include_next, #import and
543 #pragma dependency. Returns zero on success. */
545 parse_include (pfile
, header
)
549 int is_pragma
= pfile
->directive
== &dtable
[T_PRAGMA
];
550 const unsigned char *dir
;
553 dir
= U
"pragma dependency";
555 dir
= pfile
->directive
->name
;
557 /* Allow macro expansion. */
558 cpp_get_token (pfile
, header
);
559 if (header
->type
!= CPP_STRING
&& header
->type
!= CPP_HEADER_NAME
)
561 if (header
->type
!= CPP_LESS
)
563 cpp_error (pfile
, "#%s expects \"FILENAME\" or <FILENAME>", dir
);
566 if (glue_header_name (pfile
, header
))
570 if (header
->val
.str
.len
== 0)
572 cpp_error (pfile
, "empty file name in #%s", dir
);
579 /* Get out of macro context, if we are. */
580 skip_rest_of_line (pfile
);
581 if (pfile
->cb
.include
)
582 (*pfile
->cb
.include
) (pfile
, dir
, header
);
588 /* Handle #include, #include_next and #import. */
590 do_include_common (pfile
, type
)
592 enum include_type type
;
596 if (!parse_include (pfile
, &header
))
598 /* Prevent #include recursion. */
599 if (pfile
->buffer_stack_depth
>= CPP_STACK_MAX
)
600 cpp_fatal (pfile
, "#include nested too deeply");
601 else if (pfile
->context
->prev
)
602 cpp_ice (pfile
, "attempt to push file buffer with contexts stacked");
605 /* For #include_next, if this is the primary source file,
606 warn and use the normal search logic. */
607 if (type
== IT_INCLUDE_NEXT
&& ! pfile
->buffer
->prev
)
609 cpp_warning (pfile
, "#include_next in primary source file");
613 _cpp_execute_include (pfile
, &header
, type
);
622 do_include_common (pfile
, IT_INCLUDE
);
629 if (!pfile
->import_warning
&& CPP_OPTION (pfile
, warn_import
))
631 pfile
->import_warning
= 1;
633 "#import is obsolete, use an #ifndef wrapper in the header file");
636 do_include_common (pfile
, IT_IMPORT
);
640 do_include_next (pfile
)
643 do_include_common (pfile
, IT_INCLUDE_NEXT
);
646 /* Subroutine of do_line. Read possible flags after file name. LAST
647 is the last flag seen; 0 if this is the first flag. Return the flag
648 if it is valid, 0 at the end of the directive. Otherwise complain. */
651 read_flag (pfile
, last
)
657 _cpp_lex_token (pfile
, &token
);
658 if (token
.type
== CPP_NUMBER
&& token
.val
.str
.len
== 1)
660 unsigned int flag
= token
.val
.str
.text
[0] - '0';
662 if (flag
> last
&& flag
<= 4
663 && (flag
!= 4 || last
== 3)
664 && (flag
!= 2 || last
== 0))
668 if (token
.type
!= CPP_EOF
)
669 cpp_error (pfile
, "invalid flag \"%s\" in line directive",
670 cpp_token_as_text (pfile
, &token
));
674 /* Another subroutine of do_line. Convert a number in STR, of length
675 LEN, to binary; store it in NUMP, and return 0 if the number was
676 well-formed, 1 if not. Temporary, hopefully. */
678 strtoul_for_line (str
, len
, nump
)
683 unsigned long reg
= 0;
697 /* Interpret #line command.
698 Note that the filename string (if any) is treated as if it were an
699 include filename. That means no escape handling. */
705 cpp_buffer
*buffer
= pfile
->buffer
;
706 const char *filename
= buffer
->nominal_fname
;
707 unsigned int lineno
= buffer
->lineno
;
708 enum cpp_fc_reason reason
= FC_RENAME
;
709 unsigned long new_lineno
;
713 /* C99 raised the minimum limit on #line numbers. */
714 cap
= CPP_OPTION (pfile
, c99
) ? 2147483647 : 32767;
716 /* #line commands expand macros. */
717 cpp_get_token (pfile
, &token
);
718 if (token
.type
!= CPP_NUMBER
719 || strtoul_for_line (token
.val
.str
.text
, token
.val
.str
.len
, &new_lineno
))
721 cpp_error (pfile
, "\"%s\" after #line is not a positive integer",
722 cpp_token_as_text (pfile
, &token
));
726 if (CPP_PEDANTIC (pfile
) && (new_lineno
== 0 || new_lineno
> cap
))
727 cpp_pedwarn (pfile
, "line number out of range");
729 cpp_get_token (pfile
, &token
);
730 if (token
.type
== CPP_STRING
)
732 const char *fname
= (const char *) token
.val
.str
.text
;
734 /* Only accept flags for the # 55 form. */
735 if (! pfile
->state
.line_extension
)
739 int flag
= 0, sysp
= 0;
741 flag
= read_flag (pfile
, flag
);
745 flag
= read_flag (pfile
, flag
);
750 flag
= read_flag (pfile
, flag
);
755 flag
= read_flag (pfile
, flag
);
757 sysp
= 2, read_flag (pfile
, flag
);
760 if (reason
== FC_ENTER
)
762 /* Fake a buffer stack for diagnostics. */
763 cpp_push_buffer (pfile
, 0, 0, BUF_FAKE
, fname
);
764 /* Fake an include for cpp_included. */
765 _cpp_fake_include (pfile
, fname
);
766 buffer
= pfile
->buffer
;
768 else if (reason
== FC_LEAVE
)
770 if (buffer
->type
!= BUF_FAKE
)
771 cpp_warning (pfile
, "file \"%s\" left but not entered",
772 buffer
->nominal_fname
);
775 cpp_pop_buffer (pfile
);
776 buffer
= pfile
->buffer
;
777 #ifdef ENABLE_CHECKING
778 if (strcmp (buffer
->nominal_fname
, fname
))
779 cpp_warning (pfile
, "expected to return to file \"%s\"",
780 buffer
->nominal_fname
);
781 if (buffer
->lineno
+ 1 != new_lineno
)
782 cpp_warning (pfile
, "expected to return to line number %u",
784 if (buffer
->sysp
!= sysp
)
785 cpp_warning (pfile
, "header flags for \"%s\" have changed",
786 buffer
->nominal_fname
);
792 buffer
->nominal_fname
= fname
;
794 else if (token
.type
!= CPP_EOF
)
796 cpp_error (pfile
, "\"%s\" is not a valid filename",
797 cpp_token_as_text (pfile
, &token
));
801 /* Our line number is incremented after the directive is processed. */
802 buffer
->lineno
= new_lineno
- 1;
803 _cpp_do_file_change (pfile
, reason
, filename
, lineno
);
806 /* Arrange the file_change callback. */
808 _cpp_do_file_change (pfile
, reason
, from_file
, from_lineno
)
810 enum cpp_fc_reason reason
;
811 const char *from_file
;
812 unsigned int from_lineno
;
814 if (pfile
->cb
.file_change
)
817 cpp_buffer
*buffer
= pfile
->buffer
;
820 fc
.to
.filename
= buffer
->nominal_fname
;
821 fc
.to
.lineno
= buffer
->lineno
+ 1;
822 fc
.sysp
= buffer
->sysp
;
823 fc
.externc
= CPP_OPTION (pfile
, cplusplus
) && buffer
->sysp
== 2;
825 /* Caller doesn't need to handle FC_ENTER. */
826 if (reason
== FC_ENTER
)
830 from_file
= buffer
->prev
->nominal_fname
;
831 from_lineno
= buffer
->prev
->lineno
;
836 /* Special case for file "foo.i" with "# 1 foo.c" on first line. */
837 else if (reason
== FC_RENAME
&& ! buffer
->prev
838 && pfile
->directive_pos
.line
== 1)
841 fc
.from
.filename
= from_file
;
842 fc
.from
.lineno
= from_lineno
;
843 pfile
->cb
.file_change (pfile
, &fc
);
848 * Report a warning or error detected by the program we are
849 * processing. Use the directive's tokens in the error message.
853 do_diagnostic (pfile
, code
, print_dir
)
855 enum error_type code
;
858 if (_cpp_begin_message (pfile
, code
, NULL
, 0))
861 fprintf (stderr
, "#%s ", pfile
->directive
->name
);
862 pfile
->state
.prevent_expansion
++;
863 cpp_output_line (pfile
, stderr
);
864 pfile
->state
.prevent_expansion
--;
872 do_diagnostic (pfile
, ERROR
, 1);
879 /* We want #warning diagnostics to be emitted in system headers too. */
880 do_diagnostic (pfile
, WARNING_SYSHDR
, 1);
883 /* Report program identification. */
891 cpp_get_token (pfile
, &str
);
892 if (str
.type
!= CPP_STRING
)
893 cpp_error (pfile
, "invalid #ident");
894 else if (pfile
->cb
.ident
)
895 (*pfile
->cb
.ident
) (pfile
, &str
.val
.str
);
900 /* Pragmata handling. We handle some of these, and pass the rest on
901 to the front end. C99 defines three pragmas and says that no macro
902 expansion is to be performed on them; whether or not macro
903 expansion happens for other pragmas is implementation defined.
904 This implementation never macro-expands the text after #pragma. */
906 /* Sub-handlers for the pragmas needing treatment here.
907 They return 1 if the token buffer is to be popped, 0 if not. */
910 struct pragma_entry
*next
;
915 void (*handler
) PARAMS ((cpp_reader
*));
916 struct pragma_entry
*space
;
921 cpp_register_pragma (pfile
, space
, name
, handler
)
925 void (*handler
) PARAMS ((cpp_reader
*));
927 struct pragma_entry
**x
, *new;
933 struct pragma_entry
*p
= pfile
->pragmas
;
934 len
= strlen (space
);
937 if (p
->isnspace
&& p
->len
== len
&& !memcmp (p
->name
, space
, len
))
944 cpp_ice (pfile
, "unknown #pragma namespace %s", space
);
949 new = xnew (struct pragma_entry
);
951 new->len
= strlen (name
);
953 new->u
.handler
= handler
;
960 cpp_register_pragma_space (pfile
, space
)
964 struct pragma_entry
*new;
965 const struct pragma_entry
*p
= pfile
->pragmas
;
966 size_t len
= strlen (space
);
970 if (p
->isnspace
&& p
->len
== len
&& !memcmp (p
->name
, space
, len
))
971 /* Multiple different callers are allowed to register the same
977 new = xnew (struct pragma_entry
);
983 new->next
= pfile
->pragmas
;
984 pfile
->pragmas
= new;
988 _cpp_init_internal_pragmas (pfile
)
992 cpp_register_pragma (pfile
, 0, "poison", do_pragma_poison
);
993 cpp_register_pragma (pfile
, 0, "once", do_pragma_once
);
996 cpp_register_pragma_space (pfile
, "GCC");
998 cpp_register_pragma (pfile
, "GCC", "poison", do_pragma_poison
);
999 cpp_register_pragma (pfile
, "GCC", "system_header", do_pragma_system_header
);
1000 cpp_register_pragma (pfile
, "GCC", "dependency", do_pragma_dependency
);
1007 const struct pragma_entry
*p
;
1009 const cpp_hashnode
*node
;
1015 pfile
->state
.prevent_expansion
++;
1016 cpp_start_lookahead (pfile
);
1019 cpp_get_token (pfile
, &tok
);
1020 if (tok
.type
== CPP_NAME
)
1022 node
= tok
.val
.node
;
1027 if (strlen (p
->name
) == len
&& !memcmp (p
->name
, name
, len
))
1036 (*p
->u
.handler
) (pfile
);
1045 cpp_stop_lookahead (pfile
, drop
);
1046 pfile
->state
.prevent_expansion
--;
1048 if (!drop
&& pfile
->cb
.def_pragma
)
1049 (*pfile
->cb
.def_pragma
) (pfile
);
1053 do_pragma_once (pfile
)
1056 cpp_warning (pfile
, "#pragma once is obsolete");
1058 if (pfile
->buffer
->prev
== NULL
)
1059 cpp_warning (pfile
, "#pragma once in main file");
1061 _cpp_never_reread (pfile
->buffer
->inc
);
1067 do_pragma_poison (pfile
)
1070 /* Poison these symbols so that all subsequent usage produces an
1075 pfile
->state
.poisoned_ok
= 1;
1078 _cpp_lex_token (pfile
, &tok
);
1079 if (tok
.type
== CPP_EOF
)
1081 if (tok
.type
!= CPP_NAME
)
1083 cpp_error (pfile
, "invalid #pragma GCC poison directive");
1088 if (hp
->flags
& NODE_POISONED
)
1091 if (hp
->type
== NT_MACRO
)
1092 cpp_warning (pfile
, "poisoning existing macro \"%s\"", hp
->name
);
1093 _cpp_free_definition (hp
);
1094 hp
->flags
|= NODE_POISONED
| NODE_DIAGNOSTIC
;
1096 pfile
->state
.poisoned_ok
= 0;
1098 #if 0 /* Doesn't quite work yet. */
1099 if (tok
.type
== CPP_EOF
&& pfile
->cb
.poison
)
1100 (*pfile
->cb
.poison
) (pfile
);
1104 /* Mark the current header as a system header. This will suppress
1105 some categories of warnings (notably those from -pedantic). It is
1106 intended for use in system libraries that cannot be implemented in
1107 conforming C, but cannot be certain that their headers appear in a
1108 system include directory. To prevent abuse, it is rejected in the
1109 primary source file. */
1111 do_pragma_system_header (pfile
)
1114 cpp_buffer
*buffer
= pfile
->buffer
;
1116 if (buffer
->prev
== 0)
1117 cpp_warning (pfile
, "#pragma system_header ignored outside include file");
1119 cpp_make_system_header (pfile
, 1, 0);
1124 /* Check the modified date of the current include file against a specified
1125 file. Issue a diagnostic, if the specified file is newer. We use this to
1126 determine if a fixed header should be refixed. */
1128 do_pragma_dependency (pfile
)
1131 cpp_token header
, msg
;
1134 if (parse_include (pfile
, &header
))
1137 ordering
= _cpp_compare_file_date (pfile
, &header
);
1139 cpp_warning (pfile
, "cannot find source %s",
1140 cpp_token_as_text (pfile
, &header
));
1141 else if (ordering
> 0)
1143 cpp_warning (pfile
, "current file is older than %s",
1144 cpp_token_as_text (pfile
, &header
));
1145 cpp_start_lookahead (pfile
);
1146 cpp_get_token (pfile
, &msg
);
1147 cpp_stop_lookahead (pfile
, msg
.type
== CPP_EOF
);
1148 if (msg
.type
!= CPP_EOF
)
1149 do_diagnostic (pfile
, WARNING
, 0);
1153 /* Check syntax is "(string-literal)". Returns 0 on success. */
1155 get__Pragma_string (pfile
, string
)
1161 cpp_get_token (pfile
, &paren
);
1162 if (paren
.type
!= CPP_OPEN_PAREN
)
1165 cpp_get_token (pfile
, string
);
1166 if (string
->type
!= CPP_STRING
&& string
->type
!= CPP_WSTRING
)
1169 cpp_get_token (pfile
, &paren
);
1170 return paren
.type
!= CPP_CLOSE_PAREN
;
1173 /* Returns a malloced buffer containing a destringized cpp_string by
1174 removing the first \ of \" and \\ sequences. */
1175 static unsigned char *
1176 destringize (in
, len
)
1177 const cpp_string
*in
;
1180 const unsigned char *src
, *limit
;
1181 unsigned char *dest
, *result
;
1183 dest
= result
= (unsigned char *) xmalloc (in
->len
);
1184 for (src
= in
->text
, limit
= src
+ in
->len
; src
< limit
;)
1186 /* We know there is a character following the backslash. */
1187 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1192 *len
= dest
- result
;
1197 _cpp_do__Pragma (pfile
)
1201 unsigned char *buffer
;
1204 if (get__Pragma_string (pfile
, &string
))
1206 cpp_error (pfile
, "_Pragma takes a parenthesized string literal");
1210 buffer
= destringize (&string
.val
.str
, &len
);
1211 run_directive (pfile
, T_PRAGMA
, BUF_PRAGMA
, (char *) buffer
, len
);
1212 free ((PTR
) buffer
);
1215 /* Just ignore #sccs, on systems where we define it at all. */
1216 #ifdef SCCS_DIRECTIVE
1219 cpp_reader
*pfile ATTRIBUTE_UNUSED
;
1230 if (! pfile
->buffer
->was_skipping
)
1232 const cpp_hashnode
*node
= lex_macro_node (pfile
);
1235 skip
= node
->type
!= NT_MACRO
;
1241 push_conditional (pfile
, skip
, T_IFDEF
, 0);
1249 const cpp_hashnode
*node
= 0;
1251 if (! pfile
->buffer
->was_skipping
)
1253 node
= lex_macro_node (pfile
);
1255 skip
= node
->type
== NT_MACRO
;
1261 push_conditional (pfile
, skip
, T_IFNDEF
, node
);
1264 /* #if cooperates with parse_defined to handle multiple-include
1265 optimisations. If macro expansions or identifiers appear in the
1266 expression, we cannot treat it as a controlling conditional, since
1267 their values could change in the future. */
1274 const cpp_hashnode
*cmacro
= 0;
1276 if (! pfile
->buffer
->was_skipping
)
1278 /* Controlling macro of #if ! defined () */
1279 pfile
->mi_ind_cmacro
= 0;
1280 skip
= _cpp_parse_expr (pfile
) == 0;
1281 cmacro
= pfile
->mi_ind_cmacro
;
1284 push_conditional (pfile
, skip
, T_IF
, cmacro
);
1287 /* Flip skipping state if appropriate and continue without changing
1288 if_stack; this is so that the error message for missing #endif's
1289 etc. will point to the original #if. */
1295 cpp_buffer
*buffer
= pfile
->buffer
;
1296 struct if_stack
*ifs
= buffer
->if_stack
;
1299 cpp_error (pfile
, "#else without #if");
1302 if (ifs
->type
== T_ELSE
)
1304 cpp_error (pfile
, "#else after #else");
1305 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1306 "the conditional began here");
1310 /* Buffer->was_skipping is 1 if all conditionals in this chain
1311 have been false, 2 if a conditional has been true. */
1312 if (! ifs
->was_skipping
&& buffer
->was_skipping
!= 2)
1313 buffer
->was_skipping
= ! buffer
->was_skipping
;
1315 /* Invalidate any controlling macro. */
1322 /* handle a #elif directive by not changing if_stack either. see the
1323 comment above do_else. */
1329 cpp_buffer
*buffer
= pfile
->buffer
;
1330 struct if_stack
*ifs
= buffer
->if_stack
;
1333 cpp_error (pfile
, "#elif without #if");
1336 if (ifs
->type
== T_ELSE
)
1338 cpp_error (pfile
, "#elif after #else");
1339 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1340 "the conditional began here");
1344 /* Don't evaluate #elif if our higher level is skipping. */
1345 if (! ifs
->was_skipping
)
1347 /* Buffer->was_skipping is 1 if all conditionals in this
1348 chain have been false, 2 if a conditional has been true. */
1349 if (buffer
->was_skipping
== 1)
1350 buffer
->was_skipping
= ! _cpp_parse_expr (pfile
);
1352 buffer
->was_skipping
= 2;
1354 /* Invalidate any controlling macro. */
1360 /* #endif pops the if stack and resets pfile->skipping. */
1366 cpp_buffer
*buffer
= pfile
->buffer
;
1367 struct if_stack
*ifs
= buffer
->if_stack
;
1370 cpp_error (pfile
, "#endif without #if");
1373 /* If potential control macro, we go back outside again. */
1374 if (ifs
->next
== 0 && ifs
->mi_cmacro
)
1376 pfile
->mi_state
= MI_OUTSIDE
;
1377 pfile
->mi_cmacro
= ifs
->mi_cmacro
;
1380 buffer
->if_stack
= ifs
->next
;
1381 buffer
->was_skipping
= ifs
->was_skipping
;
1382 obstack_free (pfile
->buffer_ob
, ifs
);
1388 /* Push an if_stack entry and set pfile->skipping accordingly.
1389 If this is a #ifndef starting at the beginning of a file,
1390 CMACRO is the macro name tested by the #ifndef. */
1393 push_conditional (pfile
, skip
, type
, cmacro
)
1397 const cpp_hashnode
*cmacro
;
1399 struct if_stack
*ifs
;
1400 cpp_buffer
*buffer
= pfile
->buffer
;
1402 ifs
= xobnew (pfile
->buffer_ob
, struct if_stack
);
1403 ifs
->pos
= pfile
->directive_pos
;
1404 ifs
->next
= buffer
->if_stack
;
1405 ifs
->was_skipping
= buffer
->was_skipping
;
1407 if (pfile
->mi_state
== MI_OUTSIDE
&& pfile
->mi_cmacro
== 0)
1408 ifs
->mi_cmacro
= cmacro
;
1412 buffer
->was_skipping
= skip
;
1413 buffer
->if_stack
= ifs
;
1416 /* Read the tokens of the answer into the macro pool. Only commit the
1417 memory if we intend it as permanent storage, i.e. the #assert case.
1418 Returns 0 on success. */
1421 parse_answer (pfile
, answerp
, type
)
1423 struct answer
**answerp
;
1426 cpp_token paren
, *token
;
1427 struct answer
*answer
;
1429 if (POOL_FRONT (&pfile
->macro_pool
) + sizeof (struct answer
) >
1430 POOL_LIMIT (&pfile
->macro_pool
))
1431 _cpp_next_chunk (&pfile
->macro_pool
, sizeof (struct answer
), 0);
1432 answer
= (struct answer
*) POOL_FRONT (&pfile
->macro_pool
);
1435 /* In a conditional, it is legal to not have an open paren. We
1436 should save the following token in this case. */
1438 cpp_start_lookahead (pfile
);
1439 cpp_get_token (pfile
, &paren
);
1441 cpp_stop_lookahead (pfile
, paren
.type
== CPP_OPEN_PAREN
);
1443 /* If not a paren, see if we're OK. */
1444 if (paren
.type
!= CPP_OPEN_PAREN
)
1446 /* In a conditional no answer is a test for any answer. It
1447 could be followed by any token. */
1451 /* #unassert with no answer is valid - it removes all answers. */
1452 if (type
== T_UNASSERT
&& paren
.type
== CPP_EOF
)
1455 cpp_error (pfile
, "missing '(' after predicate");
1461 token
= &answer
->first
[answer
->count
];
1462 /* Check we have room for the token. */
1463 if ((unsigned char *) (token
+ 1) >= POOL_LIMIT (&pfile
->macro_pool
))
1465 _cpp_next_chunk (&pfile
->macro_pool
, sizeof (cpp_token
),
1466 (unsigned char **) &answer
);
1467 token
= &answer
->first
[answer
->count
];
1470 cpp_get_token (pfile
, token
);
1471 if (token
->type
== CPP_CLOSE_PAREN
)
1474 if (token
->type
== CPP_EOF
)
1476 cpp_error (pfile
, "missing ')' to complete answer");
1482 if (answer
->count
== 0)
1484 cpp_error (pfile
, "predicate's answer is empty");
1488 /* Drop whitespace at start. */
1489 answer
->first
->flags
&= ~PREV_WHITE
;
1492 if (type
== T_ASSERT
|| type
== T_UNASSERT
)
1497 /* Parses an assertion, returning a pointer to the hash node of the
1498 predicate, or 0 on error. If an answer was supplied, it is placed
1499 in ANSWERP, otherwise it is set to 0. */
1500 static cpp_hashnode
*
1501 parse_assertion (pfile
, answerp
, type
)
1503 struct answer
**answerp
;
1506 cpp_hashnode
*result
= 0;
1507 cpp_token predicate
;
1509 /* We don't expand predicates or answers. */
1510 pfile
->state
.prevent_expansion
++;
1513 cpp_get_token (pfile
, &predicate
);
1514 if (predicate
.type
== CPP_EOF
)
1515 cpp_error (pfile
, "assertion without predicate");
1516 else if (predicate
.type
!= CPP_NAME
)
1517 cpp_error (pfile
, "predicate must be an identifier");
1518 else if (parse_answer (pfile
, answerp
, type
) == 0)
1520 unsigned int len
= predicate
.val
.node
->length
;
1521 unsigned char *sym
= alloca (len
+ 1);
1523 /* Prefix '#' to get it out of macro namespace. */
1525 memcpy (sym
+ 1, predicate
.val
.node
->name
, len
);
1526 result
= cpp_lookup (pfile
, sym
, len
+ 1);
1529 pfile
->state
.prevent_expansion
--;
1533 /* Returns a pointer to the pointer to the answer in the answer chain,
1534 or a pointer to NULL if the answer is not in the chain. */
1535 static struct answer
**
1536 find_answer (node
, candidate
)
1538 const struct answer
*candidate
;
1541 struct answer
**result
;
1543 for (result
= &node
->value
.answers
; *result
; result
= &(*result
)->next
)
1545 struct answer
*answer
= *result
;
1547 if (answer
->count
== candidate
->count
)
1549 for (i
= 0; i
< answer
->count
; i
++)
1550 if (! _cpp_equiv_tokens (&answer
->first
[i
], &candidate
->first
[i
]))
1553 if (i
== answer
->count
)
1561 /* Test an assertion within a preprocessor conditional. Returns
1562 non-zero on failure, zero on success. On success, the result of
1563 the test is written into VALUE. */
1565 _cpp_test_assertion (pfile
, value
)
1569 struct answer
*answer
;
1572 node
= parse_assertion (pfile
, &answer
, T_IF
);
1574 *value
= (node
->type
== NT_ASSERTION
&&
1575 (answer
== 0 || *find_answer (node
, answer
) != 0));
1577 /* We don't commit the memory for the answer - it's temporary only. */
1585 struct answer
*new_answer
;
1588 node
= parse_assertion (pfile
, &new_answer
, T_ASSERT
);
1591 /* Place the new answer in the answer list. First check there
1592 is not a duplicate. */
1593 new_answer
->next
= 0;
1594 if (node
->type
== NT_ASSERTION
)
1596 if (*find_answer (node
, new_answer
))
1598 cpp_warning (pfile
, "\"%s\" re-asserted", node
->name
+ 1);
1601 new_answer
->next
= node
->value
.answers
;
1603 node
->type
= NT_ASSERTION
;
1604 node
->value
.answers
= new_answer
;
1605 POOL_COMMIT (&pfile
->macro_pool
, (sizeof (struct answer
)
1606 + (new_answer
->count
- 1)
1607 * sizeof (cpp_token
)));
1616 struct answer
*answer
;
1618 node
= parse_assertion (pfile
, &answer
, T_UNASSERT
);
1619 /* It isn't an error to #unassert something that isn't asserted. */
1620 if (node
&& node
->type
== NT_ASSERTION
)
1624 struct answer
**p
= find_answer (node
, answer
), *temp
;
1626 /* Remove the answer from the list. */
1631 /* Did we free the last answer? */
1632 if (node
->value
.answers
== 0)
1633 node
->type
= NT_VOID
;
1636 _cpp_free_definition (node
);
1639 /* We don't commit the memory for the answer - it's temporary only. */
1642 /* These are for -D, -U, -A. */
1644 /* Process the string STR as if it appeared as the body of a #define.
1645 If STR is just an identifier, define it with value 1.
1646 If STR has anything after the identifier, then it should
1647 be identifier=definition. */
1650 cpp_define (pfile
, str
)
1657 /* Copy the entire option so we can modify it.
1658 Change the first "=" in the string to a space. If there is none,
1659 tack " 1" on the end. */
1661 /* Length including the null. */
1662 count
= strlen (str
);
1663 buf
= (char *) alloca (count
+ 2);
1664 memcpy (buf
, str
, count
);
1666 p
= strchr (str
, '=');
1675 run_directive (pfile
, T_DEFINE
, BUF_CL_OPTION
, buf
, count
);
1678 /* Slight variant of the above for use by initialize_builtins. */
1680 _cpp_define_builtin (pfile
, str
)
1684 run_directive (pfile
, T_DEFINE
, BUF_BUILTIN
, str
, strlen (str
));
1687 /* Process MACRO as if it appeared as the body of an #undef. */
1689 cpp_undef (pfile
, macro
)
1693 run_directive (pfile
, T_UNDEF
, BUF_CL_OPTION
, macro
, strlen (macro
));
1696 /* Process the string STR as if it appeared as the body of a #assert. */
1698 cpp_assert (pfile
, str
)
1702 handle_assertion (pfile
, str
, T_ASSERT
);
1705 /* Process STR as if it appeared as the body of an #unassert. */
1707 cpp_unassert (pfile
, str
)
1711 handle_assertion (pfile
, str
, T_UNASSERT
);
1714 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1716 handle_assertion (pfile
, str
, type
)
1721 size_t count
= strlen (str
);
1722 const char *p
= strchr (str
, '=');
1726 /* Copy the entire option so we can modify it. Change the first
1727 "=" in the string to a '(', and tack a ')' on the end. */
1728 char *buf
= (char *) alloca (count
+ 1);
1730 memcpy (buf
, str
, count
);
1736 run_directive (pfile
, type
, BUF_CL_OPTION
, str
, count
);
1739 /* The number of errors for a given reader. */
1744 return pfile
->errors
;
1747 /* The options structure. */
1749 cpp_get_options (pfile
)
1752 return &pfile
->opts
;
1755 /* The callbacks structure. */
1757 cpp_get_callbacks (pfile
)
1763 /* Copy the given callbacks structure to our own. */
1765 cpp_set_callbacks (pfile
, cb
)
1772 /* Push a new buffer on the buffer stack. Returns the new buffer; it
1773 doesn't fail. It does not generate a file change call back; that
1774 is the responsibility of the caller. */
1776 cpp_push_buffer (pfile
, buffer
, len
, type
, filename
)
1778 const U_CHAR
*buffer
;
1780 enum cpp_buffer_type type
;
1781 const char *filename
;
1783 cpp_buffer
*new = xobnew (pfile
->buffer_ob
, cpp_buffer
);
1785 if (type
== BUF_FAKE
)
1787 /* A copy of the current buffer, just with a new name and type. */
1788 memcpy (new, pfile
->buffer
, sizeof (cpp_buffer
));
1789 new->type
= BUF_FAKE
;
1793 if (type
== BUF_BUILTIN
)
1794 filename
= _("<builtin>");
1795 else if (type
== BUF_CL_OPTION
)
1796 filename
= _("<command line>");
1797 else if (type
== BUF_PRAGMA
)
1798 filename
= "<_Pragma>";
1800 /* Clears, amongst other things, if_stack and mi_cmacro. */
1801 memset (new, 0, sizeof (cpp_buffer
));
1803 new->line_base
= new->buf
= new->cur
= buffer
;
1804 new->rlimit
= buffer
+ len
;
1807 /* No read ahead or extra char initially. */
1808 new->read_ahead
= EOF
;
1809 new->extra_char
= EOF
;
1811 /* Preprocessed files, builtins, _Pragma and command line
1812 options don't do trigraph and escaped newline processing. */
1813 new->from_stage3
= type
!= BUF_FILE
|| CPP_OPTION (pfile
, preprocessed
);
1815 pfile
->lexer_pos
.output_line
= 1;
1818 if (*filename
== '\0')
1819 new->nominal_fname
= _("<stdin>");
1821 new->nominal_fname
= filename
;
1823 new->prev
= pfile
->buffer
;
1825 new->include_stack_listed
= 0;
1828 pfile
->state
.next_bol
= 1;
1829 pfile
->buffer_stack_depth
++;
1830 pfile
->buffer
= new;
1835 /* If called from do_line, pops a single buffer. Otherwise pops all
1836 buffers until a real file is reached. Generates appropriate
1839 cpp_pop_buffer (pfile
)
1843 struct if_stack
*ifs
;
1847 buffer
= pfile
->buffer
;
1848 /* Walk back up the conditional stack till we reach its level at
1849 entry to this file, issuing error messages. */
1850 for (ifs
= buffer
->if_stack
; ifs
; ifs
= ifs
->next
)
1851 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1852 "unterminated #%s", dtable
[ifs
->type
].name
);
1854 if (buffer
->type
== BUF_FAKE
)
1855 buffer
->prev
->cur
= buffer
->cur
;
1856 else if (buffer
->type
== BUF_FILE
)
1857 _cpp_pop_file_buffer (pfile
, buffer
);
1859 pfile
->buffer
= buffer
->prev
;
1860 pfile
->buffer_stack_depth
--;
1862 /* Callbacks only generated for faked or real files. */
1863 if (buffer
->type
!= BUF_FILE
&& buffer
->type
!= BUF_FAKE
)
1866 /* No callback for EOF of last file. */
1870 /* do_line does its own call backs. */
1871 pfile
->buffer
->include_stack_listed
= 0;
1872 if (pfile
->directive
== &dtable
[T_LINE
])
1875 _cpp_do_file_change (pfile
, FC_LEAVE
, buffer
->nominal_fname
,
1877 if (pfile
->buffer
->type
== BUF_FILE
)
1880 cpp_warning (pfile
, "file \"%s\" entered but not left",
1881 buffer
->nominal_fname
);
1884 obstack_free (pfile
->buffer_ob
, buffer
);
1885 return pfile
->buffer
;
1888 #define obstack_chunk_alloc xmalloc
1889 #define obstack_chunk_free free
1891 _cpp_init_stacks (pfile
)
1897 pfile
->buffer_ob
= xnew (struct obstack
);
1898 obstack_init (pfile
->buffer_ob
);
1900 /* Register the directives. */
1901 for (i
= 0; i
< (unsigned int) N_DIRECTIVES
; i
++)
1903 node
= cpp_lookup (pfile
, dtable
[i
].name
, dtable
[i
].length
);
1904 node
->directive_index
= i
+ 1;
1909 _cpp_cleanup_stacks (pfile
)
1912 obstack_free (pfile
->buffer_ob
, 0);
1913 free (pfile
->buffer_ob
);