1 /* CPP Library. (Directive handling.)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
4 Contributed by Per Bothner, 1994-95.
5 Based on CCCP program by Paul Rubin, June 1986
6 Adapted to ANSI C, Richard Stallman, Jan 1987
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
29 /* Chained list of answers to an assertion. */
37 /* Stack of conditionals currently in progress
38 (including both successful and failing conditionals). */
41 struct if_stack *next;
42 unsigned int line; /* Line where condition started. */
43 const cpp_hashnode *mi_cmacro;/* macro name for #ifndef around entire file */
44 bool skip_elses; /* Can future #else / #elif be skipped? */
45 bool was_skipping; /* If were skipping on entry. */
46 int type; /* Most recent conditional, for diagnostics. */
49 /* Contains a registered pragma or pragma namespace. */
50 typedef void (*pragma_cb) PARAMS ((cpp_reader *));
53 struct pragma_entry *next;
54 const cpp_hashnode *pragma; /* Name and length. */
58 struct pragma_entry *space;
62 /* Values for the origin field of struct directive. KANDR directives
63 come from traditional (K&R) C. STDC89 directives come from the
64 1989 C standard. EXTENSION directives are extensions. */
69 /* Values for the flags field of struct directive. COND indicates a
70 conditional; IF_COND an opening conditional. INCL means to treat
71 "..." and <...> as q-char and h-char sequences respectively. IN_I
72 means this directive should be handled even if -fpreprocessed is in
73 effect (these are the directives with callback hooks). */
75 #define IF_COND (1 << 1)
79 /* Defines one #-directive, including how to handle it. */
80 typedef void (*directive_handler) PARAMS ((cpp_reader *));
81 typedef struct directive directive;
84 directive_handler handler; /* Function to handle directive. */
85 const U_CHAR *name; /* Name of directive. */
86 unsigned short length; /* Length of name. */
87 unsigned char origin; /* Origin of directive. */
88 unsigned char flags; /* Flags describing this directive. */
91 /* Forward declarations. */
93 static void skip_rest_of_line PARAMS ((cpp_reader *));
94 static void check_eol PARAMS ((cpp_reader *));
95 static void start_directive PARAMS ((cpp_reader *));
96 static void end_directive PARAMS ((cpp_reader *, int));
97 static void directive_diagnostics
98 PARAMS ((cpp_reader *, const directive *, int));
99 static void run_directive PARAMS ((cpp_reader *, int,
100 const char *, size_t));
101 static const cpp_token *glue_header_name PARAMS ((cpp_reader *));
102 static const cpp_token *parse_include PARAMS ((cpp_reader *));
103 static void push_conditional PARAMS ((cpp_reader *, int, int,
104 const cpp_hashnode *));
105 static unsigned int read_flag PARAMS ((cpp_reader *, unsigned int));
106 static U_CHAR *dequote_string PARAMS ((cpp_reader *, const U_CHAR *,
108 static int strtoul_for_line PARAMS ((const U_CHAR *, unsigned int,
110 static void do_diagnostic PARAMS ((cpp_reader *, enum error_type, int));
111 static cpp_hashnode *lex_macro_node PARAMS ((cpp_reader *));
112 static void do_include_common PARAMS ((cpp_reader *, enum include_type));
113 static struct pragma_entry *lookup_pragma_entry
114 PARAMS ((struct pragma_entry *, const cpp_hashnode *pragma));
115 static struct pragma_entry *insert_pragma_entry
116 PARAMS ((cpp_reader *, struct pragma_entry **, const cpp_hashnode *,
118 static void do_pragma_once PARAMS ((cpp_reader *));
119 static void do_pragma_poison PARAMS ((cpp_reader *));
120 static void do_pragma_system_header PARAMS ((cpp_reader *));
121 static void do_pragma_dependency PARAMS ((cpp_reader *));
122 static void do_linemarker PARAMS ((cpp_reader *));
123 static const cpp_token *get_token_no_padding PARAMS ((cpp_reader *));
124 static const cpp_token *get__Pragma_string PARAMS ((cpp_reader *));
125 static void destringize_and_run PARAMS ((cpp_reader *, const cpp_string *));
126 static int parse_answer PARAMS ((cpp_reader *, struct answer **, int));
127 static cpp_hashnode *parse_assertion PARAMS ((cpp_reader *, struct answer **,
129 static struct answer ** find_answer PARAMS ((cpp_hashnode *,
130 const struct answer *));
131 static void handle_assertion PARAMS ((cpp_reader *, const char *, int));
133 /* This is the table of directive handlers. It is ordered by
134 frequency of occurrence; the numbers at the end are directive
135 counts from all the source code I have lying around (egcs and libc
136 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
137 pcmcia-cs-3.0.9). This is no longer important as directive lookup
138 is now O(1). All extensions other than #warning and #include_next
139 are deprecated. The name is where the extension appears to have
142 #define DIRECTIVE_TABLE \
143 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
144 D(include, T_INCLUDE, KANDR, INCL) /* 52262 */ \
145 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
146 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
147 D(if, T_IF, KANDR, COND | IF_COND) /* 18162 */ \
148 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
149 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
150 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
151 D(line, T_LINE, KANDR, 0) /* 2465 */ \
152 D(elif, T_ELIF, STDC89, COND) /* 610 */ \
153 D(error, T_ERROR, STDC89, 0) /* 475 */ \
154 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
155 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
156 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL) /* 19 */ \
157 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
158 D(import, T_IMPORT, EXTENSION, INCL) /* 0 ObjC */ \
159 D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
160 D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
161 SCCS_ENTRY /* 0 SVR4? */
163 /* #sccs is not always recognized. */
164 #ifdef SCCS_DIRECTIVE
165 # define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION, 0)
167 # define SCCS_ENTRY /* nothing */
170 /* Use the table to generate a series of prototypes, an enum for the
171 directive names, and an array of directive handlers. */
173 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
174 #define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
178 #define D(n, tag, o, f) tag,
186 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
187 #define D(name, t, origin, flags) \
188 { CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
189 sizeof STRINGX(name) - 1, origin, flags },
190 static const directive dtable[] =
195 #undef DIRECTIVE_TABLE
197 /* Wrapper struct directive for linemarkers.
198 The origin is more or less true - the original K+R cpp
199 did use this notation in its preprocessed output. */
200 static const directive linemarker_dir =
202 do_linemarker, U"#", 1, KANDR, IN_I
205 #define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
207 /* Skip any remaining tokens in a directive. */
209 skip_rest_of_line (pfile)
212 /* Discard all stacked contexts. */
213 while (pfile->context != &pfile->base_context)
214 _cpp_pop_context (pfile);
216 /* Sweep up all tokens remaining on the line. */
218 while (_cpp_lex_token (pfile)->type != CPP_EOF)
222 /* Ensure there are no stray tokens at the end of a directive. */
227 if (! SEEN_EOL () && _cpp_lex_token (pfile)->type != CPP_EOF)
228 cpp_pedwarn (pfile, "extra tokens at end of #%s directive",
229 pfile->directive->name);
232 /* Called when entering a directive, _Pragma or command-line directive. */
234 start_directive (pfile)
237 /* Setup in-directive state. */
238 pfile->state.in_directive = 1;
239 pfile->state.save_comments = 0;
241 /* Some handlers need the position of the # for diagnostics. */
242 pfile->directive_line = pfile->line;
245 /* Called when leaving a directive, _Pragma or command-line directive. */
247 end_directive (pfile, skip_line)
251 /* We don't skip for an assembler #. */
254 skip_rest_of_line (pfile);
255 if (!pfile->keep_tokens)
257 pfile->cur_run = &pfile->base_run;
258 pfile->cur_token = pfile->base_run.base;
263 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
264 pfile->state.in_directive = 0;
265 pfile->state.angled_headers = 0;
266 pfile->directive = 0;
269 /* Output diagnostics for a directive DIR. INDENTED is non-zero if
270 the '#' was indented. */
272 directive_diagnostics (pfile, dir, indented)
274 const directive *dir;
277 /* Issue -pedantic warnings for extensions. */
278 if (CPP_PEDANTIC (pfile)
279 && ! pfile->state.skipping
280 && dir->origin == EXTENSION)
281 cpp_pedwarn (pfile, "#%s is a GCC extension", dir->name);
283 /* Traditionally, a directive is ignored unless its # is in
284 column 1. Therefore in code intended to work with K+R
285 compilers, directives added by C89 must have their #
286 indented, and directives present in traditional C must not.
287 This is true even of directives in skipped conditional
288 blocks. #elif cannot be used at all. */
289 if (CPP_WTRADITIONAL (pfile))
291 if (dir == &dtable[T_ELIF])
292 cpp_warning (pfile, "suggest not using #elif in traditional C");
293 else if (indented && dir->origin == KANDR)
295 "traditional C ignores #%s with the # indented",
297 else if (!indented && dir->origin != KANDR)
299 "suggest hiding #%s from traditional C with an indented #",
304 /* Check if we have a known directive. INDENTED is non-zero if the
305 '#' of the directive was indented. This function is in this file
306 to save unnecessarily exporting dtable etc. to cpplex.c. Returns
307 non-zero if the line of tokens has been handled, zero if we should
308 continue processing the line. */
310 _cpp_handle_directive (pfile, indented)
314 const directive *dir = 0;
315 const cpp_token *dname;
316 bool was_parsing_args = pfile->state.parsing_args;
319 if (was_parsing_args)
321 if (CPP_OPTION (pfile, pedantic))
323 "embedding a directive within macro arguments is not portable");
324 pfile->state.parsing_args = 0;
325 pfile->state.prevent_expansion = 0;
327 start_directive (pfile);
328 dname = _cpp_lex_token (pfile);
330 if (dname->type == CPP_NAME)
332 if (dname->val.node->directive_index)
333 dir = &dtable[dname->val.node->directive_index - 1];
335 /* We do not recognise the # followed by a number extension in
337 else if (dname->type == CPP_NUMBER && CPP_OPTION (pfile, lang) != CLK_ASM)
339 dir = &linemarker_dir;
340 if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed)
341 && ! pfile->state.skipping)
342 cpp_pedwarn (pfile, "style of line directive is a GCC extension");
347 /* If we have a directive that is not an opening conditional,
348 invalidate any control macro. */
349 if (! (dir->flags & IF_COND))
350 pfile->mi_valid = false;
352 /* Kluge alert. In order to be sure that code like this
357 does not cause '#define foo bar' to get executed when
358 compiled with -save-temps, we recognize directives in
359 -fpreprocessed mode only if the # is in column 1. cppmacro.c
360 puts a space in front of any '#' at the start of a macro. */
361 if (CPP_OPTION (pfile, preprocessed)
362 && (indented || !(dir->flags & IN_I)))
369 /* In failed conditional groups, all non-conditional
370 directives are ignored. Before doing that, whether
371 skipping or not, we should lex angle-bracketed headers
372 correctly, and maybe output some diagnostics. */
373 pfile->state.angled_headers = dir->flags & INCL;
374 if (! CPP_OPTION (pfile, preprocessed))
375 directive_diagnostics (pfile, dir, indented);
376 if (pfile->state.skipping && !(dir->flags & COND))
380 else if (dname->type == CPP_EOF)
381 ; /* CPP_EOF is the "null directive". */
384 /* An unknown directive. Don't complain about it in assembly
385 source: we don't know where the comments are, and # may
386 introduce assembler pseudo-ops. Don't complain about invalid
387 directives in skipped conditional groups (6.10 p4). */
388 if (CPP_OPTION (pfile, lang) == CLK_ASM)
390 else if (!pfile->state.skipping)
391 cpp_error (pfile, "invalid preprocessing directive #%s",
392 cpp_token_as_text (pfile, dname));
397 pfile->directive = dir;
398 (*pfile->directive->handler) (pfile);
401 _cpp_backup_tokens (pfile, 1);
403 end_directive (pfile, skip);
404 if (was_parsing_args)
406 /* Restore state when within macro args. */
407 pfile->state.parsing_args = 2;
408 pfile->state.prevent_expansion = 1;
409 pfile->buffer->saved_flags |= PREV_WHITE;
414 /* Directive handler wrapper used by the command line option
417 run_directive (pfile, dir_no, buf, count)
423 cpp_push_buffer (pfile, (const U_CHAR *) buf, count,
424 /* from_stage3 */ true, 1);
425 start_directive (pfile);
426 /* We don't want a leading # to be interpreted as a directive. */
427 pfile->buffer->saved_flags = 0;
428 pfile->directive = &dtable[dir_no];
429 (void) (*pfile->directive->handler) (pfile);
430 end_directive (pfile, 1);
431 _cpp_pop_buffer (pfile);
434 /* Checks for validity the macro name in #define, #undef, #ifdef and
435 #ifndef directives. */
436 static cpp_hashnode *
437 lex_macro_node (pfile)
441 const cpp_token *token = _cpp_lex_token (pfile);
443 /* The token immediately after #define must be an identifier. That
444 identifier may not be "defined", per C99 6.10.8p4.
445 In C++, it may not be any of the "named operators" either,
446 per C++98 [lex.digraph], [lex.key].
447 Finally, the identifier may not have been poisoned. (In that case
448 the lexer has issued the error message for us.) */
450 if (token->type != CPP_NAME)
452 if (token->type == CPP_EOF)
453 cpp_error (pfile, "no macro name given in #%s directive",
454 pfile->directive->name);
455 else if (token->flags & NAMED_OP)
457 "\"%s\" cannot be used as a macro name as it is an operator in C++",
458 NODE_NAME (token->val.node));
460 cpp_error (pfile, "macro names must be identifiers");
465 node = token->val.node;
466 if (node->flags & NODE_POISONED)
469 if (node == pfile->spec_nodes.n_defined)
471 cpp_error (pfile, "\"%s\" cannot be used as a macro name",
479 /* Process a #define directive. Most work is done in cppmacro.c. */
484 cpp_hashnode *node = lex_macro_node (pfile);
488 if (_cpp_create_definition (pfile, node))
489 if (pfile->cb.define)
490 (*pfile->cb.define) (pfile, pfile->directive_line, node);
494 /* Handle #undef. Mark the identifier NT_VOID in the hash table. */
499 cpp_hashnode *node = lex_macro_node (pfile);
501 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
502 is not currently defined as a macro name. */
503 if (node && node->type == NT_MACRO)
506 (*pfile->cb.undef) (pfile, pfile->directive_line, node);
508 if (node->flags & NODE_WARN)
509 cpp_warning (pfile, "undefining \"%s\"", NODE_NAME (node));
511 _cpp_free_definition (node);
516 /* Helper routine used by parse_include. Reinterpret the current line
517 as an h-char-sequence (< ... >); we are looking at the first token
518 after the <. Returns the header as a token, or NULL on failure. */
519 static const cpp_token *
520 glue_header_name (pfile)
523 cpp_token *header = NULL;
524 const cpp_token *token;
525 unsigned char *buffer;
526 size_t len, total_len = 0, capacity = 1024;
528 /* To avoid lexed tokens overwriting our glued name, we can only
529 allocate from the string pool once we've lexed everything. */
530 buffer = (unsigned char *) xmalloc (capacity);
533 token = cpp_get_token (pfile);
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 unsigned char *token_mem = _cpp_unaligned_alloc (pfile, total_len + 1);
556 memcpy (token_mem, buffer, total_len);
557 token_mem[total_len] = '\0';
559 header = _cpp_temp_token (pfile);
560 header->type = CPP_HEADER_NAME;
562 header->val.str.len = total_len;
563 header->val.str.text = token_mem;
570 /* Returns the header string of #include, #include_next, #import and
571 #pragma dependency. Returns NULL on error. */
572 static const cpp_token *
573 parse_include (pfile)
576 const unsigned char *dir;
577 const cpp_token *header;
579 if (pfile->directive == &dtable[T_PRAGMA])
580 dir = U"pragma dependency";
582 dir = pfile->directive->name;
584 /* Allow macro expansion. */
585 header = cpp_get_token (pfile);
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);
594 header = glue_header_name (pfile);
599 if (header->val.str.len == 0)
601 cpp_error (pfile, "empty file name in #%s", dir);
608 /* Handle #include, #include_next and #import. */
610 do_include_common (pfile, type)
612 enum include_type type;
614 const cpp_token *header;
616 /* For #include_next, if this is the primary source file, warn and
617 use the normal search logic. */
618 if (type == IT_INCLUDE_NEXT && ! pfile->buffer->prev)
620 cpp_warning (pfile, "#include_next in primary source file");
623 else if (type == IT_IMPORT && CPP_OPTION (pfile, warn_import))
625 CPP_OPTION (pfile, warn_import) = 0;
627 "#import is obsolete, use an #ifndef wrapper in the header file");
630 header = parse_include (pfile);
633 /* Prevent #include recursion. */
634 if (pfile->line_maps.depth >= CPP_STACK_MAX)
635 cpp_fatal (pfile, "#include nested too deeply");
639 /* Get out of macro context, if we are. */
640 skip_rest_of_line (pfile);
641 if (pfile->cb.include)
642 (*pfile->cb.include) (pfile, pfile->directive_line,
643 pfile->directive->name, header);
645 _cpp_execute_include (pfile, header, type);
654 do_include_common (pfile, IT_INCLUDE);
661 do_include_common (pfile, IT_IMPORT);
665 do_include_next (pfile)
668 do_include_common (pfile, IT_INCLUDE_NEXT);
671 /* Subroutine of do_linemarker. Read possible flags after file name.
672 LAST is the last flag seen; 0 if this is the first flag. Return the
673 flag if it is valid, 0 at the end of the directive. Otherwise
676 read_flag (pfile, last)
680 const cpp_token *token = _cpp_lex_token (pfile);
682 if (token->type == CPP_NUMBER && token->val.str.len == 1)
684 unsigned int flag = token->val.str.text[0] - '0';
686 if (flag > last && flag <= 4
687 && (flag != 4 || last == 3)
688 && (flag != 2 || last == 0))
692 if (token->type != CPP_EOF)
693 cpp_error (pfile, "invalid flag \"%s\" in line directive",
694 cpp_token_as_text (pfile, token));
698 /* Subroutine of do_line and do_linemarker. Returns a version of STR
699 which has a NUL terminator and all escape sequences converted to
700 their equivalents. Temporary, hopefully. */
702 dequote_string (pfile, str, len)
707 U_CHAR *result = _cpp_unaligned_alloc (pfile, len + 1);
708 U_CHAR *dst = result;
709 const U_CHAR *limit = str + len;
711 unsigned HOST_WIDE_INT mask;
713 /* We need the mask to match the host's 'unsigned char', not the
715 if (CHAR_BIT < HOST_BITS_PER_WIDE_INT)
716 mask = ((unsigned HOST_WIDE_INT) 1 << CHAR_BIT) - 1;
718 mask = ~(unsigned HOST_WIDE_INT)0;
726 *dst++ = cpp_parse_escape (pfile, (const U_CHAR **)&str, limit, mask);
732 /* Subroutine of do_line and do_linemarker. Convert a number in STR,
733 of length LEN, to binary; store it in NUMP, and return 0 if the
734 number was well-formed, 1 if not. Temporary, hopefully. */
736 strtoul_for_line (str, len, nump)
741 unsigned long reg = 0;
755 /* Interpret #line command.
756 Note that the filename string (if any) is a true string constant
757 (escapes are interpreted), unlike in #line. */
762 const cpp_token *token;
763 const char *new_file = pfile->map->to_file;
764 unsigned long new_lineno;
766 /* C99 raised the minimum limit on #line numbers. */
767 unsigned int cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
769 /* #line commands expand macros. */
770 token = cpp_get_token (pfile);
771 if (token->type != CPP_NUMBER
772 || strtoul_for_line (token->val.str.text, token->val.str.len,
775 cpp_error (pfile, "\"%s\" after #line is not a positive integer",
776 cpp_token_as_text (pfile, token));
780 if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
781 cpp_pedwarn (pfile, "line number out of range");
783 token = cpp_get_token (pfile);
784 if (token->type == CPP_STRING)
786 new_file = (const char *) dequote_string (pfile, token->val.str.text,
790 else if (token->type != CPP_EOF)
792 cpp_error (pfile, "\"%s\" is not a valid filename",
793 cpp_token_as_text (pfile, token));
797 skip_rest_of_line (pfile);
798 _cpp_do_file_change (pfile, LC_RENAME, new_file, new_lineno,
802 /* Interpret the # 44 "file" [flags] notation, which has slightly
803 different syntax and semantics from #line: Flags are allowed,
804 and we never complain about the line number being too big. */
806 do_linemarker (pfile)
809 const cpp_token *token;
810 const char *new_file = pfile->map->to_file;
811 unsigned long new_lineno;
812 unsigned int new_sysp = pfile->map->sysp;
813 enum lc_reason reason = LC_RENAME;
816 /* Back up so we can get the number again. Putting this in
817 _cpp_handle_directive risks two calls to _cpp_backup_tokens in
818 some circumstances, which can segfault. */
819 _cpp_backup_tokens (pfile, 1);
821 /* #line commands expand macros. */
822 token = cpp_get_token (pfile);
823 if (token->type != CPP_NUMBER
824 || strtoul_for_line (token->val.str.text, token->val.str.len,
827 cpp_error (pfile, "\"%s\" after # is not a positive integer",
828 cpp_token_as_text (pfile, token));
832 token = cpp_get_token (pfile);
833 if (token->type == CPP_STRING)
835 new_file = (const char *) dequote_string (pfile, token->val.str.text,
838 flag = read_flag (pfile, 0);
842 /* Fake an include for cpp_included (). */
843 _cpp_fake_include (pfile, new_file);
844 flag = read_flag (pfile, flag);
849 flag = read_flag (pfile, flag);
854 flag = read_flag (pfile, flag);
861 else if (token->type != CPP_EOF)
863 cpp_error (pfile, "\"%s\" is not a valid filename",
864 cpp_token_as_text (pfile, token));
868 skip_rest_of_line (pfile);
869 _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp);
872 /* Arrange the file_change callback. pfile->line has changed to
873 FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system
874 header, 2 for a system header that needs to be extern "C" protected,
875 and zero otherwise. */
877 _cpp_do_file_change (pfile, reason, to_file, file_line, sysp)
879 enum lc_reason reason;
881 unsigned int file_line;
884 pfile->map = add_line_map (&pfile->line_maps, reason, sysp,
885 pfile->line, to_file, file_line);
887 if (pfile->cb.file_change)
888 (*pfile->cb.file_change) (pfile, pfile->map);
891 /* Report a warning or error detected by the program we are
892 processing. Use the directive's tokens in the error message. */
894 do_diagnostic (pfile, code, print_dir)
896 enum error_type code;
899 if (_cpp_begin_message (pfile, code, 0, 0))
902 fprintf (stderr, "#%s ", pfile->directive->name);
903 pfile->state.prevent_expansion++;
904 cpp_output_line (pfile, stderr);
905 pfile->state.prevent_expansion--;
913 do_diagnostic (pfile, ERROR, 1);
920 /* We want #warning diagnostics to be emitted in system headers too. */
921 do_diagnostic (pfile, WARNING_SYSHDR, 1);
924 /* Report program identification. */
929 const cpp_token *str = cpp_get_token (pfile);
931 if (str->type != CPP_STRING)
932 cpp_error (pfile, "invalid #ident directive");
933 else if (pfile->cb.ident)
934 (*pfile->cb.ident) (pfile, pfile->directive_line, &str->val.str);
939 /* Lookup a PRAGMA name in a singly-linked CHAIN. Returns the
940 matching entry, or NULL if none is found. The returned entry could
941 be the start of a namespace chain, or a pragma. */
942 static struct pragma_entry *
943 lookup_pragma_entry (chain, pragma)
944 struct pragma_entry *chain;
945 const cpp_hashnode *pragma;
947 while (chain && chain->pragma != pragma)
953 /* Create and insert a pragma entry for NAME at the beginning of a
954 singly-linked CHAIN. If handler is NULL, it is a namespace,
955 otherwise it is a pragma and its handler. */
956 static struct pragma_entry *
957 insert_pragma_entry (pfile, chain, pragma, handler)
959 struct pragma_entry **chain;
960 const cpp_hashnode *pragma;
963 struct pragma_entry *new;
965 new = (struct pragma_entry *)
966 _cpp_aligned_alloc (pfile, sizeof (struct pragma_entry));
967 new->pragma = pragma;
971 new->u.handler = handler;
984 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
985 goes in the global namespace. HANDLER is the handler it will call,
986 which must be non-NULL. */
988 cpp_register_pragma (pfile, space, name, handler)
994 struct pragma_entry **chain = &pfile->pragmas;
995 struct pragma_entry *entry;
996 const cpp_hashnode *node;
1003 node = cpp_lookup (pfile, U space, strlen (space));
1004 entry = lookup_pragma_entry (*chain, node);
1006 entry = insert_pragma_entry (pfile, chain, node, NULL);
1007 else if (!entry->is_nspace)
1009 chain = &entry->u.space;
1012 /* Check for duplicates. */
1013 node = cpp_lookup (pfile, U name, strlen (name));
1014 entry = lookup_pragma_entry (*chain, node);
1017 if (entry->is_nspace)
1020 "registering \"%s\" as both a pragma and a pragma namespace",
1023 cpp_ice (pfile, "#pragma %s %s is already registered", space, name);
1025 cpp_ice (pfile, "#pragma %s is already registered", name);
1028 insert_pragma_entry (pfile, chain, node, handler);
1031 /* Register the pragmas the preprocessor itself handles. */
1033 _cpp_init_internal_pragmas (pfile)
1036 /* Pragmas in the global namespace. */
1037 cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
1038 cpp_register_pragma (pfile, 0, "once", do_pragma_once);
1040 /* New GCC-specific pragmas should be put in the GCC namespace. */
1041 cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
1042 cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
1043 cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
1046 /* Pragmata handling. We handle some, and pass the rest on to the
1047 front end. C99 defines three pragmas and says that no macro
1048 expansion is to be performed on them; whether or not macro
1049 expansion happens for other pragmas is implementation defined.
1050 This implementation never macro-expands the text after #pragma. */
1055 const struct pragma_entry *p = NULL;
1056 const cpp_token *token;
1057 unsigned int count = 1;
1059 pfile->state.prevent_expansion++;
1061 token = cpp_get_token (pfile);
1062 if (token->type == CPP_NAME)
1064 p = lookup_pragma_entry (pfile->pragmas, token->val.node);
1065 if (p && p->is_nspace)
1068 token = cpp_get_token (pfile);
1069 if (token->type == CPP_NAME)
1070 p = lookup_pragma_entry (p->u.space, token->val.node);
1076 /* FIXME. This is an awful kludge to get the front ends to update
1077 their notion of line number for diagnostic purposes. The line
1078 number should be passed to the handler and they should do it
1079 themselves. Stand-alone CPP must ignore us, otherwise it will
1080 prefix the directive with spaces, hence the 1. Ugh. */
1081 if (pfile->cb.line_change)
1082 (*pfile->cb.line_change)(pfile, token, 1);
1085 (*p->u.handler) (pfile);
1086 else if (pfile->cb.def_pragma)
1088 _cpp_backup_tokens (pfile, count);
1089 (*pfile->cb.def_pragma) (pfile, pfile->directive_line);
1092 pfile->state.prevent_expansion--;
1095 /* Handle #pragma once. */
1097 do_pragma_once (pfile)
1100 cpp_warning (pfile, "#pragma once is obsolete");
1102 if (pfile->buffer->prev == NULL)
1103 cpp_warning (pfile, "#pragma once in main file");
1105 _cpp_never_reread (pfile->buffer->inc);
1110 /* Handle #pragma poison, to poison one or more identifiers so that
1111 the lexer produces a hard error for each subsequent usage. */
1113 do_pragma_poison (pfile)
1116 const cpp_token *tok;
1119 pfile->state.poisoned_ok = 1;
1122 tok = _cpp_lex_token (pfile);
1123 if (tok->type == CPP_EOF)
1125 if (tok->type != CPP_NAME)
1127 cpp_error (pfile, "invalid #pragma GCC poison directive");
1132 if (hp->flags & NODE_POISONED)
1135 if (hp->type == NT_MACRO)
1136 cpp_warning (pfile, "poisoning existing macro \"%s\"", NODE_NAME (hp));
1137 _cpp_free_definition (hp);
1138 hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1140 pfile->state.poisoned_ok = 0;
1143 /* Mark the current header as a system header. This will suppress
1144 some categories of warnings (notably those from -pedantic). It is
1145 intended for use in system libraries that cannot be implemented in
1146 conforming C, but cannot be certain that their headers appear in a
1147 system include directory. To prevent abuse, it is rejected in the
1148 primary source file. */
1150 do_pragma_system_header (pfile)
1153 cpp_buffer *buffer = pfile->buffer;
1155 if (buffer->prev == 0)
1156 cpp_warning (pfile, "#pragma system_header ignored outside include file");
1160 skip_rest_of_line (pfile);
1161 cpp_make_system_header (pfile, 1, 0);
1165 /* Check the modified date of the current include file against a specified
1166 file. Issue a diagnostic, if the specified file is newer. We use this to
1167 determine if a fixed header should be refixed. */
1169 do_pragma_dependency (pfile)
1172 const cpp_token *header;
1175 header = parse_include (pfile);
1179 ordering = _cpp_compare_file_date (pfile, header);
1181 cpp_warning (pfile, "cannot find source %s",
1182 cpp_token_as_text (pfile, header));
1183 else if (ordering > 0)
1185 cpp_warning (pfile, "current file is older than %s",
1186 cpp_token_as_text (pfile, header));
1187 if (cpp_get_token (pfile)->type != CPP_EOF)
1189 _cpp_backup_tokens (pfile, 1);
1190 do_diagnostic (pfile, WARNING, 0);
1195 /* Get a token but skip padding. */
1196 static const cpp_token *
1197 get_token_no_padding (pfile)
1202 const cpp_token *result = cpp_get_token (pfile);
1203 if (result->type != CPP_PADDING)
1208 /* Check syntax is "(string-literal)". Returns the string on success,
1209 or NULL on failure. */
1210 static const cpp_token *
1211 get__Pragma_string (pfile)
1214 const cpp_token *string;
1216 if (get_token_no_padding (pfile)->type != CPP_OPEN_PAREN)
1219 string = get_token_no_padding (pfile);
1220 if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1223 if (get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
1229 /* Destringize IN into a temporary buffer, by removing the first \ of
1230 \" and \\ sequences, and process the result as a #pragma directive. */
1232 destringize_and_run (pfile, in)
1234 const cpp_string *in;
1236 const unsigned char *src, *limit;
1237 char *dest, *result;
1239 dest = result = alloca (in->len + 1);
1240 for (src = in->text, limit = src + in->len; src < limit;)
1242 /* We know there is a character following the backslash. */
1243 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1249 run_directive (pfile, T_PRAGMA, result, dest - result);
1252 /* Handle the _Pragma operator. */
1254 _cpp_do__Pragma (pfile)
1257 const cpp_token *string = get__Pragma_string (pfile);
1260 cpp_error (pfile, "_Pragma takes a parenthesized string literal");
1263 /* Ideally, we'd like
1264 token1 _Pragma ("foo") token2
1271 Getting these correct line markers is a little tricky. */
1273 unsigned int orig_line = pfile->line;
1274 destringize_and_run (pfile, &string->val.str);
1275 pfile->line = orig_line;
1276 pfile->buffer->saved_flags = BOL;
1280 /* Just ignore #sccs, on systems where we define it at all. */
1281 #ifdef SCCS_DIRECTIVE
1284 cpp_reader *pfile ATTRIBUTE_UNUSED;
1289 /* Handle #ifdef. */
1296 if (! pfile->state.skipping)
1298 const cpp_hashnode *node = lex_macro_node (pfile);
1301 skip = node->type != NT_MACRO;
1307 push_conditional (pfile, skip, T_IFDEF, 0);
1310 /* Handle #ifndef. */
1316 const cpp_hashnode *node = 0;
1318 if (! pfile->state.skipping)
1320 node = lex_macro_node (pfile);
1322 skip = node->type == NT_MACRO;
1328 push_conditional (pfile, skip, T_IFNDEF, node);
1331 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1332 pfile->mi_ind_cmacro so we can handle multiple-include
1333 optimisations. If macro expansion occurs in the expression, we
1334 cannot treat it as a controlling conditional, since the expansion
1335 could change in the future. That is handled by cpp_get_token. */
1342 if (! pfile->state.skipping)
1343 skip = _cpp_parse_expr (pfile) == 0;
1345 push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
1348 /* Flip skipping state if appropriate and continue without changing
1349 if_stack; this is so that the error message for missing #endif's
1350 etc. will point to the original #if. */
1355 cpp_buffer *buffer = pfile->buffer;
1356 struct if_stack *ifs = buffer->if_stack;
1359 cpp_error (pfile, "#else without #if");
1362 if (ifs->type == T_ELSE)
1364 cpp_error (pfile, "#else after #else");
1365 cpp_error_with_line (pfile, ifs->line, 0,
1366 "the conditional began here");
1370 /* Skip any future (erroneous) #elses or #elifs. */
1371 pfile->state.skipping = ifs->skip_elses;
1372 ifs->skip_elses = true;
1374 /* Invalidate any controlling macro. */
1377 /* Only check EOL if was not originally skipping. */
1378 if (!ifs->was_skipping)
1383 /* Handle a #elif directive by not changing if_stack either. See the
1384 comment above do_else. */
1389 cpp_buffer *buffer = pfile->buffer;
1390 struct if_stack *ifs = buffer->if_stack;
1393 cpp_error (pfile, "#elif without #if");
1396 if (ifs->type == T_ELSE)
1398 cpp_error (pfile, "#elif after #else");
1399 cpp_error_with_line (pfile, ifs->line, 0,
1400 "the conditional began here");
1404 /* Only evaluate this if we aren't skipping elses. During
1405 evaluation, set skipping to false to get lexer warnings. */
1406 if (ifs->skip_elses)
1407 pfile->state.skipping = 1;
1410 pfile->state.skipping = 0;
1411 pfile->state.skipping = ! _cpp_parse_expr (pfile);
1412 ifs->skip_elses = ! pfile->state.skipping;
1415 /* Invalidate any controlling macro. */
1420 /* #endif pops the if stack and resets pfile->state.skipping. */
1425 cpp_buffer *buffer = pfile->buffer;
1426 struct if_stack *ifs = buffer->if_stack;
1429 cpp_error (pfile, "#endif without #if");
1432 /* Only check EOL if was not originally skipping. */
1433 if (!ifs->was_skipping)
1436 /* If potential control macro, we go back outside again. */
1437 if (ifs->next == 0 && ifs->mi_cmacro)
1439 pfile->mi_valid = true;
1440 pfile->mi_cmacro = ifs->mi_cmacro;
1443 buffer->if_stack = ifs->next;
1444 pfile->state.skipping = ifs->was_skipping;
1445 obstack_free (&pfile->buffer_ob, ifs);
1449 /* Push an if_stack entry for a preprocessor conditional, and set
1450 pfile->state.skipping to SKIP. If TYPE indicates the conditional
1451 is #if or #ifndef, CMACRO is a potentially controlling macro, and
1452 we need to check here that we are at the top of the file. */
1454 push_conditional (pfile, skip, type, cmacro)
1458 const cpp_hashnode *cmacro;
1460 struct if_stack *ifs;
1461 cpp_buffer *buffer = pfile->buffer;
1463 ifs = xobnew (&pfile->buffer_ob, struct if_stack);
1464 ifs->line = pfile->directive_line;
1465 ifs->next = buffer->if_stack;
1466 ifs->skip_elses = pfile->state.skipping || !skip;
1467 ifs->was_skipping = pfile->state.skipping;
1469 /* This condition is effectively a test for top-of-file. */
1470 if (pfile->mi_valid && pfile->mi_cmacro == 0)
1471 ifs->mi_cmacro = cmacro;
1475 pfile->state.skipping = skip;
1476 buffer->if_stack = ifs;
1479 /* Read the tokens of the answer into the macro pool, in a directive
1480 of type TYPE. Only commit the memory if we intend it as permanent
1481 storage, i.e. the #assert case. Returns 0 on success, and sets
1482 ANSWERP to point to the answer. */
1484 parse_answer (pfile, answerp, type)
1486 struct answer **answerp;
1489 const cpp_token *paren;
1490 struct answer *answer;
1491 unsigned int acount;
1493 /* In a conditional, it is legal to not have an open paren. We
1494 should save the following token in this case. */
1495 paren = cpp_get_token (pfile);
1497 /* If not a paren, see if we're OK. */
1498 if (paren->type != CPP_OPEN_PAREN)
1500 /* In a conditional no answer is a test for any answer. It
1501 could be followed by any token. */
1504 _cpp_backup_tokens (pfile, 1);
1508 /* #unassert with no answer is valid - it removes all answers. */
1509 if (type == T_UNASSERT && paren->type == CPP_EOF)
1512 cpp_error (pfile, "missing '(' after predicate");
1516 for (acount = 0;; acount++)
1519 const cpp_token *token = cpp_get_token (pfile);
1522 if (token->type == CPP_CLOSE_PAREN)
1525 if (token->type == CPP_EOF)
1527 cpp_error (pfile, "missing ')' to complete answer");
1531 /* struct answer includes the space for one token. */
1532 room_needed = (sizeof (struct answer) + acount * sizeof (cpp_token));
1534 if (BUFF_ROOM (pfile->a_buff) < room_needed)
1535 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer));
1537 dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount];
1540 /* Drop whitespace at start, for answer equivalence purposes. */
1542 dest->flags &= ~PREV_WHITE;
1547 cpp_error (pfile, "predicate's answer is empty");
1551 answer = (struct answer *) BUFF_FRONT (pfile->a_buff);
1552 answer->count = acount;
1553 answer->next = NULL;
1559 /* Parses an assertion directive of type TYPE, returning a pointer to
1560 the hash node of the predicate, or 0 on error. If an answer was
1561 supplied, it is placed in ANSWERP, otherwise it is set to 0. */
1562 static cpp_hashnode *
1563 parse_assertion (pfile, answerp, type)
1565 struct answer **answerp;
1568 cpp_hashnode *result = 0;
1569 const cpp_token *predicate;
1571 /* We don't expand predicates or answers. */
1572 pfile->state.prevent_expansion++;
1575 predicate = cpp_get_token (pfile);
1576 if (predicate->type == CPP_EOF)
1577 cpp_error (pfile, "assertion without predicate");
1578 else if (predicate->type != CPP_NAME)
1579 cpp_error (pfile, "predicate must be an identifier");
1580 else if (parse_answer (pfile, answerp, type) == 0)
1582 unsigned int len = NODE_LEN (predicate->val.node);
1583 unsigned char *sym = alloca (len + 1);
1585 /* Prefix '#' to get it out of macro namespace. */
1587 memcpy (sym + 1, NODE_NAME (predicate->val.node), len);
1588 result = cpp_lookup (pfile, sym, len + 1);
1591 pfile->state.prevent_expansion--;
1595 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
1596 or a pointer to NULL if the answer is not in the chain. */
1597 static struct answer **
1598 find_answer (node, candidate)
1600 const struct answer *candidate;
1603 struct answer **result;
1605 for (result = &node->value.answers; *result; result = &(*result)->next)
1607 struct answer *answer = *result;
1609 if (answer->count == candidate->count)
1611 for (i = 0; i < answer->count; i++)
1612 if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1615 if (i == answer->count)
1623 /* Test an assertion within a preprocessor conditional. Returns
1624 non-zero on failure, zero on success. On success, the result of
1625 the test is written into VALUE. */
1627 _cpp_test_assertion (pfile, value)
1631 struct answer *answer;
1634 node = parse_assertion (pfile, &answer, T_IF);
1636 *value = (node->type == NT_ASSERTION &&
1637 (answer == 0 || *find_answer (node, answer) != 0));
1639 /* We don't commit the memory for the answer - it's temporary only. */
1643 /* Handle #assert. */
1648 struct answer *new_answer;
1651 node = parse_assertion (pfile, &new_answer, T_ASSERT);
1654 /* Place the new answer in the answer list. First check there
1655 is not a duplicate. */
1656 new_answer->next = 0;
1657 if (node->type == NT_ASSERTION)
1659 if (*find_answer (node, new_answer))
1661 cpp_warning (pfile, "\"%s\" re-asserted", NODE_NAME (node) + 1);
1664 new_answer->next = node->value.answers;
1667 node->type = NT_ASSERTION;
1668 node->value.answers = new_answer;
1669 BUFF_FRONT (pfile->a_buff) += (sizeof (struct answer)
1670 + (new_answer->count - 1)
1671 * sizeof (cpp_token));
1676 /* Handle #unassert. */
1682 struct answer *answer;
1684 node = parse_assertion (pfile, &answer, T_UNASSERT);
1685 /* It isn't an error to #unassert something that isn't asserted. */
1686 if (node && node->type == NT_ASSERTION)
1690 struct answer **p = find_answer (node, answer), *temp;
1692 /* Remove the answer from the list. */
1697 /* Did we free the last answer? */
1698 if (node->value.answers == 0)
1699 node->type = NT_VOID;
1704 _cpp_free_definition (node);
1707 /* We don't commit the memory for the answer - it's temporary only. */
1710 /* These are for -D, -U, -A. */
1712 /* Process the string STR as if it appeared as the body of a #define.
1713 If STR is just an identifier, define it with value 1.
1714 If STR has anything after the identifier, then it should
1715 be identifier=definition. */
1717 cpp_define (pfile, str)
1724 /* Copy the entire option so we can modify it.
1725 Change the first "=" in the string to a space. If there is none,
1726 tack " 1" on the end. */
1728 count = strlen (str);
1729 buf = (char *) alloca (count + 3);
1730 memcpy (buf, str, count);
1732 p = strchr (str, '=');
1742 run_directive (pfile, T_DEFINE, buf, count);
1745 /* Slight variant of the above for use by initialize_builtins. */
1747 _cpp_define_builtin (pfile, str)
1751 run_directive (pfile, T_DEFINE, str, strlen (str));
1754 /* Process MACRO as if it appeared as the body of an #undef. */
1756 cpp_undef (pfile, macro)
1760 run_directive (pfile, T_UNDEF, macro, strlen (macro));
1763 /* Process the string STR as if it appeared as the body of a #assert. */
1765 cpp_assert (pfile, str)
1769 handle_assertion (pfile, str, T_ASSERT);
1772 /* Process STR as if it appeared as the body of an #unassert. */
1774 cpp_unassert (pfile, str)
1778 handle_assertion (pfile, str, T_UNASSERT);
1781 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1783 handle_assertion (pfile, str, type)
1788 size_t count = strlen (str);
1789 const char *p = strchr (str, '=');
1793 /* Copy the entire option so we can modify it. Change the first
1794 "=" in the string to a '(', and tack a ')' on the end. */
1795 char *buf = (char *) alloca (count + 2);
1797 memcpy (buf, str, count);
1804 run_directive (pfile, type, str, count);
1807 /* The number of errors for a given reader. */
1812 return pfile->errors;
1815 /* The options structure. */
1817 cpp_get_options (pfile)
1820 return &pfile->opts;
1823 /* The callbacks structure. */
1825 cpp_get_callbacks (pfile)
1831 /* The line map set. */
1832 const struct line_maps *
1833 cpp_get_line_maps (pfile)
1836 return &pfile->line_maps;
1839 /* Copy the given callbacks structure to our own. */
1841 cpp_set_callbacks (pfile, cb)
1848 /* Push a new buffer on the buffer stack. Returns the new buffer; it
1849 doesn't fail. It does not generate a file change call back; that
1850 is the responsibility of the caller. */
1852 cpp_push_buffer (pfile, buffer, len, from_stage3, return_at_eof)
1854 const U_CHAR *buffer;
1859 cpp_buffer *new = xobnew (&pfile->buffer_ob, cpp_buffer);
1861 /* Clears, amongst other things, if_stack and mi_cmacro. */
1862 memset (new, 0, sizeof (cpp_buffer));
1864 new->line_base = new->buf = new->cur = buffer;
1865 new->rlimit = buffer + len;
1866 new->from_stage3 = from_stage3;
1867 new->prev = pfile->buffer;
1868 new->return_at_eof = return_at_eof;
1869 new->saved_flags = BOL;
1871 pfile->buffer = new;
1876 /* If called from do_line, pops a single buffer. Otherwise pops all
1877 buffers until a real file is reached. Generates appropriate
1880 _cpp_pop_buffer (pfile)
1883 cpp_buffer *buffer = pfile->buffer;
1884 struct if_stack *ifs;
1885 bool pushed = false;
1887 /* Walk back up the conditional stack till we reach its level at
1888 entry to this file, issuing error messages. */
1889 for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
1890 cpp_error_with_line (pfile, ifs->line, 0,
1891 "unterminated #%s", dtable[ifs->type].name);
1893 /* In case of a missing #endif. */
1894 pfile->state.skipping = 0;
1896 /* Update the reader's buffer before _cpp_do_file_change. */
1897 pfile->buffer = buffer->prev;
1900 pushed = _cpp_pop_file_buffer (pfile, buffer->inc);
1903 obstack_free (&pfile->buffer_ob, buffer);
1906 /* Enter all recognised directives in the hash table. */
1908 _cpp_init_directives (pfile)
1914 for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
1916 node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
1917 node->directive_index = i + 1;