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;
229 /* Don't save directive tokens for external clients. */
230 pfile->la_saved = pfile->la_write;
234 /* Called when leaving a directive, _Pragma or command-line directive. */
236 end_directive (pfile, skip_line)
240 /* We don't skip for an assembler #. */
242 skip_rest_of_line (pfile);
245 pfile->la_write = pfile->la_saved;
246 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
247 pfile->state.in_directive = 0;
248 pfile->state.angled_headers = 0;
249 pfile->state.line_extension = 0;
250 pfile->directive = 0;
253 /* Check if a token's name matches that of a known directive. Put in
254 this file to save exporting dtable and other unneeded information. */
256 _cpp_handle_directive (pfile, indented)
260 const directive *dir = 0;
264 start_directive (pfile);
266 /* Lex the directive name directly. */
267 _cpp_lex_token (pfile, &dname);
269 if (dname.type == CPP_NAME)
271 unsigned int index = dname.val.node->directive_index;
273 dir = &dtable[index - 1];
275 else if (dname.type == CPP_NUMBER)
277 /* # followed by a number is equivalent to #line. Do not
278 recognize this form in assembly language source files or
279 skipped conditional groups. Complain about this form if
280 we're being pedantic, but not if this is regurgitated input
281 (preprocessed or fed back in by the C++ frontend). */
282 if (! pfile->state.skipping && CPP_OPTION (pfile, lang) != CLK_ASM)
284 dir = &dtable[T_LINE];
285 pfile->state.line_extension = 1;
286 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
287 if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed))
288 cpp_pedwarn (pfile, "# followed by integer");
292 pfile->directive = dir;
295 /* Make sure we lex headers correctly, whether skipping or not. */
296 pfile->state.angled_headers = dir->flags & INCL;
298 /* If we are rescanning preprocessed input, only directives tagged
299 with IN_I are honored, and the warnings below are suppressed. */
300 if (CPP_OPTION (pfile, preprocessed))
302 /* Kluge alert. In order to be sure that code like this
305 does not cause '#define foo bar' to get executed when
306 compiled with -save-temps, we recognize directives in
307 -fpreprocessed mode only if the # is in column 1 and the
308 directive name starts in column 2. This output can only
309 be generated by the directive callbacks in cppmain.c (see
310 also the special case in scan_buffer). */
311 if (dir->flags & IN_I && !indented && !(dname.flags & PREV_WHITE))
312 (*dir->handler) (pfile);
313 /* That check misses '# 123' linemarkers. Let them through too. */
314 else if (dname.type == CPP_NUMBER)
315 (*dir->handler) (pfile);
318 /* We don't want to process this directive. Put back the
319 tokens so caller will see them (and issue an error,
321 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
327 /* Traditionally, a directive is ignored unless its # is in
328 column 1. Therefore in code intended to work with K+R
329 compilers, directives added by C89 must have their #
330 indented, and directives present in traditional C must
331 not. This is true even of directives in skipped
332 conditional blocks. */
333 if (CPP_WTRADITIONAL (pfile))
335 if (dir == &dtable[T_ELIF])
337 "suggest not using #elif in traditional C");
338 else if (indented && dir->origin == KANDR)
340 "traditional C ignores #%s with the # indented",
342 else if (!indented && dir->origin != KANDR)
344 "suggest hiding #%s from traditional C with an indented #",
348 /* If we are skipping a failed conditional group, all
349 non-conditional directives are ignored. */
350 if (! pfile->state.skipping || (dir->flags & COND))
352 /* Issue -pedantic warnings for extensions. */
353 if (CPP_PEDANTIC (pfile) && dir->origin == EXTENSION)
354 cpp_pedwarn (pfile, "#%s is a GCC extension", dir->name);
356 /* If we have a directive that is not an opening
357 conditional, invalidate any control macro. */
358 if (! (dir->flags & IF_COND))
359 pfile->mi_valid = false;
361 (*dir->handler) (pfile);
365 else if (dname.type != CPP_EOF && ! pfile->state.skipping)
367 /* An unknown directive. Don't complain about it in assembly
368 source: we don't know where the comments are, and # may
369 introduce assembler pseudo-ops. Don't complain about invalid
370 directives in skipped conditional groups (6.10 p4). */
371 if (CPP_OPTION (pfile, lang) == CLK_ASM)
373 /* Output the # and lookahead token for the assembler. */
374 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
378 cpp_error (pfile, "invalid preprocessing directive #%s",
379 cpp_token_as_text (pfile, &dname));
382 if (pfile->state.in_directive)
383 end_directive (pfile, skip);
387 /* Directive handler wrapper used by the command line option
390 run_directive (pfile, dir_no, type, buf, count)
393 enum cpp_buffer_type type;
397 unsigned int output_line = pfile->lexer_pos.output_line;
400 buffer = cpp_push_buffer (pfile, (const U_CHAR *) buf, count, type, 0, 1);
402 if (dir_no == T_PRAGMA)
404 /* A kludge to avoid line markers for _Pragma. */
405 pfile->lexer_pos.output_line = output_line;
406 /* Avoid interpretation of directives in a _Pragma string. */
407 pfile->state.next_bol = 0;
410 start_directive (pfile);
411 pfile->state.prevent_expansion++;
412 pfile->directive = &dtable[dir_no];
413 (void) (*pfile->directive->handler) (pfile);
414 pfile->state.prevent_expansion--;
416 end_directive (pfile, 1);
417 _cpp_pop_buffer (pfile);
420 /* Checks for validity the macro name in #define, #undef, #ifdef and
421 #ifndef directives. */
422 static cpp_hashnode *
423 lex_macro_node (pfile)
429 /* Lex the macro name directly. */
430 _cpp_lex_token (pfile, &token);
432 /* The token immediately after #define must be an identifier. That
433 identifier may not be "defined", per C99 6.10.8p4.
434 In C++, it may not be any of the "named operators" either,
435 per C++98 [lex.digraph], [lex.key].
436 Finally, the identifier may not have been poisoned. (In that case
437 the lexer has issued the error message for us.) */
439 if (token.type != CPP_NAME)
441 if (token.type == CPP_EOF)
442 cpp_error (pfile, "no macro name given in #%s directive",
443 pfile->directive->name);
444 else if (token.flags & NAMED_OP)
446 "\"%s\" cannot be used as a macro name as it is an operator in C++",
447 NODE_NAME (token.val.node));
449 cpp_error (pfile, "macro names must be identifiers");
454 node = token.val.node;
455 if (node->flags & NODE_POISONED)
458 if (node == pfile->spec_nodes.n_defined)
460 cpp_error (pfile, "\"%s\" cannot be used as a macro name",
468 /* Process a #define directive. Most work is done in cppmacro.c. */
473 cpp_hashnode *node = lex_macro_node (pfile);
477 if (_cpp_create_definition (pfile, node))
478 if (pfile->cb.define)
479 (*pfile->cb.define) (pfile, node);
483 /* Handle #undef. Marks the identifier NT_VOID in the hash table. */
488 cpp_hashnode *node = lex_macro_node (pfile);
490 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
491 is not currently defined as a macro name. */
492 if (node && node->type == NT_MACRO)
495 (*pfile->cb.undef) (pfile, node);
497 if (node->flags & NODE_WARN)
498 cpp_warning (pfile, "undefining \"%s\"", NODE_NAME (node));
500 _cpp_free_definition (node);
505 /* Helper routine used by parse_include. Reinterpret the current line
506 as an h-char-sequence (< ... >); we are looking at the first token
507 after the <. Returns zero on success. */
509 glue_header_name (pfile, header)
514 unsigned char *buffer, *token_mem;
515 size_t len, total_len = 0, capacity = 1024;
517 /* To avoid lexed tokens overwriting our glued name, we can only
518 allocate from the string pool once we've lexed everything. */
520 buffer = (unsigned char *) xmalloc (capacity);
523 cpp_get_token (pfile, &token);
525 if (token.type == CPP_GREATER || token.type == CPP_EOF)
528 len = cpp_token_len (&token);
529 if (total_len + len > capacity)
531 capacity = (capacity + len) * 2;
532 buffer = (unsigned char *) xrealloc (buffer, capacity);
535 if (token.flags & PREV_WHITE)
536 buffer[total_len++] = ' ';
538 total_len = cpp_spell_token (pfile, &token, &buffer[total_len]) - buffer;
541 if (token.type == CPP_EOF)
542 cpp_error (pfile, "missing terminating > character");
545 token_mem = _cpp_pool_alloc (&pfile->ident_pool, total_len + 1);
546 memcpy (token_mem, buffer, total_len);
547 token_mem[total_len] = '\0';
549 header->type = CPP_HEADER_NAME;
550 header->flags &= ~PREV_WHITE;
551 header->val.str.len = total_len;
552 header->val.str.text = token_mem;
556 return token.type == CPP_EOF;
559 /* Parse the header name of #include, #include_next, #import and
560 #pragma dependency. Returns zero on success. */
562 parse_include (pfile, header)
566 const unsigned char *dir;
568 if (pfile->directive == &dtable[T_PRAGMA])
569 dir = U"pragma dependency";
571 dir = pfile->directive->name;
573 /* Allow macro expansion. */
574 cpp_get_token (pfile, header);
575 if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
577 if (header->type != CPP_LESS)
579 cpp_error (pfile, "#%s expects \"FILENAME\" or <FILENAME>", dir);
582 if (glue_header_name (pfile, header))
586 if (header->val.str.len == 0)
588 cpp_error (pfile, "empty file name in #%s", dir);
595 /* Handle #include, #include_next and #import. */
597 do_include_common (pfile, type)
599 enum include_type type;
603 /* For #include_next, if this is the primary source file, warn and
604 use the normal search logic. */
605 if (type == IT_INCLUDE_NEXT && ! pfile->buffer->prev)
607 cpp_warning (pfile, "#include_next in primary source file");
610 else if (type == IT_IMPORT && CPP_OPTION (pfile, warn_import))
612 CPP_OPTION (pfile, warn_import) = 0;
614 "#import is obsolete, use an #ifndef wrapper in the header file");
617 if (!parse_include (pfile, &header))
619 /* Prevent #include recursion. */
620 if (pfile->buffer_stack_depth >= CPP_STACK_MAX)
621 cpp_fatal (pfile, "#include nested too deeply");
625 /* Get out of macro context, if we are. */
626 end_directive (pfile, 1);
627 if (pfile->cb.include)
628 (*pfile->cb.include) (pfile, pfile->directive->name, &header);
630 _cpp_execute_include (pfile, &header, type);
639 do_include_common (pfile, IT_INCLUDE);
646 do_include_common (pfile, IT_IMPORT);
650 do_include_next (pfile)
653 do_include_common (pfile, IT_INCLUDE_NEXT);
656 /* Subroutine of do_line. Read possible flags after file name. LAST
657 is the last flag seen; 0 if this is the first flag. Return the flag
658 if it is valid, 0 at the end of the directive. Otherwise complain. */
661 read_flag (pfile, last)
667 _cpp_lex_token (pfile, &token);
668 if (token.type == CPP_NUMBER && token.val.str.len == 1)
670 unsigned int flag = token.val.str.text[0] - '0';
672 if (flag > last && flag <= 4
673 && (flag != 4 || last == 3)
674 && (flag != 2 || last == 0))
678 if (token.type != CPP_EOF)
679 cpp_error (pfile, "invalid flag \"%s\" in line directive",
680 cpp_token_as_text (pfile, &token));
684 /* Another subroutine of do_line. Convert a number in STR, of length
685 LEN, to binary; store it in NUMP, and return 0 if the number was
686 well-formed, 1 if not. Temporary, hopefully. */
688 strtoul_for_line (str, len, nump)
693 unsigned long reg = 0;
707 /* Interpret #line command.
708 Note that the filename string (if any) is treated as if it were an
709 include filename. That means no escape handling. */
715 cpp_buffer *buffer = pfile->buffer;
716 enum lc_reason reason = LC_RENAME;
717 unsigned long new_lineno;
721 /* C99 raised the minimum limit on #line numbers. */
722 cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
724 /* #line commands expand macros. */
725 cpp_get_token (pfile, &token);
726 if (token.type != CPP_NUMBER
727 || strtoul_for_line (token.val.str.text, token.val.str.len, &new_lineno))
729 cpp_error (pfile, "\"%s\" after #line is not a positive integer",
730 cpp_token_as_text (pfile, &token));
734 if (CPP_PEDANTIC (pfile) && ! pfile->state.line_extension
735 && (new_lineno == 0 || new_lineno > cap))
736 cpp_pedwarn (pfile, "line number out of range");
738 cpp_get_token (pfile, &token);
739 if (token.type == CPP_STRING)
741 const char *fname = (const char *) token.val.str.text;
743 /* Only accept flags for the # 55 form. */
744 if (! pfile->state.line_extension)
748 int flag = 0, sysp = 0;
750 flag = read_flag (pfile, flag);
754 flag = read_flag (pfile, flag);
759 flag = read_flag (pfile, flag);
764 flag = read_flag (pfile, flag);
766 sysp = 2, read_flag (pfile, flag);
769 if (reason == LC_ENTER)
771 /* Fake a buffer stack for diagnostics. */
772 cpp_push_buffer (pfile, 0, 0, BUF_FAKE, fname, 0);
773 /* Fake an include for cpp_included. */
774 _cpp_fake_include (pfile, fname);
775 buffer = pfile->buffer;
777 else if (reason == LC_LEAVE)
779 if (buffer->type != BUF_FAKE)
780 cpp_warning (pfile, "file \"%s\" left but not entered",
781 buffer->nominal_fname);
784 _cpp_pop_buffer (pfile);
785 buffer = pfile->buffer;
786 #ifdef ENABLE_CHECKING
787 if (strcmp (buffer->nominal_fname, fname))
788 cpp_warning (pfile, "expected to return to file \"%s\"",
789 buffer->nominal_fname);
790 if (buffer->lineno + 1 != new_lineno)
791 cpp_warning (pfile, "expected to return to line number %u",
793 if (buffer->sysp != sysp)
794 cpp_warning (pfile, "header flags for \"%s\" have changed",
795 buffer->nominal_fname);
801 buffer->nominal_fname = fname;
803 else if (token.type != CPP_EOF)
805 cpp_error (pfile, "\"%s\" is not a valid filename",
806 cpp_token_as_text (pfile, &token));
810 end_directive (pfile, 1);
811 buffer->lineno = new_lineno - 1;
812 _cpp_do_file_change (pfile, reason);
815 /* Arrange the file_change callback. It is assumed that the next line
816 is given by incrementing buffer->lineno and pfile->line. */
818 _cpp_do_file_change (pfile, reason)
820 enum lc_reason reason;
823 struct line_map *map;
825 buffer = pfile->buffer;
826 map = add_line_map (&pfile->line_maps, reason,
827 pfile->line + 1, buffer->nominal_fname, buffer->lineno + 1);
829 if (pfile->cb.file_change)
834 fc.line = pfile->line + 1;
836 fc.sysp = buffer->sysp;
837 fc.externc = CPP_OPTION (pfile, cplusplus) && buffer->sysp == 2;
839 (*pfile->cb.file_change) (pfile, &fc);
844 * Report a warning or error detected by the program we are
845 * processing. Use the directive's tokens in the error message.
849 do_diagnostic (pfile, code, print_dir)
851 enum error_type code;
854 if (_cpp_begin_message (pfile, code, NULL, 0))
857 fprintf (stderr, "#%s ", pfile->directive->name);
858 pfile->state.prevent_expansion++;
859 cpp_output_line (pfile, stderr);
860 pfile->state.prevent_expansion--;
868 do_diagnostic (pfile, ERROR, 1);
875 /* We want #warning diagnostics to be emitted in system headers too. */
876 do_diagnostic (pfile, WARNING_SYSHDR, 1);
879 /* Report program identification. */
887 cpp_get_token (pfile, &str);
888 if (str.type != CPP_STRING)
889 cpp_error (pfile, "invalid #ident");
890 else if (pfile->cb.ident)
891 (*pfile->cb.ident) (pfile, &str.val.str);
896 /* Pragmata handling. We handle some of these, and pass the rest on
897 to the front end. C99 defines three pragmas and says that no macro
898 expansion is to be performed on them; whether or not macro
899 expansion happens for other pragmas is implementation defined.
900 This implementation never macro-expands the text after #pragma. */
902 /* Sub-handlers for the pragmas needing treatment here.
903 They return 1 if the token buffer is to be popped, 0 if not. */
904 typedef void (*pragma_cb) PARAMS ((cpp_reader *));
907 struct pragma_entry *next;
913 struct pragma_entry *space;
918 cpp_register_pragma (pfile, space, name, handler)
924 struct pragma_entry **x, *new;
930 struct pragma_entry *p = pfile->pragmas;
931 len = strlen (space);
934 if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
941 cpp_ice (pfile, "unknown #pragma namespace %s", space);
946 new = xnew (struct pragma_entry);
948 new->len = strlen (name);
950 new->u.handler = handler;
957 cpp_register_pragma_space (pfile, space)
961 struct pragma_entry *new;
962 const struct pragma_entry *p = pfile->pragmas;
963 size_t len = strlen (space);
967 if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
968 /* Multiple different callers are allowed to register the same
974 new = xnew (struct pragma_entry);
980 new->next = pfile->pragmas;
981 pfile->pragmas = new;
985 _cpp_init_internal_pragmas (pfile)
989 cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
990 cpp_register_pragma (pfile, 0, "once", do_pragma_once);
993 cpp_register_pragma_space (pfile, "GCC");
995 cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
996 cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
997 cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
1004 pragma_cb handler = NULL;
1005 const struct pragma_entry *p;
1009 pfile->state.prevent_expansion++;
1010 cpp_start_lookahead (pfile);
1013 cpp_get_token (pfile, &tok);
1014 if (tok.type == CPP_NAME)
1016 const cpp_hashnode *node = tok.val.node;
1017 size_t len = NODE_LEN (node);
1021 if (strlen (p->name) == len
1022 && !memcmp (p->name, NODE_NAME (node), len))
1031 handler = p->u.handler;
1039 cpp_stop_lookahead (pfile, handler != NULL);
1040 pfile->state.prevent_expansion--;
1044 else if (pfile->cb.def_pragma)
1045 (*pfile->cb.def_pragma) (pfile);
1049 do_pragma_once (pfile)
1052 cpp_warning (pfile, "#pragma once is obsolete");
1054 if (pfile->buffer->prev == NULL)
1055 cpp_warning (pfile, "#pragma once in main file");
1057 _cpp_never_reread (pfile->buffer->inc);
1063 do_pragma_poison (pfile)
1066 /* Poison these symbols so that all subsequent usage produces an
1071 pfile->state.poisoned_ok = 1;
1074 _cpp_lex_token (pfile, &tok);
1075 if (tok.type == CPP_EOF)
1077 if (tok.type != CPP_NAME)
1079 cpp_error (pfile, "invalid #pragma GCC poison directive");
1084 if (hp->flags & NODE_POISONED)
1087 if (hp->type == NT_MACRO)
1088 cpp_warning (pfile, "poisoning existing macro \"%s\"", NODE_NAME (hp));
1089 _cpp_free_definition (hp);
1090 hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1092 pfile->state.poisoned_ok = 0;
1095 /* Mark the current header as a system header. This will suppress
1096 some categories of warnings (notably those from -pedantic). It is
1097 intended for use in system libraries that cannot be implemented in
1098 conforming C, but cannot be certain that their headers appear in a
1099 system include directory. To prevent abuse, it is rejected in the
1100 primary source file. */
1102 do_pragma_system_header (pfile)
1105 cpp_buffer *buffer = pfile->buffer;
1107 if (buffer->prev == 0)
1108 cpp_warning (pfile, "#pragma system_header ignored outside include file");
1112 end_directive (pfile, 1);
1113 cpp_make_system_header (pfile, 1, 0);
1117 /* Check the modified date of the current include file against a specified
1118 file. Issue a diagnostic, if the specified file is newer. We use this to
1119 determine if a fixed header should be refixed. */
1121 do_pragma_dependency (pfile)
1124 cpp_token header, msg;
1127 if (parse_include (pfile, &header))
1130 ordering = _cpp_compare_file_date (pfile, &header);
1132 cpp_warning (pfile, "cannot find source %s",
1133 cpp_token_as_text (pfile, &header));
1134 else if (ordering > 0)
1136 cpp_warning (pfile, "current file is older than %s",
1137 cpp_token_as_text (pfile, &header));
1138 cpp_start_lookahead (pfile);
1139 cpp_get_token (pfile, &msg);
1140 cpp_stop_lookahead (pfile, msg.type == CPP_EOF);
1141 if (msg.type != CPP_EOF)
1142 do_diagnostic (pfile, WARNING, 0);
1146 /* Check syntax is "(string-literal)". Returns 0 on success. */
1148 get__Pragma_string (pfile, string)
1154 cpp_get_token (pfile, &paren);
1155 if (paren.type != CPP_OPEN_PAREN)
1158 cpp_get_token (pfile, string);
1159 if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1162 cpp_get_token (pfile, &paren);
1163 return paren.type != CPP_CLOSE_PAREN;
1166 /* Returns a malloced buffer containing a destringized cpp_string by
1167 removing the first \ of \" and \\ sequences. */
1168 static unsigned char *
1169 destringize (in, len)
1170 const cpp_string *in;
1173 const unsigned char *src, *limit;
1174 unsigned char *dest, *result;
1176 dest = result = (unsigned char *) xmalloc (in->len);
1177 for (src = in->text, limit = src + in->len; src < limit;)
1179 /* We know there is a character following the backslash. */
1180 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1185 *len = dest - result;
1190 _cpp_do__Pragma (pfile)
1194 unsigned char *buffer;
1197 if (get__Pragma_string (pfile, &string))
1199 cpp_error (pfile, "_Pragma takes a parenthesized string literal");
1203 buffer = destringize (&string.val.str, &len);
1204 run_directive (pfile, T_PRAGMA, BUF_PRAGMA, (char *) buffer, len);
1205 free ((PTR) buffer);
1208 /* Just ignore #sccs, on systems where we define it at all. */
1209 #ifdef SCCS_DIRECTIVE
1212 cpp_reader *pfile ATTRIBUTE_UNUSED;
1223 if (! pfile->state.skipping)
1225 const cpp_hashnode *node = lex_macro_node (pfile);
1228 skip = node->type != NT_MACRO;
1234 push_conditional (pfile, skip, T_IFDEF, 0);
1242 const cpp_hashnode *node = 0;
1244 if (! pfile->state.skipping)
1246 node = lex_macro_node (pfile);
1248 skip = node->type == NT_MACRO;
1254 push_conditional (pfile, skip, T_IFNDEF, node);
1257 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1258 pfile->mi_ind_cmacro so we can handle multiple-include
1259 optimisations. If macro expansion occurs in the expression, we
1260 cannot treat it as a controlling conditional, since the expansion
1261 could change in the future. That is handled by cpp_get_token. */
1269 if (! pfile->state.skipping)
1270 skip = _cpp_parse_expr (pfile) == 0;
1272 push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
1275 /* Flip skipping state if appropriate and continue without changing
1276 if_stack; this is so that the error message for missing #endif's
1277 etc. will point to the original #if. */
1283 cpp_buffer *buffer = pfile->buffer;
1284 struct if_stack *ifs = buffer->if_stack;
1287 cpp_error (pfile, "#else without #if");
1290 if (ifs->type == T_ELSE)
1292 cpp_error (pfile, "#else after #else");
1293 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1294 "the conditional began here");
1298 /* Skip any future (erroneous) #elses or #elifs. */
1299 pfile->state.skipping = ifs->skip_elses;
1300 ifs->skip_elses = true;
1302 /* Invalidate any controlling macro. */
1305 /* Only check EOL if was not originally skipping. */
1306 if (!ifs->was_skipping)
1311 /* handle a #elif directive by not changing if_stack either. see the
1312 comment above do_else. */
1318 cpp_buffer *buffer = pfile->buffer;
1319 struct if_stack *ifs = buffer->if_stack;
1322 cpp_error (pfile, "#elif without #if");
1325 if (ifs->type == T_ELSE)
1327 cpp_error (pfile, "#elif after #else");
1328 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1329 "the conditional began here");
1333 /* Only evaluate this if we aren't skipping elses. During
1334 evaluation, set skipping to false to get lexer warnings. */
1335 if (ifs->skip_elses)
1336 pfile->state.skipping = 1;
1339 pfile->state.skipping = 0;
1340 pfile->state.skipping = ! _cpp_parse_expr (pfile);
1341 ifs->skip_elses = ! pfile->state.skipping;
1344 /* Invalidate any controlling macro. */
1349 /* #endif pops the if stack and resets pfile->state.skipping. */
1355 cpp_buffer *buffer = pfile->buffer;
1356 struct if_stack *ifs = buffer->if_stack;
1359 cpp_error (pfile, "#endif without #if");
1362 /* Only check EOL if was not originally skipping. */
1363 if (!ifs->was_skipping)
1366 /* If potential control macro, we go back outside again. */
1367 if (ifs->next == 0 && ifs->mi_cmacro)
1369 pfile->mi_valid = true;
1370 pfile->mi_cmacro = ifs->mi_cmacro;
1373 buffer->if_stack = ifs->next;
1374 pfile->state.skipping = ifs->was_skipping;
1375 obstack_free (&pfile->buffer_ob, ifs);
1379 /* Push an if_stack entry and set pfile->state.skipping accordingly.
1380 If this is a #if or #ifndef, CMACRO is a potentially controlling
1381 macro - we need to check here that we are at the top of the file. */
1384 push_conditional (pfile, skip, type, cmacro)
1388 const cpp_hashnode *cmacro;
1390 struct if_stack *ifs;
1391 cpp_buffer *buffer = pfile->buffer;
1393 ifs = xobnew (&pfile->buffer_ob, struct if_stack);
1394 ifs->pos = pfile->directive_pos;
1395 ifs->next = buffer->if_stack;
1396 ifs->skip_elses = pfile->state.skipping || !skip;
1397 ifs->was_skipping = pfile->state.skipping;
1399 /* This condition is effectively a test for top-of-file. */
1400 if (pfile->mi_valid && pfile->mi_cmacro == 0)
1401 ifs->mi_cmacro = cmacro;
1405 pfile->state.skipping = skip;
1406 buffer->if_stack = ifs;
1409 /* Read the tokens of the answer into the macro pool. Only commit the
1410 memory if we intend it as permanent storage, i.e. the #assert case.
1411 Returns 0 on success. */
1414 parse_answer (pfile, answerp, type)
1416 struct answer **answerp;
1419 cpp_token paren, *token;
1420 struct answer *answer;
1422 if (POOL_FRONT (&pfile->macro_pool) + sizeof (struct answer) >
1423 POOL_LIMIT (&pfile->macro_pool))
1424 _cpp_next_chunk (&pfile->macro_pool, sizeof (struct answer), 0);
1425 answer = (struct answer *) POOL_FRONT (&pfile->macro_pool);
1428 /* In a conditional, it is legal to not have an open paren. We
1429 should save the following token in this case. */
1431 cpp_start_lookahead (pfile);
1432 cpp_get_token (pfile, &paren);
1434 cpp_stop_lookahead (pfile, paren.type == CPP_OPEN_PAREN);
1436 /* If not a paren, see if we're OK. */
1437 if (paren.type != CPP_OPEN_PAREN)
1439 /* In a conditional no answer is a test for any answer. It
1440 could be followed by any token. */
1444 /* #unassert with no answer is valid - it removes all answers. */
1445 if (type == T_UNASSERT && paren.type == CPP_EOF)
1448 cpp_error (pfile, "missing '(' after predicate");
1454 token = &answer->first[answer->count];
1455 /* Check we have room for the token. */
1456 if ((unsigned char *) (token + 1) >= POOL_LIMIT (&pfile->macro_pool))
1458 _cpp_next_chunk (&pfile->macro_pool, sizeof (cpp_token),
1459 (unsigned char **) &answer);
1460 token = &answer->first[answer->count];
1463 cpp_get_token (pfile, token);
1464 if (token->type == CPP_CLOSE_PAREN)
1467 if (token->type == CPP_EOF)
1469 cpp_error (pfile, "missing ')' to complete answer");
1475 if (answer->count == 0)
1477 cpp_error (pfile, "predicate's answer is empty");
1481 /* Drop whitespace at start. */
1482 answer->first->flags &= ~PREV_WHITE;
1485 if (type == T_ASSERT || type == T_UNASSERT)
1490 /* Parses an assertion, returning a pointer to the hash node of the
1491 predicate, or 0 on error. If an answer was supplied, it is placed
1492 in ANSWERP, otherwise it is set to 0. */
1493 static cpp_hashnode *
1494 parse_assertion (pfile, answerp, type)
1496 struct answer **answerp;
1499 cpp_hashnode *result = 0;
1500 cpp_token predicate;
1502 /* We don't expand predicates or answers. */
1503 pfile->state.prevent_expansion++;
1506 cpp_get_token (pfile, &predicate);
1507 if (predicate.type == CPP_EOF)
1508 cpp_error (pfile, "assertion without predicate");
1509 else if (predicate.type != CPP_NAME)
1510 cpp_error (pfile, "predicate must be an identifier");
1511 else if (parse_answer (pfile, answerp, type) == 0)
1513 unsigned int len = NODE_LEN (predicate.val.node);
1514 unsigned char *sym = alloca (len + 1);
1516 /* Prefix '#' to get it out of macro namespace. */
1518 memcpy (sym + 1, NODE_NAME (predicate.val.node), len);
1519 result = cpp_lookup (pfile, sym, len + 1);
1522 pfile->state.prevent_expansion--;
1526 /* Returns a pointer to the pointer to the answer in the answer chain,
1527 or a pointer to NULL if the answer is not in the chain. */
1528 static struct answer **
1529 find_answer (node, candidate)
1531 const struct answer *candidate;
1534 struct answer **result;
1536 for (result = &node->value.answers; *result; result = &(*result)->next)
1538 struct answer *answer = *result;
1540 if (answer->count == candidate->count)
1542 for (i = 0; i < answer->count; i++)
1543 if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1546 if (i == answer->count)
1554 /* Test an assertion within a preprocessor conditional. Returns
1555 non-zero on failure, zero on success. On success, the result of
1556 the test is written into VALUE. */
1558 _cpp_test_assertion (pfile, value)
1562 struct answer *answer;
1565 node = parse_assertion (pfile, &answer, T_IF);
1567 *value = (node->type == NT_ASSERTION &&
1568 (answer == 0 || *find_answer (node, answer) != 0));
1570 /* We don't commit the memory for the answer - it's temporary only. */
1578 struct answer *new_answer;
1581 node = parse_assertion (pfile, &new_answer, T_ASSERT);
1584 /* Place the new answer in the answer list. First check there
1585 is not a duplicate. */
1586 new_answer->next = 0;
1587 if (node->type == NT_ASSERTION)
1589 if (*find_answer (node, new_answer))
1591 cpp_warning (pfile, "\"%s\" re-asserted", NODE_NAME (node) + 1);
1594 new_answer->next = node->value.answers;
1596 node->type = NT_ASSERTION;
1597 node->value.answers = new_answer;
1598 POOL_COMMIT (&pfile->macro_pool, (sizeof (struct answer)
1599 + (new_answer->count - 1)
1600 * sizeof (cpp_token)));
1609 struct answer *answer;
1611 node = parse_assertion (pfile, &answer, T_UNASSERT);
1612 /* It isn't an error to #unassert something that isn't asserted. */
1613 if (node && node->type == NT_ASSERTION)
1617 struct answer **p = find_answer (node, answer), *temp;
1619 /* Remove the answer from the list. */
1624 /* Did we free the last answer? */
1625 if (node->value.answers == 0)
1626 node->type = NT_VOID;
1629 _cpp_free_definition (node);
1632 /* We don't commit the memory for the answer - it's temporary only. */
1635 /* These are for -D, -U, -A. */
1637 /* Process the string STR as if it appeared as the body of a #define.
1638 If STR is just an identifier, define it with value 1.
1639 If STR has anything after the identifier, then it should
1640 be identifier=definition. */
1643 cpp_define (pfile, str)
1650 /* Copy the entire option so we can modify it.
1651 Change the first "=" in the string to a space. If there is none,
1652 tack " 1" on the end. */
1654 /* Length including the null. */
1655 count = strlen (str);
1656 buf = (char *) alloca (count + 2);
1657 memcpy (buf, str, count);
1659 p = strchr (str, '=');
1668 run_directive (pfile, T_DEFINE, BUF_CL_OPTION, buf, count);
1671 /* Slight variant of the above for use by initialize_builtins. */
1673 _cpp_define_builtin (pfile, str)
1677 run_directive (pfile, T_DEFINE, BUF_BUILTIN, str, strlen (str));
1680 /* Process MACRO as if it appeared as the body of an #undef. */
1682 cpp_undef (pfile, macro)
1686 run_directive (pfile, T_UNDEF, BUF_CL_OPTION, macro, strlen (macro));
1689 /* Process the string STR as if it appeared as the body of a #assert. */
1691 cpp_assert (pfile, str)
1695 handle_assertion (pfile, str, T_ASSERT);
1698 /* Process STR as if it appeared as the body of an #unassert. */
1700 cpp_unassert (pfile, str)
1704 handle_assertion (pfile, str, T_UNASSERT);
1707 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1709 handle_assertion (pfile, str, type)
1714 size_t count = strlen (str);
1715 const char *p = strchr (str, '=');
1719 /* Copy the entire option so we can modify it. Change the first
1720 "=" in the string to a '(', and tack a ')' on the end. */
1721 char *buf = (char *) alloca (count + 1);
1723 memcpy (buf, str, count);
1729 run_directive (pfile, type, BUF_CL_OPTION, str, count);
1732 /* The number of errors for a given reader. */
1737 return pfile->errors;
1740 /* The options structure. */
1742 cpp_get_options (pfile)
1745 return &pfile->opts;
1748 /* The callbacks structure. */
1750 cpp_get_callbacks (pfile)
1756 /* The line map set. */
1758 cpp_get_line_maps (pfile)
1761 return &pfile->line_maps;
1764 /* Copy the given callbacks structure to our own. */
1766 cpp_set_callbacks (pfile, cb)
1773 /* Push a new buffer on the buffer stack. Returns the new buffer; it
1774 doesn't fail. It does not generate a file change call back; that
1775 is the responsibility of the caller. */
1777 cpp_push_buffer (pfile, buffer, len, type, filename, return_at_eof)
1779 const U_CHAR *buffer;
1781 enum cpp_buffer_type type;
1782 const char *filename;
1785 cpp_buffer *new = xobnew (&pfile->buffer_ob, cpp_buffer);
1787 if (type == BUF_FAKE)
1789 /* A copy of the current buffer, just with a new name and type. */
1790 memcpy (new, pfile->buffer, sizeof (cpp_buffer));
1791 new->type = BUF_FAKE;
1795 if (type == BUF_BUILTIN)
1796 filename = _("<builtin>");
1797 else if (type == BUF_CL_OPTION)
1798 filename = _("<command line>");
1799 else if (type == BUF_PRAGMA)
1800 filename = "<_Pragma>";
1802 /* Clears, amongst other things, if_stack and mi_cmacro. */
1803 memset (new, 0, sizeof (cpp_buffer));
1805 new->line_base = new->buf = new->cur = buffer;
1806 new->rlimit = buffer + len;
1809 /* No read ahead or extra char initially. */
1810 new->read_ahead = EOF;
1811 new->extra_char = EOF;
1813 /* Preprocessed files, builtins, _Pragma and command line
1814 options don't do trigraph and escaped newline processing. */
1815 new->from_stage3 = type != BUF_FILE || CPP_OPTION (pfile, preprocessed);
1817 pfile->lexer_pos.output_line = 1;
1820 if (*filename == '\0')
1821 new->nominal_fname = _("<stdin>");
1823 new->nominal_fname = filename;
1825 new->prev = pfile->buffer;
1827 new->include_stack_listed = 0;
1829 new->return_at_eof = return_at_eof;
1831 pfile->state.next_bol = 1;
1832 pfile->buffer_stack_depth++;
1833 pfile->buffer = new;
1838 /* If called from do_line, pops a single buffer. Otherwise pops all
1839 buffers until a real file is reached. Generates appropriate
1842 _cpp_pop_buffer (pfile)
1846 struct if_stack *ifs;
1850 buffer = pfile->buffer;
1851 /* Walk back up the conditional stack till we reach its level at
1852 entry to this file, issuing error messages. */
1853 for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
1854 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1855 "unterminated #%s", dtable[ifs->type].name);
1857 if (buffer->type == BUF_FAKE)
1858 buffer->prev->cur = buffer->cur;
1859 else if (buffer->type == BUF_FILE)
1860 _cpp_pop_file_buffer (pfile, buffer);
1862 pfile->buffer = buffer->prev;
1863 pfile->buffer_stack_depth--;
1865 /* Callbacks only generated for faked or real files. */
1866 if (buffer->type != BUF_FILE && buffer->type != BUF_FAKE)
1869 /* No callback for EOF of last file. */
1873 /* do_line does its own call backs. */
1874 pfile->buffer->include_stack_listed = 0;
1875 if (pfile->directive == &dtable[T_LINE])
1878 pfile->line--; /* We have a '\n' at the end of #include. */
1879 _cpp_do_file_change (pfile, LC_LEAVE);
1880 if (pfile->buffer->type == BUF_FILE)
1883 cpp_warning (pfile, "file \"%s\" entered but not left",
1884 buffer->nominal_fname);
1887 obstack_free (&pfile->buffer_ob, buffer);
1889 pfile->state.skipping = 0; /* In case missing #endif. */
1893 _cpp_init_directives (pfile)
1899 /* Register the directives. */
1900 for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
1902 node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
1903 node->directive_index = i + 1;