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 /* If we are processing a `#define' directive and we have been
398 requested to expand comments into macros, then re-enable
399 saving of comments. */
400 if (dir == &dtable[T_DEFINE])
401 pfile->state.save_comments =
402 ! CPP_OPTION (pfile, discard_comments_in_macro_exp);
404 pfile->directive = dir;
405 (*pfile->directive->handler) (pfile);
408 _cpp_backup_tokens (pfile, 1);
410 end_directive (pfile, skip);
411 if (was_parsing_args)
413 /* Restore state when within macro args. */
414 pfile->state.parsing_args = 2;
415 pfile->state.prevent_expansion = 1;
416 pfile->buffer->saved_flags |= PREV_WHITE;
421 /* Directive handler wrapper used by the command line option
424 run_directive (pfile, dir_no, buf, count)
430 cpp_push_buffer (pfile, (const U_CHAR *) buf, count,
431 /* from_stage3 */ true, 1);
432 start_directive (pfile);
433 /* We don't want a leading # to be interpreted as a directive. */
434 pfile->buffer->saved_flags = 0;
435 pfile->directive = &dtable[dir_no];
436 (void) (*pfile->directive->handler) (pfile);
437 end_directive (pfile, 1);
438 _cpp_pop_buffer (pfile);
441 /* Checks for validity the macro name in #define, #undef, #ifdef and
442 #ifndef directives. */
443 static cpp_hashnode *
444 lex_macro_node (pfile)
448 const cpp_token *token = _cpp_lex_token (pfile);
450 /* The token immediately after #define must be an identifier. That
451 identifier may not be "defined", per C99 6.10.8p4.
452 In C++, it may not be any of the "named operators" either,
453 per C++98 [lex.digraph], [lex.key].
454 Finally, the identifier may not have been poisoned. (In that case
455 the lexer has issued the error message for us.)
457 Note that if we're copying comments into macro expansions, we
458 could encounter comment tokens here, so eat them all up first. */
460 if (! CPP_OPTION (pfile, discard_comments_in_macro_exp))
462 while (token->type == CPP_COMMENT)
463 token = _cpp_lex_token (pfile);
466 if (token->type != CPP_NAME)
468 if (token->type == CPP_EOF)
469 cpp_error (pfile, "no macro name given in #%s directive",
470 pfile->directive->name);
471 else if (token->flags & NAMED_OP)
473 "\"%s\" cannot be used as a macro name as it is an operator in C++",
474 NODE_NAME (token->val.node));
476 cpp_error (pfile, "macro names must be identifiers");
481 node = token->val.node;
482 if (node->flags & NODE_POISONED)
485 if (node == pfile->spec_nodes.n_defined)
487 cpp_error (pfile, "\"%s\" cannot be used as a macro name",
495 /* Process a #define directive. Most work is done in cppmacro.c. */
500 cpp_hashnode *node = lex_macro_node (pfile);
504 if (_cpp_create_definition (pfile, node))
505 if (pfile->cb.define)
506 (*pfile->cb.define) (pfile, pfile->directive_line, node);
510 /* Handle #undef. Mark the identifier NT_VOID in the hash table. */
515 cpp_hashnode *node = lex_macro_node (pfile);
517 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
518 is not currently defined as a macro name. */
519 if (node && node->type == NT_MACRO)
522 (*pfile->cb.undef) (pfile, pfile->directive_line, node);
524 if (node->flags & NODE_WARN)
525 cpp_warning (pfile, "undefining \"%s\"", NODE_NAME (node));
527 _cpp_free_definition (node);
532 /* Helper routine used by parse_include. Reinterpret the current line
533 as an h-char-sequence (< ... >); we are looking at the first token
534 after the <. Returns the header as a token, or NULL on failure. */
535 static const cpp_token *
536 glue_header_name (pfile)
539 cpp_token *header = NULL;
540 const cpp_token *token;
541 unsigned char *buffer;
542 size_t len, total_len = 0, capacity = 1024;
544 /* To avoid lexed tokens overwriting our glued name, we can only
545 allocate from the string pool once we've lexed everything. */
546 buffer = (unsigned char *) xmalloc (capacity);
549 token = cpp_get_token (pfile);
551 if (token->type == CPP_GREATER || token->type == CPP_EOF)
554 len = cpp_token_len (token);
555 if (total_len + len > capacity)
557 capacity = (capacity + len) * 2;
558 buffer = (unsigned char *) xrealloc (buffer, capacity);
561 if (token->flags & PREV_WHITE)
562 buffer[total_len++] = ' ';
564 total_len = cpp_spell_token (pfile, token, &buffer[total_len]) - buffer;
567 if (token->type == CPP_EOF)
568 cpp_error (pfile, "missing terminating > character");
571 unsigned char *token_mem = _cpp_unaligned_alloc (pfile, total_len + 1);
572 memcpy (token_mem, buffer, total_len);
573 token_mem[total_len] = '\0';
575 header = _cpp_temp_token (pfile);
576 header->type = CPP_HEADER_NAME;
578 header->val.str.len = total_len;
579 header->val.str.text = token_mem;
586 /* Returns the header string of #include, #include_next, #import and
587 #pragma dependency. Returns NULL on error. */
588 static const cpp_token *
589 parse_include (pfile)
592 const unsigned char *dir;
593 const cpp_token *header;
595 if (pfile->directive == &dtable[T_PRAGMA])
596 dir = U"pragma dependency";
598 dir = pfile->directive->name;
600 /* Allow macro expansion. */
601 header = cpp_get_token (pfile);
602 if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
604 if (header->type != CPP_LESS)
606 cpp_error (pfile, "#%s expects \"FILENAME\" or <FILENAME>", dir);
610 header = glue_header_name (pfile);
615 if (header->val.str.len == 0)
617 cpp_error (pfile, "empty file name in #%s", dir);
624 /* Handle #include, #include_next and #import. */
626 do_include_common (pfile, type)
628 enum include_type type;
630 const cpp_token *header;
632 /* For #include_next, if this is the primary source file, warn and
633 use the normal search logic. */
634 if (type == IT_INCLUDE_NEXT && ! pfile->buffer->prev)
636 cpp_warning (pfile, "#include_next in primary source file");
639 else if (type == IT_IMPORT && CPP_OPTION (pfile, warn_import))
641 CPP_OPTION (pfile, warn_import) = 0;
643 "#import is obsolete, use an #ifndef wrapper in the header file");
646 header = parse_include (pfile);
649 /* Prevent #include recursion. */
650 if (pfile->line_maps.depth >= CPP_STACK_MAX)
651 cpp_fatal (pfile, "#include nested too deeply");
655 /* Get out of macro context, if we are. */
656 skip_rest_of_line (pfile);
657 if (pfile->cb.include)
658 (*pfile->cb.include) (pfile, pfile->directive_line,
659 pfile->directive->name, header);
661 _cpp_execute_include (pfile, header, type);
670 do_include_common (pfile, IT_INCLUDE);
677 do_include_common (pfile, IT_IMPORT);
681 do_include_next (pfile)
684 do_include_common (pfile, IT_INCLUDE_NEXT);
687 /* Subroutine of do_linemarker. Read possible flags after file name.
688 LAST is the last flag seen; 0 if this is the first flag. Return the
689 flag if it is valid, 0 at the end of the directive. Otherwise
692 read_flag (pfile, last)
696 const cpp_token *token = _cpp_lex_token (pfile);
698 if (token->type == CPP_NUMBER && token->val.str.len == 1)
700 unsigned int flag = token->val.str.text[0] - '0';
702 if (flag > last && flag <= 4
703 && (flag != 4 || last == 3)
704 && (flag != 2 || last == 0))
708 if (token->type != CPP_EOF)
709 cpp_error (pfile, "invalid flag \"%s\" in line directive",
710 cpp_token_as_text (pfile, token));
714 /* Subroutine of do_line and do_linemarker. Returns a version of STR
715 which has a NUL terminator and all escape sequences converted to
716 their equivalents. Temporary, hopefully. */
718 dequote_string (pfile, str, len)
723 U_CHAR *result = _cpp_unaligned_alloc (pfile, len + 1);
724 U_CHAR *dst = result;
725 const U_CHAR *limit = str + len;
727 unsigned HOST_WIDE_INT mask;
729 /* We need the mask to match the host's 'unsigned char', not the
731 if (CHAR_BIT < HOST_BITS_PER_WIDE_INT)
732 mask = ((unsigned HOST_WIDE_INT) 1 << CHAR_BIT) - 1;
734 mask = ~(unsigned HOST_WIDE_INT)0;
742 *dst++ = cpp_parse_escape (pfile, (const U_CHAR **)&str, limit, mask);
748 /* Subroutine of do_line and do_linemarker. Convert a number in STR,
749 of length LEN, to binary; store it in NUMP, and return 0 if the
750 number was well-formed, 1 if not. Temporary, hopefully. */
752 strtoul_for_line (str, len, nump)
757 unsigned long reg = 0;
771 /* Interpret #line command.
772 Note that the filename string (if any) is a true string constant
773 (escapes are interpreted), unlike in #line. */
778 const cpp_token *token;
779 const char *new_file = pfile->map->to_file;
780 unsigned long new_lineno;
782 /* C99 raised the minimum limit on #line numbers. */
783 unsigned int cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
785 /* #line commands expand macros. */
786 token = cpp_get_token (pfile);
787 if (token->type != CPP_NUMBER
788 || strtoul_for_line (token->val.str.text, token->val.str.len,
791 cpp_error (pfile, "\"%s\" after #line is not a positive integer",
792 cpp_token_as_text (pfile, token));
796 if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
797 cpp_pedwarn (pfile, "line number out of range");
799 token = cpp_get_token (pfile);
800 if (token->type == CPP_STRING)
802 new_file = (const char *) dequote_string (pfile, token->val.str.text,
806 else if (token->type != CPP_EOF)
808 cpp_error (pfile, "\"%s\" is not a valid filename",
809 cpp_token_as_text (pfile, token));
813 skip_rest_of_line (pfile);
814 _cpp_do_file_change (pfile, LC_RENAME, new_file, new_lineno,
818 /* Interpret the # 44 "file" [flags] notation, which has slightly
819 different syntax and semantics from #line: Flags are allowed,
820 and we never complain about the line number being too big. */
822 do_linemarker (pfile)
825 const cpp_token *token;
826 const char *new_file = pfile->map->to_file;
827 unsigned long new_lineno;
828 unsigned int new_sysp = pfile->map->sysp;
829 enum lc_reason reason = LC_RENAME;
832 /* Back up so we can get the number again. Putting this in
833 _cpp_handle_directive risks two calls to _cpp_backup_tokens in
834 some circumstances, which can segfault. */
835 _cpp_backup_tokens (pfile, 1);
837 /* #line commands expand macros. */
838 token = cpp_get_token (pfile);
839 if (token->type != CPP_NUMBER
840 || strtoul_for_line (token->val.str.text, token->val.str.len,
843 cpp_error (pfile, "\"%s\" after # is not a positive integer",
844 cpp_token_as_text (pfile, token));
848 token = cpp_get_token (pfile);
849 if (token->type == CPP_STRING)
851 new_file = (const char *) dequote_string (pfile, token->val.str.text,
854 flag = read_flag (pfile, 0);
858 /* Fake an include for cpp_included (). */
859 _cpp_fake_include (pfile, new_file);
860 flag = read_flag (pfile, flag);
865 flag = read_flag (pfile, flag);
870 flag = read_flag (pfile, flag);
877 else if (token->type != CPP_EOF)
879 cpp_error (pfile, "\"%s\" is not a valid filename",
880 cpp_token_as_text (pfile, token));
884 skip_rest_of_line (pfile);
885 _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp);
888 /* Arrange the file_change callback. pfile->line has changed to
889 FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system
890 header, 2 for a system header that needs to be extern "C" protected,
891 and zero otherwise. */
893 _cpp_do_file_change (pfile, reason, to_file, file_line, sysp)
895 enum lc_reason reason;
897 unsigned int file_line;
900 pfile->map = add_line_map (&pfile->line_maps, reason, sysp,
901 pfile->line, to_file, file_line);
903 if (pfile->cb.file_change)
904 (*pfile->cb.file_change) (pfile, pfile->map);
907 /* Report a warning or error detected by the program we are
908 processing. Use the directive's tokens in the error message. */
910 do_diagnostic (pfile, code, print_dir)
912 enum error_type code;
915 if (_cpp_begin_message (pfile, code, 0, 0))
918 fprintf (stderr, "#%s ", pfile->directive->name);
919 pfile->state.prevent_expansion++;
920 cpp_output_line (pfile, stderr);
921 pfile->state.prevent_expansion--;
929 do_diagnostic (pfile, ERROR, 1);
936 /* We want #warning diagnostics to be emitted in system headers too. */
937 do_diagnostic (pfile, WARNING_SYSHDR, 1);
940 /* Report program identification. */
945 const cpp_token *str = cpp_get_token (pfile);
947 if (str->type != CPP_STRING)
948 cpp_error (pfile, "invalid #ident directive");
949 else if (pfile->cb.ident)
950 (*pfile->cb.ident) (pfile, pfile->directive_line, &str->val.str);
955 /* Lookup a PRAGMA name in a singly-linked CHAIN. Returns the
956 matching entry, or NULL if none is found. The returned entry could
957 be the start of a namespace chain, or a pragma. */
958 static struct pragma_entry *
959 lookup_pragma_entry (chain, pragma)
960 struct pragma_entry *chain;
961 const cpp_hashnode *pragma;
963 while (chain && chain->pragma != pragma)
969 /* Create and insert a pragma entry for NAME at the beginning of a
970 singly-linked CHAIN. If handler is NULL, it is a namespace,
971 otherwise it is a pragma and its handler. */
972 static struct pragma_entry *
973 insert_pragma_entry (pfile, chain, pragma, handler)
975 struct pragma_entry **chain;
976 const cpp_hashnode *pragma;
979 struct pragma_entry *new;
981 new = (struct pragma_entry *)
982 _cpp_aligned_alloc (pfile, sizeof (struct pragma_entry));
983 new->pragma = pragma;
987 new->u.handler = handler;
1000 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
1001 goes in the global namespace. HANDLER is the handler it will call,
1002 which must be non-NULL. */
1004 cpp_register_pragma (pfile, space, name, handler)
1010 struct pragma_entry **chain = &pfile->pragmas;
1011 struct pragma_entry *entry;
1012 const cpp_hashnode *node;
1019 node = cpp_lookup (pfile, U space, strlen (space));
1020 entry = lookup_pragma_entry (*chain, node);
1022 entry = insert_pragma_entry (pfile, chain, node, NULL);
1023 else if (!entry->is_nspace)
1025 chain = &entry->u.space;
1028 /* Check for duplicates. */
1029 node = cpp_lookup (pfile, U name, strlen (name));
1030 entry = lookup_pragma_entry (*chain, node);
1033 if (entry->is_nspace)
1036 "registering \"%s\" as both a pragma and a pragma namespace",
1039 cpp_ice (pfile, "#pragma %s %s is already registered", space, name);
1041 cpp_ice (pfile, "#pragma %s is already registered", name);
1044 insert_pragma_entry (pfile, chain, node, handler);
1047 /* Register the pragmas the preprocessor itself handles. */
1049 _cpp_init_internal_pragmas (pfile)
1052 /* Pragmas in the global namespace. */
1053 cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
1054 cpp_register_pragma (pfile, 0, "once", do_pragma_once);
1056 /* New GCC-specific pragmas should be put in the GCC namespace. */
1057 cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
1058 cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
1059 cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
1062 /* Pragmata handling. We handle some, and pass the rest on to the
1063 front end. C99 defines three pragmas and says that no macro
1064 expansion is to be performed on them; whether or not macro
1065 expansion happens for other pragmas is implementation defined.
1066 This implementation never macro-expands the text after #pragma. */
1071 const struct pragma_entry *p = NULL;
1072 const cpp_token *token;
1073 unsigned int count = 1;
1075 pfile->state.prevent_expansion++;
1077 token = cpp_get_token (pfile);
1078 if (token->type == CPP_NAME)
1080 p = lookup_pragma_entry (pfile->pragmas, token->val.node);
1081 if (p && p->is_nspace)
1084 token = cpp_get_token (pfile);
1085 if (token->type == CPP_NAME)
1086 p = lookup_pragma_entry (p->u.space, token->val.node);
1092 /* FIXME. This is an awful kludge to get the front ends to update
1093 their notion of line number for diagnostic purposes. The line
1094 number should be passed to the handler and they should do it
1095 themselves. Stand-alone CPP must ignore us, otherwise it will
1096 prefix the directive with spaces, hence the 1. Ugh. */
1097 if (pfile->cb.line_change)
1098 (*pfile->cb.line_change)(pfile, token, 1);
1101 (*p->u.handler) (pfile);
1102 else if (pfile->cb.def_pragma)
1104 _cpp_backup_tokens (pfile, count);
1105 (*pfile->cb.def_pragma) (pfile, pfile->directive_line);
1108 pfile->state.prevent_expansion--;
1111 /* Handle #pragma once. */
1113 do_pragma_once (pfile)
1116 cpp_warning (pfile, "#pragma once is obsolete");
1118 if (pfile->buffer->prev == NULL)
1119 cpp_warning (pfile, "#pragma once in main file");
1121 _cpp_never_reread (pfile->buffer->inc);
1126 /* Handle #pragma poison, to poison one or more identifiers so that
1127 the lexer produces a hard error for each subsequent usage. */
1129 do_pragma_poison (pfile)
1132 const cpp_token *tok;
1135 pfile->state.poisoned_ok = 1;
1138 tok = _cpp_lex_token (pfile);
1139 if (tok->type == CPP_EOF)
1141 if (tok->type != CPP_NAME)
1143 cpp_error (pfile, "invalid #pragma GCC poison directive");
1148 if (hp->flags & NODE_POISONED)
1151 if (hp->type == NT_MACRO)
1152 cpp_warning (pfile, "poisoning existing macro \"%s\"", NODE_NAME (hp));
1153 _cpp_free_definition (hp);
1154 hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1156 pfile->state.poisoned_ok = 0;
1159 /* Mark the current header as a system header. This will suppress
1160 some categories of warnings (notably those from -pedantic). It is
1161 intended for use in system libraries that cannot be implemented in
1162 conforming C, but cannot be certain that their headers appear in a
1163 system include directory. To prevent abuse, it is rejected in the
1164 primary source file. */
1166 do_pragma_system_header (pfile)
1169 cpp_buffer *buffer = pfile->buffer;
1171 if (buffer->prev == 0)
1172 cpp_warning (pfile, "#pragma system_header ignored outside include file");
1176 skip_rest_of_line (pfile);
1177 cpp_make_system_header (pfile, 1, 0);
1181 /* Check the modified date of the current include file against a specified
1182 file. Issue a diagnostic, if the specified file is newer. We use this to
1183 determine if a fixed header should be refixed. */
1185 do_pragma_dependency (pfile)
1188 const cpp_token *header;
1191 header = parse_include (pfile);
1195 ordering = _cpp_compare_file_date (pfile, header);
1197 cpp_warning (pfile, "cannot find source %s",
1198 cpp_token_as_text (pfile, header));
1199 else if (ordering > 0)
1201 cpp_warning (pfile, "current file is older than %s",
1202 cpp_token_as_text (pfile, header));
1203 if (cpp_get_token (pfile)->type != CPP_EOF)
1205 _cpp_backup_tokens (pfile, 1);
1206 do_diagnostic (pfile, WARNING, 0);
1211 /* Get a token but skip padding. */
1212 static const cpp_token *
1213 get_token_no_padding (pfile)
1218 const cpp_token *result = cpp_get_token (pfile);
1219 if (result->type != CPP_PADDING)
1224 /* Check syntax is "(string-literal)". Returns the string on success,
1225 or NULL on failure. */
1226 static const cpp_token *
1227 get__Pragma_string (pfile)
1230 const cpp_token *string;
1232 if (get_token_no_padding (pfile)->type != CPP_OPEN_PAREN)
1235 string = get_token_no_padding (pfile);
1236 if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1239 if (get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
1245 /* Destringize IN into a temporary buffer, by removing the first \ of
1246 \" and \\ sequences, and process the result as a #pragma directive. */
1248 destringize_and_run (pfile, in)
1250 const cpp_string *in;
1252 const unsigned char *src, *limit;
1253 char *dest, *result;
1255 dest = result = alloca (in->len + 1);
1256 for (src = in->text, limit = src + in->len; src < limit;)
1258 /* We know there is a character following the backslash. */
1259 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1265 run_directive (pfile, T_PRAGMA, result, dest - result);
1268 /* Handle the _Pragma operator. */
1270 _cpp_do__Pragma (pfile)
1273 const cpp_token *string = get__Pragma_string (pfile);
1276 cpp_error (pfile, "_Pragma takes a parenthesized string literal");
1279 /* Ideally, we'd like
1280 token1 _Pragma ("foo") token2
1287 Getting these correct line markers is a little tricky. */
1289 unsigned int orig_line = pfile->line;
1290 destringize_and_run (pfile, &string->val.str);
1291 pfile->line = orig_line;
1292 pfile->buffer->saved_flags = BOL;
1296 /* Just ignore #sccs, on systems where we define it at all. */
1297 #ifdef SCCS_DIRECTIVE
1300 cpp_reader *pfile ATTRIBUTE_UNUSED;
1305 /* Handle #ifdef. */
1312 if (! pfile->state.skipping)
1314 const cpp_hashnode *node = lex_macro_node (pfile);
1317 skip = node->type != NT_MACRO;
1323 push_conditional (pfile, skip, T_IFDEF, 0);
1326 /* Handle #ifndef. */
1332 const cpp_hashnode *node = 0;
1334 if (! pfile->state.skipping)
1336 node = lex_macro_node (pfile);
1338 skip = node->type == NT_MACRO;
1344 push_conditional (pfile, skip, T_IFNDEF, node);
1347 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1348 pfile->mi_ind_cmacro so we can handle multiple-include
1349 optimisations. If macro expansion occurs in the expression, we
1350 cannot treat it as a controlling conditional, since the expansion
1351 could change in the future. That is handled by cpp_get_token. */
1358 if (! pfile->state.skipping)
1359 skip = _cpp_parse_expr (pfile) == 0;
1361 push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
1364 /* Flip skipping state if appropriate and continue without changing
1365 if_stack; this is so that the error message for missing #endif's
1366 etc. will point to the original #if. */
1371 cpp_buffer *buffer = pfile->buffer;
1372 struct if_stack *ifs = buffer->if_stack;
1375 cpp_error (pfile, "#else without #if");
1378 if (ifs->type == T_ELSE)
1380 cpp_error (pfile, "#else after #else");
1381 cpp_error_with_line (pfile, ifs->line, 0,
1382 "the conditional began here");
1386 /* Skip any future (erroneous) #elses or #elifs. */
1387 pfile->state.skipping = ifs->skip_elses;
1388 ifs->skip_elses = true;
1390 /* Invalidate any controlling macro. */
1393 /* Only check EOL if was not originally skipping. */
1394 if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
1399 /* Handle a #elif directive by not changing if_stack either. See the
1400 comment above do_else. */
1405 cpp_buffer *buffer = pfile->buffer;
1406 struct if_stack *ifs = buffer->if_stack;
1409 cpp_error (pfile, "#elif without #if");
1412 if (ifs->type == T_ELSE)
1414 cpp_error (pfile, "#elif after #else");
1415 cpp_error_with_line (pfile, ifs->line, 0,
1416 "the conditional began here");
1420 /* Only evaluate this if we aren't skipping elses. During
1421 evaluation, set skipping to false to get lexer warnings. */
1422 if (ifs->skip_elses)
1423 pfile->state.skipping = 1;
1426 pfile->state.skipping = 0;
1427 pfile->state.skipping = ! _cpp_parse_expr (pfile);
1428 ifs->skip_elses = ! pfile->state.skipping;
1431 /* Invalidate any controlling macro. */
1436 /* #endif pops the if stack and resets pfile->state.skipping. */
1441 cpp_buffer *buffer = pfile->buffer;
1442 struct if_stack *ifs = buffer->if_stack;
1445 cpp_error (pfile, "#endif without #if");
1448 /* Only check EOL if was not originally skipping. */
1449 if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
1452 /* If potential control macro, we go back outside again. */
1453 if (ifs->next == 0 && ifs->mi_cmacro)
1455 pfile->mi_valid = true;
1456 pfile->mi_cmacro = ifs->mi_cmacro;
1459 buffer->if_stack = ifs->next;
1460 pfile->state.skipping = ifs->was_skipping;
1461 obstack_free (&pfile->buffer_ob, ifs);
1465 /* Push an if_stack entry for a preprocessor conditional, and set
1466 pfile->state.skipping to SKIP. If TYPE indicates the conditional
1467 is #if or #ifndef, CMACRO is a potentially controlling macro, and
1468 we need to check here that we are at the top of the file. */
1470 push_conditional (pfile, skip, type, cmacro)
1474 const cpp_hashnode *cmacro;
1476 struct if_stack *ifs;
1477 cpp_buffer *buffer = pfile->buffer;
1479 ifs = xobnew (&pfile->buffer_ob, struct if_stack);
1480 ifs->line = pfile->directive_line;
1481 ifs->next = buffer->if_stack;
1482 ifs->skip_elses = pfile->state.skipping || !skip;
1483 ifs->was_skipping = pfile->state.skipping;
1485 /* This condition is effectively a test for top-of-file. */
1486 if (pfile->mi_valid && pfile->mi_cmacro == 0)
1487 ifs->mi_cmacro = cmacro;
1491 pfile->state.skipping = skip;
1492 buffer->if_stack = ifs;
1495 /* Read the tokens of the answer into the macro pool, in a directive
1496 of type TYPE. Only commit the memory if we intend it as permanent
1497 storage, i.e. the #assert case. Returns 0 on success, and sets
1498 ANSWERP to point to the answer. */
1500 parse_answer (pfile, answerp, type)
1502 struct answer **answerp;
1505 const cpp_token *paren;
1506 struct answer *answer;
1507 unsigned int acount;
1509 /* In a conditional, it is legal to not have an open paren. We
1510 should save the following token in this case. */
1511 paren = cpp_get_token (pfile);
1513 /* If not a paren, see if we're OK. */
1514 if (paren->type != CPP_OPEN_PAREN)
1516 /* In a conditional no answer is a test for any answer. It
1517 could be followed by any token. */
1520 _cpp_backup_tokens (pfile, 1);
1524 /* #unassert with no answer is valid - it removes all answers. */
1525 if (type == T_UNASSERT && paren->type == CPP_EOF)
1528 cpp_error (pfile, "missing '(' after predicate");
1532 for (acount = 0;; acount++)
1535 const cpp_token *token = cpp_get_token (pfile);
1538 if (token->type == CPP_CLOSE_PAREN)
1541 if (token->type == CPP_EOF)
1543 cpp_error (pfile, "missing ')' to complete answer");
1547 /* struct answer includes the space for one token. */
1548 room_needed = (sizeof (struct answer) + acount * sizeof (cpp_token));
1550 if (BUFF_ROOM (pfile->a_buff) < room_needed)
1551 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer));
1553 dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount];
1556 /* Drop whitespace at start, for answer equivalence purposes. */
1558 dest->flags &= ~PREV_WHITE;
1563 cpp_error (pfile, "predicate's answer is empty");
1567 answer = (struct answer *) BUFF_FRONT (pfile->a_buff);
1568 answer->count = acount;
1569 answer->next = NULL;
1575 /* Parses an assertion directive of type TYPE, returning a pointer to
1576 the hash node of the predicate, or 0 on error. If an answer was
1577 supplied, it is placed in ANSWERP, otherwise it is set to 0. */
1578 static cpp_hashnode *
1579 parse_assertion (pfile, answerp, type)
1581 struct answer **answerp;
1584 cpp_hashnode *result = 0;
1585 const cpp_token *predicate;
1587 /* We don't expand predicates or answers. */
1588 pfile->state.prevent_expansion++;
1591 predicate = cpp_get_token (pfile);
1592 if (predicate->type == CPP_EOF)
1593 cpp_error (pfile, "assertion without predicate");
1594 else if (predicate->type != CPP_NAME)
1595 cpp_error (pfile, "predicate must be an identifier");
1596 else if (parse_answer (pfile, answerp, type) == 0)
1598 unsigned int len = NODE_LEN (predicate->val.node);
1599 unsigned char *sym = alloca (len + 1);
1601 /* Prefix '#' to get it out of macro namespace. */
1603 memcpy (sym + 1, NODE_NAME (predicate->val.node), len);
1604 result = cpp_lookup (pfile, sym, len + 1);
1607 pfile->state.prevent_expansion--;
1611 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
1612 or a pointer to NULL if the answer is not in the chain. */
1613 static struct answer **
1614 find_answer (node, candidate)
1616 const struct answer *candidate;
1619 struct answer **result;
1621 for (result = &node->value.answers; *result; result = &(*result)->next)
1623 struct answer *answer = *result;
1625 if (answer->count == candidate->count)
1627 for (i = 0; i < answer->count; i++)
1628 if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1631 if (i == answer->count)
1639 /* Test an assertion within a preprocessor conditional. Returns
1640 non-zero on failure, zero on success. On success, the result of
1641 the test is written into VALUE. */
1643 _cpp_test_assertion (pfile, value)
1647 struct answer *answer;
1650 node = parse_assertion (pfile, &answer, T_IF);
1652 *value = (node->type == NT_ASSERTION &&
1653 (answer == 0 || *find_answer (node, answer) != 0));
1655 /* We don't commit the memory for the answer - it's temporary only. */
1659 /* Handle #assert. */
1664 struct answer *new_answer;
1667 node = parse_assertion (pfile, &new_answer, T_ASSERT);
1670 /* Place the new answer in the answer list. First check there
1671 is not a duplicate. */
1672 new_answer->next = 0;
1673 if (node->type == NT_ASSERTION)
1675 if (*find_answer (node, new_answer))
1677 cpp_warning (pfile, "\"%s\" re-asserted", NODE_NAME (node) + 1);
1680 new_answer->next = node->value.answers;
1683 node->type = NT_ASSERTION;
1684 node->value.answers = new_answer;
1685 BUFF_FRONT (pfile->a_buff) += (sizeof (struct answer)
1686 + (new_answer->count - 1)
1687 * sizeof (cpp_token));
1692 /* Handle #unassert. */
1698 struct answer *answer;
1700 node = parse_assertion (pfile, &answer, T_UNASSERT);
1701 /* It isn't an error to #unassert something that isn't asserted. */
1702 if (node && node->type == NT_ASSERTION)
1706 struct answer **p = find_answer (node, answer), *temp;
1708 /* Remove the answer from the list. */
1713 /* Did we free the last answer? */
1714 if (node->value.answers == 0)
1715 node->type = NT_VOID;
1720 _cpp_free_definition (node);
1723 /* We don't commit the memory for the answer - it's temporary only. */
1726 /* These are for -D, -U, -A. */
1728 /* Process the string STR as if it appeared as the body of a #define.
1729 If STR is just an identifier, define it with value 1.
1730 If STR has anything after the identifier, then it should
1731 be identifier=definition. */
1733 cpp_define (pfile, str)
1740 /* Copy the entire option so we can modify it.
1741 Change the first "=" in the string to a space. If there is none,
1742 tack " 1" on the end. */
1744 count = strlen (str);
1745 buf = (char *) alloca (count + 3);
1746 memcpy (buf, str, count);
1748 p = strchr (str, '=');
1758 run_directive (pfile, T_DEFINE, buf, count);
1761 /* Slight variant of the above for use by initialize_builtins. */
1763 _cpp_define_builtin (pfile, str)
1767 run_directive (pfile, T_DEFINE, str, strlen (str));
1770 /* Process MACRO as if it appeared as the body of an #undef. */
1772 cpp_undef (pfile, macro)
1776 run_directive (pfile, T_UNDEF, macro, strlen (macro));
1779 /* Process the string STR as if it appeared as the body of a #assert. */
1781 cpp_assert (pfile, str)
1785 handle_assertion (pfile, str, T_ASSERT);
1788 /* Process STR as if it appeared as the body of an #unassert. */
1790 cpp_unassert (pfile, str)
1794 handle_assertion (pfile, str, T_UNASSERT);
1797 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1799 handle_assertion (pfile, str, type)
1804 size_t count = strlen (str);
1805 const char *p = strchr (str, '=');
1809 /* Copy the entire option so we can modify it. Change the first
1810 "=" in the string to a '(', and tack a ')' on the end. */
1811 char *buf = (char *) alloca (count + 2);
1813 memcpy (buf, str, count);
1820 run_directive (pfile, type, str, count);
1823 /* The number of errors for a given reader. */
1828 return pfile->errors;
1831 /* The options structure. */
1833 cpp_get_options (pfile)
1836 return &pfile->opts;
1839 /* The callbacks structure. */
1841 cpp_get_callbacks (pfile)
1847 /* The line map set. */
1848 const struct line_maps *
1849 cpp_get_line_maps (pfile)
1852 return &pfile->line_maps;
1855 /* Copy the given callbacks structure to our own. */
1857 cpp_set_callbacks (pfile, cb)
1864 /* Push a new buffer on the buffer stack. Returns the new buffer; it
1865 doesn't fail. It does not generate a file change call back; that
1866 is the responsibility of the caller. */
1868 cpp_push_buffer (pfile, buffer, len, from_stage3, return_at_eof)
1870 const U_CHAR *buffer;
1875 cpp_buffer *new = xobnew (&pfile->buffer_ob, cpp_buffer);
1877 /* Clears, amongst other things, if_stack and mi_cmacro. */
1878 memset (new, 0, sizeof (cpp_buffer));
1880 new->line_base = new->buf = new->cur = buffer;
1881 new->rlimit = buffer + len;
1882 new->from_stage3 = from_stage3;
1883 new->prev = pfile->buffer;
1884 new->return_at_eof = return_at_eof;
1885 new->saved_flags = BOL;
1887 pfile->buffer = new;
1892 /* If called from do_line, pops a single buffer. Otherwise pops all
1893 buffers until a real file is reached. Generates appropriate
1896 _cpp_pop_buffer (pfile)
1899 cpp_buffer *buffer = pfile->buffer;
1900 struct if_stack *ifs;
1901 bool pushed = false;
1903 /* Walk back up the conditional stack till we reach its level at
1904 entry to this file, issuing error messages. */
1905 for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
1906 cpp_error_with_line (pfile, ifs->line, 0,
1907 "unterminated #%s", dtable[ifs->type].name);
1909 /* In case of a missing #endif. */
1910 pfile->state.skipping = 0;
1912 /* Update the reader's buffer before _cpp_do_file_change. */
1913 pfile->buffer = buffer->prev;
1916 pushed = _cpp_pop_file_buffer (pfile, buffer->inc);
1919 obstack_free (&pfile->buffer_ob, buffer);
1922 /* Enter all recognised directives in the hash table. */
1924 _cpp_init_directives (pfile)
1930 for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
1932 node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
1933 node->directive_index = i + 1;