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 uchar *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 uchar *dequote_string PARAMS ((cpp_reader *, const uchar *,
108 static int strtoul_for_line PARAMS ((const uchar *, unsigned int,
110 static void do_diagnostic PARAMS ((cpp_reader *, int, 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 uchar *) 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_error (pfile, DL_PEDWARN, "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_error (pfile, DL_PEDWARN, "#%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_error (pfile, DL_WARNING,
293 "suggest not using #elif in traditional C");
294 else if (indented && dir->origin == KANDR)
295 cpp_error (pfile, DL_WARNING,
296 "traditional C ignores #%s with the # indented",
298 else if (!indented && dir->origin != KANDR)
299 cpp_error (pfile, DL_WARNING,
300 "suggest hiding #%s from traditional C with an indented #",
305 /* Check if we have a known directive. INDENTED is non-zero if the
306 '#' of the directive was indented. This function is in this file
307 to save unnecessarily exporting dtable etc. to cpplex.c. Returns
308 non-zero if the line of tokens has been handled, zero if we should
309 continue processing the line. */
311 _cpp_handle_directive (pfile, indented)
315 const directive *dir = 0;
316 const cpp_token *dname;
317 bool was_parsing_args = pfile->state.parsing_args;
320 if (was_parsing_args)
322 if (CPP_OPTION (pfile, pedantic))
323 cpp_error (pfile, DL_PEDWARN,
324 "embedding a directive within macro arguments is not portable");
325 pfile->state.parsing_args = 0;
326 pfile->state.prevent_expansion = 0;
328 start_directive (pfile);
329 dname = _cpp_lex_token (pfile);
331 if (dname->type == CPP_NAME)
333 if (dname->val.node->directive_index)
334 dir = &dtable[dname->val.node->directive_index - 1];
336 /* We do not recognise the # followed by a number extension in
338 else if (dname->type == CPP_NUMBER && CPP_OPTION (pfile, lang) != CLK_ASM)
340 dir = &linemarker_dir;
341 if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed)
342 && ! pfile->state.skipping)
343 cpp_error (pfile, DL_PEDWARN,
344 "style of line directive is a GCC extension");
349 /* If we have a directive that is not an opening conditional,
350 invalidate any control macro. */
351 if (! (dir->flags & IF_COND))
352 pfile->mi_valid = false;
354 /* Kluge alert. In order to be sure that code like this
359 does not cause '#define foo bar' to get executed when
360 compiled with -save-temps, we recognize directives in
361 -fpreprocessed mode only if the # is in column 1. cppmacro.c
362 puts a space in front of any '#' at the start of a macro. */
363 if (CPP_OPTION (pfile, preprocessed)
364 && (indented || !(dir->flags & IN_I)))
371 /* In failed conditional groups, all non-conditional
372 directives are ignored. Before doing that, whether
373 skipping or not, we should lex angle-bracketed headers
374 correctly, and maybe output some diagnostics. */
375 pfile->state.angled_headers = dir->flags & INCL;
376 if (! CPP_OPTION (pfile, preprocessed))
377 directive_diagnostics (pfile, dir, indented);
378 if (pfile->state.skipping && !(dir->flags & COND))
382 else if (dname->type == CPP_EOF)
383 ; /* CPP_EOF is the "null directive". */
386 /* An unknown directive. Don't complain about it in assembly
387 source: we don't know where the comments are, and # may
388 introduce assembler pseudo-ops. Don't complain about invalid
389 directives in skipped conditional groups (6.10 p4). */
390 if (CPP_OPTION (pfile, lang) == CLK_ASM)
392 else if (!pfile->state.skipping)
393 cpp_error (pfile, DL_ERROR, "invalid preprocessing directive #%s",
394 cpp_token_as_text (pfile, dname));
399 /* If we are processing a `#define' directive and we have been
400 requested to expand comments into macros, then re-enable
401 saving of comments. */
402 if (dir == &dtable[T_DEFINE])
403 pfile->state.save_comments =
404 ! CPP_OPTION (pfile, discard_comments_in_macro_exp);
406 pfile->directive = dir;
407 (*pfile->directive->handler) (pfile);
410 _cpp_backup_tokens (pfile, 1);
412 end_directive (pfile, skip);
413 if (was_parsing_args)
415 /* Restore state when within macro args. */
416 pfile->state.parsing_args = 2;
417 pfile->state.prevent_expansion = 1;
418 pfile->buffer->saved_flags |= PREV_WHITE;
423 /* Directive handler wrapper used by the command line option
426 run_directive (pfile, dir_no, buf, count)
432 cpp_push_buffer (pfile, (const uchar *) buf, count,
433 /* from_stage3 */ true, 1);
434 start_directive (pfile);
435 /* We don't want a leading # to be interpreted as a directive. */
436 pfile->buffer->saved_flags = 0;
437 pfile->directive = &dtable[dir_no];
438 (void) (*pfile->directive->handler) (pfile);
439 end_directive (pfile, 1);
440 _cpp_pop_buffer (pfile);
443 /* Checks for validity the macro name in #define, #undef, #ifdef and
444 #ifndef directives. */
445 static cpp_hashnode *
446 lex_macro_node (pfile)
450 const cpp_token *token = _cpp_lex_token (pfile);
452 /* The token immediately after #define must be an identifier. That
453 identifier may not be "defined", per C99 6.10.8p4.
454 In C++, it may not be any of the "named operators" either,
455 per C++98 [lex.digraph], [lex.key].
456 Finally, the identifier may not have been poisoned. (In that case
457 the lexer has issued the error message for us.)
459 Note that if we're copying comments into macro expansions, we
460 could encounter comment tokens here, so eat them all up first. */
462 if (! CPP_OPTION (pfile, discard_comments_in_macro_exp))
464 while (token->type == CPP_COMMENT)
465 token = _cpp_lex_token (pfile);
468 if (token->type != CPP_NAME)
470 if (token->type == CPP_EOF)
471 cpp_error (pfile, DL_ERROR, "no macro name given in #%s directive",
472 pfile->directive->name);
473 else if (token->flags & NAMED_OP)
474 cpp_error (pfile, DL_ERROR,
475 "\"%s\" cannot be used as a macro name as it is an operator in C++",
476 NODE_NAME (token->val.node));
478 cpp_error (pfile, DL_ERROR, "macro names must be identifiers");
483 node = token->val.node;
484 if (node->flags & NODE_POISONED)
487 if (node == pfile->spec_nodes.n_defined)
489 cpp_error (pfile, DL_ERROR, "\"%s\" cannot be used as a macro name",
497 /* Process a #define directive. Most work is done in cppmacro.c. */
502 cpp_hashnode *node = lex_macro_node (pfile);
506 if (_cpp_create_definition (pfile, node))
507 if (pfile->cb.define)
508 (*pfile->cb.define) (pfile, pfile->directive_line, node);
512 /* Handle #undef. Mark the identifier NT_VOID in the hash table. */
517 cpp_hashnode *node = lex_macro_node (pfile);
519 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
520 is not currently defined as a macro name. */
521 if (node && node->type == NT_MACRO)
524 (*pfile->cb.undef) (pfile, pfile->directive_line, node);
526 if (node->flags & NODE_WARN)
527 cpp_error (pfile, DL_WARNING, "undefining \"%s\"", NODE_NAME (node));
529 _cpp_free_definition (node);
534 /* Helper routine used by parse_include. Reinterpret the current line
535 as an h-char-sequence (< ... >); we are looking at the first token
536 after the <. Returns the header as a token, or NULL on failure. */
537 static const cpp_token *
538 glue_header_name (pfile)
541 cpp_token *header = NULL;
542 const cpp_token *token;
543 unsigned char *buffer;
544 size_t len, total_len = 0, capacity = 1024;
546 /* To avoid lexed tokens overwriting our glued name, we can only
547 allocate from the string pool once we've lexed everything. */
548 buffer = (unsigned char *) xmalloc (capacity);
551 token = cpp_get_token (pfile);
553 if (token->type == CPP_GREATER || token->type == CPP_EOF)
556 len = cpp_token_len (token);
557 if (total_len + len > capacity)
559 capacity = (capacity + len) * 2;
560 buffer = (unsigned char *) xrealloc (buffer, capacity);
563 if (token->flags & PREV_WHITE)
564 buffer[total_len++] = ' ';
566 total_len = cpp_spell_token (pfile, token, &buffer[total_len]) - buffer;
569 if (token->type == CPP_EOF)
570 cpp_error (pfile, DL_ERROR, "missing terminating > character");
573 unsigned char *token_mem = _cpp_unaligned_alloc (pfile, total_len + 1);
574 memcpy (token_mem, buffer, total_len);
575 token_mem[total_len] = '\0';
577 header = _cpp_temp_token (pfile);
578 header->type = CPP_HEADER_NAME;
580 header->val.str.len = total_len;
581 header->val.str.text = token_mem;
588 /* Returns the header string of #include, #include_next, #import and
589 #pragma dependency. Returns NULL on error. */
590 static const cpp_token *
591 parse_include (pfile)
594 const unsigned char *dir;
595 const cpp_token *header;
597 if (pfile->directive == &dtable[T_PRAGMA])
598 dir = U"pragma dependency";
600 dir = pfile->directive->name;
602 /* Allow macro expansion. */
603 header = cpp_get_token (pfile);
604 if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
606 if (header->type != CPP_LESS)
608 cpp_error (pfile, DL_ERROR,
609 "#%s expects \"FILENAME\" or <FILENAME>", dir);
613 header = glue_header_name (pfile);
618 if (header->val.str.len == 0)
620 cpp_error (pfile, DL_ERROR, "empty file name in #%s", dir);
627 /* Handle #include, #include_next and #import. */
629 do_include_common (pfile, type)
631 enum include_type type;
633 const cpp_token *header;
635 /* For #include_next, if this is the primary source file, warn and
636 use the normal search logic. */
637 if (type == IT_INCLUDE_NEXT && ! pfile->buffer->prev)
639 cpp_error (pfile, DL_WARNING, "#include_next in primary source file");
642 else if (type == IT_IMPORT && CPP_OPTION (pfile, warn_import))
644 CPP_OPTION (pfile, warn_import) = 0;
645 cpp_error (pfile, DL_WARNING,
646 "#import is obsolete, use an #ifndef wrapper in the header file");
649 header = parse_include (pfile);
652 /* Prevent #include recursion. */
653 if (pfile->line_maps.depth >= CPP_STACK_MAX)
654 cpp_error (pfile, DL_FATAL, "#include nested too deeply");
658 /* Get out of macro context, if we are. */
659 skip_rest_of_line (pfile);
660 if (pfile->cb.include)
661 (*pfile->cb.include) (pfile, pfile->directive_line,
662 pfile->directive->name, header);
664 _cpp_execute_include (pfile, header, type);
673 do_include_common (pfile, IT_INCLUDE);
680 do_include_common (pfile, IT_IMPORT);
684 do_include_next (pfile)
687 do_include_common (pfile, IT_INCLUDE_NEXT);
690 /* Subroutine of do_linemarker. Read possible flags after file name.
691 LAST is the last flag seen; 0 if this is the first flag. Return the
692 flag if it is valid, 0 at the end of the directive. Otherwise
695 read_flag (pfile, last)
699 const cpp_token *token = _cpp_lex_token (pfile);
701 if (token->type == CPP_NUMBER && token->val.str.len == 1)
703 unsigned int flag = token->val.str.text[0] - '0';
705 if (flag > last && flag <= 4
706 && (flag != 4 || last == 3)
707 && (flag != 2 || last == 0))
711 if (token->type != CPP_EOF)
712 cpp_error (pfile, DL_ERROR, "invalid flag \"%s\" in line directive",
713 cpp_token_as_text (pfile, token));
717 /* Subroutine of do_line and do_linemarker. Returns a version of STR
718 which has a NUL terminator and all escape sequences converted to
719 their equivalents. Temporary, hopefully. */
721 dequote_string (pfile, str, len)
726 uchar *result = _cpp_unaligned_alloc (pfile, len + 1);
728 const uchar *limit = str + len;
730 unsigned HOST_WIDE_INT mask;
732 /* We need the mask to match the host's 'unsigned char', not the
734 if (CHAR_BIT < HOST_BITS_PER_WIDE_INT)
735 mask = ((unsigned HOST_WIDE_INT) 1 << CHAR_BIT) - 1;
737 mask = ~(unsigned HOST_WIDE_INT)0;
745 *dst++ = cpp_parse_escape (pfile, (const uchar **)&str, limit, mask);
751 /* Subroutine of do_line and do_linemarker. Convert a number in STR,
752 of length LEN, to binary; store it in NUMP, and return 0 if the
753 number was well-formed, 1 if not. Temporary, hopefully. */
755 strtoul_for_line (str, len, nump)
760 unsigned long reg = 0;
774 /* Interpret #line command.
775 Note that the filename string (if any) is a true string constant
776 (escapes are interpreted), unlike in #line. */
781 const cpp_token *token;
782 const char *new_file = pfile->map->to_file;
783 unsigned long new_lineno;
785 /* C99 raised the minimum limit on #line numbers. */
786 unsigned int cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
788 /* #line commands expand macros. */
789 token = cpp_get_token (pfile);
790 if (token->type != CPP_NUMBER
791 || strtoul_for_line (token->val.str.text, token->val.str.len,
794 cpp_error (pfile, DL_ERROR,
795 "\"%s\" after #line is not a positive integer",
796 cpp_token_as_text (pfile, token));
800 if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
801 cpp_error (pfile, DL_PEDWARN, "line number out of range");
803 token = cpp_get_token (pfile);
804 if (token->type == CPP_STRING)
806 new_file = (const char *) dequote_string (pfile, token->val.str.text,
810 else if (token->type != CPP_EOF)
812 cpp_error (pfile, DL_ERROR, "\"%s\" is not a valid filename",
813 cpp_token_as_text (pfile, token));
817 skip_rest_of_line (pfile);
818 _cpp_do_file_change (pfile, LC_RENAME, new_file, new_lineno,
822 /* Interpret the # 44 "file" [flags] notation, which has slightly
823 different syntax and semantics from #line: Flags are allowed,
824 and we never complain about the line number being too big. */
826 do_linemarker (pfile)
829 const cpp_token *token;
830 const char *new_file = pfile->map->to_file;
831 unsigned long new_lineno;
832 unsigned int new_sysp = pfile->map->sysp;
833 enum lc_reason reason = LC_RENAME;
836 /* Back up so we can get the number again. Putting this in
837 _cpp_handle_directive risks two calls to _cpp_backup_tokens in
838 some circumstances, which can segfault. */
839 _cpp_backup_tokens (pfile, 1);
841 /* #line commands expand macros. */
842 token = cpp_get_token (pfile);
843 if (token->type != CPP_NUMBER
844 || strtoul_for_line (token->val.str.text, token->val.str.len,
847 cpp_error (pfile, DL_ERROR, "\"%s\" after # is not a positive integer",
848 cpp_token_as_text (pfile, token));
852 token = cpp_get_token (pfile);
853 if (token->type == CPP_STRING)
855 new_file = (const char *) dequote_string (pfile, token->val.str.text,
858 flag = read_flag (pfile, 0);
862 /* Fake an include for cpp_included (). */
863 _cpp_fake_include (pfile, new_file);
864 flag = read_flag (pfile, flag);
869 flag = read_flag (pfile, flag);
874 flag = read_flag (pfile, flag);
881 else if (token->type != CPP_EOF)
883 cpp_error (pfile, DL_ERROR, "\"%s\" is not a valid filename",
884 cpp_token_as_text (pfile, token));
888 skip_rest_of_line (pfile);
889 _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp);
892 /* Arrange the file_change callback. pfile->line has changed to
893 FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system
894 header, 2 for a system header that needs to be extern "C" protected,
895 and zero otherwise. */
897 _cpp_do_file_change (pfile, reason, to_file, file_line, sysp)
899 enum lc_reason reason;
901 unsigned int file_line;
904 pfile->map = add_line_map (&pfile->line_maps, reason, sysp,
905 pfile->line, to_file, file_line);
907 if (pfile->cb.file_change)
908 (*pfile->cb.file_change) (pfile, pfile->map);
911 /* Report a warning or error detected by the program we are
912 processing. Use the directive's tokens in the error message. */
914 do_diagnostic (pfile, code, print_dir)
919 if (_cpp_begin_message (pfile, code,
920 pfile->cur_token[-1].line,
921 pfile->cur_token[-1].col))
924 fprintf (stderr, "#%s ", pfile->directive->name);
925 pfile->state.prevent_expansion++;
926 cpp_output_line (pfile, stderr);
927 pfile->state.prevent_expansion--;
935 do_diagnostic (pfile, DL_ERROR, 1);
942 /* We want #warning diagnostics to be emitted in system headers too. */
943 do_diagnostic (pfile, DL_WARNING_SYSHDR, 1);
946 /* Report program identification. */
951 const cpp_token *str = cpp_get_token (pfile);
953 if (str->type != CPP_STRING)
954 cpp_error (pfile, DL_ERROR, "invalid #ident directive");
955 else if (pfile->cb.ident)
956 (*pfile->cb.ident) (pfile, pfile->directive_line, &str->val.str);
961 /* Lookup a PRAGMA name in a singly-linked CHAIN. Returns the
962 matching entry, or NULL if none is found. The returned entry could
963 be the start of a namespace chain, or a pragma. */
964 static struct pragma_entry *
965 lookup_pragma_entry (chain, pragma)
966 struct pragma_entry *chain;
967 const cpp_hashnode *pragma;
969 while (chain && chain->pragma != pragma)
975 /* Create and insert a pragma entry for NAME at the beginning of a
976 singly-linked CHAIN. If handler is NULL, it is a namespace,
977 otherwise it is a pragma and its handler. */
978 static struct pragma_entry *
979 insert_pragma_entry (pfile, chain, pragma, handler)
981 struct pragma_entry **chain;
982 const cpp_hashnode *pragma;
985 struct pragma_entry *new;
987 new = (struct pragma_entry *)
988 _cpp_aligned_alloc (pfile, sizeof (struct pragma_entry));
989 new->pragma = pragma;
993 new->u.handler = handler;
1006 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
1007 goes in the global namespace. HANDLER is the handler it will call,
1008 which must be non-NULL. */
1010 cpp_register_pragma (pfile, space, name, handler)
1016 struct pragma_entry **chain = &pfile->pragmas;
1017 struct pragma_entry *entry;
1018 const cpp_hashnode *node;
1025 node = cpp_lookup (pfile, U space, strlen (space));
1026 entry = lookup_pragma_entry (*chain, node);
1028 entry = insert_pragma_entry (pfile, chain, node, NULL);
1029 else if (!entry->is_nspace)
1031 chain = &entry->u.space;
1034 /* Check for duplicates. */
1035 node = cpp_lookup (pfile, U name, strlen (name));
1036 entry = lookup_pragma_entry (*chain, node);
1039 if (entry->is_nspace)
1041 cpp_error (pfile, DL_ICE,
1042 "registering \"%s\" as both a pragma and a pragma namespace",
1045 cpp_error (pfile, DL_ICE, "#pragma %s %s is already registered",
1048 cpp_error (pfile, DL_ICE, "#pragma %s is already registered", name);
1051 insert_pragma_entry (pfile, chain, node, handler);
1054 /* Register the pragmas the preprocessor itself handles. */
1056 _cpp_init_internal_pragmas (pfile)
1059 /* Pragmas in the global namespace. */
1060 cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
1061 cpp_register_pragma (pfile, 0, "once", do_pragma_once);
1063 /* New GCC-specific pragmas should be put in the GCC namespace. */
1064 cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
1065 cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
1066 cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
1069 /* Pragmata handling. We handle some, and pass the rest on to the
1070 front end. C99 defines three pragmas and says that no macro
1071 expansion is to be performed on them; whether or not macro
1072 expansion happens for other pragmas is implementation defined.
1073 This implementation never macro-expands the text after #pragma. */
1078 const struct pragma_entry *p = NULL;
1079 const cpp_token *token;
1080 unsigned int count = 1;
1082 pfile->state.prevent_expansion++;
1084 token = cpp_get_token (pfile);
1085 if (token->type == CPP_NAME)
1087 p = lookup_pragma_entry (pfile->pragmas, token->val.node);
1088 if (p && p->is_nspace)
1091 token = cpp_get_token (pfile);
1092 if (token->type == CPP_NAME)
1093 p = lookup_pragma_entry (p->u.space, token->val.node);
1099 /* FIXME. This is an awful kludge to get the front ends to update
1100 their notion of line number for diagnostic purposes. The line
1101 number should be passed to the handler and they should do it
1102 themselves. Stand-alone CPP must ignore us, otherwise it will
1103 prefix the directive with spaces, hence the 1. Ugh. */
1104 if (pfile->cb.line_change)
1105 (*pfile->cb.line_change)(pfile, token, 1);
1108 (*p->u.handler) (pfile);
1109 else if (pfile->cb.def_pragma)
1111 _cpp_backup_tokens (pfile, count);
1112 (*pfile->cb.def_pragma) (pfile, pfile->directive_line);
1115 pfile->state.prevent_expansion--;
1118 /* Handle #pragma once. */
1120 do_pragma_once (pfile)
1123 cpp_error (pfile, DL_WARNING, "#pragma once is obsolete");
1125 if (pfile->buffer->prev == NULL)
1126 cpp_error (pfile, DL_WARNING, "#pragma once in main file");
1128 _cpp_never_reread (pfile->buffer->inc);
1133 /* Handle #pragma poison, to poison one or more identifiers so that
1134 the lexer produces a hard error for each subsequent usage. */
1136 do_pragma_poison (pfile)
1139 const cpp_token *tok;
1142 pfile->state.poisoned_ok = 1;
1145 tok = _cpp_lex_token (pfile);
1146 if (tok->type == CPP_EOF)
1148 if (tok->type != CPP_NAME)
1150 cpp_error (pfile, DL_ERROR, "invalid #pragma GCC poison directive");
1155 if (hp->flags & NODE_POISONED)
1158 if (hp->type == NT_MACRO)
1159 cpp_error (pfile, DL_WARNING, "poisoning existing macro \"%s\"",
1161 _cpp_free_definition (hp);
1162 hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1164 pfile->state.poisoned_ok = 0;
1167 /* Mark the current header as a system header. This will suppress
1168 some categories of warnings (notably those from -pedantic). It is
1169 intended for use in system libraries that cannot be implemented in
1170 conforming C, but cannot be certain that their headers appear in a
1171 system include directory. To prevent abuse, it is rejected in the
1172 primary source file. */
1174 do_pragma_system_header (pfile)
1177 cpp_buffer *buffer = pfile->buffer;
1179 if (buffer->prev == 0)
1180 cpp_error (pfile, DL_WARNING,
1181 "#pragma system_header ignored outside include file");
1185 skip_rest_of_line (pfile);
1186 cpp_make_system_header (pfile, 1, 0);
1190 /* Check the modified date of the current include file against a specified
1191 file. Issue a diagnostic, if the specified file is newer. We use this to
1192 determine if a fixed header should be refixed. */
1194 do_pragma_dependency (pfile)
1197 const cpp_token *header;
1200 header = parse_include (pfile);
1204 ordering = _cpp_compare_file_date (pfile, header);
1206 cpp_error (pfile, DL_WARNING, "cannot find source %s",
1207 cpp_token_as_text (pfile, header));
1208 else if (ordering > 0)
1210 cpp_error (pfile, DL_WARNING, "current file is older than %s",
1211 cpp_token_as_text (pfile, header));
1212 if (cpp_get_token (pfile)->type != CPP_EOF)
1214 _cpp_backup_tokens (pfile, 1);
1215 do_diagnostic (pfile, DL_WARNING, 0);
1220 /* Get a token but skip padding. */
1221 static const cpp_token *
1222 get_token_no_padding (pfile)
1227 const cpp_token *result = cpp_get_token (pfile);
1228 if (result->type != CPP_PADDING)
1233 /* Check syntax is "(string-literal)". Returns the string on success,
1234 or NULL on failure. */
1235 static const cpp_token *
1236 get__Pragma_string (pfile)
1239 const cpp_token *string;
1241 if (get_token_no_padding (pfile)->type != CPP_OPEN_PAREN)
1244 string = get_token_no_padding (pfile);
1245 if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1248 if (get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
1254 /* Destringize IN into a temporary buffer, by removing the first \ of
1255 \" and \\ sequences, and process the result as a #pragma directive. */
1257 destringize_and_run (pfile, in)
1259 const cpp_string *in;
1261 const unsigned char *src, *limit;
1262 char *dest, *result;
1264 dest = result = alloca (in->len + 1);
1265 for (src = in->text, limit = src + in->len; src < limit;)
1267 /* We know there is a character following the backslash. */
1268 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1274 run_directive (pfile, T_PRAGMA, result, dest - result);
1277 /* Handle the _Pragma operator. */
1279 _cpp_do__Pragma (pfile)
1282 const cpp_token *string = get__Pragma_string (pfile);
1285 cpp_error (pfile, DL_ERROR,
1286 "_Pragma takes a parenthesized string literal");
1289 /* Ideally, we'd like
1290 token1 _Pragma ("foo") token2
1297 Getting these correct line markers is a little tricky. */
1299 unsigned int orig_line = pfile->line;
1300 destringize_and_run (pfile, &string->val.str);
1301 pfile->line = orig_line;
1302 pfile->buffer->saved_flags = BOL;
1306 /* Just ignore #sccs, on systems where we define it at all. */
1307 #ifdef SCCS_DIRECTIVE
1310 cpp_reader *pfile ATTRIBUTE_UNUSED;
1315 /* Handle #ifdef. */
1322 if (! pfile->state.skipping)
1324 const cpp_hashnode *node = lex_macro_node (pfile);
1327 skip = node->type != NT_MACRO;
1333 push_conditional (pfile, skip, T_IFDEF, 0);
1336 /* Handle #ifndef. */
1342 const cpp_hashnode *node = 0;
1344 if (! pfile->state.skipping)
1346 node = lex_macro_node (pfile);
1348 skip = node->type == NT_MACRO;
1354 push_conditional (pfile, skip, T_IFNDEF, node);
1357 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1358 pfile->mi_ind_cmacro so we can handle multiple-include
1359 optimisations. If macro expansion occurs in the expression, we
1360 cannot treat it as a controlling conditional, since the expansion
1361 could change in the future. That is handled by cpp_get_token. */
1368 if (! pfile->state.skipping)
1369 skip = _cpp_parse_expr (pfile) == 0;
1371 push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
1374 /* Flip skipping state if appropriate and continue without changing
1375 if_stack; this is so that the error message for missing #endif's
1376 etc. will point to the original #if. */
1381 cpp_buffer *buffer = pfile->buffer;
1382 struct if_stack *ifs = buffer->if_stack;
1385 cpp_error (pfile, DL_ERROR, "#else without #if");
1388 if (ifs->type == T_ELSE)
1390 cpp_error (pfile, DL_ERROR, "#else after #else");
1391 cpp_error_with_line (pfile, DL_ERROR, ifs->line, 0,
1392 "the conditional began here");
1396 /* Skip any future (erroneous) #elses or #elifs. */
1397 pfile->state.skipping = ifs->skip_elses;
1398 ifs->skip_elses = true;
1400 /* Invalidate any controlling macro. */
1403 /* Only check EOL if was not originally skipping. */
1404 if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
1409 /* Handle a #elif directive by not changing if_stack either. See the
1410 comment above do_else. */
1415 cpp_buffer *buffer = pfile->buffer;
1416 struct if_stack *ifs = buffer->if_stack;
1419 cpp_error (pfile, DL_ERROR, "#elif without #if");
1422 if (ifs->type == T_ELSE)
1424 cpp_error (pfile, DL_ERROR, "#elif after #else");
1425 cpp_error_with_line (pfile, DL_ERROR, ifs->line, 0,
1426 "the conditional began here");
1430 /* Only evaluate this if we aren't skipping elses. During
1431 evaluation, set skipping to false to get lexer warnings. */
1432 if (ifs->skip_elses)
1433 pfile->state.skipping = 1;
1436 pfile->state.skipping = 0;
1437 pfile->state.skipping = ! _cpp_parse_expr (pfile);
1438 ifs->skip_elses = ! pfile->state.skipping;
1441 /* Invalidate any controlling macro. */
1446 /* #endif pops the if stack and resets pfile->state.skipping. */
1451 cpp_buffer *buffer = pfile->buffer;
1452 struct if_stack *ifs = buffer->if_stack;
1455 cpp_error (pfile, DL_ERROR, "#endif without #if");
1458 /* Only check EOL if was not originally skipping. */
1459 if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
1462 /* If potential control macro, we go back outside again. */
1463 if (ifs->next == 0 && ifs->mi_cmacro)
1465 pfile->mi_valid = true;
1466 pfile->mi_cmacro = ifs->mi_cmacro;
1469 buffer->if_stack = ifs->next;
1470 pfile->state.skipping = ifs->was_skipping;
1471 obstack_free (&pfile->buffer_ob, ifs);
1475 /* Push an if_stack entry for a preprocessor conditional, and set
1476 pfile->state.skipping to SKIP. If TYPE indicates the conditional
1477 is #if or #ifndef, CMACRO is a potentially controlling macro, and
1478 we need to check here that we are at the top of the file. */
1480 push_conditional (pfile, skip, type, cmacro)
1484 const cpp_hashnode *cmacro;
1486 struct if_stack *ifs;
1487 cpp_buffer *buffer = pfile->buffer;
1489 ifs = xobnew (&pfile->buffer_ob, struct if_stack);
1490 ifs->line = pfile->directive_line;
1491 ifs->next = buffer->if_stack;
1492 ifs->skip_elses = pfile->state.skipping || !skip;
1493 ifs->was_skipping = pfile->state.skipping;
1495 /* This condition is effectively a test for top-of-file. */
1496 if (pfile->mi_valid && pfile->mi_cmacro == 0)
1497 ifs->mi_cmacro = cmacro;
1501 pfile->state.skipping = skip;
1502 buffer->if_stack = ifs;
1505 /* Read the tokens of the answer into the macro pool, in a directive
1506 of type TYPE. Only commit the memory if we intend it as permanent
1507 storage, i.e. the #assert case. Returns 0 on success, and sets
1508 ANSWERP to point to the answer. */
1510 parse_answer (pfile, answerp, type)
1512 struct answer **answerp;
1515 const cpp_token *paren;
1516 struct answer *answer;
1517 unsigned int acount;
1519 /* In a conditional, it is legal to not have an open paren. We
1520 should save the following token in this case. */
1521 paren = cpp_get_token (pfile);
1523 /* If not a paren, see if we're OK. */
1524 if (paren->type != CPP_OPEN_PAREN)
1526 /* In a conditional no answer is a test for any answer. It
1527 could be followed by any token. */
1530 _cpp_backup_tokens (pfile, 1);
1534 /* #unassert with no answer is valid - it removes all answers. */
1535 if (type == T_UNASSERT && paren->type == CPP_EOF)
1538 cpp_error (pfile, DL_ERROR, "missing '(' after predicate");
1542 for (acount = 0;; acount++)
1545 const cpp_token *token = cpp_get_token (pfile);
1548 if (token->type == CPP_CLOSE_PAREN)
1551 if (token->type == CPP_EOF)
1553 cpp_error (pfile, DL_ERROR, "missing ')' to complete answer");
1557 /* struct answer includes the space for one token. */
1558 room_needed = (sizeof (struct answer) + acount * sizeof (cpp_token));
1560 if (BUFF_ROOM (pfile->a_buff) < room_needed)
1561 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer));
1563 dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount];
1566 /* Drop whitespace at start, for answer equivalence purposes. */
1568 dest->flags &= ~PREV_WHITE;
1573 cpp_error (pfile, DL_ERROR, "predicate's answer is empty");
1577 answer = (struct answer *) BUFF_FRONT (pfile->a_buff);
1578 answer->count = acount;
1579 answer->next = NULL;
1585 /* Parses an assertion directive of type TYPE, returning a pointer to
1586 the hash node of the predicate, or 0 on error. If an answer was
1587 supplied, it is placed in ANSWERP, otherwise it is set to 0. */
1588 static cpp_hashnode *
1589 parse_assertion (pfile, answerp, type)
1591 struct answer **answerp;
1594 cpp_hashnode *result = 0;
1595 const cpp_token *predicate;
1597 /* We don't expand predicates or answers. */
1598 pfile->state.prevent_expansion++;
1601 predicate = cpp_get_token (pfile);
1602 if (predicate->type == CPP_EOF)
1603 cpp_error (pfile, DL_ERROR, "assertion without predicate");
1604 else if (predicate->type != CPP_NAME)
1605 cpp_error (pfile, DL_ERROR, "predicate must be an identifier");
1606 else if (parse_answer (pfile, answerp, type) == 0)
1608 unsigned int len = NODE_LEN (predicate->val.node);
1609 unsigned char *sym = alloca (len + 1);
1611 /* Prefix '#' to get it out of macro namespace. */
1613 memcpy (sym + 1, NODE_NAME (predicate->val.node), len);
1614 result = cpp_lookup (pfile, sym, len + 1);
1617 pfile->state.prevent_expansion--;
1621 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
1622 or a pointer to NULL if the answer is not in the chain. */
1623 static struct answer **
1624 find_answer (node, candidate)
1626 const struct answer *candidate;
1629 struct answer **result;
1631 for (result = &node->value.answers; *result; result = &(*result)->next)
1633 struct answer *answer = *result;
1635 if (answer->count == candidate->count)
1637 for (i = 0; i < answer->count; i++)
1638 if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1641 if (i == answer->count)
1649 /* Test an assertion within a preprocessor conditional. Returns
1650 non-zero on failure, zero on success. On success, the result of
1651 the test is written into VALUE. */
1653 _cpp_test_assertion (pfile, value)
1657 struct answer *answer;
1660 node = parse_assertion (pfile, &answer, T_IF);
1662 *value = (node->type == NT_ASSERTION &&
1663 (answer == 0 || *find_answer (node, answer) != 0));
1665 /* We don't commit the memory for the answer - it's temporary only. */
1669 /* Handle #assert. */
1674 struct answer *new_answer;
1677 node = parse_assertion (pfile, &new_answer, T_ASSERT);
1680 /* Place the new answer in the answer list. First check there
1681 is not a duplicate. */
1682 new_answer->next = 0;
1683 if (node->type == NT_ASSERTION)
1685 if (*find_answer (node, new_answer))
1687 cpp_error (pfile, DL_WARNING, "\"%s\" re-asserted",
1688 NODE_NAME (node) + 1);
1691 new_answer->next = node->value.answers;
1694 node->type = NT_ASSERTION;
1695 node->value.answers = new_answer;
1696 BUFF_FRONT (pfile->a_buff) += (sizeof (struct answer)
1697 + (new_answer->count - 1)
1698 * sizeof (cpp_token));
1703 /* Handle #unassert. */
1709 struct answer *answer;
1711 node = parse_assertion (pfile, &answer, T_UNASSERT);
1712 /* It isn't an error to #unassert something that isn't asserted. */
1713 if (node && node->type == NT_ASSERTION)
1717 struct answer **p = find_answer (node, answer), *temp;
1719 /* Remove the answer from the list. */
1724 /* Did we free the last answer? */
1725 if (node->value.answers == 0)
1726 node->type = NT_VOID;
1731 _cpp_free_definition (node);
1734 /* We don't commit the memory for the answer - it's temporary only. */
1737 /* These are for -D, -U, -A. */
1739 /* Process the string STR as if it appeared as the body of a #define.
1740 If STR is just an identifier, define it with value 1.
1741 If STR has anything after the identifier, then it should
1742 be identifier=definition. */
1744 cpp_define (pfile, str)
1751 /* Copy the entire option so we can modify it.
1752 Change the first "=" in the string to a space. If there is none,
1753 tack " 1" on the end. */
1755 count = strlen (str);
1756 buf = (char *) alloca (count + 3);
1757 memcpy (buf, str, count);
1759 p = strchr (str, '=');
1769 run_directive (pfile, T_DEFINE, buf, count);
1772 /* Slight variant of the above for use by initialize_builtins. */
1774 _cpp_define_builtin (pfile, str)
1778 run_directive (pfile, T_DEFINE, str, strlen (str));
1781 /* Process MACRO as if it appeared as the body of an #undef. */
1783 cpp_undef (pfile, macro)
1787 run_directive (pfile, T_UNDEF, macro, strlen (macro));
1790 /* Process the string STR as if it appeared as the body of a #assert. */
1792 cpp_assert (pfile, str)
1796 handle_assertion (pfile, str, T_ASSERT);
1799 /* Process STR as if it appeared as the body of an #unassert. */
1801 cpp_unassert (pfile, str)
1805 handle_assertion (pfile, str, T_UNASSERT);
1808 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1810 handle_assertion (pfile, str, type)
1815 size_t count = strlen (str);
1816 const char *p = strchr (str, '=');
1820 /* Copy the entire option so we can modify it. Change the first
1821 "=" in the string to a '(', and tack a ')' on the end. */
1822 char *buf = (char *) alloca (count + 2);
1824 memcpy (buf, str, count);
1831 run_directive (pfile, type, str, count);
1834 /* The number of errors for a given reader. */
1839 return pfile->errors;
1842 /* The options structure. */
1844 cpp_get_options (pfile)
1847 return &pfile->opts;
1850 /* The callbacks structure. */
1852 cpp_get_callbacks (pfile)
1858 /* The line map set. */
1859 const struct line_maps *
1860 cpp_get_line_maps (pfile)
1863 return &pfile->line_maps;
1866 /* Copy the given callbacks structure to our own. */
1868 cpp_set_callbacks (pfile, cb)
1875 /* Push a new buffer on the buffer stack. Returns the new buffer; it
1876 doesn't fail. It does not generate a file change call back; that
1877 is the responsibility of the caller. */
1879 cpp_push_buffer (pfile, buffer, len, from_stage3, return_at_eof)
1881 const uchar *buffer;
1886 cpp_buffer *new = xobnew (&pfile->buffer_ob, cpp_buffer);
1888 /* Clears, amongst other things, if_stack and mi_cmacro. */
1889 memset (new, 0, sizeof (cpp_buffer));
1891 new->line_base = new->buf = new->cur = buffer;
1892 new->rlimit = buffer + len;
1893 new->from_stage3 = from_stage3;
1894 new->prev = pfile->buffer;
1895 new->return_at_eof = return_at_eof;
1896 new->saved_flags = BOL;
1898 pfile->buffer = new;
1903 /* Pops a single buffer, with a file change call-back if appropriate.
1904 Then pushes the next -include file, if any remain. */
1906 _cpp_pop_buffer (pfile)
1909 cpp_buffer *buffer = pfile->buffer;
1910 struct include_file *inc = buffer->inc;
1911 struct if_stack *ifs;
1913 /* Walk back up the conditional stack till we reach its level at
1914 entry to this file, issuing error messages. */
1915 for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
1916 cpp_error_with_line (pfile, DL_ERROR, ifs->line, 0,
1917 "unterminated #%s", dtable[ifs->type].name);
1919 /* In case of a missing #endif. */
1920 pfile->state.skipping = 0;
1922 /* _cpp_do_file_change expects pfile->buffer to be the new one. */
1923 pfile->buffer = buffer->prev;
1925 /* Free the buffer object now; we may want to push a new buffer
1926 in _cpp_push_next_include_file. */
1927 obstack_free (&pfile->buffer_ob, buffer);
1931 _cpp_pop_file_buffer (pfile, inc);
1933 /* Don't generate a callback for popping the main file. */
1936 _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
1938 /* If this is the main file, there may be some -include
1939 files left to push. */
1940 if (!pfile->buffer->prev)
1941 _cpp_maybe_push_include_file (pfile);
1946 /* Enter all recognised directives in the hash table. */
1948 _cpp_init_directives (pfile)
1954 for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
1956 node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
1957 node->directive_index = i + 1;