1 /* CPP Library. (Directive handling.)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 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. */
31 /* Chained list of answers to an assertion. */
39 /* Stack of conditionals currently in progress
40 (including both successful and failing conditionals). */
44 struct if_stack *next;
45 cpp_lexer_pos pos; /* line and column where condition started */
46 const cpp_hashnode *mi_cmacro;/* macro name for #ifndef around entire file */
47 int was_skipping; /* value of pfile->skipping before this if */
48 int type; /* type of last directive seen in this group */
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 run_directive PARAMS ((cpp_reader *, int,
87 static int glue_header_name PARAMS ((cpp_reader *, cpp_token *));
88 static int parse_include PARAMS ((cpp_reader *, cpp_token *));
89 static void push_conditional PARAMS ((cpp_reader *, int, int,
90 const cpp_hashnode *));
91 static int read_line_number PARAMS ((cpp_reader *, int *));
92 static int strtoul_for_line PARAMS ((const U_CHAR *, unsigned int,
94 static void do_diagnostic PARAMS ((cpp_reader *, enum error_type));
96 lex_macro_node PARAMS ((cpp_reader *));
97 static void unwind_if_stack PARAMS ((cpp_reader *, cpp_buffer *));
98 static void do_pragma_once PARAMS ((cpp_reader *));
99 static void do_pragma_poison PARAMS ((cpp_reader *));
100 static void do_pragma_system_header PARAMS ((cpp_reader *));
101 static void do_pragma_dependency PARAMS ((cpp_reader *));
102 static int get__Pragma_string PARAMS ((cpp_reader *, cpp_token *));
103 static unsigned char *destringize PARAMS ((const cpp_string *,
105 static int parse_answer PARAMS ((cpp_reader *, struct answer **, int));
106 static cpp_hashnode *parse_assertion PARAMS ((cpp_reader *, struct answer **,
108 static struct answer ** find_answer PARAMS ((cpp_hashnode *,
109 const struct answer *));
110 static void handle_assertion PARAMS ((cpp_reader *, const char *, int));
112 /* This is the table of directive handlers. It is ordered by
113 frequency of occurrence; the numbers at the end are directive
114 counts from all the source code I have lying around (egcs and libc
115 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
116 pcmcia-cs-3.0.9). This is no longer important as directive lookup
117 is now O(1). All extensions other than #warning and #include_next
118 are deprecated. The name is where the extension appears to have
121 #define DIRECTIVE_TABLE \
122 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
123 D(include, T_INCLUDE, KANDR, INCL) /* 52262 */ \
124 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
125 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
126 D(if, T_IF, KANDR, COND | IF_COND) /* 18162 */ \
127 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
128 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
129 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
130 D(line, T_LINE, KANDR, IN_I) /* 2465 */ \
131 D(elif, T_ELIF, KANDR, COND) /* 610 */ \
132 D(error, T_ERROR, STDC89, 0) /* 475 */ \
133 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
134 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
135 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL) /* 19 */ \
136 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
137 D(import, T_IMPORT, EXTENSION, INCL) /* 0 ObjC */ \
138 D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
139 D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
140 SCCS_ENTRY /* 0 SVR4? */
142 /* #sccs is not always recognized. */
143 #ifdef SCCS_DIRECTIVE
144 # define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION, 0)
146 # define SCCS_ENTRY /* nothing */
149 /* Use the table to generate a series of prototypes, an enum for the
150 directive names, and an array of directive handlers. */
152 /* The directive-processing functions are declared to return int
153 instead of void, because some old compilers have trouble with
154 pointers to functions returning void. */
156 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
157 #define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
161 #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 stacked contexts. */
189 while (pfile->context != &pfile->base_context)
190 _cpp_pop_context (pfile);
192 /* Sweep up all tokens remaining on the line. We need to read
193 tokens from lookahead, but cannot just drop the lookahead buffers
194 because they may be saving tokens prior to this directive for an
195 external client. So we use _cpp_get_token, with macros disabled. */
196 pfile->state.prevent_expansion++;
197 while (!pfile->state.next_bol)
198 _cpp_get_token (pfile, &token);
199 pfile->state.prevent_expansion--;
202 /* Ensure there are no stray tokens at the end of a directive. */
207 if (!pfile->state.next_bol)
211 _cpp_lex_token (pfile, &token);
212 if (token.type != CPP_EOF)
213 cpp_pedwarn (pfile, "extra tokens at end of #%s directive",
214 pfile->directive->name);
218 /* Check if a token's name matches that of a known directive. Put in
219 this file to save exporting dtable and other unneeded information. */
221 _cpp_handle_directive (pfile, indented)
225 const directive *dir = 0;
229 /* Some handlers need the position of the # for diagnostics. */
230 pfile->directive_pos = pfile->lexer_pos;
232 /* We're now in a directive. This ensures we get pedantic warnings
233 about /v and /f in whitespace. */
234 pfile->state.in_directive = 1;
235 pfile->state.save_comments = 0;
237 /* Lex the directive name directly. */
238 _cpp_lex_token (pfile, &dname);
240 if (dname.type == CPP_NAME)
242 unsigned int index = dname.val.node->directive_index;
244 dir = &dtable[index - 1];
246 else if (dname.type == CPP_NUMBER)
248 /* # followed by a number is equivalent to #line. Do not
249 recognize this form in assembly language source files or
250 skipped conditional groups. Complain about this form if
251 we're being pedantic, but not if this is regurgitated input
252 (preprocessed or fed back in by the C++ frontend). */
253 if (!pfile->skipping && !CPP_OPTION (pfile, lang_asm))
255 dir = &dtable[T_LINE];
256 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
257 if (CPP_PEDANTIC (pfile) && CPP_BUFFER (pfile)->inc
258 && ! CPP_OPTION (pfile, preprocessed))
259 cpp_pedwarn (pfile, "# followed by integer");
263 pfile->directive = dir;
266 /* Make sure we lex headers correctly, whether skipping or not. */
267 pfile->state.angled_headers = dir->flags & INCL;
269 /* If we are rescanning preprocessed input, only directives tagged
270 with IN_I are honored, and the warnings below are suppressed. */
271 if (! CPP_OPTION (pfile, preprocessed) || dir->flags & IN_I)
273 /* Traditionally, a directive is ignored unless its # is in
274 column 1. Therefore in code intended to work with K+R
275 compilers, directives added by C89 must have their #
276 indented, and directives present in traditional C must
277 not. This is true even of directives in skipped
278 conditional blocks. */
279 if (CPP_WTRADITIONAL (pfile))
281 if (indented && dir->origin == KANDR)
283 "traditional C ignores #%s with the # indented",
285 else if (!indented && dir->origin != KANDR)
287 "suggest hiding #%s from traditional C with an indented #",
291 /* If we are skipping a failed conditional group, all
292 non-conditional directives are ignored. */
293 if (!pfile->skipping || (dir->flags & COND))
295 /* Issue -pedantic warnings for extensions. */
296 if (CPP_PEDANTIC (pfile) && dir->origin == EXTENSION)
297 cpp_pedwarn (pfile, "#%s is a GCC extension", dir->name);
299 /* If we have a directive that is not an opening
300 conditional, invalidate any control macro. */
301 if (! (dir->flags & IF_COND))
302 pfile->mi_state = MI_FAILED;
304 (*dir->handler) (pfile);
308 else if (dname.type == CPP_EOF)
310 /* The null directive. */
311 if (indented && CPP_WTRADITIONAL (pfile))
312 cpp_warning (pfile, "traditional C ignores #\\n with the # indented");
316 /* An unknown directive. Don't complain about it in assembly
317 source: we don't know where the comments are, and # may
318 introduce assembler pseudo-ops. Don't complain about invalid
319 directives in skipped conditional groups (6.10 p4). */
320 if (CPP_OPTION (pfile, lang_asm))
322 /* Output the # and lookahead token for the assembler. */
324 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
326 else if (!pfile->skipping)
327 cpp_error (pfile, "invalid preprocessing directive #%s",
328 cpp_token_as_text (pfile, &dname));
331 /* Save the lookahead token for assembler. */
333 skip_rest_of_line (pfile);
334 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
335 pfile->state.in_directive = 0;
336 pfile->state.angled_headers = 0;
337 pfile->directive = 0;
342 /* Directive handler wrapper used by the command line option
345 run_directive (pfile, dir_no, buf, count, name)
352 unsigned int output_line = pfile->lexer_pos.output_line;
354 if (cpp_push_buffer (pfile, (const U_CHAR *) buf, count) != NULL)
356 const struct directive *dir = &dtable[dir_no], *orig_dir;
357 unsigned char orig_in_directive;
360 CPP_BUFFER (pfile)->nominal_fname = name;
362 CPP_BUFFER (pfile)->nominal_fname = _("<command line>");
364 /* A kludge to avoid line markers for _Pragma. */
365 if (dir_no == T_PRAGMA)
366 pfile->lexer_pos.output_line = output_line;
368 /* Save any in-process directive; _Pragma can appear in one. */
369 orig_dir = pfile->directive;
370 orig_in_directive = pfile->state.in_directive;
372 /* For _Pragma, the text is passed through preprocessing stage 3
373 only, i.e. no trigraphs, no escaped newline removal, and no
374 macro expansion. Do the same for command-line directives. */
375 pfile->buffer->from_stage3 = 1;
376 pfile->state.in_directive = 1;
377 pfile->directive = dir;
378 pfile->state.prevent_expansion++;
379 (void) (*dir->handler) (pfile);
380 pfile->state.prevent_expansion--;
381 pfile->directive = orig_dir;
382 pfile->state.in_directive = orig_in_directive;
384 skip_rest_of_line (pfile);
385 if (pfile->buffer->cur != pfile->buffer->rlimit)
386 cpp_error (pfile, "extra text after end of #%s directive",
387 dtable[dir_no].name);
388 cpp_pop_buffer (pfile);
392 /* Checks for validity the macro name in #define, #undef, #ifdef and
393 #ifndef directives. */
394 static cpp_hashnode *
395 lex_macro_node (pfile)
400 /* Lex the macro name directly. */
401 _cpp_lex_token (pfile, &token);
403 /* The token immediately after #define must be an identifier. That
404 identifier is not allowed to be "defined". See predefined macro
405 names (6.10.8.4). In C++, it is not allowed to be any of the
406 <iso646.h> macro names (which are keywords in C++) either. */
408 if (token.type != CPP_NAME)
410 if (token.type == CPP_EOF)
411 cpp_error (pfile, "no macro name given in #%s directive",
412 pfile->directive->name);
413 else if (token.flags & NAMED_OP)
415 "\"%s\" cannot be used as a macro name as it is an operator in C++",
416 token.val.node->name);
418 cpp_error (pfile, "macro names must be identifiers");
422 cpp_hashnode *node = token.val.node;
424 /* In Objective C, some keywords begin with '@', but general
425 identifiers do not, and you're not allowed to #define them. */
426 if (node == pfile->spec_nodes.n_defined || node->name[0] == '@')
427 cpp_error (pfile, "\"%s\" cannot be used as a macro name", node->name);
428 else if (!(node->flags & NODE_POISONED))
435 /* Process a #define directive. Most work is done in cppmacro.c. */
440 cpp_hashnode *node = lex_macro_node (pfile);
444 /* Use the permanent pool for storage. */
445 pfile->string_pool = &pfile->ident_pool;
447 if (_cpp_create_definition (pfile, node))
448 if (pfile->cb.define)
449 (*pfile->cb.define) (pfile, node);
451 /* Revert to the temporary pool. */
452 pfile->string_pool = &pfile->temp_string_pool;
456 /* Handle #undef. Marks the identifier NT_VOID in the hash table. */
461 cpp_hashnode *node = lex_macro_node (pfile);
463 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
464 is not currently defined as a macro name. */
465 if (node && node->type == NT_MACRO)
468 (*pfile->cb.undef) (pfile, node);
470 if (node->flags & NODE_BUILTIN)
471 cpp_warning (pfile, "undefining \"%s\"", node->name);
473 _cpp_free_definition (node);
478 /* Helper routine used by parse_include. Reinterpret the current line
479 as an h-char-sequence (< ... >); we are looking at the first token
480 after the <. Returns zero on success. */
482 glue_header_name (pfile, header)
487 unsigned char *buffer, *token_mem;
488 size_t len, total_len = 0, capacity = 1024;
490 /* To avoid lexed tokens overwriting our glued name, we can only
491 allocate from the string pool once we've lexed everything. */
493 buffer = (unsigned char *) xmalloc (capacity);
496 _cpp_get_token (pfile, &token);
498 if (token.type == CPP_GREATER || token.type == CPP_EOF)
501 len = cpp_token_len (&token);
502 if (total_len + len > capacity)
504 capacity = (capacity + len) * 2;
505 buffer = (unsigned char *) realloc (buffer, capacity);
508 if (token.flags & PREV_WHITE)
509 buffer[total_len++] = ' ';
511 total_len = cpp_spell_token (pfile, &token, &buffer[total_len]) - buffer;
514 if (token.type == CPP_EOF)
515 cpp_error (pfile, "missing terminating > character");
518 token_mem = _cpp_pool_alloc (pfile->string_pool, total_len);
519 memcpy (token_mem, buffer, total_len);
521 header->type = CPP_HEADER_NAME;
522 header->flags &= ~PREV_WHITE;
523 header->val.str.len = total_len;
524 header->val.str.text = token_mem;
528 return token.type == CPP_EOF;
531 /* Parse the header name of #include, #include_next, #import and
532 #pragma dependency. Returns zero on success. */
534 parse_include (pfile, header)
538 int is_pragma = pfile->directive == &dtable[T_PRAGMA];
539 const unsigned char *dir;
542 dir = U"pragma dependency";
544 dir = pfile->directive->name;
546 /* Allow macro expansion. */
547 cpp_get_token (pfile, header);
548 if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
550 if (header->type != CPP_LESS)
552 cpp_error (pfile, "#%s expects \"FILENAME\" or <FILENAME>", dir);
555 if (glue_header_name (pfile, header))
559 if (header->val.str.len == 0)
561 cpp_error (pfile, "empty file name in #%s", dir);
568 /* Get out of macro context, if we are. */
569 skip_rest_of_line (pfile);
570 if (pfile->cb.include)
571 (*pfile->cb.include) (pfile, dir, header);
583 if (!parse_include (pfile, &header))
584 _cpp_execute_include (pfile, &header, 0, 0);
593 if (!pfile->import_warning && CPP_OPTION (pfile, warn_import))
595 pfile->import_warning = 1;
597 "#import is obsolete, use an #ifndef wrapper in the header file");
600 if (!parse_include (pfile, &header))
601 _cpp_execute_include (pfile, &header, 1, 0);
605 do_include_next (pfile)
609 struct file_name_list *search_start = 0;
611 if (parse_include (pfile, &header))
614 /* For #include_next, skip in the search path past the dir in which
615 the current file was found. If this is the last directory in the
616 search path, don't include anything. If the current file was
617 specified with an absolute path, use the normal search logic. If
618 this is the primary source file, use the normal search logic and
619 generate a warning. */
620 if (CPP_PREV_BUFFER (CPP_BUFFER (pfile)))
622 if (CPP_BUFFER (pfile)->inc->foundhere)
624 search_start = CPP_BUFFER (pfile)->inc->foundhere->next;
630 cpp_warning (pfile, "#include_next in primary source file");
632 _cpp_execute_include (pfile, &header, 0, search_start);
635 /* Subroutine of do_line. Read next token from PFILE without adding it to
636 the output buffer. If it is a number between 1 and 4, store it in *NUM
637 and return 1; otherwise, return 0 and complain if we aren't at the end
641 read_line_number (pfile, num)
648 _cpp_lex_token (pfile, &token);
649 if (token.type == CPP_NUMBER && token.val.str.len == 1)
651 val = token.val.str.text[0] - '1';
659 if (token.type != CPP_EOF)
660 cpp_error (pfile, "invalid format #line");
664 /* Another subroutine of do_line. Convert a number in STR, of length
665 LEN, to binary; store it in NUMP, and return 0 if the number was
666 well-formed, 1 if not. Temporary, hopefully. */
668 strtoul_for_line (str, len, nump)
673 unsigned long reg = 0;
687 /* Interpret #line command.
688 Note that the filename string (if any) is treated as if it were an
689 include filename. That means no escape handling. */
695 cpp_buffer *ip = CPP_BUFFER (pfile);
696 unsigned long new_lineno;
697 /* C99 raised the minimum limit on #line numbers. */
698 unsigned int cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
699 int enter = 0, leave = 0, rename = 0;
702 /* #line commands expand macros. */
703 _cpp_get_token (pfile, &token);
704 if (token.type != CPP_NUMBER
705 || strtoul_for_line (token.val.str.text, token.val.str.len, &new_lineno))
707 cpp_error (pfile, "\"%s\" after #line is not a positive integer",
708 cpp_token_as_text (pfile, &token));
712 if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
713 cpp_pedwarn (pfile, "line number out of range");
715 _cpp_get_token (pfile, &token);
717 if (token.type != CPP_EOF)
721 int action_number = 0;
723 if (token.type != CPP_STRING)
725 cpp_error (pfile, "\"%s\" is not a valid filename",
726 cpp_token_as_text (pfile, &token));
730 len = token.val.str.len;
731 fname = alloca (len + 1);
732 memcpy (fname, token.val.str.text, len);
735 if (strcmp (fname, ip->nominal_fname))
738 if (!strcmp (fname, ip->inc->name))
739 ip->nominal_fname = ip->inc->name;
741 ip->nominal_fname = _cpp_fake_include (pfile, fname);
744 if (read_line_number (pfile, &action_number) != 0)
746 if (! CPP_OPTION (pfile, preprocessed) && CPP_PEDANTIC (pfile))
747 cpp_pedwarn (pfile, "extra tokens at end of #line directive");
749 if (action_number == 1)
752 cpp_make_system_header (pfile, ip, 0);
753 read_line_number (pfile, &action_number);
755 else if (action_number == 2)
758 cpp_make_system_header (pfile, ip, 0);
759 read_line_number (pfile, &action_number);
761 if (action_number == 3)
763 cpp_make_system_header (pfile, ip, 1);
764 read_line_number (pfile, &action_number);
766 if (action_number == 4)
768 cpp_make_system_header (pfile, ip, 2);
769 read_line_number (pfile, &action_number);
775 /* Our line number is incremented after the directive is processed. */
776 ip->lineno = new_lineno - 1;
777 pfile->lexer_pos.output_line = ip->lineno;
778 if (enter && pfile->cb.enter_file)
779 (*pfile->cb.enter_file) (pfile);
780 if (leave && pfile->cb.leave_file)
781 (*pfile->cb.leave_file) (pfile);
782 if (rename && pfile->cb.rename_file)
783 (*pfile->cb.rename_file) (pfile);
787 * Report a warning or error detected by the program we are
788 * processing. Use the directive's tokens in the error message.
792 do_diagnostic (pfile, code)
794 enum error_type code;
796 if (_cpp_begin_message (pfile, code, NULL, 0))
798 fprintf (stderr, "#%s ", pfile->directive->name);
799 pfile->state.prevent_expansion++;
800 cpp_output_line (pfile, stderr);
801 pfile->state.prevent_expansion--;
809 do_diagnostic (pfile, ERROR);
816 do_diagnostic (pfile, WARNING);
819 /* Report program identification. */
827 _cpp_get_token (pfile, &str);
828 if (str.type != CPP_STRING)
829 cpp_error (pfile, "invalid #ident");
830 else if (pfile->cb.ident)
831 (*pfile->cb.ident) (pfile, &str.val.str);
836 /* Pragmata handling. We handle some of these, and pass the rest on
837 to the front end. C99 defines three pragmas and says that no macro
838 expansion is to be performed on them; whether or not macro
839 expansion happens for other pragmas is implementation defined.
840 This implementation never macro-expands the text after #pragma. */
842 /* Sub-handlers for the pragmas needing treatment here.
843 They return 1 if the token buffer is to be popped, 0 if not. */
846 struct pragma_entry *next;
851 void (*handler) PARAMS ((cpp_reader *));
852 struct pragma_entry *space;
857 cpp_register_pragma (pfile, space, name, handler)
861 void (*handler) PARAMS ((cpp_reader *));
863 struct pragma_entry **x, *new;
869 struct pragma_entry *p = pfile->pragmas;
870 len = strlen (space);
873 if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
880 cpp_ice (pfile, "unknown #pragma namespace %s", space);
885 new = xnew (struct pragma_entry);
887 new->len = strlen (name);
889 new->u.handler = handler;
896 cpp_register_pragma_space (pfile, space)
900 struct pragma_entry *new;
901 const struct pragma_entry *p = pfile->pragmas;
902 size_t len = strlen (space);
906 if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
907 /* Multiple different callers are allowed to register the same
913 new = xnew (struct pragma_entry);
919 new->next = pfile->pragmas;
920 pfile->pragmas = new;
924 _cpp_init_internal_pragmas (pfile)
928 cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
929 cpp_register_pragma (pfile, 0, "once", do_pragma_once);
932 cpp_register_pragma_space (pfile, "GCC");
934 cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
935 cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
936 cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
943 const struct pragma_entry *p;
945 const cpp_hashnode *node;
951 pfile->state.prevent_expansion++;
952 cpp_start_lookahead (pfile);
955 cpp_get_token (pfile, &tok);
956 if (tok.type == CPP_NAME)
963 if (strlen (p->name) == len && !memcmp (p->name, name, len))
972 (*p->u.handler) (pfile);
981 cpp_stop_lookahead (pfile, drop);
982 pfile->state.prevent_expansion--;
984 if (!drop && pfile->cb.def_pragma)
985 (*pfile->cb.def_pragma) (pfile);
989 do_pragma_once (pfile)
992 cpp_buffer *ip = CPP_BUFFER (pfile);
994 cpp_warning (pfile, "#pragma once is obsolete");
996 if (CPP_PREV_BUFFER (ip) == NULL)
997 cpp_warning (pfile, "#pragma once in main file");
999 ip->inc->cmacro = NEVER_REREAD;
1005 do_pragma_poison (pfile)
1008 /* Poison these symbols so that all subsequent usage produces an
1013 pfile->state.poisoned_ok = 1;
1016 _cpp_lex_token (pfile, &tok);
1017 if (tok.type == CPP_EOF)
1019 if (tok.type != CPP_NAME)
1021 cpp_error (pfile, "invalid #pragma GCC poison directive");
1026 if (hp->flags & NODE_POISONED)
1029 if (hp->type == NT_MACRO)
1030 cpp_warning (pfile, "poisoning existing macro \"%s\"", hp->name);
1031 _cpp_free_definition (hp);
1032 hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1034 pfile->state.poisoned_ok = 0;
1036 #if 0 /* Doesn't quite work yet. */
1037 if (tok.type == CPP_EOF && pfile->cb.poison)
1038 (*pfile->cb.poison) (pfile);
1042 /* Mark the current header as a system header. This will suppress
1043 some categories of warnings (notably those from -pedantic). It is
1044 intended for use in system libraries that cannot be implemented in
1045 conforming C, but cannot be certain that their headers appear in a
1046 system include directory. To prevent abuse, it is rejected in the
1047 primary source file. */
1049 do_pragma_system_header (pfile)
1052 cpp_buffer *ip = CPP_BUFFER (pfile);
1053 if (CPP_PREV_BUFFER (ip) == NULL)
1054 cpp_warning (pfile, "#pragma system_header outside include file");
1056 cpp_make_system_header (pfile, ip, 1);
1061 /* Check the modified date of the current include file against a specified
1062 file. Issue a diagnostic, if the specified file is newer. We use this to
1063 determine if a fixed header should be refixed. */
1065 do_pragma_dependency (pfile)
1068 cpp_token header, msg;
1071 if (parse_include (pfile, &header))
1074 ordering = _cpp_compare_file_date (pfile, &header);
1076 cpp_warning (pfile, "cannot find source %s",
1077 cpp_token_as_text (pfile, &header));
1078 else if (ordering > 0)
1080 cpp_warning (pfile, "current file is older than %s",
1081 cpp_token_as_text (pfile, &header));
1082 cpp_start_lookahead (pfile);
1083 cpp_get_token (pfile, &msg);
1084 cpp_stop_lookahead (pfile, msg.type == CPP_EOF);
1085 if (msg.type != CPP_EOF && _cpp_begin_message (pfile, WARNING, NULL, 0))
1086 cpp_output_line (pfile, stderr);
1090 /* Check syntax is "(string-literal)". Returns 0 on success. */
1092 get__Pragma_string (pfile, string)
1098 cpp_get_token (pfile, &paren);
1099 if (paren.type != CPP_OPEN_PAREN)
1102 cpp_get_token (pfile, string);
1103 if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1106 cpp_get_token (pfile, &paren);
1107 return paren.type != CPP_CLOSE_PAREN;
1110 /* Returns a malloced buffer containing a destringized cpp_string by
1111 removing the first \ of \" and \\ sequences. */
1112 static unsigned char *
1113 destringize (in, len)
1114 const cpp_string *in;
1117 const unsigned char *src, *limit;
1118 unsigned char *dest, *result;
1120 dest = result = (unsigned char *) xmalloc (in->len);
1121 for (src = in->text, limit = src + in->len; src < limit;)
1123 /* We know there is a character following the backslash. */
1124 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1129 *len = dest - result;
1134 _cpp_do__Pragma (pfile)
1138 unsigned char *buffer;
1141 if (get__Pragma_string (pfile, &string))
1143 cpp_error (pfile, "_Pragma takes a parenthesized string literal");
1147 buffer = destringize (&string.val.str, &len);
1148 run_directive (pfile, T_PRAGMA, (char *) buffer, len, _("<_Pragma>"));
1149 free ((PTR) buffer);
1152 /* Just ignore #sccs, on systems where we define it at all. */
1153 #ifdef SCCS_DIRECTIVE
1156 cpp_reader *pfile ATTRIBUTE_UNUSED;
1167 if (! pfile->skipping)
1169 const cpp_hashnode *node = lex_macro_node (pfile);
1172 skip = node->type != NT_MACRO;
1175 push_conditional (pfile, skip, T_IFDEF, 0);
1183 const cpp_hashnode *node = 0;
1185 if (! pfile->skipping)
1187 node = lex_macro_node (pfile);
1189 skip = node->type == NT_MACRO;
1192 push_conditional (pfile, skip, T_IFNDEF, node);
1195 /* #if cooperates with parse_defined to handle multiple-include
1196 optimisations. If macro expansions or identifiers appear in the
1197 expression, we cannot treat it as a controlling conditional, since
1198 their values could change in the future. */
1205 const cpp_hashnode *cmacro = 0;
1207 if (!pfile->skipping)
1209 /* Controlling macro of #if ! defined () */
1210 pfile->mi_ind_cmacro = 0;
1211 skip = _cpp_parse_expr (pfile) == 0;
1212 cmacro = pfile->mi_ind_cmacro;
1215 push_conditional (pfile, skip, T_IF, cmacro);
1218 /* #else flips pfile->skipping and continues without changing
1219 if_stack; this is so that the error message for missing #endif's
1220 etc. will point to the original #if. */
1226 struct if_stack *ifs = CPP_BUFFER (pfile)->if_stack;
1229 cpp_error (pfile, "#else without #if");
1232 if (ifs->type == T_ELSE)
1234 cpp_error (pfile, "#else after #else");
1235 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1236 "the conditional began here");
1239 /* Invalidate any controlling macro. */
1243 if (! ifs->was_skipping)
1245 /* If pfile->skipping is 2, one of the blocks in an #if
1246 #elif ... chain succeeded, so we skip the else block. */
1247 if (pfile->skipping < 2)
1248 pfile->skipping = ! pfile->skipping;
1255 /* handle a #elif directive by not changing if_stack either. see the
1256 comment above do_else. */
1262 struct if_stack *ifs = CPP_BUFFER (pfile)->if_stack;
1266 cpp_error (pfile, "#elif without #if");
1270 if (ifs->type == T_ELSE)
1272 cpp_error (pfile, "#elif after #else");
1273 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1274 "the conditional began here");
1277 /* Invalidate any controlling macro. */
1281 if (ifs->was_skipping)
1282 return; /* Don't evaluate a nested #if */
1284 if (pfile->skipping != 1)
1286 pfile->skipping = 2; /* one block succeeded, so don't do any others */
1290 pfile->skipping = ! _cpp_parse_expr (pfile);
1293 /* #endif pops the if stack and resets pfile->skipping. */
1299 struct if_stack *ifs = CPP_BUFFER (pfile)->if_stack;
1302 cpp_error (pfile, "#endif without #if");
1305 /* If potential control macro, we go back outside again. */
1306 if (ifs->next == 0 && ifs->mi_cmacro)
1308 pfile->mi_state = MI_OUTSIDE;
1309 pfile->mi_cmacro = ifs->mi_cmacro;
1312 CPP_BUFFER (pfile)->if_stack = ifs->next;
1313 pfile->skipping = ifs->was_skipping;
1314 obstack_free (pfile->buffer_ob, ifs);
1320 /* Push an if_stack entry and set pfile->skipping accordingly.
1321 If this is a #ifndef starting at the beginning of a file,
1322 CMACRO is the macro name tested by the #ifndef. */
1325 push_conditional (pfile, skip, type, cmacro)
1329 const cpp_hashnode *cmacro;
1331 struct if_stack *ifs;
1333 ifs = xobnew (pfile->buffer_ob, struct if_stack);
1334 ifs->pos = pfile->directive_pos;
1335 ifs->next = CPP_BUFFER (pfile)->if_stack;
1336 ifs->was_skipping = pfile->skipping;
1338 if (pfile->mi_state == MI_OUTSIDE && pfile->mi_cmacro == 0)
1339 ifs->mi_cmacro = cmacro;
1343 if (!pfile->skipping)
1344 pfile->skipping = skip;
1346 CPP_BUFFER (pfile)->if_stack = ifs;
1349 /* Called when we reach the end of a file. Walk back up the
1350 conditional stack till we reach its level at entry to this file,
1351 issuing error messages. Then force skipping off. */
1353 unwind_if_stack (pfile, pbuf)
1357 struct if_stack *ifs;
1359 /* No need to free stack - they'll all go away with the buffer. */
1360 for (ifs = pbuf->if_stack; ifs; ifs = ifs->next)
1361 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1362 "unterminated #%s", dtable[ifs->type].name);
1364 pfile->skipping = 0;
1367 /* Read the tokens of the answer into the macro pool. Only commit the
1368 memory if we intend it as permanent storage, i.e. the #assert case.
1369 Returns 0 on success. */
1372 parse_answer (pfile, answerp, type)
1374 struct answer **answerp;
1377 cpp_token paren, *token;
1378 struct answer *answer;
1380 if (POOL_FRONT (&pfile->macro_pool) + sizeof (struct answer) >
1381 POOL_LIMIT (&pfile->macro_pool))
1382 _cpp_next_chunk (&pfile->macro_pool, sizeof (struct answer), 0);
1383 answer = (struct answer *) POOL_FRONT (&pfile->macro_pool);
1386 /* In a conditional, it is legal to not have an open paren. We
1387 should save the following token in this case. */
1389 cpp_start_lookahead (pfile);
1390 cpp_get_token (pfile, &paren);
1392 cpp_stop_lookahead (pfile, paren.type == CPP_OPEN_PAREN);
1394 /* If not a paren, see if we're OK. */
1395 if (paren.type != CPP_OPEN_PAREN)
1397 /* In a conditional no answer is a test for any answer. It
1398 could be followed by any token. */
1402 /* #unassert with no answer is valid - it removes all answers. */
1403 if (type == T_UNASSERT && paren.type == CPP_EOF)
1406 cpp_error (pfile, "missing '(' after predicate");
1412 token = &answer->first[answer->count];
1413 /* Check we have room for the token. */
1414 if ((unsigned char *) (token + 1) >= POOL_LIMIT (&pfile->macro_pool))
1416 _cpp_next_chunk (&pfile->macro_pool, sizeof (cpp_token),
1417 (unsigned char **) &answer);
1418 token = &answer->first[answer->count];
1421 _cpp_get_token (pfile, token);
1422 if (token->type == CPP_CLOSE_PAREN)
1425 if (token->type == CPP_EOF)
1427 cpp_error (pfile, "missing ')' to complete answer");
1433 if (answer->count == 0)
1435 cpp_error (pfile, "predicate's answer is empty");
1439 /* Drop whitespace at start. */
1440 answer->first->flags &= ~PREV_WHITE;
1443 if (type == T_ASSERT || type == T_UNASSERT)
1448 /* Parses an assertion, returning a pointer to the hash node of the
1449 predicate, or 0 on error. If an answer was supplied, it is placed
1450 in ANSWERP, otherwise it is set to 0. We use _cpp_get_raw_token,
1451 since we cannot assume tokens are consecutive in a #if statement
1452 (we may be in a macro), and we don't want to macro expand. */
1453 static cpp_hashnode *
1454 parse_assertion (pfile, answerp, type)
1456 struct answer **answerp;
1459 cpp_hashnode *result = 0;
1460 cpp_token predicate;
1462 /* We don't expand predicates or answers. */
1463 pfile->state.prevent_expansion++;
1465 /* Use the permanent pool for storage (for the answers). */
1466 pfile->string_pool = &pfile->ident_pool;
1469 _cpp_get_token (pfile, &predicate);
1470 if (predicate.type == CPP_EOF)
1471 cpp_error (pfile, "assertion without predicate");
1472 else if (predicate.type != CPP_NAME)
1473 cpp_error (pfile, "predicate must be an identifier");
1474 else if (parse_answer (pfile, answerp, type) == 0)
1476 unsigned int len = predicate.val.node->length;
1477 unsigned char *sym = alloca (len + 1);
1479 /* Prefix '#' to get it out of macro namespace. */
1481 memcpy (sym + 1, predicate.val.node->name, len);
1482 result = cpp_lookup (pfile, sym, len + 1);
1485 pfile->string_pool = &pfile->temp_string_pool;
1486 pfile->state.prevent_expansion--;
1490 /* Returns a pointer to the pointer to the answer in the answer chain,
1491 or a pointer to NULL if the answer is not in the chain. */
1492 static struct answer **
1493 find_answer (node, candidate)
1495 const struct answer *candidate;
1498 struct answer **result;
1500 for (result = &node->value.answers; *result; result = &(*result)->next)
1502 struct answer *answer = *result;
1504 if (answer->count == candidate->count)
1506 for (i = 0; i < answer->count; i++)
1507 if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1510 if (i == answer->count)
1518 /* Test an assertion within a preprocessor conditional. Returns
1519 non-zero on failure, zero on success. On success, the result of
1520 the test is written into VALUE. */
1522 _cpp_test_assertion (pfile, value)
1526 struct answer *answer;
1529 node = parse_assertion (pfile, &answer, T_IF);
1531 *value = (node->type == NT_ASSERTION &&
1532 (answer == 0 || *find_answer (node, answer) != 0));
1534 /* We don't commit the memory for the answer - it's temporary only. */
1542 struct answer *new_answer;
1545 node = parse_assertion (pfile, &new_answer, T_ASSERT);
1548 /* Place the new answer in the answer list. First check there
1549 is not a duplicate. */
1550 new_answer->next = 0;
1551 if (node->type == NT_ASSERTION)
1553 if (*find_answer (node, new_answer))
1555 cpp_warning (pfile, "\"%s\" re-asserted", node->name + 1);
1558 new_answer->next = node->value.answers;
1560 node->type = NT_ASSERTION;
1561 node->value.answers = new_answer;
1562 POOL_COMMIT (&pfile->macro_pool, (sizeof (struct answer)
1563 + (new_answer->count - 1)
1564 * sizeof (cpp_token)));
1573 struct answer *answer;
1575 node = parse_assertion (pfile, &answer, T_UNASSERT);
1576 /* It isn't an error to #unassert something that isn't asserted. */
1577 if (node && node->type == NT_ASSERTION)
1581 struct answer **p = find_answer (node, answer), *temp;
1583 /* Remove the answer from the list. */
1588 /* Did we free the last answer? */
1589 if (node->value.answers == 0)
1590 node->type = NT_VOID;
1593 _cpp_free_definition (node);
1596 /* We don't commit the memory for the answer - it's temporary only. */
1599 /* These are for -D, -U, -A. */
1601 /* Process the string STR as if it appeared as the body of a #define.
1602 If STR is just an identifier, define it with value 1.
1603 If STR has anything after the identifier, then it should
1604 be identifier=definition. */
1607 cpp_define (pfile, str)
1614 /* Copy the entire option so we can modify it.
1615 Change the first "=" in the string to a space. If there is none,
1616 tack " 1" on the end. */
1618 /* Length including the null. */
1619 count = strlen (str);
1620 buf = (char *) alloca (count + 2);
1621 memcpy (buf, str, count);
1623 p = strchr (str, '=');
1632 run_directive (pfile, T_DEFINE, buf, count, 0);
1635 /* Slight variant of the above for use by initialize_builtins, which (a)
1636 knows how to set up the buffer itself, (b) needs a different "filename"
1639 _cpp_define_builtin (pfile, str)
1643 run_directive (pfile, T_DEFINE, str, strlen (str), _("<builtin>"));
1646 /* Process MACRO as if it appeared as the body of an #undef. */
1648 cpp_undef (pfile, macro)
1652 run_directive (pfile, T_UNDEF, macro, strlen (macro), 0);
1655 /* Process the string STR as if it appeared as the body of a #assert. */
1657 cpp_assert (pfile, str)
1661 handle_assertion (pfile, str, T_ASSERT);
1664 /* Process STR as if it appeared as the body of an #unassert. */
1666 cpp_unassert (pfile, str)
1670 handle_assertion (pfile, str, T_UNASSERT);
1673 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1675 handle_assertion (pfile, str, type)
1680 size_t count = strlen (str);
1681 const char *p = strchr (str, '=');
1685 /* Copy the entire option so we can modify it. Change the first
1686 "=" in the string to a '(', and tack a ')' on the end. */
1687 char *buf = (char *) alloca (count + 1);
1689 memcpy (buf, str, count);
1695 run_directive (pfile, type, str, count, 0);
1698 /* Allocate a new cpp_buffer for PFILE, and push it on the input
1699 buffer stack. If BUFFER != NULL, then use the LENGTH characters in
1700 BUFFER as the new input buffer. Return the new buffer, or NULL on
1704 cpp_push_buffer (pfile, buffer, length)
1706 const U_CHAR *buffer;
1709 cpp_buffer *buf = CPP_BUFFER (pfile);
1711 if (++pfile->buffer_stack_depth == CPP_STACK_MAX)
1713 cpp_fatal (pfile, "#include nested too deeply");
1717 new = xobnew (pfile->buffer_ob, cpp_buffer);
1718 /* Clears, amongst other things, if_stack and mi_cmacro. */
1719 memset (new, 0, sizeof (cpp_buffer));
1721 pfile->lexer_pos.output_line = 1;
1722 new->line_base = new->buf = new->cur = buffer;
1723 new->rlimit = buffer + length;
1726 /* Preprocessed files don't do trigraph and escaped newline processing. */
1727 new->from_stage3 = CPP_OPTION (pfile, preprocessed);
1728 /* No read ahead or extra char initially. */
1729 new->read_ahead = EOF;
1730 new->extra_char = EOF;
1731 pfile->state.next_bol = 1;
1733 CPP_BUFFER (pfile) = new;
1738 cpp_pop_buffer (pfile)
1742 cpp_buffer *buf = CPP_BUFFER (pfile);
1744 unwind_if_stack (pfile, buf);
1745 wfb = (buf->inc != 0);
1747 _cpp_pop_file_buffer (pfile, buf);
1749 CPP_BUFFER (pfile) = CPP_PREV_BUFFER (buf);
1750 obstack_free (pfile->buffer_ob, buf);
1751 pfile->buffer_stack_depth--;
1753 if (CPP_BUFFER (pfile) && wfb && pfile->cb.leave_file)
1754 (*pfile->cb.leave_file) (pfile);
1756 return CPP_BUFFER (pfile);
1759 #define obstack_chunk_alloc xmalloc
1760 #define obstack_chunk_free free
1762 _cpp_init_stacks (pfile)
1768 pfile->buffer_ob = xnew (struct obstack);
1769 obstack_init (pfile->buffer_ob);
1771 /* Register the directives. */
1772 for (i = 1; i < N_DIRECTIVES; i++)
1774 node = cpp_lookup (pfile, dtable[i - 1].name, dtable[i - 1].length);
1775 node->directive_index = i;
1780 _cpp_cleanup_stacks (pfile)
1783 obstack_free (pfile->buffer_ob, 0);
1784 free (pfile->buffer_ob);