1 /* CPP Library. (Directive handling.)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 Free Software Foundation, Inc.
4 Contributed by Per Bothner, 1994-95.
5 Based on CCCP program by Paul Rubin, June 1986
6 Adapted to ANSI C, Richard Stallman, Jan 1987
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
30 /* Chained list of answers to an assertion. */
38 /* Stack of conditionals currently in progress
39 (including both successful and failing conditionals). */
43 struct if_stack *next;
44 cpp_lexer_pos pos; /* line and column where condition started */
45 const cpp_hashnode *mi_cmacro;/* macro name for #ifndef around entire file */
46 bool skip_elses; /* Can future #else / #elif be skipped? */
47 bool was_skipping; /* If were skipping on entry. */
48 int type; /* Most recent conditional, for diagnostics. */
51 /* Values for the origin field of struct directive. KANDR directives
52 come from traditional (K&R) C. STDC89 directives come from the
53 1989 C standard. EXTENSION directives are extensions. */
58 /* Values for the flags field of struct directive. COND indicates a
59 conditional; IF_COND an opening conditional. INCL means to treat
60 "..." and <...> as q-char and h-char sequences respectively. IN_I
61 means this directive should be handled even if -fpreprocessed is in
62 effect (these are the directives with callback hooks). */
64 #define IF_COND (1 << 1)
68 /* Defines one #-directive, including how to handle it. */
69 typedef void (*directive_handler) PARAMS ((cpp_reader *));
70 typedef struct directive directive;
73 directive_handler handler; /* Function to handle directive. */
74 const U_CHAR *name; /* Name of directive. */
75 unsigned short length; /* Length of name. */
76 unsigned char origin; /* Origin of directive. */
77 unsigned char flags; /* Flags describing this directive. */
80 /* Forward declarations. */
82 static void skip_rest_of_line PARAMS ((cpp_reader *));
83 static void check_eol PARAMS ((cpp_reader *));
84 static void start_directive PARAMS ((cpp_reader *));
85 static void end_directive PARAMS ((cpp_reader *, int));
86 static void run_directive PARAMS ((cpp_reader *, int,
88 const char *, size_t));
89 static int glue_header_name PARAMS ((cpp_reader *, cpp_token *));
90 static int parse_include PARAMS ((cpp_reader *, cpp_token *));
91 static void push_conditional PARAMS ((cpp_reader *, int, int,
92 const cpp_hashnode *));
93 static unsigned int read_flag PARAMS ((cpp_reader *, unsigned int));
94 static int strtoul_for_line PARAMS ((const U_CHAR *, unsigned int,
96 static void do_diagnostic PARAMS ((cpp_reader *, enum error_type, int));
97 static cpp_hashnode *lex_macro_node PARAMS ((cpp_reader *));
98 static void do_include_common PARAMS ((cpp_reader *, enum include_type));
99 static void do_pragma_once PARAMS ((cpp_reader *));
100 static void do_pragma_poison PARAMS ((cpp_reader *));
101 static void do_pragma_system_header PARAMS ((cpp_reader *));
102 static void do_pragma_dependency PARAMS ((cpp_reader *));
103 static int get__Pragma_string PARAMS ((cpp_reader *, cpp_token *));
104 static unsigned char *destringize PARAMS ((const cpp_string *,
106 static int parse_answer PARAMS ((cpp_reader *, struct answer **, int));
107 static cpp_hashnode *parse_assertion PARAMS ((cpp_reader *, struct answer **,
109 static struct answer ** find_answer PARAMS ((cpp_hashnode *,
110 const struct answer *));
111 static void handle_assertion PARAMS ((cpp_reader *, const char *, int));
113 /* This is the table of directive handlers. It is ordered by
114 frequency of occurrence; the numbers at the end are directive
115 counts from all the source code I have lying around (egcs and libc
116 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
117 pcmcia-cs-3.0.9). This is no longer important as directive lookup
118 is now O(1). All extensions other than #warning and #include_next
119 are deprecated. The name is where the extension appears to have
122 #define DIRECTIVE_TABLE \
123 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
124 D(include, T_INCLUDE, KANDR, INCL) /* 52262 */ \
125 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
126 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
127 D(if, T_IF, KANDR, COND | IF_COND) /* 18162 */ \
128 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
129 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
130 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
131 D(line, T_LINE, KANDR, IN_I) /* 2465 */ \
132 D(elif, T_ELIF, STDC89, COND) /* 610 */ \
133 D(error, T_ERROR, STDC89, 0) /* 475 */ \
134 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
135 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
136 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL) /* 19 */ \
137 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
138 D(import, T_IMPORT, EXTENSION, INCL) /* 0 ObjC */ \
139 D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
140 D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
141 SCCS_ENTRY /* 0 SVR4? */
143 /* #sccs is not always recognized. */
144 #ifdef SCCS_DIRECTIVE
145 # define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION, 0)
147 # define SCCS_ENTRY /* nothing */
150 /* Use the table to generate a series of prototypes, an enum for the
151 directive names, and an array of directive handlers. */
153 /* The directive-processing functions are declared to return int
154 instead of void, because some old compilers have trouble with
155 pointers to functions returning void. */
157 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
158 #define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
162 #define D(n, tag, o, f) tag,
170 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
171 #define D(name, t, origin, flags) \
172 { CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
173 sizeof STRINGX(name) - 1, origin, flags },
174 static const directive dtable[] =
179 #undef DIRECTIVE_TABLE
181 /* Skip any remaining tokens in a directive. */
183 skip_rest_of_line (pfile)
188 /* Discard all input lookaheads. */
189 while (pfile->la_read)
190 _cpp_release_lookahead (pfile);
192 /* Discard all stacked contexts. */
193 while (pfile->context != &pfile->base_context)
194 _cpp_pop_context (pfile);
196 /* Sweep up all tokens remaining on the line. */
197 while (!pfile->state.next_bol)
198 _cpp_lex_token (pfile, &token);
201 /* Ensure there are no stray tokens at the end of a directive. */
206 if (!pfile->state.next_bol)
210 _cpp_lex_token (pfile, &token);
211 if (token.type != CPP_EOF)
212 cpp_pedwarn (pfile, "extra tokens at end of #%s directive",
213 pfile->directive->name);
217 /* Called when entering a directive, _Pragma or command-line directive. */
219 start_directive (pfile)
222 /* Setup in-directive state. */
223 pfile->state.in_directive = 1;
224 pfile->state.save_comments = 0;
226 /* Some handlers need the position of the # for diagnostics. */
227 pfile->directive_pos = pfile->lexer_pos;
228 pfile->directive_line = pfile->line;
230 /* Don't save directive tokens for external clients. */
231 pfile->la_saved = pfile->la_write;
235 /* Called when leaving a directive, _Pragma or command-line directive. */
237 end_directive (pfile, skip_line)
241 /* We don't skip for an assembler #. */
243 skip_rest_of_line (pfile);
246 pfile->la_write = pfile->la_saved;
247 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
248 pfile->state.in_directive = 0;
249 pfile->state.angled_headers = 0;
250 pfile->state.line_extension = 0;
251 pfile->directive = 0;
254 /* Check if a token's name matches that of a known directive. Put in
255 this file to save exporting dtable and other unneeded information. */
257 _cpp_handle_directive (pfile, indented)
261 const directive *dir = 0;
265 start_directive (pfile);
267 /* Lex the directive name directly. */
268 _cpp_lex_token (pfile, &dname);
270 if (dname.type == CPP_NAME)
272 unsigned int index = dname.val.node->directive_index;
274 dir = &dtable[index - 1];
276 else if (dname.type == CPP_NUMBER)
278 /* # followed by a number is equivalent to #line. Do not
279 recognize this form in assembly language source files or
280 skipped conditional groups. Complain about this form if
281 we're being pedantic, but not if this is regurgitated input
282 (preprocessed or fed back in by the C++ frontend). */
283 if (! pfile->state.skipping && CPP_OPTION (pfile, lang) != CLK_ASM)
285 dir = &dtable[T_LINE];
286 pfile->state.line_extension = 1;
287 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
288 if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed))
289 cpp_pedwarn (pfile, "# followed by integer");
293 pfile->directive = dir;
296 /* Make sure we lex headers correctly, whether skipping or not. */
297 pfile->state.angled_headers = dir->flags & INCL;
299 /* If we are rescanning preprocessed input, only directives tagged
300 with IN_I are honored, and the warnings below are suppressed. */
301 if (CPP_OPTION (pfile, preprocessed))
303 /* Kluge alert. In order to be sure that code like this
306 does not cause '#define foo bar' to get executed when
307 compiled with -save-temps, we recognize directives in
308 -fpreprocessed mode only if the # is in column 1 and the
309 directive name starts in column 2. This output can only
310 be generated by the directive callbacks in cppmain.c (see
311 also the special case in scan_buffer). */
312 if (dir->flags & IN_I && !indented && !(dname.flags & PREV_WHITE))
313 (*dir->handler) (pfile);
314 /* That check misses '# 123' linemarkers. Let them through too. */
315 else if (dname.type == CPP_NUMBER)
316 (*dir->handler) (pfile);
319 /* We don't want to process this directive. Put back the
320 tokens so caller will see them (and issue an error,
322 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
328 /* Traditionally, a directive is ignored unless its # is in
329 column 1. Therefore in code intended to work with K+R
330 compilers, directives added by C89 must have their #
331 indented, and directives present in traditional C must
332 not. This is true even of directives in skipped
333 conditional blocks. */
334 if (CPP_WTRADITIONAL (pfile))
336 if (dir == &dtable[T_ELIF])
338 "suggest not using #elif in traditional C");
339 else if (indented && dir->origin == KANDR)
341 "traditional C ignores #%s with the # indented",
343 else if (!indented && dir->origin != KANDR)
345 "suggest hiding #%s from traditional C with an indented #",
349 /* If we are skipping a failed conditional group, all
350 non-conditional directives are ignored. */
351 if (! pfile->state.skipping || (dir->flags & COND))
353 /* Issue -pedantic warnings for extensions. */
354 if (CPP_PEDANTIC (pfile) && dir->origin == EXTENSION)
355 cpp_pedwarn (pfile, "#%s is a GCC extension", dir->name);
357 /* If we have a directive that is not an opening
358 conditional, invalidate any control macro. */
359 if (! (dir->flags & IF_COND))
360 pfile->mi_valid = false;
362 (*dir->handler) (pfile);
366 else if (dname.type != CPP_EOF && ! pfile->state.skipping)
368 /* An unknown directive. Don't complain about it in assembly
369 source: we don't know where the comments are, and # may
370 introduce assembler pseudo-ops. Don't complain about invalid
371 directives in skipped conditional groups (6.10 p4). */
372 if (CPP_OPTION (pfile, lang) == CLK_ASM)
374 /* Output the # and lookahead token for the assembler. */
375 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
379 cpp_error (pfile, "invalid preprocessing directive #%s",
380 cpp_token_as_text (pfile, &dname));
383 if (pfile->state.in_directive)
384 end_directive (pfile, skip);
388 /* Directive handler wrapper used by the command line option
391 run_directive (pfile, dir_no, type, buf, count)
394 enum cpp_buffer_type type;
398 unsigned int output_line = pfile->lexer_pos.output_line;
401 buffer = cpp_push_buffer (pfile, (const U_CHAR *) buf, count, type, 0, 1);
403 if (dir_no == T_PRAGMA)
405 /* A kludge to avoid line markers for _Pragma. */
406 pfile->lexer_pos.output_line = output_line;
407 /* Avoid interpretation of directives in a _Pragma string. */
408 pfile->state.next_bol = 0;
411 start_directive (pfile);
412 pfile->state.prevent_expansion++;
413 pfile->directive = &dtable[dir_no];
414 (void) (*pfile->directive->handler) (pfile);
415 pfile->state.prevent_expansion--;
417 end_directive (pfile, 1);
418 _cpp_pop_buffer (pfile);
421 /* Checks for validity the macro name in #define, #undef, #ifdef and
422 #ifndef directives. */
423 static cpp_hashnode *
424 lex_macro_node (pfile)
430 /* Lex the macro name directly. */
431 _cpp_lex_token (pfile, &token);
433 /* The token immediately after #define must be an identifier. That
434 identifier may not be "defined", per C99 6.10.8p4.
435 In C++, it may not be any of the "named operators" either,
436 per C++98 [lex.digraph], [lex.key].
437 Finally, the identifier may not have been poisoned. (In that case
438 the lexer has issued the error message for us.) */
440 if (token.type != CPP_NAME)
442 if (token.type == CPP_EOF)
443 cpp_error (pfile, "no macro name given in #%s directive",
444 pfile->directive->name);
445 else if (token.flags & NAMED_OP)
447 "\"%s\" cannot be used as a macro name as it is an operator in C++",
448 NODE_NAME (token.val.node));
450 cpp_error (pfile, "macro names must be identifiers");
455 node = token.val.node;
456 if (node->flags & NODE_POISONED)
459 if (node == pfile->spec_nodes.n_defined)
461 cpp_error (pfile, "\"%s\" cannot be used as a macro name",
469 /* Process a #define directive. Most work is done in cppmacro.c. */
474 cpp_hashnode *node = lex_macro_node (pfile);
478 if (_cpp_create_definition (pfile, node))
479 if (pfile->cb.define)
480 (*pfile->cb.define) (pfile, pfile->directive_line, node);
484 /* Handle #undef. Marks the identifier NT_VOID in the hash table. */
489 cpp_hashnode *node = lex_macro_node (pfile);
491 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
492 is not currently defined as a macro name. */
493 if (node && node->type == NT_MACRO)
496 (*pfile->cb.undef) (pfile, pfile->directive_line, node);
498 if (node->flags & NODE_WARN)
499 cpp_warning (pfile, "undefining \"%s\"", NODE_NAME (node));
501 _cpp_free_definition (node);
506 /* Helper routine used by parse_include. Reinterpret the current line
507 as an h-char-sequence (< ... >); we are looking at the first token
508 after the <. Returns zero on success. */
510 glue_header_name (pfile, header)
515 unsigned char *buffer, *token_mem;
516 size_t len, total_len = 0, capacity = 1024;
518 /* To avoid lexed tokens overwriting our glued name, we can only
519 allocate from the string pool once we've lexed everything. */
521 buffer = (unsigned char *) xmalloc (capacity);
524 cpp_get_token (pfile, &token);
526 if (token.type == CPP_GREATER || token.type == CPP_EOF)
529 len = cpp_token_len (&token);
530 if (total_len + len > capacity)
532 capacity = (capacity + len) * 2;
533 buffer = (unsigned char *) xrealloc (buffer, capacity);
536 if (token.flags & PREV_WHITE)
537 buffer[total_len++] = ' ';
539 total_len = cpp_spell_token (pfile, &token, &buffer[total_len]) - buffer;
542 if (token.type == CPP_EOF)
543 cpp_error (pfile, "missing terminating > character");
546 token_mem = _cpp_pool_alloc (&pfile->ident_pool, total_len + 1);
547 memcpy (token_mem, buffer, total_len);
548 token_mem[total_len] = '\0';
550 header->type = CPP_HEADER_NAME;
551 header->flags &= ~PREV_WHITE;
552 header->val.str.len = total_len;
553 header->val.str.text = token_mem;
557 return token.type == CPP_EOF;
560 /* Parse the header name of #include, #include_next, #import and
561 #pragma dependency. Returns zero on success. */
563 parse_include (pfile, header)
567 const unsigned char *dir;
569 if (pfile->directive == &dtable[T_PRAGMA])
570 dir = U"pragma dependency";
572 dir = pfile->directive->name;
574 /* Allow macro expansion. */
575 cpp_get_token (pfile, header);
576 if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
578 if (header->type != CPP_LESS)
580 cpp_error (pfile, "#%s expects \"FILENAME\" or <FILENAME>", dir);
583 if (glue_header_name (pfile, header))
587 if (header->val.str.len == 0)
589 cpp_error (pfile, "empty file name in #%s", dir);
596 /* Handle #include, #include_next and #import. */
598 do_include_common (pfile, type)
600 enum include_type type;
604 /* For #include_next, if this is the primary source file, warn and
605 use the normal search logic. */
606 if (type == IT_INCLUDE_NEXT && ! pfile->buffer->prev)
608 cpp_warning (pfile, "#include_next in primary source file");
611 else if (type == IT_IMPORT && CPP_OPTION (pfile, warn_import))
613 CPP_OPTION (pfile, warn_import) = 0;
615 "#import is obsolete, use an #ifndef wrapper in the header file");
618 if (!parse_include (pfile, &header))
620 /* Prevent #include recursion. */
621 if (pfile->buffer_stack_depth >= CPP_STACK_MAX)
622 cpp_fatal (pfile, "#include nested too deeply");
626 /* Get out of macro context, if we are. */
627 end_directive (pfile, 1);
628 if (pfile->cb.include)
629 (*pfile->cb.include) (pfile, pfile->directive_line,
630 pfile->directive->name, &header);
632 _cpp_execute_include (pfile, &header, type);
641 do_include_common (pfile, IT_INCLUDE);
648 do_include_common (pfile, IT_IMPORT);
652 do_include_next (pfile)
655 do_include_common (pfile, IT_INCLUDE_NEXT);
658 /* Subroutine of do_line. Read possible flags after file name. LAST
659 is the last flag seen; 0 if this is the first flag. Return the flag
660 if it is valid, 0 at the end of the directive. Otherwise complain. */
663 read_flag (pfile, last)
669 _cpp_lex_token (pfile, &token);
670 if (token.type == CPP_NUMBER && token.val.str.len == 1)
672 unsigned int flag = token.val.str.text[0] - '0';
674 if (flag > last && flag <= 4
675 && (flag != 4 || last == 3)
676 && (flag != 2 || last == 0))
680 if (token.type != CPP_EOF)
681 cpp_error (pfile, "invalid flag \"%s\" in line directive",
682 cpp_token_as_text (pfile, &token));
686 /* Another subroutine of do_line. Convert a number in STR, of length
687 LEN, to binary; store it in NUMP, and return 0 if the number was
688 well-formed, 1 if not. Temporary, hopefully. */
690 strtoul_for_line (str, len, nump)
695 unsigned long reg = 0;
709 /* Interpret #line command.
710 Note that the filename string (if any) is treated as if it were an
711 include filename. That means no escape handling. */
717 cpp_buffer *buffer = pfile->buffer;
718 enum lc_reason reason = LC_RENAME;
719 unsigned long new_lineno;
723 /* C99 raised the minimum limit on #line numbers. */
724 cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
726 /* #line commands expand macros. */
727 cpp_get_token (pfile, &token);
728 if (token.type != CPP_NUMBER
729 || strtoul_for_line (token.val.str.text, token.val.str.len, &new_lineno))
731 cpp_error (pfile, "\"%s\" after #line is not a positive integer",
732 cpp_token_as_text (pfile, &token));
736 if (CPP_PEDANTIC (pfile) && ! pfile->state.line_extension
737 && (new_lineno == 0 || new_lineno > cap))
738 cpp_pedwarn (pfile, "line number out of range");
740 cpp_get_token (pfile, &token);
741 if (token.type == CPP_STRING)
743 const char *fname = (const char *) token.val.str.text;
745 /* Only accept flags for the # 55 form. */
746 if (! pfile->state.line_extension)
750 int flag = 0, sysp = 0;
752 flag = read_flag (pfile, flag);
756 flag = read_flag (pfile, flag);
761 flag = read_flag (pfile, flag);
766 flag = read_flag (pfile, flag);
768 sysp = 2, read_flag (pfile, flag);
771 if (reason == LC_ENTER)
773 /* Fake a buffer stack for diagnostics. */
774 cpp_push_buffer (pfile, 0, 0, BUF_FAKE, fname, 0);
775 /* Fake an include for cpp_included. */
776 _cpp_fake_include (pfile, fname);
777 buffer = pfile->buffer;
779 else if (reason == LC_LEAVE)
781 if (buffer->type != BUF_FAKE)
782 cpp_warning (pfile, "file \"%s\" left but not entered",
783 buffer->nominal_fname);
786 _cpp_pop_buffer (pfile);
787 buffer = pfile->buffer;
788 #ifdef ENABLE_CHECKING
789 if (strcmp (buffer->nominal_fname, fname))
790 cpp_warning (pfile, "expected to return to file \"%s\"",
791 buffer->nominal_fname);
792 if (buffer->lineno + 1 != new_lineno)
793 cpp_warning (pfile, "expected to return to line number %u",
795 if (buffer->sysp != sysp)
796 cpp_warning (pfile, "header flags for \"%s\" have changed",
797 buffer->nominal_fname);
803 buffer->nominal_fname = fname;
805 else if (token.type != CPP_EOF)
807 cpp_error (pfile, "\"%s\" is not a valid filename",
808 cpp_token_as_text (pfile, &token));
812 end_directive (pfile, 1);
813 buffer->lineno = new_lineno - 1;
814 _cpp_do_file_change (pfile, reason);
817 /* Arrange the file_change callback. It is assumed that the next line
818 is given by incrementing buffer->lineno and pfile->line. */
820 _cpp_do_file_change (pfile, reason)
822 enum lc_reason reason;
825 struct line_map *map;
827 buffer = pfile->buffer;
828 map = add_line_map (&pfile->line_maps, reason,
829 pfile->line + 1, buffer->nominal_fname, buffer->lineno + 1);
831 if (pfile->cb.file_change)
836 fc.line = pfile->line + 1;
838 fc.sysp = buffer->sysp;
839 fc.externc = CPP_OPTION (pfile, cplusplus) && buffer->sysp == 2;
841 (*pfile->cb.file_change) (pfile, &fc);
846 * Report a warning or error detected by the program we are
847 * processing. Use the directive's tokens in the error message.
851 do_diagnostic (pfile, code, print_dir)
853 enum error_type code;
856 if (_cpp_begin_message (pfile, code, NULL, 0))
859 fprintf (stderr, "#%s ", pfile->directive->name);
860 pfile->state.prevent_expansion++;
861 cpp_output_line (pfile, stderr);
862 pfile->state.prevent_expansion--;
870 do_diagnostic (pfile, ERROR, 1);
877 /* We want #warning diagnostics to be emitted in system headers too. */
878 do_diagnostic (pfile, WARNING_SYSHDR, 1);
881 /* Report program identification. */
889 cpp_get_token (pfile, &str);
890 if (str.type != CPP_STRING)
891 cpp_error (pfile, "invalid #ident");
892 else if (pfile->cb.ident)
893 (*pfile->cb.ident) (pfile, pfile->directive_line, &str.val.str);
898 /* Pragmata handling. We handle some of these, and pass the rest on
899 to the front end. C99 defines three pragmas and says that no macro
900 expansion is to be performed on them; whether or not macro
901 expansion happens for other pragmas is implementation defined.
902 This implementation never macro-expands the text after #pragma. */
904 /* Sub-handlers for the pragmas needing treatment here.
905 They return 1 if the token buffer is to be popped, 0 if not. */
906 typedef void (*pragma_cb) PARAMS ((cpp_reader *));
909 struct pragma_entry *next;
915 struct pragma_entry *space;
920 cpp_register_pragma (pfile, space, name, handler)
926 struct pragma_entry **x, *new;
932 struct pragma_entry *p = pfile->pragmas;
933 len = strlen (space);
936 if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
943 cpp_ice (pfile, "unknown #pragma namespace %s", space);
948 new = xnew (struct pragma_entry);
950 new->len = strlen (name);
952 new->u.handler = handler;
959 cpp_register_pragma_space (pfile, space)
963 struct pragma_entry *new;
964 const struct pragma_entry *p = pfile->pragmas;
965 size_t len = strlen (space);
969 if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
970 /* Multiple different callers are allowed to register the same
976 new = xnew (struct pragma_entry);
982 new->next = pfile->pragmas;
983 pfile->pragmas = new;
987 _cpp_init_internal_pragmas (pfile)
991 cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
992 cpp_register_pragma (pfile, 0, "once", do_pragma_once);
995 cpp_register_pragma_space (pfile, "GCC");
997 cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
998 cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
999 cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
1006 pragma_cb handler = NULL;
1007 const struct pragma_entry *p;
1011 pfile->state.prevent_expansion++;
1012 cpp_start_lookahead (pfile);
1015 cpp_get_token (pfile, &tok);
1016 if (tok.type == CPP_NAME)
1018 const cpp_hashnode *node = tok.val.node;
1019 size_t len = NODE_LEN (node);
1023 if (strlen (p->name) == len
1024 && !memcmp (p->name, NODE_NAME (node), len))
1033 handler = p->u.handler;
1041 cpp_stop_lookahead (pfile, handler != NULL);
1042 pfile->state.prevent_expansion--;
1046 else if (pfile->cb.def_pragma)
1047 (*pfile->cb.def_pragma) (pfile, pfile->directive_line);
1051 do_pragma_once (pfile)
1054 cpp_warning (pfile, "#pragma once is obsolete");
1056 if (pfile->buffer->prev == NULL)
1057 cpp_warning (pfile, "#pragma once in main file");
1059 _cpp_never_reread (pfile->buffer->inc);
1065 do_pragma_poison (pfile)
1068 /* Poison these symbols so that all subsequent usage produces an
1073 pfile->state.poisoned_ok = 1;
1076 _cpp_lex_token (pfile, &tok);
1077 if (tok.type == CPP_EOF)
1079 if (tok.type != CPP_NAME)
1081 cpp_error (pfile, "invalid #pragma GCC poison directive");
1086 if (hp->flags & NODE_POISONED)
1089 if (hp->type == NT_MACRO)
1090 cpp_warning (pfile, "poisoning existing macro \"%s\"", NODE_NAME (hp));
1091 _cpp_free_definition (hp);
1092 hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1094 pfile->state.poisoned_ok = 0;
1097 /* Mark the current header as a system header. This will suppress
1098 some categories of warnings (notably those from -pedantic). It is
1099 intended for use in system libraries that cannot be implemented in
1100 conforming C, but cannot be certain that their headers appear in a
1101 system include directory. To prevent abuse, it is rejected in the
1102 primary source file. */
1104 do_pragma_system_header (pfile)
1107 cpp_buffer *buffer = pfile->buffer;
1109 if (buffer->prev == 0)
1110 cpp_warning (pfile, "#pragma system_header ignored outside include file");
1114 end_directive (pfile, 1);
1115 cpp_make_system_header (pfile, 1, 0);
1119 /* Check the modified date of the current include file against a specified
1120 file. Issue a diagnostic, if the specified file is newer. We use this to
1121 determine if a fixed header should be refixed. */
1123 do_pragma_dependency (pfile)
1126 cpp_token header, msg;
1129 if (parse_include (pfile, &header))
1132 ordering = _cpp_compare_file_date (pfile, &header);
1134 cpp_warning (pfile, "cannot find source %s",
1135 cpp_token_as_text (pfile, &header));
1136 else if (ordering > 0)
1138 cpp_warning (pfile, "current file is older than %s",
1139 cpp_token_as_text (pfile, &header));
1140 cpp_start_lookahead (pfile);
1141 cpp_get_token (pfile, &msg);
1142 cpp_stop_lookahead (pfile, msg.type == CPP_EOF);
1143 if (msg.type != CPP_EOF)
1144 do_diagnostic (pfile, WARNING, 0);
1148 /* Check syntax is "(string-literal)". Returns 0 on success. */
1150 get__Pragma_string (pfile, string)
1156 cpp_get_token (pfile, &paren);
1157 if (paren.type != CPP_OPEN_PAREN)
1160 cpp_get_token (pfile, string);
1161 if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1164 cpp_get_token (pfile, &paren);
1165 return paren.type != CPP_CLOSE_PAREN;
1168 /* Returns a malloced buffer containing a destringized cpp_string by
1169 removing the first \ of \" and \\ sequences. */
1170 static unsigned char *
1171 destringize (in, len)
1172 const cpp_string *in;
1175 const unsigned char *src, *limit;
1176 unsigned char *dest, *result;
1178 dest = result = (unsigned char *) xmalloc (in->len);
1179 for (src = in->text, limit = src + in->len; src < limit;)
1181 /* We know there is a character following the backslash. */
1182 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1187 *len = dest - result;
1192 _cpp_do__Pragma (pfile)
1196 unsigned char *buffer;
1199 if (get__Pragma_string (pfile, &string))
1201 cpp_error (pfile, "_Pragma takes a parenthesized string literal");
1205 buffer = destringize (&string.val.str, &len);
1206 run_directive (pfile, T_PRAGMA, BUF_PRAGMA, (char *) buffer, len);
1207 free ((PTR) buffer);
1210 /* Just ignore #sccs, on systems where we define it at all. */
1211 #ifdef SCCS_DIRECTIVE
1214 cpp_reader *pfile ATTRIBUTE_UNUSED;
1225 if (! pfile->state.skipping)
1227 const cpp_hashnode *node = lex_macro_node (pfile);
1230 skip = node->type != NT_MACRO;
1236 push_conditional (pfile, skip, T_IFDEF, 0);
1244 const cpp_hashnode *node = 0;
1246 if (! pfile->state.skipping)
1248 node = lex_macro_node (pfile);
1250 skip = node->type == NT_MACRO;
1256 push_conditional (pfile, skip, T_IFNDEF, node);
1259 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1260 pfile->mi_ind_cmacro so we can handle multiple-include
1261 optimisations. If macro expansion occurs in the expression, we
1262 cannot treat it as a controlling conditional, since the expansion
1263 could change in the future. That is handled by cpp_get_token. */
1271 if (! pfile->state.skipping)
1272 skip = _cpp_parse_expr (pfile) == 0;
1274 push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
1277 /* Flip skipping state if appropriate and continue without changing
1278 if_stack; this is so that the error message for missing #endif's
1279 etc. will point to the original #if. */
1285 cpp_buffer *buffer = pfile->buffer;
1286 struct if_stack *ifs = buffer->if_stack;
1289 cpp_error (pfile, "#else without #if");
1292 if (ifs->type == T_ELSE)
1294 cpp_error (pfile, "#else after #else");
1295 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1296 "the conditional began here");
1300 /* Skip any future (erroneous) #elses or #elifs. */
1301 pfile->state.skipping = ifs->skip_elses;
1302 ifs->skip_elses = true;
1304 /* Invalidate any controlling macro. */
1307 /* Only check EOL if was not originally skipping. */
1308 if (!ifs->was_skipping)
1313 /* handle a #elif directive by not changing if_stack either. see the
1314 comment above do_else. */
1320 cpp_buffer *buffer = pfile->buffer;
1321 struct if_stack *ifs = buffer->if_stack;
1324 cpp_error (pfile, "#elif without #if");
1327 if (ifs->type == T_ELSE)
1329 cpp_error (pfile, "#elif after #else");
1330 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1331 "the conditional began here");
1335 /* Only evaluate this if we aren't skipping elses. During
1336 evaluation, set skipping to false to get lexer warnings. */
1337 if (ifs->skip_elses)
1338 pfile->state.skipping = 1;
1341 pfile->state.skipping = 0;
1342 pfile->state.skipping = ! _cpp_parse_expr (pfile);
1343 ifs->skip_elses = ! pfile->state.skipping;
1346 /* Invalidate any controlling macro. */
1351 /* #endif pops the if stack and resets pfile->state.skipping. */
1357 cpp_buffer *buffer = pfile->buffer;
1358 struct if_stack *ifs = buffer->if_stack;
1361 cpp_error (pfile, "#endif without #if");
1364 /* Only check EOL if was not originally skipping. */
1365 if (!ifs->was_skipping)
1368 /* If potential control macro, we go back outside again. */
1369 if (ifs->next == 0 && ifs->mi_cmacro)
1371 pfile->mi_valid = true;
1372 pfile->mi_cmacro = ifs->mi_cmacro;
1375 buffer->if_stack = ifs->next;
1376 pfile->state.skipping = ifs->was_skipping;
1377 obstack_free (&pfile->buffer_ob, ifs);
1381 /* Push an if_stack entry and set pfile->state.skipping accordingly.
1382 If this is a #if or #ifndef, CMACRO is a potentially controlling
1383 macro - we need to check here that we are at the top of the file. */
1386 push_conditional (pfile, skip, type, cmacro)
1390 const cpp_hashnode *cmacro;
1392 struct if_stack *ifs;
1393 cpp_buffer *buffer = pfile->buffer;
1395 ifs = xobnew (&pfile->buffer_ob, struct if_stack);
1396 ifs->pos = pfile->directive_pos;
1397 ifs->next = buffer->if_stack;
1398 ifs->skip_elses = pfile->state.skipping || !skip;
1399 ifs->was_skipping = pfile->state.skipping;
1401 /* This condition is effectively a test for top-of-file. */
1402 if (pfile->mi_valid && pfile->mi_cmacro == 0)
1403 ifs->mi_cmacro = cmacro;
1407 pfile->state.skipping = skip;
1408 buffer->if_stack = ifs;
1411 /* Read the tokens of the answer into the macro pool. Only commit the
1412 memory if we intend it as permanent storage, i.e. the #assert case.
1413 Returns 0 on success. */
1416 parse_answer (pfile, answerp, type)
1418 struct answer **answerp;
1421 cpp_token paren, *token;
1422 struct answer *answer;
1424 if (POOL_FRONT (&pfile->macro_pool) + sizeof (struct answer) >
1425 POOL_LIMIT (&pfile->macro_pool))
1426 _cpp_next_chunk (&pfile->macro_pool, sizeof (struct answer), 0);
1427 answer = (struct answer *) POOL_FRONT (&pfile->macro_pool);
1430 /* In a conditional, it is legal to not have an open paren. We
1431 should save the following token in this case. */
1433 cpp_start_lookahead (pfile);
1434 cpp_get_token (pfile, &paren);
1436 cpp_stop_lookahead (pfile, paren.type == CPP_OPEN_PAREN);
1438 /* If not a paren, see if we're OK. */
1439 if (paren.type != CPP_OPEN_PAREN)
1441 /* In a conditional no answer is a test for any answer. It
1442 could be followed by any token. */
1446 /* #unassert with no answer is valid - it removes all answers. */
1447 if (type == T_UNASSERT && paren.type == CPP_EOF)
1450 cpp_error (pfile, "missing '(' after predicate");
1456 token = &answer->first[answer->count];
1457 /* Check we have room for the token. */
1458 if ((unsigned char *) (token + 1) >= POOL_LIMIT (&pfile->macro_pool))
1460 _cpp_next_chunk (&pfile->macro_pool, sizeof (cpp_token),
1461 (unsigned char **) &answer);
1462 token = &answer->first[answer->count];
1465 cpp_get_token (pfile, token);
1466 if (token->type == CPP_CLOSE_PAREN)
1469 if (token->type == CPP_EOF)
1471 cpp_error (pfile, "missing ')' to complete answer");
1477 if (answer->count == 0)
1479 cpp_error (pfile, "predicate's answer is empty");
1483 /* Drop whitespace at start. */
1484 answer->first->flags &= ~PREV_WHITE;
1487 if (type == T_ASSERT || type == T_UNASSERT)
1492 /* Parses an assertion, returning a pointer to the hash node of the
1493 predicate, or 0 on error. If an answer was supplied, it is placed
1494 in ANSWERP, otherwise it is set to 0. */
1495 static cpp_hashnode *
1496 parse_assertion (pfile, answerp, type)
1498 struct answer **answerp;
1501 cpp_hashnode *result = 0;
1502 cpp_token predicate;
1504 /* We don't expand predicates or answers. */
1505 pfile->state.prevent_expansion++;
1508 cpp_get_token (pfile, &predicate);
1509 if (predicate.type == CPP_EOF)
1510 cpp_error (pfile, "assertion without predicate");
1511 else if (predicate.type != CPP_NAME)
1512 cpp_error (pfile, "predicate must be an identifier");
1513 else if (parse_answer (pfile, answerp, type) == 0)
1515 unsigned int len = NODE_LEN (predicate.val.node);
1516 unsigned char *sym = alloca (len + 1);
1518 /* Prefix '#' to get it out of macro namespace. */
1520 memcpy (sym + 1, NODE_NAME (predicate.val.node), len);
1521 result = cpp_lookup (pfile, sym, len + 1);
1524 pfile->state.prevent_expansion--;
1528 /* Returns a pointer to the pointer to the answer in the answer chain,
1529 or a pointer to NULL if the answer is not in the chain. */
1530 static struct answer **
1531 find_answer (node, candidate)
1533 const struct answer *candidate;
1536 struct answer **result;
1538 for (result = &node->value.answers; *result; result = &(*result)->next)
1540 struct answer *answer = *result;
1542 if (answer->count == candidate->count)
1544 for (i = 0; i < answer->count; i++)
1545 if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1548 if (i == answer->count)
1556 /* Test an assertion within a preprocessor conditional. Returns
1557 non-zero on failure, zero on success. On success, the result of
1558 the test is written into VALUE. */
1560 _cpp_test_assertion (pfile, value)
1564 struct answer *answer;
1567 node = parse_assertion (pfile, &answer, T_IF);
1569 *value = (node->type == NT_ASSERTION &&
1570 (answer == 0 || *find_answer (node, answer) != 0));
1572 /* We don't commit the memory for the answer - it's temporary only. */
1580 struct answer *new_answer;
1583 node = parse_assertion (pfile, &new_answer, T_ASSERT);
1586 /* Place the new answer in the answer list. First check there
1587 is not a duplicate. */
1588 new_answer->next = 0;
1589 if (node->type == NT_ASSERTION)
1591 if (*find_answer (node, new_answer))
1593 cpp_warning (pfile, "\"%s\" re-asserted", NODE_NAME (node) + 1);
1596 new_answer->next = node->value.answers;
1598 node->type = NT_ASSERTION;
1599 node->value.answers = new_answer;
1600 POOL_COMMIT (&pfile->macro_pool, (sizeof (struct answer)
1601 + (new_answer->count - 1)
1602 * sizeof (cpp_token)));
1611 struct answer *answer;
1613 node = parse_assertion (pfile, &answer, T_UNASSERT);
1614 /* It isn't an error to #unassert something that isn't asserted. */
1615 if (node && node->type == NT_ASSERTION)
1619 struct answer **p = find_answer (node, answer), *temp;
1621 /* Remove the answer from the list. */
1626 /* Did we free the last answer? */
1627 if (node->value.answers == 0)
1628 node->type = NT_VOID;
1631 _cpp_free_definition (node);
1634 /* We don't commit the memory for the answer - it's temporary only. */
1637 /* These are for -D, -U, -A. */
1639 /* Process the string STR as if it appeared as the body of a #define.
1640 If STR is just an identifier, define it with value 1.
1641 If STR has anything after the identifier, then it should
1642 be identifier=definition. */
1645 cpp_define (pfile, str)
1652 /* Copy the entire option so we can modify it.
1653 Change the first "=" in the string to a space. If there is none,
1654 tack " 1" on the end. */
1656 /* Length including the null. */
1657 count = strlen (str);
1658 buf = (char *) alloca (count + 2);
1659 memcpy (buf, str, count);
1661 p = strchr (str, '=');
1670 run_directive (pfile, T_DEFINE, BUF_CL_OPTION, buf, count);
1673 /* Slight variant of the above for use by initialize_builtins. */
1675 _cpp_define_builtin (pfile, str)
1679 run_directive (pfile, T_DEFINE, BUF_BUILTIN, str, strlen (str));
1682 /* Process MACRO as if it appeared as the body of an #undef. */
1684 cpp_undef (pfile, macro)
1688 run_directive (pfile, T_UNDEF, BUF_CL_OPTION, macro, strlen (macro));
1691 /* Process the string STR as if it appeared as the body of a #assert. */
1693 cpp_assert (pfile, str)
1697 handle_assertion (pfile, str, T_ASSERT);
1700 /* Process STR as if it appeared as the body of an #unassert. */
1702 cpp_unassert (pfile, str)
1706 handle_assertion (pfile, str, T_UNASSERT);
1709 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1711 handle_assertion (pfile, str, type)
1716 size_t count = strlen (str);
1717 const char *p = strchr (str, '=');
1721 /* Copy the entire option so we can modify it. Change the first
1722 "=" in the string to a '(', and tack a ')' on the end. */
1723 char *buf = (char *) alloca (count + 1);
1725 memcpy (buf, str, count);
1731 run_directive (pfile, type, BUF_CL_OPTION, str, count);
1734 /* The number of errors for a given reader. */
1739 return pfile->errors;
1742 /* The options structure. */
1744 cpp_get_options (pfile)
1747 return &pfile->opts;
1750 /* The callbacks structure. */
1752 cpp_get_callbacks (pfile)
1758 /* The line map set. */
1760 cpp_get_line_maps (pfile)
1763 return &pfile->line_maps;
1766 /* Copy the given callbacks structure to our own. */
1768 cpp_set_callbacks (pfile, cb)
1775 /* Push a new buffer on the buffer stack. Returns the new buffer; it
1776 doesn't fail. It does not generate a file change call back; that
1777 is the responsibility of the caller. */
1779 cpp_push_buffer (pfile, buffer, len, type, filename, return_at_eof)
1781 const U_CHAR *buffer;
1783 enum cpp_buffer_type type;
1784 const char *filename;
1787 cpp_buffer *new = xobnew (&pfile->buffer_ob, cpp_buffer);
1789 if (type == BUF_FAKE)
1791 /* A copy of the current buffer, just with a new name and type. */
1792 memcpy (new, pfile->buffer, sizeof (cpp_buffer));
1793 new->type = BUF_FAKE;
1797 if (type == BUF_BUILTIN)
1798 filename = _("<builtin>");
1799 else if (type == BUF_CL_OPTION)
1800 filename = _("<command line>");
1801 else if (type == BUF_PRAGMA)
1802 filename = "<_Pragma>";
1804 /* Clears, amongst other things, if_stack and mi_cmacro. */
1805 memset (new, 0, sizeof (cpp_buffer));
1807 new->line_base = new->buf = new->cur = buffer;
1808 new->rlimit = buffer + len;
1811 /* No read ahead or extra char initially. */
1812 new->read_ahead = EOF;
1813 new->extra_char = EOF;
1815 /* Preprocessed files, builtins, _Pragma and command line
1816 options don't do trigraph and escaped newline processing. */
1817 new->from_stage3 = type != BUF_FILE || CPP_OPTION (pfile, preprocessed);
1819 pfile->lexer_pos.output_line = 1;
1822 if (*filename == '\0')
1823 new->nominal_fname = _("<stdin>");
1825 new->nominal_fname = filename;
1827 new->prev = pfile->buffer;
1829 new->include_stack_listed = 0;
1831 new->return_at_eof = return_at_eof;
1833 pfile->state.next_bol = 1;
1834 pfile->buffer_stack_depth++;
1835 pfile->buffer = new;
1840 /* If called from do_line, pops a single buffer. Otherwise pops all
1841 buffers until a real file is reached. Generates appropriate
1844 _cpp_pop_buffer (pfile)
1848 struct if_stack *ifs;
1852 buffer = pfile->buffer;
1853 /* Walk back up the conditional stack till we reach its level at
1854 entry to this file, issuing error messages. */
1855 for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
1856 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1857 "unterminated #%s", dtable[ifs->type].name);
1859 if (buffer->type == BUF_FAKE)
1860 buffer->prev->cur = buffer->cur;
1861 else if (buffer->type == BUF_FILE)
1862 _cpp_pop_file_buffer (pfile, buffer);
1864 pfile->buffer = buffer->prev;
1865 pfile->buffer_stack_depth--;
1867 /* Callbacks only generated for faked or real files. */
1868 if (buffer->type != BUF_FILE && buffer->type != BUF_FAKE)
1871 /* No callback for EOF of last file. */
1875 /* do_line does its own call backs. */
1876 pfile->buffer->include_stack_listed = 0;
1877 if (pfile->directive == &dtable[T_LINE])
1880 pfile->line--; /* We have a '\n' at the end of #include. */
1881 _cpp_do_file_change (pfile, LC_LEAVE);
1882 if (pfile->buffer->type == BUF_FILE)
1885 cpp_warning (pfile, "file \"%s\" entered but not left",
1886 buffer->nominal_fname);
1889 obstack_free (&pfile->buffer_ob, buffer);
1891 pfile->state.skipping = 0; /* In case missing #endif. */
1895 _cpp_init_directives (pfile)
1901 /* Register the directives. */
1902 for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
1904 node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
1905 node->directive_index = i + 1;