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_sdcc_hash PARAMS ((cpp_reader *));
101 static void do_pragma_preproc_asm PARAMS ((cpp_reader *));
102 static void do_pragma_system_header PARAMS ((cpp_reader *));
103 static void do_pragma_dependency PARAMS ((cpp_reader *));
104 static int get__Pragma_string PARAMS ((cpp_reader *, cpp_token *));
105 static unsigned char *destringize PARAMS ((const cpp_string *,
107 static int parse_answer PARAMS ((cpp_reader *, struct answer **, int));
108 static cpp_hashnode *parse_assertion PARAMS ((cpp_reader *, struct answer **,
110 static struct answer ** find_answer PARAMS ((cpp_hashnode *,
111 const struct answer *));
112 static void handle_assertion PARAMS ((cpp_reader *, const char *, int));
114 extern cpp_output_string (const char *s);
116 /* This is the table of directive handlers. It is ordered by
117 frequency of occurrence; the numbers at the end are directive
118 counts from all the source code I have lying around (egcs and libc
119 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
120 pcmcia-cs-3.0.9). This is no longer important as directive lookup
121 is now O(1). All extensions other than #warning and #include_next
122 are deprecated. The name is where the extension appears to have
125 #define DIRECTIVE_TABLE \
126 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
127 D(include, T_INCLUDE, KANDR, INCL) /* 52262 */ \
128 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
129 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
130 D(if, T_IF, KANDR, COND | IF_COND) /* 18162 */ \
131 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
132 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
133 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
134 D(line, T_LINE, KANDR, IN_I) /* 2465 */ \
135 D(elif, T_ELIF, STDC89, COND) /* 610 */ \
136 D(error, T_ERROR, STDC89, 0) /* 475 */ \
137 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
138 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
139 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL) /* 19 */ \
140 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
141 D(import, T_IMPORT, EXTENSION, INCL) /* 0 ObjC */ \
142 D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
143 D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
144 SCCS_ENTRY /* 0 SVR4? */
146 /* #sccs is not always recognized. */
147 #ifdef SCCS_DIRECTIVE
148 # define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION, 0)
150 # define SCCS_ENTRY /* nothing */
153 /* Use the table to generate a series of prototypes, an enum for the
154 directive names, and an array of directive handlers. */
156 /* The directive-processing functions are declared to return int
157 instead of void, because some old compilers have trouble with
158 pointers to functions returning void. */
160 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
161 #define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
165 #define D(n, tag, o, f) tag,
173 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
174 #define D(name, t, origin, flags) \
175 { CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
176 sizeof STRINGX(name) - 1, origin, flags },
177 static const directive dtable[] =
182 #undef DIRECTIVE_TABLE
184 /* Skip any remaining tokens in a directive. */
186 skip_rest_of_line (pfile)
191 /* Discard all input lookaheads. */
192 while (pfile->la_read)
193 _cpp_release_lookahead (pfile);
195 /* Discard all stacked contexts. */
196 while (pfile->context != &pfile->base_context)
197 _cpp_pop_context (pfile);
199 /* Sweep up all tokens remaining on the line. */
200 pfile->state.prevent_expansion++;
201 while (!pfile->state.next_bol)
202 _cpp_lex_token (pfile, &token);
203 pfile->state.prevent_expansion--;
206 /* Ensure there are no stray tokens at the end of a directive. */
211 if (!pfile->state.next_bol)
215 _cpp_lex_token (pfile, &token);
216 if (token.type != CPP_EOF)
217 cpp_pedwarn (pfile, "extra tokens at end of #%s directive",
218 pfile->directive->name);
222 /* Called when entering a directive, _Pragma or command-line directive. */
224 start_directive (pfile)
227 cpp_buffer *buffer = pfile->buffer;
229 /* Setup in-directive state. */
230 pfile->state.in_directive = 1;
231 pfile->state.save_comments = 0;
233 /* Some handlers need the position of the # for diagnostics. */
234 pfile->directive_pos = pfile->lexer_pos;
236 /* Don't save directive tokens for external clients. */
237 pfile->la_saved = pfile->la_write;
240 /* Turn off skipping. */
241 buffer->was_skipping = pfile->skipping;
245 /* Called when leaving a directive, _Pragma or command-line directive. */
247 end_directive (pfile, skip_line)
251 cpp_buffer *buffer = pfile->buffer;
253 /* Restore pfile->skipping before skip_rest_of_line, so that e.g.
254 __VA_ARGS__ in the rest of the directive doesn't warn. */
255 pfile->skipping = buffer->was_skipping;
257 /* We don't skip for an assembler #. */
259 skip_rest_of_line (pfile);
262 pfile->la_write = pfile->la_saved;
263 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
264 pfile->state.in_directive = 0;
265 pfile->state.angled_headers = 0;
266 pfile->state.line_extension = 0;
267 pfile->directive = 0;
270 /* Check if a token's name matches that of a known directive. Put in
271 this file to save exporting dtable and other unneeded information. */
273 _cpp_handle_directive (pfile, indented)
277 cpp_buffer *buffer = pfile->buffer;
278 const directive *dir = 0;
282 start_directive (pfile);
284 /* Lex the directive name directly. */
285 _cpp_lex_token (pfile, &dname);
287 if (dname.type == CPP_NAME)
289 unsigned int index = dname.val.node->directive_index;
291 dir = &dtable[index - 1];
293 else if (dname.type == CPP_NUMBER)
295 /* # followed by a number is equivalent to #line. Do not
296 recognize this form in assembly language source files or
297 skipped conditional groups. Complain about this form if
298 we're being pedantic, but not if this is regurgitated input
299 (preprocessed or fed back in by the C++ frontend). */
300 if (! buffer->was_skipping && CPP_OPTION (pfile, lang) != CLK_ASM)
302 dir = &dtable[T_LINE];
303 pfile->state.line_extension = 1;
304 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
305 if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed))
306 cpp_pedwarn (pfile, "# followed by integer");
310 pfile->directive = dir;
313 /* Make sure we lex headers correctly, whether skipping or not. */
314 pfile->state.angled_headers = dir->flags & INCL;
316 /* If we are rescanning preprocessed input, only directives tagged
317 with IN_I are honored, and the warnings below are suppressed. */
318 if (CPP_OPTION (pfile, preprocessed))
320 /* Kluge alert. In order to be sure that code like this
323 does not cause '#define foo bar' to get executed when
324 compiled with -save-temps, we recognize directives in
325 -fpreprocessed mode only if the # is in column 1 and the
326 directive name starts in column 2. This output can only
327 be generated by the directive callbacks in cppmain.c (see
328 also the special case in scan_buffer). */
329 if (dir->flags & IN_I && !indented && !(dname.flags & PREV_WHITE))
330 (*dir->handler) (pfile);
331 /* That check misses '# 123' linemarkers. Let them through too. */
332 else if (dname.type == CPP_NUMBER)
333 (*dir->handler) (pfile);
336 /* We don't want to process this directive. Put back the
337 tokens so caller will see them (and issue an error,
339 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
345 /* Traditionally, a directive is ignored unless its # is in
346 column 1. Therefore in code intended to work with K+R
347 compilers, directives added by C89 must have their #
348 indented, and directives present in traditional C must
349 not. This is true even of directives in skipped
350 conditional blocks. */
351 if (CPP_WTRADITIONAL (pfile))
353 if (dir == &dtable[T_ELIF])
355 "suggest not using #elif in traditional C");
356 else if (indented && dir->origin == KANDR)
358 "traditional C ignores #%s with the # indented",
360 else if (!indented && dir->origin != KANDR)
362 "suggest hiding #%s from traditional C with an indented #",
366 /* If we are skipping a failed conditional group, all
367 non-conditional directives are ignored. */
368 if (! buffer->was_skipping || (dir->flags & COND))
370 /* Issue -pedantic warnings for extensions. */
371 if (CPP_PEDANTIC (pfile) && dir->origin == EXTENSION)
372 cpp_pedwarn (pfile, "#%s is a GCC extension", dir->name);
374 /* If we have a directive that is not an opening
375 conditional, invalidate any control macro. */
376 if (! (dir->flags & IF_COND))
377 pfile->mi_state = MI_FAILED;
379 (*dir->handler) (pfile);
383 else if (dname.type != CPP_EOF && ! buffer->was_skipping)
385 /* An unknown directive. Don't complain about it in assembly
386 source: we don't know where the comments are, and # may
387 introduce assembler pseudo-ops. Don't complain about invalid
388 directives in skipped conditional groups (6.10 p4). */
389 if (CPP_OPTION (pfile, lang) == CLK_ASM)
391 /* Output the # and lookahead token for the assembler. */
392 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
396 cpp_error (pfile, "invalid preprocessing directive #%s",
397 cpp_token_as_text (pfile, &dname));
400 end_directive (pfile, skip);
404 /* Directive handler wrapper used by the command line option
407 run_directive (pfile, dir_no, type, buf, count)
410 enum cpp_buffer_type type;
414 unsigned int output_line = pfile->lexer_pos.output_line;
417 buffer = cpp_push_buffer (pfile, (const U_CHAR *) buf, count, type, 0);
419 if (dir_no == T_PRAGMA)
421 /* A kludge to avoid line markers for _Pragma. */
422 pfile->lexer_pos.output_line = output_line;
423 /* Avoid interpretation of directives in a _Pragma string. */
424 pfile->state.next_bol = 0;
427 start_directive (pfile);
428 pfile->state.prevent_expansion++;
429 pfile->directive = &dtable[dir_no];
430 (void) (*pfile->directive->handler) (pfile);
431 pfile->state.prevent_expansion--;
433 end_directive (pfile, 1);
435 cpp_pop_buffer (pfile);
438 /* Checks for validity the macro name in #define, #undef, #ifdef and
439 #ifndef directives. */
440 static cpp_hashnode *
441 lex_macro_node (pfile)
446 /* Lex the macro name directly. */
447 _cpp_lex_token (pfile, &token);
449 /* The token immediately after #define must be an identifier. That
450 identifier is not allowed to be "defined". See predefined macro
451 names (6.10.8.4). In C++, it is not allowed to be any of the
452 <iso646.h> macro names (which are keywords in C++) either. */
454 if (token.type != CPP_NAME)
456 if (token.type == CPP_EOF)
457 cpp_error (pfile, "no macro name given in #%s directive",
458 pfile->directive->name);
459 else if (token.flags & NAMED_OP)
461 "\"%s\" cannot be used as a macro name as it is an operator in C++",
462 NODE_NAME (token.val.node));
464 cpp_error (pfile, "macro names must be identifiers");
468 cpp_hashnode *node = token.val.node;
470 /* In Objective C, some keywords begin with '@', but general
471 identifiers do not, and you're not allowed to #define them. */
472 if (node == pfile->spec_nodes.n_defined || NODE_NAME (node)[0] == '@')
473 cpp_error (pfile, "\"%s\" cannot be used as a macro name",
475 else if (!(node->flags & NODE_POISONED))
482 /* Process a #define directive. Most work is done in cppmacro.c. */
487 cpp_hashnode *node = lex_macro_node (pfile);
491 if (_cpp_create_definition (pfile, node))
492 if (pfile->cb.define)
493 (*pfile->cb.define) (pfile, node);
497 /* Handle #undef. Marks the identifier NT_VOID in the hash table. */
502 cpp_hashnode *node = lex_macro_node (pfile);
504 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
505 is not currently defined as a macro name. */
506 if (node && node->type == NT_MACRO)
509 (*pfile->cb.undef) (pfile, node);
511 if (node->flags & NODE_WARN)
512 cpp_warning (pfile, "undefining \"%s\"", NODE_NAME (node));
514 _cpp_free_definition (node);
519 /* Helper routine used by parse_include. Reinterpret the current line
520 as an h-char-sequence (< ... >); we are looking at the first token
521 after the <. Returns zero on success. */
523 glue_header_name (pfile, header)
528 unsigned char *buffer, *token_mem;
529 size_t len, total_len = 0, capacity = 1024;
531 /* To avoid lexed tokens overwriting our glued name, we can only
532 allocate from the string pool once we've lexed everything. */
534 buffer = (unsigned char *) xmalloc (capacity);
537 cpp_get_token (pfile, &token);
539 if (token.type == CPP_GREATER || token.type == CPP_EOF)
542 len = cpp_token_len (&token);
543 if (total_len + len > capacity)
545 capacity = (capacity + len) * 2;
546 buffer = (unsigned char *) xrealloc (buffer, capacity);
549 if (token.flags & PREV_WHITE)
550 buffer[total_len++] = ' ';
552 total_len = cpp_spell_token (pfile, &token, &buffer[total_len]) - buffer;
555 if (token.type == CPP_EOF)
556 cpp_error (pfile, "missing terminating > character");
559 token_mem = _cpp_pool_alloc (&pfile->ident_pool, total_len + 1);
560 memcpy (token_mem, buffer, total_len);
561 token_mem[total_len] = '\0';
563 header->type = CPP_HEADER_NAME;
564 header->flags &= ~PREV_WHITE;
565 header->val.str.len = total_len;
566 header->val.str.text = token_mem;
570 return token.type == CPP_EOF;
573 /* Parse the header name of #include, #include_next, #import and
574 #pragma dependency. Returns zero on success. */
576 parse_include (pfile, header)
580 int is_pragma = pfile->directive == &dtable[T_PRAGMA];
581 const unsigned char *dir;
584 dir = U"pragma dependency";
586 dir = pfile->directive->name;
588 /* Allow macro expansion. */
589 cpp_get_token (pfile, header);
590 if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
592 if (header->type != CPP_LESS)
594 cpp_error (pfile, "#%s expects \"FILENAME\" or <FILENAME>", dir);
597 if (glue_header_name (pfile, header))
601 if (header->val.str.len == 0)
603 cpp_error (pfile, "empty file name in #%s", dir);
610 /* Get out of macro context, if we are. */
611 skip_rest_of_line (pfile);
612 if (pfile->cb.include)
613 (*pfile->cb.include) (pfile, dir, header);
619 /* Handle #include, #include_next and #import. */
621 do_include_common (pfile, type)
623 enum include_type type;
627 if (!parse_include (pfile, &header))
629 /* Prevent #include recursion. */
630 if (pfile->buffer_stack_depth >= CPP_STACK_MAX)
631 cpp_fatal (pfile, "#include nested too deeply");
632 else if (pfile->context->prev)
633 cpp_ice (pfile, "attempt to push file buffer with contexts stacked");
636 /* For #include_next, if this is the primary source file,
637 warn and use the normal search logic. */
638 if (type == IT_INCLUDE_NEXT && ! pfile->buffer->prev)
640 cpp_warning (pfile, "#include_next in primary source file");
644 _cpp_execute_include (pfile, &header, type);
653 do_include_common (pfile, IT_INCLUDE);
660 if (!pfile->import_warning && CPP_OPTION (pfile, warn_import))
662 pfile->import_warning = 1;
664 "#import is obsolete, use an #ifndef wrapper in the header file");
667 do_include_common (pfile, IT_IMPORT);
671 do_include_next (pfile)
674 do_include_common (pfile, IT_INCLUDE_NEXT);
677 /* Subroutine of do_line. Read possible flags after file name. LAST
678 is the last flag seen; 0 if this is the first flag. Return the flag
679 if it is valid, 0 at the end of the directive. Otherwise complain. */
682 read_flag (pfile, last)
688 _cpp_lex_token (pfile, &token);
689 if (token.type == CPP_NUMBER && token.val.str.len == 1)
691 unsigned int flag = token.val.str.text[0] - '0';
693 if (flag > last && flag <= 4
694 && (flag != 4 || last == 3)
695 && (flag != 2 || last == 0))
699 if (token.type != CPP_EOF)
700 cpp_error (pfile, "invalid flag \"%s\" in line directive",
701 cpp_token_as_text (pfile, &token));
705 /* Another subroutine of do_line. Convert a number in STR, of length
706 LEN, to binary; store it in NUMP, and return 0 if the number was
707 well-formed, 1 if not. Temporary, hopefully. */
709 strtoul_for_line (str, len, nump)
714 unsigned long reg = 0;
728 /* Interpret #line command.
729 Note that the filename string (if any) is treated as if it were an
730 include filename. That means no escape handling. */
736 cpp_buffer *buffer = pfile->buffer;
737 const char *filename = buffer->nominal_fname;
738 unsigned int lineno = buffer->lineno;
739 enum cpp_fc_reason reason = FC_RENAME;
740 unsigned long new_lineno;
744 /* C99 raised the minimum limit on #line numbers. */
745 cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
747 /* #line commands expand macros. */
748 cpp_get_token (pfile, &token);
749 if (token.type != CPP_NUMBER
750 || strtoul_for_line (token.val.str.text, token.val.str.len, &new_lineno))
752 cpp_error (pfile, "\"%s\" after #line is not a positive integer",
753 cpp_token_as_text (pfile, &token));
757 if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
758 cpp_pedwarn (pfile, "line number out of range");
760 cpp_get_token (pfile, &token);
761 if (token.type == CPP_STRING)
763 const char *fname = (const char *) token.val.str.text;
765 /* Only accept flags for the # 55 form. */
766 if (! pfile->state.line_extension)
770 int flag = 0, sysp = 0;
772 flag = read_flag (pfile, flag);
776 flag = read_flag (pfile, flag);
781 flag = read_flag (pfile, flag);
786 flag = read_flag (pfile, flag);
788 sysp = 2, read_flag (pfile, flag);
791 if (reason == FC_ENTER)
793 /* Fake a buffer stack for diagnostics. */
794 cpp_push_buffer (pfile, 0, 0, BUF_FAKE, fname);
795 /* Fake an include for cpp_included. */
796 _cpp_fake_include (pfile, fname);
797 buffer = pfile->buffer;
799 else if (reason == FC_LEAVE)
801 if (buffer->type != BUF_FAKE)
802 cpp_warning (pfile, "file \"%s\" left but not entered",
803 buffer->nominal_fname);
806 cpp_pop_buffer (pfile);
807 buffer = pfile->buffer;
808 #ifdef ENABLE_CHECKING
809 if (strcmp (buffer->nominal_fname, fname))
810 cpp_warning (pfile, "expected to return to file \"%s\"",
811 buffer->nominal_fname);
812 if (buffer->lineno + 1 != new_lineno)
813 cpp_warning (pfile, "expected to return to line number %u",
815 if (buffer->sysp != sysp)
816 cpp_warning (pfile, "header flags for \"%s\" have changed",
817 buffer->nominal_fname);
823 buffer->nominal_fname = fname;
825 else if (token.type != CPP_EOF)
827 cpp_error (pfile, "\"%s\" is not a valid filename",
828 cpp_token_as_text (pfile, &token));
832 /* Our line number is incremented after the directive is processed. */
833 buffer->lineno = new_lineno - 1;
834 _cpp_do_file_change (pfile, reason, filename, lineno);
837 /* Arrange the file_change callback. */
839 _cpp_do_file_change (pfile, reason, from_file, from_lineno)
841 enum cpp_fc_reason reason;
842 const char *from_file;
843 unsigned int from_lineno;
845 if (pfile->cb.file_change)
848 cpp_buffer *buffer = pfile->buffer;
851 fc.to.filename = buffer->nominal_fname;
852 fc.to.lineno = buffer->lineno + 1;
853 fc.sysp = buffer->sysp;
854 fc.externc = CPP_OPTION (pfile, cplusplus) && buffer->sysp == 2;
856 /* Caller doesn't need to handle FC_ENTER. */
857 if (reason == FC_ENTER)
861 from_file = buffer->prev->nominal_fname;
862 from_lineno = buffer->prev->lineno;
867 /* Special case for file "foo.i" with "# 1 foo.c" on first line. */
868 else if (reason == FC_RENAME && ! buffer->prev
869 && pfile->directive_pos.line == 1)
872 fc.from.filename = from_file;
873 fc.from.lineno = from_lineno;
874 pfile->cb.file_change (pfile, &fc);
879 * Report a warning or error detected by the program we are
880 * processing. Use the directive's tokens in the error message.
884 do_diagnostic (pfile, code, print_dir)
886 enum error_type code;
889 if (_cpp_begin_message (pfile, code, NULL, 0))
892 fprintf (stderr, "#%s ", pfile->directive->name);
893 pfile->state.prevent_expansion++;
894 cpp_output_line (pfile, stderr);
895 pfile->state.prevent_expansion--;
903 do_diagnostic (pfile, ERROR, 1);
910 /* We want #warning diagnostics to be emitted in system headers too. */
911 do_diagnostic (pfile, WARNING_SYSHDR, 1);
914 /* Report program identification. */
922 cpp_get_token (pfile, &str);
923 if (str.type != CPP_STRING)
924 cpp_error (pfile, "invalid #ident");
925 else if (pfile->cb.ident)
926 (*pfile->cb.ident) (pfile, &str.val.str);
931 /* Pragmata handling. We handle some of these, and pass the rest on
932 to the front end. C99 defines three pragmas and says that no macro
933 expansion is to be performed on them; whether or not macro
934 expansion happens for other pragmas is implementation defined.
935 This implementation never macro-expands the text after #pragma. */
937 /* Sub-handlers for the pragmas needing treatment here.
938 They return 1 if the token buffer is to be popped, 0 if not. */
941 struct pragma_entry *next;
946 void (*handler) PARAMS ((cpp_reader *));
947 struct pragma_entry *space;
952 cpp_register_pragma (pfile, space, name, handler)
956 void (*handler) PARAMS ((cpp_reader *));
958 struct pragma_entry **x, *new;
964 struct pragma_entry *p = pfile->pragmas;
965 len = strlen (space);
968 if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
975 cpp_ice (pfile, "unknown #pragma namespace %s", space);
980 new = xnew (struct pragma_entry);
982 new->len = strlen (name);
984 new->u.handler = handler;
991 cpp_register_pragma_space (pfile, space)
995 struct pragma_entry *new;
996 const struct pragma_entry *p = pfile->pragmas;
997 size_t len = strlen (space);
1001 if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
1002 /* Multiple different callers are allowed to register the same
1008 new = xnew (struct pragma_entry);
1014 new->next = pfile->pragmas;
1015 pfile->pragmas = new;
1019 _cpp_init_internal_pragmas (pfile)
1023 cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
1024 cpp_register_pragma (pfile, 0, "once", do_pragma_once);
1027 cpp_register_pragma_space (pfile, "GCC");
1029 cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
1030 cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
1031 cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
1033 /* Kevin abuse for SDCC. */
1034 cpp_register_pragma(pfile, 0, "sdcc_hash", do_pragma_sdcc_hash);
1035 /* SDCC _asm specific */
1036 cpp_register_pragma(pfile, 0, "preproc_asm", do_pragma_preproc_asm);
1043 const struct pragma_entry *p;
1048 pfile->state.prevent_expansion++;
1049 cpp_start_lookahead (pfile);
1052 cpp_get_token (pfile, &tok);
1053 if (tok.type == CPP_NAME)
1055 const cpp_hashnode *node = tok.val.node;
1056 size_t len = NODE_LEN (node);
1060 if (strlen (p->name) == len
1061 && !memcmp (p->name, NODE_NAME (node), len))
1070 (*p->u.handler) (pfile);
1079 cpp_stop_lookahead (pfile, drop);
1080 pfile->state.prevent_expansion--;
1082 if (!drop && pfile->cb.def_pragma)
1083 (*pfile->cb.def_pragma) (pfile);
1087 do_pragma_once (pfile)
1090 cpp_warning (pfile, "#pragma once is obsolete");
1092 if (pfile->buffer->prev == NULL)
1093 cpp_warning (pfile, "#pragma once in main file");
1095 _cpp_never_reread (pfile->buffer->inc);
1101 do_pragma_poison (pfile)
1104 /* Poison these symbols so that all subsequent usage produces an
1109 pfile->state.poisoned_ok = 1;
1112 _cpp_lex_token (pfile, &tok);
1113 if (tok.type == CPP_EOF)
1115 if (tok.type != CPP_NAME)
1117 cpp_error (pfile, "invalid #pragma GCC poison directive");
1122 if (hp->flags & NODE_POISONED)
1125 if (hp->type == NT_MACRO)
1126 cpp_warning (pfile, "poisoning existing macro \"%s\"", NODE_NAME (hp));
1127 _cpp_free_definition (hp);
1128 hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1130 pfile->state.poisoned_ok = 0;
1132 #if 0 /* Doesn't quite work yet. */
1133 if (tok.type == CPP_EOF && pfile->cb.poison)
1134 (*pfile->cb.poison) (pfile);
1139 do_pragma_sdcc_hash (pfile)
1143 /*cpp_hashnode *hp;*/
1145 _cpp_lex_token (pfile, &tok);
1146 if (tok.type == CPP_PLUS)
1148 CPP_OPTION(pfile, allow_naked_hash)++;
1150 else if (tok.type == CPP_MINUS)
1152 CPP_OPTION(pfile, allow_naked_hash)--;
1156 cpp_error (pfile, "invalid #pragma sdcc_hash directive, need '+' or '-'");
1160 /* SDCC _asm specific
1161 switch _asm block preprocessing on / off */
1163 do_pragma_preproc_asm (pfile)
1168 _cpp_lex_token (pfile, &tok);
1169 if (tok.type == CPP_PLUS)
1171 CPP_OPTION(pfile, preproc_asm) = 1;
1173 else if (tok.type == CPP_MINUS)
1175 CPP_OPTION(pfile, preproc_asm)= 0;
1179 cpp_error (pfile, "invalid #pragma preproc_asm directive, need '+' or '-'");
1183 /* Mark the current header as a system header. This will suppress
1184 some categories of warnings (notably those from -pedantic). It is
1185 intended for use in system libraries that cannot be implemented in
1186 conforming C, but cannot be certain that their headers appear in a
1187 system include directory. To prevent abuse, it is rejected in the
1188 primary source file. */
1190 do_pragma_system_header (pfile)
1193 cpp_buffer *buffer = pfile->buffer;
1195 if (buffer->prev == 0)
1196 cpp_warning (pfile, "#pragma system_header ignored outside include file");
1198 cpp_make_system_header (pfile, 1, 0);
1203 /* Check the modified date of the current include file against a specified
1204 file. Issue a diagnostic, if the specified file is newer. We use this to
1205 determine if a fixed header should be refixed. */
1207 do_pragma_dependency (pfile)
1210 cpp_token header, msg;
1213 if (parse_include (pfile, &header))
1216 ordering = _cpp_compare_file_date (pfile, &header);
1218 cpp_warning (pfile, "cannot find source %s",
1219 cpp_token_as_text (pfile, &header));
1220 else if (ordering > 0)
1222 cpp_warning (pfile, "current file is older than %s",
1223 cpp_token_as_text (pfile, &header));
1224 cpp_start_lookahead (pfile);
1225 cpp_get_token (pfile, &msg);
1226 cpp_stop_lookahead (pfile, msg.type == CPP_EOF);
1227 if (msg.type != CPP_EOF)
1228 do_diagnostic (pfile, WARNING, 0);
1232 /* Check syntax is "(string-literal)". Returns 0 on success. */
1234 get__Pragma_string (pfile, string)
1240 cpp_get_token (pfile, &paren);
1241 if (paren.type != CPP_OPEN_PAREN)
1244 cpp_get_token (pfile, string);
1245 if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1248 cpp_get_token (pfile, &paren);
1249 return paren.type != CPP_CLOSE_PAREN;
1252 /* Returns a malloced buffer containing a destringized cpp_string by
1253 removing the first \ of \" and \\ sequences. */
1254 static unsigned char *
1255 destringize (in, len)
1256 const cpp_string *in;
1259 const unsigned char *src, *limit;
1260 unsigned char *dest, *result;
1262 dest = result = (unsigned char *) xmalloc (in->len);
1263 for (src = in->text, limit = src + in->len; src < limit;)
1265 /* We know there is a character following the backslash. */
1266 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1271 *len = dest - result;
1276 _cpp_do__Pragma (pfile)
1280 unsigned char *buffer;
1283 if (get__Pragma_string (pfile, &string))
1285 cpp_error (pfile, "_Pragma takes a parenthesized string literal");
1289 buffer = destringize (&string.val.str, &len);
1291 cpp_output_string ("\n#pragma "); cpp_output_string (buffer); cpp_output_string ("\n");
1292 //run_directive (pfile, T_PRAGMA, BUF_PRAGMA, (char *) buffer, len);
1293 free ((PTR) buffer);
1296 /* Just ignore #sccs, on systems where we define it at all. */
1297 #ifdef SCCS_DIRECTIVE
1300 cpp_reader *pfile ATTRIBUTE_UNUSED;
1311 if (! pfile->buffer->was_skipping)
1313 const cpp_hashnode *node = lex_macro_node (pfile);
1316 skip = node->type != NT_MACRO;
1322 push_conditional (pfile, skip, T_IFDEF, 0);
1330 const cpp_hashnode *node = 0;
1332 if (! pfile->buffer->was_skipping)
1334 node = lex_macro_node (pfile);
1336 skip = node->type == NT_MACRO;
1342 push_conditional (pfile, skip, T_IFNDEF, node);
1345 /* #if cooperates with parse_defined to handle multiple-include
1346 optimisations. If macro expansions or identifiers appear in the
1347 expression, we cannot treat it as a controlling conditional, since
1348 their values could change in the future. */
1355 const cpp_hashnode *cmacro = 0;
1357 if (! pfile->buffer->was_skipping)
1359 /* Controlling macro of #if ! defined () */
1360 pfile->mi_ind_cmacro = 0;
1361 skip = _cpp_parse_expr (pfile) == 0;
1362 cmacro = pfile->mi_ind_cmacro;
1365 push_conditional (pfile, skip, T_IF, cmacro);
1368 /* Flip skipping state if appropriate and continue without changing
1369 if_stack; this is so that the error message for missing #endif's
1370 etc. will point to the original #if. */
1376 cpp_buffer *buffer = pfile->buffer;
1377 struct if_stack *ifs = buffer->if_stack;
1380 cpp_error (pfile, "#else without #if");
1383 if (ifs->type == T_ELSE)
1385 cpp_error (pfile, "#else after #else");
1386 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1387 "the conditional began here");
1391 /* Buffer->was_skipping is 1 if all conditionals in this chain
1392 have been false, 2 if a conditional has been true. */
1393 if (! ifs->was_skipping && buffer->was_skipping != 2)
1394 buffer->was_skipping = ! buffer->was_skipping;
1396 /* Invalidate any controlling macro. */
1403 /* handle a #elif directive by not changing if_stack either. see the
1404 comment above do_else. */
1410 cpp_buffer *buffer = pfile->buffer;
1411 struct if_stack *ifs = buffer->if_stack;
1414 cpp_error (pfile, "#elif without #if");
1417 if (ifs->type == T_ELSE)
1419 cpp_error (pfile, "#elif after #else");
1420 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1421 "the conditional began here");
1425 /* Don't evaluate #elif if our higher level is skipping. */
1426 if (! ifs->was_skipping)
1428 /* Buffer->was_skipping is 1 if all conditionals in this
1429 chain have been false, 2 if a conditional has been true. */
1430 if (buffer->was_skipping == 1)
1431 buffer->was_skipping = ! _cpp_parse_expr (pfile);
1433 buffer->was_skipping = 2;
1435 /* Invalidate any controlling macro. */
1441 /* #endif pops the if stack and resets pfile->skipping. */
1447 cpp_buffer *buffer = pfile->buffer;
1448 struct if_stack *ifs = buffer->if_stack;
1451 cpp_error (pfile, "#endif without #if");
1454 /* If potential control macro, we go back outside again. */
1455 if (ifs->next == 0 && ifs->mi_cmacro)
1457 pfile->mi_state = MI_OUTSIDE;
1458 pfile->mi_cmacro = ifs->mi_cmacro;
1461 buffer->if_stack = ifs->next;
1462 buffer->was_skipping = ifs->was_skipping;
1463 obstack_free (&pfile->buffer_ob, ifs);
1469 /* Push an if_stack entry and set pfile->skipping accordingly.
1470 If this is a #ifndef starting at the beginning of a file,
1471 CMACRO is the macro name tested by the #ifndef. */
1474 push_conditional (pfile, skip, type, cmacro)
1478 const cpp_hashnode *cmacro;
1480 struct if_stack *ifs;
1481 cpp_buffer *buffer = pfile->buffer;
1483 ifs = xobnew (&pfile->buffer_ob, struct if_stack);
1484 ifs->pos = pfile->directive_pos;
1485 ifs->next = buffer->if_stack;
1486 ifs->was_skipping = buffer->was_skipping;
1488 if (pfile->mi_state == MI_OUTSIDE && pfile->mi_cmacro == 0)
1489 ifs->mi_cmacro = cmacro;
1493 buffer->was_skipping = skip;
1494 buffer->if_stack = ifs;
1497 /* Read the tokens of the answer into the macro pool. Only commit the
1498 memory if we intend it as permanent storage, i.e. the #assert case.
1499 Returns 0 on success. */
1502 parse_answer (pfile, answerp, type)
1504 struct answer **answerp;
1507 cpp_token paren, *token;
1508 struct answer *answer;
1510 if (POOL_FRONT (&pfile->macro_pool) + sizeof (struct answer) >
1511 POOL_LIMIT (&pfile->macro_pool))
1512 _cpp_next_chunk (&pfile->macro_pool, sizeof (struct answer), 0);
1513 answer = (struct answer *) POOL_FRONT (&pfile->macro_pool);
1516 /* In a conditional, it is legal to not have an open paren. We
1517 should save the following token in this case. */
1519 cpp_start_lookahead (pfile);
1520 cpp_get_token (pfile, &paren);
1522 cpp_stop_lookahead (pfile, paren.type == CPP_OPEN_PAREN);
1524 /* If not a paren, see if we're OK. */
1525 if (paren.type != CPP_OPEN_PAREN)
1527 /* In a conditional no answer is a test for any answer. It
1528 could be followed by any token. */
1532 /* #unassert with no answer is valid - it removes all answers. */
1533 if (type == T_UNASSERT && paren.type == CPP_EOF)
1536 cpp_error (pfile, "missing '(' after predicate");
1542 token = &answer->first[answer->count];
1543 /* Check we have room for the token. */
1544 if ((unsigned char *) (token + 1) >= POOL_LIMIT (&pfile->macro_pool))
1546 _cpp_next_chunk (&pfile->macro_pool, sizeof (cpp_token),
1547 (unsigned char **) &answer);
1548 token = &answer->first[answer->count];
1551 cpp_get_token (pfile, token);
1552 if (token->type == CPP_CLOSE_PAREN)
1555 if (token->type == CPP_EOF)
1557 cpp_error (pfile, "missing ')' to complete answer");
1563 if (answer->count == 0)
1565 cpp_error (pfile, "predicate's answer is empty");
1569 /* Drop whitespace at start. */
1570 answer->first->flags &= ~PREV_WHITE;
1573 if (type == T_ASSERT || type == T_UNASSERT)
1578 /* Parses an assertion, returning a pointer to the hash node of the
1579 predicate, or 0 on error. If an answer was supplied, it is placed
1580 in ANSWERP, otherwise it is set to 0. */
1581 static cpp_hashnode *
1582 parse_assertion (pfile, answerp, type)
1584 struct answer **answerp;
1587 cpp_hashnode *result = 0;
1588 cpp_token predicate;
1590 /* We don't expand predicates or answers. */
1591 pfile->state.prevent_expansion++;
1594 cpp_get_token (pfile, &predicate);
1595 if (predicate.type == CPP_EOF)
1596 cpp_error (pfile, "assertion without predicate");
1597 else if (predicate.type != CPP_NAME)
1598 cpp_error (pfile, "predicate must be an identifier");
1599 else if (parse_answer (pfile, answerp, type) == 0)
1601 unsigned int len = NODE_LEN (predicate.val.node);
1602 unsigned char *sym = alloca (len + 1);
1604 /* Prefix '#' to get it out of macro namespace. */
1606 memcpy (sym + 1, NODE_NAME (predicate.val.node), len);
1607 result = cpp_lookup (pfile, sym, len + 1);
1610 pfile->state.prevent_expansion--;
1614 /* Returns a pointer to the pointer to the answer in the answer chain,
1615 or a pointer to NULL if the answer is not in the chain. */
1616 static struct answer **
1617 find_answer (node, candidate)
1619 const struct answer *candidate;
1622 struct answer **result;
1624 for (result = &node->value.answers; *result; result = &(*result)->next)
1626 struct answer *answer = *result;
1628 if (answer->count == candidate->count)
1630 for (i = 0; i < answer->count; i++)
1631 if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1634 if (i == answer->count)
1642 /* Test an assertion within a preprocessor conditional. Returns
1643 non-zero on failure, zero on success. On success, the result of
1644 the test is written into VALUE. */
1646 _cpp_test_assertion (pfile, value)
1650 struct answer *answer;
1653 node = parse_assertion (pfile, &answer, T_IF);
1655 *value = (node->type == NT_ASSERTION &&
1656 (answer == 0 || *find_answer (node, answer) != 0));
1658 /* We don't commit the memory for the answer - it's temporary only. */
1666 struct answer *new_answer;
1669 node = parse_assertion (pfile, &new_answer, T_ASSERT);
1672 /* Place the new answer in the answer list. First check there
1673 is not a duplicate. */
1674 new_answer->next = 0;
1675 if (node->type == NT_ASSERTION)
1677 if (*find_answer (node, new_answer))
1679 cpp_warning (pfile, "\"%s\" re-asserted", NODE_NAME (node) + 1);
1682 new_answer->next = node->value.answers;
1684 node->type = NT_ASSERTION;
1685 node->value.answers = new_answer;
1686 POOL_COMMIT (&pfile->macro_pool, (sizeof (struct answer)
1687 + (new_answer->count - 1)
1688 * sizeof (cpp_token)));
1697 struct answer *answer;
1699 node = parse_assertion (pfile, &answer, T_UNASSERT);
1700 /* It isn't an error to #unassert something that isn't asserted. */
1701 if (node && node->type == NT_ASSERTION)
1705 struct answer **p = find_answer (node, answer), *temp;
1707 /* Remove the answer from the list. */
1712 /* Did we free the last answer? */
1713 if (node->value.answers == 0)
1714 node->type = NT_VOID;
1717 _cpp_free_definition (node);
1720 /* We don't commit the memory for the answer - it's temporary only. */
1723 /* These are for -D, -U, -A. */
1725 /* Process the string STR as if it appeared as the body of a #define.
1726 If STR is just an identifier, define it with value 1.
1727 If STR has anything after the identifier, then it should
1728 be identifier=definition. */
1731 cpp_define (pfile, str)
1738 /* Copy the entire option so we can modify it.
1739 Change the first "=" in the string to a space. If there is none,
1740 tack " 1" on the end. */
1742 /* Length including the null. */
1743 count = strlen (str);
1744 buf = (char *) alloca (count + 2);
1745 memcpy (buf, str, count);
1747 p = strchr (str, '=');
1756 run_directive (pfile, T_DEFINE, BUF_CL_OPTION, buf, count);
1759 /* Slight variant of the above for use by initialize_builtins. */
1761 _cpp_define_builtin (pfile, str)
1765 run_directive (pfile, T_DEFINE, BUF_BUILTIN, str, strlen (str));
1768 /* Process MACRO as if it appeared as the body of an #undef. */
1770 cpp_undef (pfile, macro)
1774 run_directive (pfile, T_UNDEF, BUF_CL_OPTION, macro, strlen (macro));
1777 /* Process the string STR as if it appeared as the body of a #assert. */
1779 cpp_assert (pfile, str)
1783 handle_assertion (pfile, str, T_ASSERT);
1786 /* Process STR as if it appeared as the body of an #unassert. */
1788 cpp_unassert (pfile, str)
1792 handle_assertion (pfile, str, T_UNASSERT);
1795 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1797 handle_assertion (pfile, str, type)
1802 size_t count = strlen (str);
1803 const char *p = strchr (str, '=');
1807 /* Copy the entire option so we can modify it. Change the first
1808 "=" in the string to a '(', and tack a ')' on the end. */
1809 char *buf = (char *) alloca (count + 1);
1811 memcpy (buf, str, count);
1817 run_directive (pfile, type, BUF_CL_OPTION, str, count);
1820 /* The number of errors for a given reader. */
1825 return pfile->errors;
1828 /* The options structure. */
1830 cpp_get_options (pfile)
1833 return &pfile->opts;
1836 /* The callbacks structure. */
1838 cpp_get_callbacks (pfile)
1844 /* Copy the given callbacks structure to our own. */
1846 cpp_set_callbacks (pfile, cb)
1853 /* Push a new buffer on the buffer stack. Returns the new buffer; it
1854 doesn't fail. It does not generate a file change call back; that
1855 is the responsibility of the caller. */
1857 cpp_push_buffer (pfile, buffer, len, type, filename)
1859 const U_CHAR *buffer;
1861 enum cpp_buffer_type type;
1862 const char *filename;
1864 cpp_buffer *new = xobnew (&pfile->buffer_ob, cpp_buffer);
1866 if (type == BUF_FAKE)
1868 /* A copy of the current buffer, just with a new name and type. */
1869 memcpy (new, pfile->buffer, sizeof (cpp_buffer));
1870 new->type = BUF_FAKE;
1874 if (type == BUF_BUILTIN)
1875 filename = _("<builtin>");
1876 else if (type == BUF_CL_OPTION)
1877 filename = _("<command line>");
1878 else if (type == BUF_PRAGMA)
1879 filename = "<_Pragma>";
1881 /* Clears, amongst other things, if_stack and mi_cmacro. */
1882 memset (new, 0, sizeof (cpp_buffer));
1884 new->line_base = new->buf = new->cur = buffer;
1885 new->rlimit = buffer + len;
1888 /* No read ahead or extra char initially. */
1889 new->read_ahead = EOF;
1890 new->extra_char = EOF;
1892 /* Preprocessed files, builtins, _Pragma and command line
1893 options don't do trigraph and escaped newline processing. */
1894 new->from_stage3 = type != BUF_FILE || CPP_OPTION (pfile, preprocessed);
1896 pfile->lexer_pos.output_line = 1;
1899 if (*filename == '\0')
1900 new->nominal_fname = _("<stdin>");
1902 new->nominal_fname = filename;
1904 new->prev = pfile->buffer;
1906 new->include_stack_listed = 0;
1909 pfile->state.next_bol = 1;
1910 pfile->buffer_stack_depth++;
1911 pfile->buffer = new;
1916 /* If called from do_line, pops a single buffer. Otherwise pops all
1917 buffers until a real file is reached. Generates appropriate
1920 cpp_pop_buffer (pfile)
1924 struct if_stack *ifs;
1928 buffer = pfile->buffer;
1929 /* Walk back up the conditional stack till we reach its level at
1930 entry to this file, issuing error messages. */
1931 for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
1932 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1933 "unterminated #%s", dtable[ifs->type].name);
1935 if (buffer->type == BUF_FAKE)
1936 buffer->prev->cur = buffer->cur;
1937 else if (buffer->type == BUF_FILE)
1938 _cpp_pop_file_buffer (pfile, buffer);
1940 pfile->buffer = buffer->prev;
1941 pfile->buffer_stack_depth--;
1943 /* Callbacks only generated for faked or real files. */
1944 if (buffer->type != BUF_FILE && buffer->type != BUF_FAKE)
1947 /* No callback for EOF of last file. */
1951 /* do_line does its own call backs. */
1952 pfile->buffer->include_stack_listed = 0;
1953 if (pfile->directive == &dtable[T_LINE])
1956 _cpp_do_file_change (pfile, FC_LEAVE, buffer->nominal_fname,
1958 if (pfile->buffer->type == BUF_FILE)
1961 cpp_warning (pfile, "file \"%s\" entered but not left",
1962 buffer->nominal_fname);
1965 obstack_free (&pfile->buffer_ob, buffer);
1966 return pfile->buffer;
1970 _cpp_init_directives (pfile)
1976 /* Register the directives. */
1977 for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
1979 node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
1980 node->directive_index = i + 1;