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 EXPAND is set on directives that are always macro-expanded. */
77 #define IF_COND (1 << 1)
80 #define EXPAND (1 << 4)
82 /* Defines one #-directive, including how to handle it. */
83 typedef void (*directive_handler) PARAMS ((cpp_reader *));
84 typedef struct directive directive;
87 directive_handler handler; /* Function to handle directive. */
88 const uchar *name; /* Name of directive. */
89 unsigned short length; /* Length of name. */
90 unsigned char origin; /* Origin of directive. */
91 unsigned char flags; /* Flags describing this directive. */
94 /* Forward declarations. */
96 static void skip_rest_of_line PARAMS ((cpp_reader *));
97 static void check_eol PARAMS ((cpp_reader *));
98 static void start_directive PARAMS ((cpp_reader *));
99 static void prepare_directive_trad PARAMS ((cpp_reader *));
100 static void end_directive PARAMS ((cpp_reader *, int));
101 static void directive_diagnostics
102 PARAMS ((cpp_reader *, const directive *, int));
103 static void run_directive PARAMS ((cpp_reader *, int,
104 const char *, size_t));
105 static const cpp_token *glue_header_name PARAMS ((cpp_reader *));
106 static const cpp_token *parse_include PARAMS ((cpp_reader *));
107 static void push_conditional PARAMS ((cpp_reader *, int, int,
108 const cpp_hashnode *));
109 static unsigned int read_flag PARAMS ((cpp_reader *, unsigned int));
110 static uchar *dequote_string PARAMS ((cpp_reader *, const uchar *,
112 static int strtoul_for_line PARAMS ((const uchar *, unsigned int,
114 static void do_diagnostic PARAMS ((cpp_reader *, int, int));
115 static cpp_hashnode *lex_macro_node PARAMS ((cpp_reader *));
116 static void do_include_common PARAMS ((cpp_reader *, enum include_type));
117 static struct pragma_entry *lookup_pragma_entry
118 PARAMS ((struct pragma_entry *, const cpp_hashnode *pragma));
119 static struct pragma_entry *insert_pragma_entry
120 PARAMS ((cpp_reader *, struct pragma_entry **, const cpp_hashnode *,
122 static void do_pragma_once PARAMS ((cpp_reader *));
123 static void do_pragma_poison PARAMS ((cpp_reader *));
124 static void do_pragma_system_header PARAMS ((cpp_reader *));
125 static void do_pragma_dependency PARAMS ((cpp_reader *));
126 static void do_linemarker PARAMS ((cpp_reader *));
127 static const cpp_token *get_token_no_padding PARAMS ((cpp_reader *));
128 static const cpp_token *get__Pragma_string PARAMS ((cpp_reader *));
129 static void destringize_and_run PARAMS ((cpp_reader *, const cpp_string *));
130 static int parse_answer PARAMS ((cpp_reader *, struct answer **, int));
131 static cpp_hashnode *parse_assertion PARAMS ((cpp_reader *, struct answer **,
133 static struct answer ** find_answer PARAMS ((cpp_hashnode *,
134 const struct answer *));
135 static void handle_assertion PARAMS ((cpp_reader *, const char *, int));
137 /* This is the table of directive handlers. It is ordered by
138 frequency of occurrence; the numbers at the end are directive
139 counts from all the source code I have lying around (egcs and libc
140 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
141 pcmcia-cs-3.0.9). This is no longer important as directive lookup
142 is now O(1). All extensions other than #warning and #include_next
143 are deprecated. The name is where the extension appears to have
146 #define DIRECTIVE_TABLE \
147 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
148 D(include, T_INCLUDE, KANDR, INCL | EXPAND) /* 52262 */ \
149 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
150 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
151 D(if, T_IF, KANDR, COND | IF_COND | EXPAND) /* 18162 */ \
152 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
153 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
154 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
155 D(line, T_LINE, KANDR, EXPAND) /* 2465 */ \
156 D(elif, T_ELIF, STDC89, COND | EXPAND) /* 610 */ \
157 D(error, T_ERROR, STDC89, 0) /* 475 */ \
158 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
159 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
160 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL | EXPAND) /* 19 */ \
161 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
162 D(import, T_IMPORT, EXTENSION, INCL | EXPAND) /* 0 ObjC */ \
163 D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
164 D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
165 D(sccs, T_SCCS, EXTENSION, 0) /* 0 SVR4? */
167 /* Use the table to generate a series of prototypes, an enum for the
168 directive names, and an array of directive handlers. */
170 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
171 #define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
175 #define D(n, tag, o, f) tag,
183 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
184 #define D(name, t, origin, flags) \
185 { CONCAT2(do_,name), (const uchar *) STRINGX(name), \
186 sizeof STRINGX(name) - 1, origin, flags },
187 static const directive dtable[] =
192 #undef DIRECTIVE_TABLE
194 /* Wrapper struct directive for linemarkers.
195 The origin is more or less true - the original K+R cpp
196 did use this notation in its preprocessed output. */
197 static const directive linemarker_dir =
199 do_linemarker, U"#", 1, KANDR, IN_I
202 #define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
204 /* Skip any remaining tokens in a directive. */
206 skip_rest_of_line (pfile)
209 /* Discard all stacked contexts. */
210 while (pfile->context != &pfile->base_context)
211 _cpp_pop_context (pfile);
213 /* Sweep up all tokens remaining on the line. */
215 while (_cpp_lex_token (pfile)->type != CPP_EOF)
219 /* Ensure there are no stray tokens at the end of a directive. */
224 if (! SEEN_EOL () && _cpp_lex_token (pfile)->type != CPP_EOF)
225 cpp_error (pfile, DL_PEDWARN, "extra tokens at end of #%s directive",
226 pfile->directive->name);
229 /* Called when entering a directive, _Pragma or command-line directive. */
231 start_directive (pfile)
234 /* Setup in-directive state. */
235 pfile->state.in_directive = 1;
236 pfile->state.save_comments = 0;
238 /* Some handlers need the position of the # for diagnostics. */
239 pfile->directive_line = pfile->line;
242 /* Called when leaving a directive, _Pragma or command-line directive. */
244 end_directive (pfile, skip_line)
248 if (CPP_OPTION (pfile, traditional))
250 /* Revert change of prepare_directive_trad. */
251 pfile->state.prevent_expansion--;
253 if (pfile->directive != &dtable[T_DEFINE])
254 _cpp_remove_overlay (pfile);
256 /* We don't skip for an assembler #. */
259 skip_rest_of_line (pfile);
260 if (!pfile->keep_tokens)
262 pfile->cur_run = &pfile->base_run;
263 pfile->cur_token = pfile->base_run.base;
268 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
269 pfile->state.in_directive = 0;
270 pfile->state.in_expression = 0;
271 pfile->state.angled_headers = 0;
272 pfile->directive = 0;
275 /* Prepare to handle the directive in pfile->directive. */
277 prepare_directive_trad (pfile)
280 if (pfile->directive != &dtable[T_DEFINE])
282 bool no_expand = (pfile->directive
283 && ! (pfile->directive->flags & EXPAND));
284 bool was_skipping = pfile->state.skipping;
286 pfile->state.skipping = false;
287 pfile->state.in_expression = (pfile->directive == &dtable[T_IF]
288 || pfile->directive == &dtable[T_ELIF]);
290 pfile->state.prevent_expansion++;
291 _cpp_read_logical_line_trad (pfile);
293 pfile->state.prevent_expansion--;
294 pfile->state.skipping = was_skipping;
295 _cpp_overlay_buffer (pfile, pfile->out.base,
296 pfile->out.cur - pfile->out.base);
299 /* Stop ISO C from expanding anything. */
300 pfile->state.prevent_expansion++;
303 /* Output diagnostics for a directive DIR. INDENTED is non-zero if
304 the '#' was indented. */
306 directive_diagnostics (pfile, dir, indented)
308 const directive *dir;
311 /* Issue -pedantic warnings for extensions. */
312 if (CPP_PEDANTIC (pfile)
313 && ! pfile->state.skipping
314 && dir->origin == EXTENSION)
315 cpp_error (pfile, DL_PEDWARN, "#%s is a GCC extension", dir->name);
317 /* Traditionally, a directive is ignored unless its # is in
318 column 1. Therefore in code intended to work with K+R
319 compilers, directives added by C89 must have their #
320 indented, and directives present in traditional C must not.
321 This is true even of directives in skipped conditional
322 blocks. #elif cannot be used at all. */
323 if (CPP_WTRADITIONAL (pfile))
325 if (dir == &dtable[T_ELIF])
326 cpp_error (pfile, DL_WARNING,
327 "suggest not using #elif in traditional C");
328 else if (indented && dir->origin == KANDR)
329 cpp_error (pfile, DL_WARNING,
330 "traditional C ignores #%s with the # indented",
332 else if (!indented && dir->origin != KANDR)
333 cpp_error (pfile, DL_WARNING,
334 "suggest hiding #%s from traditional C with an indented #",
339 /* Check if we have a known directive. INDENTED is non-zero if the
340 '#' of the directive was indented. This function is in this file
341 to save unnecessarily exporting dtable etc. to cpplex.c. Returns
342 non-zero if the line of tokens has been handled, zero if we should
343 continue processing the line. */
345 _cpp_handle_directive (pfile, indented)
349 const directive *dir = 0;
350 const cpp_token *dname;
351 bool was_parsing_args = pfile->state.parsing_args;
354 if (was_parsing_args)
356 if (CPP_OPTION (pfile, pedantic))
357 cpp_error (pfile, DL_PEDWARN,
358 "embedding a directive within macro arguments is not portable");
359 pfile->state.parsing_args = 0;
360 pfile->state.prevent_expansion = 0;
362 start_directive (pfile);
363 dname = _cpp_lex_token (pfile);
365 if (dname->type == CPP_NAME)
367 if (dname->val.node->directive_index)
368 dir = &dtable[dname->val.node->directive_index - 1];
370 /* We do not recognise the # followed by a number extension in
372 else if (dname->type == CPP_NUMBER && CPP_OPTION (pfile, lang) != CLK_ASM)
374 dir = &linemarker_dir;
375 if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed)
376 && ! pfile->state.skipping)
377 cpp_error (pfile, DL_PEDWARN,
378 "style of line directive is a GCC extension");
383 /* If we have a directive that is not an opening conditional,
384 invalidate any control macro. */
385 if (! (dir->flags & IF_COND))
386 pfile->mi_valid = false;
388 /* Kluge alert. In order to be sure that code like this
393 does not cause '#define foo bar' to get executed when
394 compiled with -save-temps, we recognize directives in
395 -fpreprocessed mode only if the # is in column 1. cppmacro.c
396 puts a space in front of any '#' at the start of a macro. */
397 if (CPP_OPTION (pfile, preprocessed)
398 && (indented || !(dir->flags & IN_I)))
405 /* In failed conditional groups, all non-conditional
406 directives are ignored. Before doing that, whether
407 skipping or not, we should lex angle-bracketed headers
408 correctly, and maybe output some diagnostics. */
409 pfile->state.angled_headers = dir->flags & INCL;
410 if (! CPP_OPTION (pfile, preprocessed))
411 directive_diagnostics (pfile, dir, indented);
412 if (pfile->state.skipping && !(dir->flags & COND))
416 else if (dname->type == CPP_EOF)
417 ; /* CPP_EOF is the "null directive". */
420 /* An unknown directive. Don't complain about it in assembly
421 source: we don't know where the comments are, and # may
422 introduce assembler pseudo-ops. Don't complain about invalid
423 directives in skipped conditional groups (6.10 p4). */
424 if (CPP_OPTION (pfile, lang) == CLK_ASM)
426 else if (!pfile->state.skipping)
427 cpp_error (pfile, DL_ERROR, "invalid preprocessing directive #%s",
428 cpp_token_as_text (pfile, dname));
431 pfile->directive = dir;
432 if (CPP_OPTION (pfile, traditional))
433 prepare_directive_trad (pfile);
436 (*pfile->directive->handler) (pfile);
438 _cpp_backup_tokens (pfile, 1);
440 end_directive (pfile, skip);
441 if (was_parsing_args)
443 /* Restore state when within macro args. */
444 pfile->state.parsing_args = 2;
445 pfile->state.prevent_expansion = 1;
446 pfile->buffer->saved_flags |= PREV_WHITE;
451 /* Directive handler wrapper used by the command line option
454 run_directive (pfile, dir_no, buf, count)
460 cpp_push_buffer (pfile, (const uchar *) buf, count,
461 /* from_stage3 */ true, 1);
462 start_directive (pfile);
463 /* We don't want a leading # to be interpreted as a directive. */
464 pfile->buffer->saved_flags = 0;
465 pfile->directive = &dtable[dir_no];
466 if (CPP_OPTION (pfile, traditional))
467 prepare_directive_trad (pfile);
468 (void) (*pfile->directive->handler) (pfile);
469 end_directive (pfile, 1);
470 _cpp_pop_buffer (pfile);
473 /* Checks for validity the macro name in #define, #undef, #ifdef and
474 #ifndef directives. */
475 static cpp_hashnode *
476 lex_macro_node (pfile)
479 const cpp_token *token = _cpp_lex_token (pfile);
481 /* The token immediately after #define must be an identifier. That
482 identifier may not be "defined", per C99 6.10.8p4.
483 In C++, it may not be any of the "named operators" either,
484 per C++98 [lex.digraph], [lex.key].
485 Finally, the identifier may not have been poisoned. (In that case
486 the lexer has issued the error message for us.) */
488 if (token->type == CPP_NAME)
490 cpp_hashnode *node = token->val.node;
492 if (node == pfile->spec_nodes.n_defined)
493 cpp_error (pfile, DL_ERROR,
494 "\"defined\" cannot be used as a macro name");
495 else if (! (node->flags & NODE_POISONED))
498 else if (token->flags & NAMED_OP)
499 cpp_error (pfile, DL_ERROR,
500 "\"%s\" cannot be used as a macro name as it is an operator in C++",
501 NODE_NAME (token->val.node));
502 else if (token->type == CPP_EOF)
503 cpp_error (pfile, DL_ERROR, "no macro name given in #%s directive",
504 pfile->directive->name);
506 cpp_error (pfile, DL_ERROR, "macro names must be identifiers");
511 /* Process a #define directive. Most work is done in cppmacro.c. */
516 cpp_hashnode *node = lex_macro_node (pfile);
520 /* If we have been requested to expand comments into macros,
521 then re-enable saving of comments. */
522 pfile->state.save_comments =
523 ! CPP_OPTION (pfile, discard_comments_in_macro_exp);
525 if (_cpp_create_definition (pfile, node))
526 if (pfile->cb.define)
527 (*pfile->cb.define) (pfile, pfile->directive_line, node);
531 /* Handle #undef. Mark the identifier NT_VOID in the hash table. */
536 cpp_hashnode *node = lex_macro_node (pfile);
538 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
539 is not currently defined as a macro name. */
540 if (node && node->type == NT_MACRO)
543 (*pfile->cb.undef) (pfile, pfile->directive_line, node);
545 if (node->flags & NODE_WARN)
546 cpp_error (pfile, DL_WARNING, "undefining \"%s\"", NODE_NAME (node));
548 _cpp_free_definition (node);
553 /* Helper routine used by parse_include. Reinterpret the current line
554 as an h-char-sequence (< ... >); we are looking at the first token
555 after the <. Returns the header as a token, or NULL on failure. */
556 static const cpp_token *
557 glue_header_name (pfile)
560 cpp_token *header = NULL;
561 const cpp_token *token;
562 unsigned char *buffer;
563 size_t len, total_len = 0, capacity = 1024;
565 /* To avoid lexed tokens overwriting our glued name, we can only
566 allocate from the string pool once we've lexed everything. */
567 buffer = (unsigned char *) xmalloc (capacity);
570 token = cpp_get_token (pfile);
572 if (token->type == CPP_GREATER || token->type == CPP_EOF)
575 len = cpp_token_len (token);
576 if (total_len + len > capacity)
578 capacity = (capacity + len) * 2;
579 buffer = (unsigned char *) xrealloc (buffer, capacity);
582 if (token->flags & PREV_WHITE)
583 buffer[total_len++] = ' ';
585 total_len = cpp_spell_token (pfile, token, &buffer[total_len]) - buffer;
588 if (token->type == CPP_EOF)
589 cpp_error (pfile, DL_ERROR, "missing terminating > character");
592 unsigned char *token_mem = _cpp_unaligned_alloc (pfile, total_len + 1);
593 memcpy (token_mem, buffer, total_len);
594 token_mem[total_len] = '\0';
596 header = _cpp_temp_token (pfile);
597 header->type = CPP_HEADER_NAME;
599 header->val.str.len = total_len;
600 header->val.str.text = token_mem;
607 /* Returns the header string of #include, #include_next, #import and
608 #pragma dependency. Returns NULL on error. */
609 static const cpp_token *
610 parse_include (pfile)
613 const unsigned char *dir;
614 const cpp_token *header;
616 if (pfile->directive == &dtable[T_PRAGMA])
617 dir = U"pragma dependency";
619 dir = pfile->directive->name;
621 /* Allow macro expansion. */
622 header = cpp_get_token (pfile);
623 if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
625 if (header->type != CPP_LESS)
627 cpp_error (pfile, DL_ERROR,
628 "#%s expects \"FILENAME\" or <FILENAME>", dir);
632 header = glue_header_name (pfile);
637 if (header->val.str.len == 0)
639 cpp_error (pfile, DL_ERROR, "empty file name in #%s", dir);
646 /* Handle #include, #include_next and #import. */
648 do_include_common (pfile, type)
650 enum include_type type;
652 const cpp_token *header;
654 /* For #include_next, if this is the primary source file, warn and
655 use the normal search logic. */
656 if (type == IT_INCLUDE_NEXT && ! pfile->buffer->prev)
658 cpp_error (pfile, DL_WARNING, "#include_next in primary source file");
661 else if (type == IT_IMPORT && CPP_OPTION (pfile, warn_import))
663 CPP_OPTION (pfile, warn_import) = 0;
664 cpp_error (pfile, DL_WARNING,
665 "#import is obsolete, use an #ifndef wrapper in the header file");
668 header = parse_include (pfile);
671 /* Prevent #include recursion. */
672 if (pfile->line_maps.depth >= CPP_STACK_MAX)
673 cpp_error (pfile, DL_ERROR, "#include nested too deeply");
677 /* Get out of macro context, if we are. */
678 skip_rest_of_line (pfile);
679 if (pfile->cb.include)
680 (*pfile->cb.include) (pfile, pfile->directive_line,
681 pfile->directive->name, header);
682 _cpp_execute_include (pfile, header, type);
691 do_include_common (pfile, IT_INCLUDE);
698 do_include_common (pfile, IT_IMPORT);
702 do_include_next (pfile)
705 do_include_common (pfile, IT_INCLUDE_NEXT);
708 /* Subroutine of do_linemarker. Read possible flags after file name.
709 LAST is the last flag seen; 0 if this is the first flag. Return the
710 flag if it is valid, 0 at the end of the directive. Otherwise
713 read_flag (pfile, last)
717 const cpp_token *token = _cpp_lex_token (pfile);
719 if (token->type == CPP_NUMBER && token->val.str.len == 1)
721 unsigned int flag = token->val.str.text[0] - '0';
723 if (flag > last && flag <= 4
724 && (flag != 4 || last == 3)
725 && (flag != 2 || last == 0))
729 if (token->type != CPP_EOF)
730 cpp_error (pfile, DL_ERROR, "invalid flag \"%s\" in line directive",
731 cpp_token_as_text (pfile, token));
735 /* Subroutine of do_line and do_linemarker. Returns a version of STR
736 which has a NUL terminator and all escape sequences converted to
737 their equivalents. Temporary, hopefully. */
739 dequote_string (pfile, str, len)
744 uchar *result = _cpp_unaligned_alloc (pfile, len + 1);
746 const uchar *limit = str + len;
755 *dst++ = cpp_parse_escape (pfile, &str, limit, 0);
761 /* Subroutine of do_line and do_linemarker. Convert a number in STR,
762 of length LEN, to binary; store it in NUMP, and return 0 if the
763 number was well-formed, 1 if not. Temporary, hopefully. */
765 strtoul_for_line (str, len, nump)
770 unsigned long reg = 0;
784 /* Interpret #line command.
785 Note that the filename string (if any) is a true string constant
786 (escapes are interpreted), unlike in #line. */
791 const cpp_token *token;
792 const char *new_file = pfile->map->to_file;
793 unsigned long new_lineno;
795 /* C99 raised the minimum limit on #line numbers. */
796 unsigned int cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
798 /* #line commands expand macros. */
799 token = cpp_get_token (pfile);
800 if (token->type != CPP_NUMBER
801 || strtoul_for_line (token->val.str.text, token->val.str.len,
804 cpp_error (pfile, DL_ERROR,
805 "\"%s\" after #line is not a positive integer",
806 cpp_token_as_text (pfile, token));
810 if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
811 cpp_error (pfile, DL_PEDWARN, "line number out of range");
813 token = cpp_get_token (pfile);
814 if (token->type == CPP_STRING)
816 new_file = (const char *) dequote_string (pfile, token->val.str.text,
820 else if (token->type != CPP_EOF)
822 cpp_error (pfile, DL_ERROR, "\"%s\" is not a valid filename",
823 cpp_token_as_text (pfile, token));
827 skip_rest_of_line (pfile);
828 _cpp_do_file_change (pfile, LC_RENAME, new_file, new_lineno,
832 /* Interpret the # 44 "file" [flags] notation, which has slightly
833 different syntax and semantics from #line: Flags are allowed,
834 and we never complain about the line number being too big. */
836 do_linemarker (pfile)
839 const cpp_token *token;
840 const char *new_file = pfile->map->to_file;
841 unsigned long new_lineno;
842 unsigned int new_sysp = pfile->map->sysp;
843 enum lc_reason reason = LC_RENAME;
846 /* Back up so we can get the number again. Putting this in
847 _cpp_handle_directive risks two calls to _cpp_backup_tokens in
848 some circumstances, which can segfault. */
849 _cpp_backup_tokens (pfile, 1);
851 /* #line commands expand macros. */
852 token = cpp_get_token (pfile);
853 if (token->type != CPP_NUMBER
854 || strtoul_for_line (token->val.str.text, token->val.str.len,
857 cpp_error (pfile, DL_ERROR, "\"%s\" after # is not a positive integer",
858 cpp_token_as_text (pfile, token));
862 token = cpp_get_token (pfile);
863 if (token->type == CPP_STRING)
865 new_file = (const char *) dequote_string (pfile, token->val.str.text,
868 flag = read_flag (pfile, 0);
872 /* Fake an include for cpp_included (). */
873 _cpp_fake_include (pfile, new_file);
874 flag = read_flag (pfile, flag);
879 flag = read_flag (pfile, flag);
884 flag = read_flag (pfile, flag);
891 else if (token->type != CPP_EOF)
893 cpp_error (pfile, DL_ERROR, "\"%s\" is not a valid filename",
894 cpp_token_as_text (pfile, token));
898 skip_rest_of_line (pfile);
899 _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp);
902 /* Arrange the file_change callback. pfile->line has changed to
903 FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system
904 header, 2 for a system header that needs to be extern "C" protected,
905 and zero otherwise. */
907 _cpp_do_file_change (pfile, reason, to_file, file_line, sysp)
909 enum lc_reason reason;
911 unsigned int file_line;
914 pfile->map = add_line_map (&pfile->line_maps, reason, sysp,
915 pfile->line, to_file, file_line);
917 if (pfile->cb.file_change)
918 (*pfile->cb.file_change) (pfile, pfile->map);
921 /* Report a warning or error detected by the program we are
922 processing. Use the directive's tokens in the error message. */
924 do_diagnostic (pfile, code, print_dir)
929 if (_cpp_begin_message (pfile, code,
930 pfile->cur_token[-1].line,
931 pfile->cur_token[-1].col))
934 fprintf (stderr, "#%s ", pfile->directive->name);
935 pfile->state.prevent_expansion++;
936 cpp_output_line (pfile, stderr);
937 pfile->state.prevent_expansion--;
945 do_diagnostic (pfile, DL_ERROR, 1);
952 /* We want #warning diagnostics to be emitted in system headers too. */
953 do_diagnostic (pfile, DL_WARNING_SYSHDR, 1);
956 /* Report program identification. */
961 const cpp_token *str = cpp_get_token (pfile);
963 if (str->type != CPP_STRING)
964 cpp_error (pfile, DL_ERROR, "invalid #ident directive");
965 else if (pfile->cb.ident)
966 (*pfile->cb.ident) (pfile, pfile->directive_line, &str->val.str);
971 /* Lookup a PRAGMA name in a singly-linked CHAIN. Returns the
972 matching entry, or NULL if none is found. The returned entry could
973 be the start of a namespace chain, or a pragma. */
974 static struct pragma_entry *
975 lookup_pragma_entry (chain, pragma)
976 struct pragma_entry *chain;
977 const cpp_hashnode *pragma;
979 while (chain && chain->pragma != pragma)
985 /* Create and insert a pragma entry for NAME at the beginning of a
986 singly-linked CHAIN. If handler is NULL, it is a namespace,
987 otherwise it is a pragma and its handler. */
988 static struct pragma_entry *
989 insert_pragma_entry (pfile, chain, pragma, handler)
991 struct pragma_entry **chain;
992 const cpp_hashnode *pragma;
995 struct pragma_entry *new;
997 new = (struct pragma_entry *)
998 _cpp_aligned_alloc (pfile, sizeof (struct pragma_entry));
999 new->pragma = pragma;
1003 new->u.handler = handler;
1008 new->u.space = NULL;
1016 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
1017 goes in the global namespace. HANDLER is the handler it will call,
1018 which must be non-NULL. */
1020 cpp_register_pragma (pfile, space, name, handler)
1026 struct pragma_entry **chain = &pfile->pragmas;
1027 struct pragma_entry *entry;
1028 const cpp_hashnode *node;
1035 node = cpp_lookup (pfile, U space, strlen (space));
1036 entry = lookup_pragma_entry (*chain, node);
1038 entry = insert_pragma_entry (pfile, chain, node, NULL);
1039 else if (!entry->is_nspace)
1041 chain = &entry->u.space;
1044 /* Check for duplicates. */
1045 node = cpp_lookup (pfile, U name, strlen (name));
1046 entry = lookup_pragma_entry (*chain, node);
1049 if (entry->is_nspace)
1051 cpp_error (pfile, DL_ICE,
1052 "registering \"%s\" as both a pragma and a pragma namespace",
1055 cpp_error (pfile, DL_ICE, "#pragma %s %s is already registered",
1058 cpp_error (pfile, DL_ICE, "#pragma %s is already registered", name);
1061 insert_pragma_entry (pfile, chain, node, handler);
1064 /* Register the pragmas the preprocessor itself handles. */
1066 _cpp_init_internal_pragmas (pfile)
1069 /* Pragmas in the global namespace. */
1070 cpp_register_pragma (pfile, 0, "once", do_pragma_once);
1072 /* New GCC-specific pragmas should be put in the GCC namespace. */
1073 cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
1074 cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
1075 cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
1078 /* Pragmata handling. We handle some, and pass the rest on to the
1079 front end. C99 defines three pragmas and says that no macro
1080 expansion is to be performed on them; whether or not macro
1081 expansion happens for other pragmas is implementation defined.
1082 This implementation never macro-expands the text after #pragma. */
1087 const struct pragma_entry *p = NULL;
1088 const cpp_token *token;
1089 unsigned int count = 1;
1091 pfile->state.prevent_expansion++;
1093 token = cpp_get_token (pfile);
1094 if (token->type == CPP_NAME)
1096 p = lookup_pragma_entry (pfile->pragmas, token->val.node);
1097 if (p && p->is_nspace)
1100 token = cpp_get_token (pfile);
1101 if (token->type == CPP_NAME)
1102 p = lookup_pragma_entry (p->u.space, token->val.node);
1108 /* FIXME. This is an awful kludge to get the front ends to update
1109 their notion of line number for diagnostic purposes. The line
1110 number should be passed to the handler and they should do it
1111 themselves. Stand-alone CPP must ignore us, otherwise it will
1112 prefix the directive with spaces, hence the 1. Ugh. */
1113 if (pfile->cb.line_change)
1114 (*pfile->cb.line_change)(pfile, token, 1);
1117 (*p->u.handler) (pfile);
1118 else if (pfile->cb.def_pragma)
1120 _cpp_backup_tokens (pfile, count);
1121 (*pfile->cb.def_pragma) (pfile, pfile->directive_line);
1124 pfile->state.prevent_expansion--;
1127 /* Handle #pragma once. */
1129 do_pragma_once (pfile)
1132 cpp_error (pfile, DL_WARNING, "#pragma once is obsolete");
1134 if (pfile->buffer->prev == NULL)
1135 cpp_error (pfile, DL_WARNING, "#pragma once in main file");
1137 _cpp_never_reread (pfile->buffer->inc);
1142 /* Handle #pragma GCC poison, to poison one or more identifiers so
1143 that the lexer produces a hard error for each subsequent usage. */
1145 do_pragma_poison (pfile)
1148 const cpp_token *tok;
1151 pfile->state.poisoned_ok = 1;
1154 tok = _cpp_lex_token (pfile);
1155 if (tok->type == CPP_EOF)
1157 if (tok->type != CPP_NAME)
1159 cpp_error (pfile, DL_ERROR, "invalid #pragma GCC poison directive");
1164 if (hp->flags & NODE_POISONED)
1167 if (hp->type == NT_MACRO)
1168 cpp_error (pfile, DL_WARNING, "poisoning existing macro \"%s\"",
1170 _cpp_free_definition (hp);
1171 hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1173 pfile->state.poisoned_ok = 0;
1176 /* Mark the current header as a system header. This will suppress
1177 some categories of warnings (notably those from -pedantic). It is
1178 intended for use in system libraries that cannot be implemented in
1179 conforming C, but cannot be certain that their headers appear in a
1180 system include directory. To prevent abuse, it is rejected in the
1181 primary source file. */
1183 do_pragma_system_header (pfile)
1186 cpp_buffer *buffer = pfile->buffer;
1188 if (buffer->prev == 0)
1189 cpp_error (pfile, DL_WARNING,
1190 "#pragma system_header ignored outside include file");
1194 skip_rest_of_line (pfile);
1195 cpp_make_system_header (pfile, 1, 0);
1199 /* Check the modified date of the current include file against a specified
1200 file. Issue a diagnostic, if the specified file is newer. We use this to
1201 determine if a fixed header should be refixed. */
1203 do_pragma_dependency (pfile)
1206 const cpp_token *header;
1209 header = parse_include (pfile);
1213 ordering = _cpp_compare_file_date (pfile, header);
1215 cpp_error (pfile, DL_WARNING, "cannot find source %s",
1216 cpp_token_as_text (pfile, header));
1217 else if (ordering > 0)
1219 cpp_error (pfile, DL_WARNING, "current file is older than %s",
1220 cpp_token_as_text (pfile, header));
1221 if (cpp_get_token (pfile)->type != CPP_EOF)
1223 _cpp_backup_tokens (pfile, 1);
1224 do_diagnostic (pfile, DL_WARNING, 0);
1229 /* Get a token but skip padding. */
1230 static const cpp_token *
1231 get_token_no_padding (pfile)
1236 const cpp_token *result = cpp_get_token (pfile);
1237 if (result->type != CPP_PADDING)
1242 /* Check syntax is "(string-literal)". Returns the string on success,
1243 or NULL on failure. */
1244 static const cpp_token *
1245 get__Pragma_string (pfile)
1248 const cpp_token *string;
1250 if (get_token_no_padding (pfile)->type != CPP_OPEN_PAREN)
1253 string = get_token_no_padding (pfile);
1254 if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1257 if (get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
1263 /* Destringize IN into a temporary buffer, by removing the first \ of
1264 \" and \\ sequences, and process the result as a #pragma directive. */
1266 destringize_and_run (pfile, in)
1268 const cpp_string *in;
1270 const unsigned char *src, *limit;
1271 char *dest, *result;
1273 dest = result = alloca (in->len + 1);
1274 for (src = in->text, limit = src + in->len; src < limit;)
1276 /* We know there is a character following the backslash. */
1277 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1283 run_directive (pfile, T_PRAGMA, result, dest - result);
1286 /* Handle the _Pragma operator. */
1288 _cpp_do__Pragma (pfile)
1291 const cpp_token *string = get__Pragma_string (pfile);
1294 cpp_error (pfile, DL_ERROR,
1295 "_Pragma takes a parenthesized string literal");
1298 /* Ideally, we'd like
1299 token1 _Pragma ("foo") token2
1306 Getting these correct line markers is a little tricky. */
1308 unsigned int orig_line = pfile->line;
1309 destringize_and_run (pfile, &string->val.str);
1310 pfile->line = orig_line;
1311 pfile->buffer->saved_flags = BOL;
1315 /* Just ignore #sccs on all systems. */
1318 cpp_reader *pfile ATTRIBUTE_UNUSED;
1322 /* Handle #ifdef. */
1329 if (! pfile->state.skipping)
1331 const cpp_hashnode *node = lex_macro_node (pfile);
1334 skip = node->type != NT_MACRO;
1340 push_conditional (pfile, skip, T_IFDEF, 0);
1343 /* Handle #ifndef. */
1349 const cpp_hashnode *node = 0;
1351 if (! pfile->state.skipping)
1353 node = lex_macro_node (pfile);
1355 skip = node->type == NT_MACRO;
1361 push_conditional (pfile, skip, T_IFNDEF, node);
1364 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1365 pfile->mi_ind_cmacro so we can handle multiple-include
1366 optimisations. If macro expansion occurs in the expression, we
1367 cannot treat it as a controlling conditional, since the expansion
1368 could change in the future. That is handled by cpp_get_token. */
1375 if (! pfile->state.skipping)
1376 skip = _cpp_parse_expr (pfile) == false;
1378 push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
1381 /* Flip skipping state if appropriate and continue without changing
1382 if_stack; this is so that the error message for missing #endif's
1383 etc. will point to the original #if. */
1388 cpp_buffer *buffer = pfile->buffer;
1389 struct if_stack *ifs = buffer->if_stack;
1392 cpp_error (pfile, DL_ERROR, "#else without #if");
1395 if (ifs->type == T_ELSE)
1397 cpp_error (pfile, DL_ERROR, "#else after #else");
1398 cpp_error_with_line (pfile, DL_ERROR, ifs->line, 0,
1399 "the conditional began here");
1403 /* Skip any future (erroneous) #elses or #elifs. */
1404 pfile->state.skipping = ifs->skip_elses;
1405 ifs->skip_elses = true;
1407 /* Invalidate any controlling macro. */
1410 /* Only check EOL if was not originally skipping. */
1411 if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
1416 /* Handle a #elif directive by not changing if_stack either. See the
1417 comment above do_else. */
1422 cpp_buffer *buffer = pfile->buffer;
1423 struct if_stack *ifs = buffer->if_stack;
1426 cpp_error (pfile, DL_ERROR, "#elif without #if");
1429 if (ifs->type == T_ELSE)
1431 cpp_error (pfile, DL_ERROR, "#elif after #else");
1432 cpp_error_with_line (pfile, DL_ERROR, ifs->line, 0,
1433 "the conditional began here");
1437 /* Only evaluate this if we aren't skipping elses. During
1438 evaluation, set skipping to false to get lexer warnings. */
1439 if (ifs->skip_elses)
1440 pfile->state.skipping = 1;
1443 pfile->state.skipping = 0;
1444 pfile->state.skipping = ! _cpp_parse_expr (pfile);
1445 ifs->skip_elses = ! pfile->state.skipping;
1448 /* Invalidate any controlling macro. */
1453 /* #endif pops the if stack and resets pfile->state.skipping. */
1458 cpp_buffer *buffer = pfile->buffer;
1459 struct if_stack *ifs = buffer->if_stack;
1462 cpp_error (pfile, DL_ERROR, "#endif without #if");
1465 /* Only check EOL if was not originally skipping. */
1466 if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
1469 /* If potential control macro, we go back outside again. */
1470 if (ifs->next == 0 && ifs->mi_cmacro)
1472 pfile->mi_valid = true;
1473 pfile->mi_cmacro = ifs->mi_cmacro;
1476 buffer->if_stack = ifs->next;
1477 pfile->state.skipping = ifs->was_skipping;
1478 obstack_free (&pfile->buffer_ob, ifs);
1482 /* Push an if_stack entry for a preprocessor conditional, and set
1483 pfile->state.skipping to SKIP. If TYPE indicates the conditional
1484 is #if or #ifndef, CMACRO is a potentially controlling macro, and
1485 we need to check here that we are at the top of the file. */
1487 push_conditional (pfile, skip, type, cmacro)
1491 const cpp_hashnode *cmacro;
1493 struct if_stack *ifs;
1494 cpp_buffer *buffer = pfile->buffer;
1496 ifs = xobnew (&pfile->buffer_ob, struct if_stack);
1497 ifs->line = pfile->directive_line;
1498 ifs->next = buffer->if_stack;
1499 ifs->skip_elses = pfile->state.skipping || !skip;
1500 ifs->was_skipping = pfile->state.skipping;
1502 /* This condition is effectively a test for top-of-file. */
1503 if (pfile->mi_valid && pfile->mi_cmacro == 0)
1504 ifs->mi_cmacro = cmacro;
1508 pfile->state.skipping = skip;
1509 buffer->if_stack = ifs;
1512 /* Read the tokens of the answer into the macro pool, in a directive
1513 of type TYPE. Only commit the memory if we intend it as permanent
1514 storage, i.e. the #assert case. Returns 0 on success, and sets
1515 ANSWERP to point to the answer. */
1517 parse_answer (pfile, answerp, type)
1519 struct answer **answerp;
1522 const cpp_token *paren;
1523 struct answer *answer;
1524 unsigned int acount;
1526 /* In a conditional, it is legal to not have an open paren. We
1527 should save the following token in this case. */
1528 paren = cpp_get_token (pfile);
1530 /* If not a paren, see if we're OK. */
1531 if (paren->type != CPP_OPEN_PAREN)
1533 /* In a conditional no answer is a test for any answer. It
1534 could be followed by any token. */
1537 _cpp_backup_tokens (pfile, 1);
1541 /* #unassert with no answer is valid - it removes all answers. */
1542 if (type == T_UNASSERT && paren->type == CPP_EOF)
1545 cpp_error (pfile, DL_ERROR, "missing '(' after predicate");
1549 for (acount = 0;; acount++)
1552 const cpp_token *token = cpp_get_token (pfile);
1555 if (token->type == CPP_CLOSE_PAREN)
1558 if (token->type == CPP_EOF)
1560 cpp_error (pfile, DL_ERROR, "missing ')' to complete answer");
1564 /* struct answer includes the space for one token. */
1565 room_needed = (sizeof (struct answer) + acount * sizeof (cpp_token));
1567 if (BUFF_ROOM (pfile->a_buff) < room_needed)
1568 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer));
1570 dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount];
1573 /* Drop whitespace at start, for answer equivalence purposes. */
1575 dest->flags &= ~PREV_WHITE;
1580 cpp_error (pfile, DL_ERROR, "predicate's answer is empty");
1584 answer = (struct answer *) BUFF_FRONT (pfile->a_buff);
1585 answer->count = acount;
1586 answer->next = NULL;
1592 /* Parses an assertion directive of type TYPE, returning a pointer to
1593 the hash node of the predicate, or 0 on error. If an answer was
1594 supplied, it is placed in ANSWERP, otherwise it is set to 0. */
1595 static cpp_hashnode *
1596 parse_assertion (pfile, answerp, type)
1598 struct answer **answerp;
1601 cpp_hashnode *result = 0;
1602 const cpp_token *predicate;
1604 /* We don't expand predicates or answers. */
1605 pfile->state.prevent_expansion++;
1608 predicate = cpp_get_token (pfile);
1609 if (predicate->type == CPP_EOF)
1610 cpp_error (pfile, DL_ERROR, "assertion without predicate");
1611 else if (predicate->type != CPP_NAME)
1612 cpp_error (pfile, DL_ERROR, "predicate must be an identifier");
1613 else if (parse_answer (pfile, answerp, type) == 0)
1615 unsigned int len = NODE_LEN (predicate->val.node);
1616 unsigned char *sym = alloca (len + 1);
1618 /* Prefix '#' to get it out of macro namespace. */
1620 memcpy (sym + 1, NODE_NAME (predicate->val.node), len);
1621 result = cpp_lookup (pfile, sym, len + 1);
1624 pfile->state.prevent_expansion--;
1628 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
1629 or a pointer to NULL if the answer is not in the chain. */
1630 static struct answer **
1631 find_answer (node, candidate)
1633 const struct answer *candidate;
1636 struct answer **result;
1638 for (result = &node->value.answers; *result; result = &(*result)->next)
1640 struct answer *answer = *result;
1642 if (answer->count == candidate->count)
1644 for (i = 0; i < answer->count; i++)
1645 if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1648 if (i == answer->count)
1656 /* Test an assertion within a preprocessor conditional. Returns
1657 non-zero on failure, zero on success. On success, the result of
1658 the test is written into VALUE. */
1660 _cpp_test_assertion (pfile, value)
1662 unsigned int *value;
1664 struct answer *answer;
1667 node = parse_assertion (pfile, &answer, T_IF);
1669 *value = (node->type == NT_ASSERTION &&
1670 (answer == 0 || *find_answer (node, answer) != 0));
1671 else if (pfile->cur_token[-1].type == CPP_EOF)
1672 _cpp_backup_tokens (pfile, 1);
1674 /* We don't commit the memory for the answer - it's temporary only. */
1678 /* Handle #assert. */
1683 struct answer *new_answer;
1686 node = parse_assertion (pfile, &new_answer, T_ASSERT);
1689 /* Place the new answer in the answer list. First check there
1690 is not a duplicate. */
1691 new_answer->next = 0;
1692 if (node->type == NT_ASSERTION)
1694 if (*find_answer (node, new_answer))
1696 cpp_error (pfile, DL_WARNING, "\"%s\" re-asserted",
1697 NODE_NAME (node) + 1);
1700 new_answer->next = node->value.answers;
1703 node->type = NT_ASSERTION;
1704 node->value.answers = new_answer;
1705 BUFF_FRONT (pfile->a_buff) += (sizeof (struct answer)
1706 + (new_answer->count - 1)
1707 * sizeof (cpp_token));
1712 /* Handle #unassert. */
1718 struct answer *answer;
1720 node = parse_assertion (pfile, &answer, T_UNASSERT);
1721 /* It isn't an error to #unassert something that isn't asserted. */
1722 if (node && node->type == NT_ASSERTION)
1726 struct answer **p = find_answer (node, answer), *temp;
1728 /* Remove the answer from the list. */
1733 /* Did we free the last answer? */
1734 if (node->value.answers == 0)
1735 node->type = NT_VOID;
1740 _cpp_free_definition (node);
1743 /* We don't commit the memory for the answer - it's temporary only. */
1746 /* These are for -D, -U, -A. */
1748 /* Process the string STR as if it appeared as the body of a #define.
1749 If STR is just an identifier, define it with value 1.
1750 If STR has anything after the identifier, then it should
1751 be identifier=definition. */
1753 cpp_define (pfile, str)
1760 /* Copy the entire option so we can modify it.
1761 Change the first "=" in the string to a space. If there is none,
1762 tack " 1" on the end. */
1764 count = strlen (str);
1765 buf = (char *) alloca (count + 3);
1766 memcpy (buf, str, count);
1768 p = strchr (str, '=');
1778 run_directive (pfile, T_DEFINE, buf, count);
1781 /* Slight variant of the above for use by initialize_builtins. */
1783 _cpp_define_builtin (pfile, str)
1787 run_directive (pfile, T_DEFINE, str, strlen (str));
1790 /* Process MACRO as if it appeared as the body of an #undef. */
1792 cpp_undef (pfile, macro)
1796 run_directive (pfile, T_UNDEF, macro, strlen (macro));
1799 /* Process the string STR as if it appeared as the body of a #assert. */
1801 cpp_assert (pfile, str)
1805 handle_assertion (pfile, str, T_ASSERT);
1808 /* Process STR as if it appeared as the body of an #unassert. */
1810 cpp_unassert (pfile, str)
1814 handle_assertion (pfile, str, T_UNASSERT);
1817 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1819 handle_assertion (pfile, str, type)
1824 size_t count = strlen (str);
1825 const char *p = strchr (str, '=');
1829 /* Copy the entire option so we can modify it. Change the first
1830 "=" in the string to a '(', and tack a ')' on the end. */
1831 char *buf = (char *) alloca (count + 2);
1833 memcpy (buf, str, count);
1840 run_directive (pfile, type, str, count);
1843 /* The number of errors for a given reader. */
1848 return pfile->errors;
1851 /* The options structure. */
1853 cpp_get_options (pfile)
1856 return &pfile->opts;
1859 /* The callbacks structure. */
1861 cpp_get_callbacks (pfile)
1867 /* The line map set. */
1868 const struct line_maps *
1869 cpp_get_line_maps (pfile)
1872 return &pfile->line_maps;
1875 /* Copy the given callbacks structure to our own. */
1877 cpp_set_callbacks (pfile, cb)
1884 /* Push a new buffer on the buffer stack. Returns the new buffer; it
1885 doesn't fail. It does not generate a file change call back; that
1886 is the responsibility of the caller. */
1888 cpp_push_buffer (pfile, buffer, len, from_stage3, return_at_eof)
1890 const uchar *buffer;
1895 cpp_buffer *new = xobnew (&pfile->buffer_ob, cpp_buffer);
1897 /* Clears, amongst other things, if_stack and mi_cmacro. */
1898 memset (new, 0, sizeof (cpp_buffer));
1900 new->line_base = new->buf = new->cur = buffer;
1901 new->rlimit = buffer + len;
1902 new->from_stage3 = from_stage3 || CPP_OPTION (pfile, traditional);
1903 new->prev = pfile->buffer;
1904 new->return_at_eof = return_at_eof;
1905 new->saved_flags = BOL;
1907 pfile->buffer = new;
1912 /* Pops a single buffer, with a file change call-back if appropriate.
1913 Then pushes the next -include file, if any remain. */
1915 _cpp_pop_buffer (pfile)
1918 cpp_buffer *buffer = pfile->buffer;
1919 struct include_file *inc = buffer->inc;
1920 struct if_stack *ifs;
1922 /* Walk back up the conditional stack till we reach its level at
1923 entry to this file, issuing error messages. */
1924 for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
1925 cpp_error_with_line (pfile, DL_ERROR, ifs->line, 0,
1926 "unterminated #%s", dtable[ifs->type].name);
1928 /* In case of a missing #endif. */
1929 pfile->state.skipping = 0;
1931 /* _cpp_do_file_change expects pfile->buffer to be the new one. */
1932 pfile->buffer = buffer->prev;
1934 /* Free the buffer object now; we may want to push a new buffer
1935 in _cpp_push_next_include_file. */
1936 obstack_free (&pfile->buffer_ob, buffer);
1940 _cpp_pop_file_buffer (pfile, inc);
1942 /* Don't generate a callback for popping the main file. */
1945 _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
1947 /* If this is the main file, there may be some -include
1948 files left to push. */
1949 if (!pfile->buffer->prev)
1950 _cpp_maybe_push_include_file (pfile);
1955 /* Enter all recognised directives in the hash table. */
1957 _cpp_init_directives (pfile)
1963 for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
1965 node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
1966 node->directive_index = i + 1;