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. */
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 unsigned char 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 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_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,
169 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
170 #define D(name, t, origin, flags) \
171 { CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
172 sizeof STRINGX(name) - 1, origin, flags },
173 static const directive dtable[] =
178 #undef DIRECTIVE_TABLE
180 /* Skip any remaining tokens in a directive. */
182 skip_rest_of_line (pfile)
187 /* Discard all input lookaheads. */
188 while (pfile->la_read)
189 _cpp_release_lookahead (pfile);
191 /* Discard all stacked contexts. */
192 while (pfile->context != &pfile->base_context)
193 _cpp_pop_context (pfile);
195 /* Sweep up all tokens remaining on the line. */
196 pfile->state.prevent_expansion++;
197 while (!pfile->state.next_bol)
198 _cpp_lex_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 /* Called when entering a directive, _Pragma or command-line directive. */
220 start_directive (pfile)
223 cpp_buffer *buffer = pfile->buffer;
225 /* Setup in-directive state. */
226 pfile->state.in_directive = 1;
227 pfile->state.save_comments = 0;
229 /* Some handlers need the position of the # for diagnostics. */
230 pfile->directive_pos = pfile->lexer_pos;
232 /* Don't save directive tokens for external clients. */
233 pfile->la_saved = pfile->la_write;
236 /* Turn off skipping. */
237 buffer->was_skipping = pfile->skipping;
241 /* Called when leaving a directive, _Pragma or command-line directive. */
243 end_directive (pfile, skip_line)
247 cpp_buffer *buffer = pfile->buffer;
249 /* Restore pfile->skipping before skip_rest_of_line, so that e.g.
250 __VA_ARGS__ in the rest of the directive doesn't warn. */
251 pfile->skipping = buffer->was_skipping;
253 /* We don't skip for an assembler #. */
255 skip_rest_of_line (pfile);
258 pfile->la_write = pfile->la_saved;
259 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
260 pfile->state.in_directive = 0;
261 pfile->state.angled_headers = 0;
262 pfile->state.line_extension = 0;
263 pfile->directive = 0;
266 /* Check if a token's name matches that of a known directive. Put in
267 this file to save exporting dtable and other unneeded information. */
269 _cpp_handle_directive (pfile, indented)
273 cpp_buffer *buffer = pfile->buffer;
274 const directive *dir = 0;
278 start_directive (pfile);
280 /* Lex the directive name directly. */
281 _cpp_lex_token (pfile, &dname);
283 if (dname.type == CPP_NAME)
285 unsigned int index = dname.val.node->directive_index;
287 dir = &dtable[index - 1];
289 else if (dname.type == CPP_NUMBER)
291 /* # followed by a number is equivalent to #line. Do not
292 recognize this form in assembly language source files or
293 skipped conditional groups. Complain about this form if
294 we're being pedantic, but not if this is regurgitated input
295 (preprocessed or fed back in by the C++ frontend). */
296 if (! buffer->was_skipping && CPP_OPTION (pfile, lang) != CLK_ASM)
298 dir = &dtable[T_LINE];
299 pfile->state.line_extension = 1;
300 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
301 if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed))
302 cpp_pedwarn (pfile, "# followed by integer");
306 pfile->directive = dir;
309 /* Make sure we lex headers correctly, whether skipping or not. */
310 pfile->state.angled_headers = dir->flags & INCL;
312 /* If we are rescanning preprocessed input, only directives tagged
313 with IN_I are honored, and the warnings below are suppressed. */
314 if (! CPP_OPTION (pfile, preprocessed) || dir->flags & IN_I)
316 /* Traditionally, a directive is ignored unless its # is in
317 column 1. Therefore in code intended to work with K+R
318 compilers, directives added by C89 must have their #
319 indented, and directives present in traditional C must
320 not. This is true even of directives in skipped
321 conditional blocks. */
322 if (CPP_WTRADITIONAL (pfile))
324 if (indented && dir->origin == KANDR)
326 "traditional C ignores #%s with the # indented",
328 else if (!indented && dir->origin != KANDR)
330 "suggest hiding #%s from traditional C with an indented #",
334 /* If we are skipping a failed conditional group, all
335 non-conditional directives are ignored. */
336 if (! buffer->was_skipping || (dir->flags & COND))
338 /* Issue -pedantic warnings for extensions. */
339 if (CPP_PEDANTIC (pfile) && dir->origin == EXTENSION)
340 cpp_pedwarn (pfile, "#%s is a GCC extension", dir->name);
342 /* If we have a directive that is not an opening
343 conditional, invalidate any control macro. */
344 if (! (dir->flags & IF_COND))
345 pfile->mi_state = MI_FAILED;
347 (*dir->handler) (pfile);
351 else if (dname.type != CPP_EOF && ! buffer->was_skipping)
353 /* An unknown directive. Don't complain about it in assembly
354 source: we don't know where the comments are, and # may
355 introduce assembler pseudo-ops. Don't complain about invalid
356 directives in skipped conditional groups (6.10 p4). */
357 if (CPP_OPTION (pfile, lang) == CLK_ASM)
359 /* Output the # and lookahead token for the assembler. */
360 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
364 cpp_error (pfile, "invalid preprocessing directive #%s",
365 cpp_token_as_text (pfile, &dname));
368 end_directive (pfile, skip);
372 /* Directive handler wrapper used by the command line option
375 run_directive (pfile, dir_no, type, buf, count)
378 enum cpp_buffer_type type;
382 unsigned int output_line = pfile->lexer_pos.output_line;
385 buffer = cpp_push_buffer (pfile, (const U_CHAR *) buf, count, type, 0);
387 if (dir_no == T_PRAGMA)
389 /* A kludge to avoid line markers for _Pragma. */
390 pfile->lexer_pos.output_line = output_line;
391 /* Avoid interpretation of directives in a _Pragma string. */
392 pfile->state.next_bol = 0;
395 start_directive (pfile);
396 pfile->state.prevent_expansion++;
397 (void) (*dtable[dir_no].handler) (pfile);
398 pfile->state.prevent_expansion--;
400 end_directive (pfile, 1);
402 cpp_pop_buffer (pfile);
405 /* Checks for validity the macro name in #define, #undef, #ifdef and
406 #ifndef directives. */
407 static cpp_hashnode *
408 lex_macro_node (pfile)
413 /* Lex the macro name directly. */
414 _cpp_lex_token (pfile, &token);
416 /* The token immediately after #define must be an identifier. That
417 identifier is not allowed to be "defined". See predefined macro
418 names (6.10.8.4). In C++, it is not allowed to be any of the
419 <iso646.h> macro names (which are keywords in C++) either. */
421 if (token.type != CPP_NAME)
423 if (token.type == CPP_EOF)
424 cpp_error (pfile, "no macro name given in #%s directive",
425 pfile->directive->name);
426 else if (token.flags & NAMED_OP)
428 "\"%s\" cannot be used as a macro name as it is an operator in C++",
429 token.val.node->name);
431 cpp_error (pfile, "macro names must be identifiers");
435 cpp_hashnode *node = token.val.node;
437 /* In Objective C, some keywords begin with '@', but general
438 identifiers do not, and you're not allowed to #define them. */
439 if (node == pfile->spec_nodes.n_defined || node->name[0] == '@')
440 cpp_error (pfile, "\"%s\" cannot be used as a macro name", node->name);
441 else if (!(node->flags & NODE_POISONED))
448 /* Process a #define directive. Most work is done in cppmacro.c. */
453 cpp_hashnode *node = lex_macro_node (pfile);
457 if (_cpp_create_definition (pfile, node))
458 if (pfile->cb.define)
459 (*pfile->cb.define) (pfile, node);
463 /* Handle #undef. Marks the identifier NT_VOID in the hash table. */
468 cpp_hashnode *node = lex_macro_node (pfile);
470 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
471 is not currently defined as a macro name. */
472 if (node && node->type == NT_MACRO)
475 (*pfile->cb.undef) (pfile, node);
477 if (node->flags & NODE_BUILTIN)
478 cpp_warning (pfile, "undefining \"%s\"", node->name);
480 _cpp_free_definition (node);
485 /* Helper routine used by parse_include. Reinterpret the current line
486 as an h-char-sequence (< ... >); we are looking at the first token
487 after the <. Returns zero on success. */
489 glue_header_name (pfile, header)
494 unsigned char *buffer, *token_mem;
495 size_t len, total_len = 0, capacity = 1024;
497 /* To avoid lexed tokens overwriting our glued name, we can only
498 allocate from the string pool once we've lexed everything. */
500 buffer = (unsigned char *) xmalloc (capacity);
503 cpp_get_token (pfile, &token);
505 if (token.type == CPP_GREATER || token.type == CPP_EOF)
508 len = cpp_token_len (&token);
509 if (total_len + len > capacity)
511 capacity = (capacity + len) * 2;
512 buffer = (unsigned char *) xrealloc (buffer, capacity);
515 if (token.flags & PREV_WHITE)
516 buffer[total_len++] = ' ';
518 total_len = cpp_spell_token (pfile, &token, &buffer[total_len]) - buffer;
521 if (token.type == CPP_EOF)
522 cpp_error (pfile, "missing terminating > character");
525 token_mem = _cpp_pool_alloc (&pfile->ident_pool, total_len);
526 memcpy (token_mem, buffer, total_len);
528 header->type = CPP_HEADER_NAME;
529 header->flags &= ~PREV_WHITE;
530 header->val.str.len = total_len;
531 header->val.str.text = token_mem;
535 return token.type == CPP_EOF;
538 /* Parse the header name of #include, #include_next, #import and
539 #pragma dependency. Returns zero on success. */
541 parse_include (pfile, header)
545 int is_pragma = pfile->directive == &dtable[T_PRAGMA];
546 const unsigned char *dir;
549 dir = U"pragma dependency";
551 dir = pfile->directive->name;
553 /* Allow macro expansion. */
554 cpp_get_token (pfile, header);
555 if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
557 if (header->type != CPP_LESS)
559 cpp_error (pfile, "#%s expects \"FILENAME\" or <FILENAME>", dir);
562 if (glue_header_name (pfile, header))
566 if (header->val.str.len == 0)
568 cpp_error (pfile, "empty file name in #%s", dir);
575 /* Get out of macro context, if we are. */
576 skip_rest_of_line (pfile);
577 if (pfile->cb.include)
578 (*pfile->cb.include) (pfile, dir, header);
590 if (!parse_include (pfile, &header))
591 _cpp_execute_include (pfile, &header, 0, 0);
600 if (!pfile->import_warning && CPP_OPTION (pfile, warn_import))
602 pfile->import_warning = 1;
604 "#import is obsolete, use an #ifndef wrapper in the header file");
607 if (!parse_include (pfile, &header))
608 _cpp_execute_include (pfile, &header, 1, 0);
612 do_include_next (pfile)
617 if (!parse_include (pfile, &header))
618 _cpp_execute_include (pfile, &header, 0, 1);
621 /* Subroutine of do_line. Read possible flags after file name. LAST
622 is the last flag seen; 0 if this is the first flag. Return the flag
623 if it is valid, 0 at the end of the directive. Otherwise complain. */
626 read_flag (pfile, last)
632 _cpp_lex_token (pfile, &token);
633 if (token.type == CPP_NUMBER && token.val.str.len == 1)
635 unsigned int flag = token.val.str.text[0] - '0';
637 if (flag > last && flag <= 4
638 && (flag != 4 || last == 3)
639 && (flag != 2 || last == 0))
643 if (token.type != CPP_EOF)
644 cpp_error (pfile, "invalid flag \"%s\" in line directive",
645 cpp_token_as_text (pfile, &token));
649 /* Another subroutine of do_line. Convert a number in STR, of length
650 LEN, to binary; store it in NUMP, and return 0 if the number was
651 well-formed, 1 if not. Temporary, hopefully. */
653 strtoul_for_line (str, len, nump)
658 unsigned long reg = 0;
672 /* Interpret #line command.
673 Note that the filename string (if any) is treated as if it were an
674 include filename. That means no escape handling. */
680 cpp_buffer *buffer = pfile->buffer;
681 const char *filename = buffer->nominal_fname;
682 unsigned int lineno = buffer->lineno;
683 enum cpp_fc_reason reason = FC_RENAME;
684 unsigned long new_lineno;
688 /* C99 raised the minimum limit on #line numbers. */
689 cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
691 /* #line commands expand macros. */
692 cpp_get_token (pfile, &token);
693 if (token.type != CPP_NUMBER
694 || strtoul_for_line (token.val.str.text, token.val.str.len, &new_lineno))
696 cpp_error (pfile, "\"%s\" after #line is not a positive integer",
697 cpp_token_as_text (pfile, &token));
701 if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
702 cpp_pedwarn (pfile, "line number out of range");
704 cpp_get_token (pfile, &token);
705 if (token.type == CPP_STRING)
710 /* FIXME: memory leak. */
711 len = token.val.str.len;
712 fname = xmalloc (len + 1);
713 memcpy (fname, token.val.str.text, len);
716 _cpp_simplify_pathname (fname);
718 /* Only accept flags for the # 55 form. */
719 if (! pfile->state.line_extension)
723 int flag = 0, sysp = 0;
725 flag = read_flag (pfile, flag);
729 flag = read_flag (pfile, flag);
734 flag = read_flag (pfile, flag);
739 flag = read_flag (pfile, flag);
741 sysp = 2, read_flag (pfile, flag);
744 if (reason == FC_ENTER)
746 /* Fake a buffer stack for diagnostics. */
747 cpp_push_buffer (pfile, 0, 0, BUF_FAKE, fname);
748 /* Fake an include for cpp_included. */
749 _cpp_fake_include (pfile, fname);
750 buffer = pfile->buffer;
752 else if (reason == FC_LEAVE)
754 if (buffer->type != BUF_FAKE)
755 cpp_warning (pfile, "file \"%s\" left but not entered",
756 buffer->nominal_fname);
759 cpp_pop_buffer (pfile);
760 buffer = pfile->buffer;
761 if (strcmp (buffer->nominal_fname, fname))
762 cpp_warning (pfile, "expected to return to file \"%s\"",
763 buffer->nominal_fname);
764 if (buffer->lineno + 1 != new_lineno)
765 cpp_warning (pfile, "expected to return to line number %u",
767 if (buffer->sysp != sysp)
768 cpp_warning (pfile, "header flags for \"%s\" have changed",
769 buffer->nominal_fname);
774 buffer->nominal_fname = fname;
776 else if (token.type != CPP_EOF)
778 cpp_error (pfile, "\"%s\" is not a valid filename",
779 cpp_token_as_text (pfile, &token));
783 /* Our line number is incremented after the directive is processed. */
784 buffer->lineno = new_lineno - 1;
785 _cpp_do_file_change (pfile, reason, filename, lineno);
788 /* Arrange the file_change callback. */
790 _cpp_do_file_change (pfile, reason, from_file, from_lineno)
792 enum cpp_fc_reason reason;
793 const char *from_file;
794 unsigned int from_lineno;
796 if (pfile->cb.file_change)
799 cpp_buffer *buffer = pfile->buffer;
802 fc.to.filename = buffer->nominal_fname;
803 fc.to.lineno = buffer->lineno + 1;
804 fc.sysp = buffer->sysp;
805 fc.externc = CPP_OPTION (pfile, cplusplus) && buffer->sysp == 2;
807 /* Caller doesn't need to handle FC_ENTER. */
808 if (reason == FC_ENTER)
812 from_file = buffer->prev->nominal_fname;
813 from_lineno = buffer->prev->lineno;
818 /* Special case for file "foo.i" with "# 1 foo.c" on first line. */
819 else if (reason == FC_RENAME && ! buffer->prev
820 && pfile->directive_pos.line == 1)
823 fc.from.filename = from_file;
824 fc.from.lineno = from_lineno;
825 pfile->cb.file_change (pfile, &fc);
830 * Report a warning or error detected by the program we are
831 * processing. Use the directive's tokens in the error message.
835 do_diagnostic (pfile, code, print_dir)
837 enum error_type code;
840 if (_cpp_begin_message (pfile, code, NULL, 0))
843 fprintf (stderr, "#%s ", pfile->directive->name);
844 pfile->state.prevent_expansion++;
845 cpp_output_line (pfile, stderr);
846 pfile->state.prevent_expansion--;
854 do_diagnostic (pfile, ERROR, 1);
861 do_diagnostic (pfile, WARNING, 1);
864 /* Report program identification. */
872 cpp_get_token (pfile, &str);
873 if (str.type != CPP_STRING)
874 cpp_error (pfile, "invalid #ident");
875 else if (pfile->cb.ident)
876 (*pfile->cb.ident) (pfile, &str.val.str);
881 /* Pragmata handling. We handle some of these, and pass the rest on
882 to the front end. C99 defines three pragmas and says that no macro
883 expansion is to be performed on them; whether or not macro
884 expansion happens for other pragmas is implementation defined.
885 This implementation never macro-expands the text after #pragma. */
887 /* Sub-handlers for the pragmas needing treatment here.
888 They return 1 if the token buffer is to be popped, 0 if not. */
891 struct pragma_entry *next;
896 void (*handler) PARAMS ((cpp_reader *));
897 struct pragma_entry *space;
902 cpp_register_pragma (pfile, space, name, handler)
906 void (*handler) PARAMS ((cpp_reader *));
908 struct pragma_entry **x, *new;
914 struct pragma_entry *p = pfile->pragmas;
915 len = strlen (space);
918 if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
925 cpp_ice (pfile, "unknown #pragma namespace %s", space);
930 new = xnew (struct pragma_entry);
932 new->len = strlen (name);
934 new->u.handler = handler;
941 cpp_register_pragma_space (pfile, space)
945 struct pragma_entry *new;
946 const struct pragma_entry *p = pfile->pragmas;
947 size_t len = strlen (space);
951 if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
952 /* Multiple different callers are allowed to register the same
958 new = xnew (struct pragma_entry);
964 new->next = pfile->pragmas;
965 pfile->pragmas = new;
969 _cpp_init_internal_pragmas (pfile)
973 cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
974 cpp_register_pragma (pfile, 0, "once", do_pragma_once);
977 cpp_register_pragma_space (pfile, "GCC");
979 cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
980 cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
981 cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
988 const struct pragma_entry *p;
990 const cpp_hashnode *node;
996 pfile->state.prevent_expansion++;
997 cpp_start_lookahead (pfile);
1000 cpp_get_token (pfile, &tok);
1001 if (tok.type == CPP_NAME)
1003 node = tok.val.node;
1008 if (strlen (p->name) == len && !memcmp (p->name, name, len))
1017 (*p->u.handler) (pfile);
1026 cpp_stop_lookahead (pfile, drop);
1027 pfile->state.prevent_expansion--;
1029 if (!drop && pfile->cb.def_pragma)
1030 (*pfile->cb.def_pragma) (pfile);
1034 do_pragma_once (pfile)
1037 cpp_warning (pfile, "#pragma once is obsolete");
1039 if (pfile->buffer->prev == NULL)
1040 cpp_warning (pfile, "#pragma once in main file");
1042 _cpp_never_reread (pfile->buffer->inc);
1048 do_pragma_poison (pfile)
1051 /* Poison these symbols so that all subsequent usage produces an
1056 pfile->state.poisoned_ok = 1;
1059 _cpp_lex_token (pfile, &tok);
1060 if (tok.type == CPP_EOF)
1062 if (tok.type != CPP_NAME)
1064 cpp_error (pfile, "invalid #pragma GCC poison directive");
1069 if (hp->flags & NODE_POISONED)
1072 if (hp->type == NT_MACRO)
1073 cpp_warning (pfile, "poisoning existing macro \"%s\"", hp->name);
1074 _cpp_free_definition (hp);
1075 hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1077 pfile->state.poisoned_ok = 0;
1079 #if 0 /* Doesn't quite work yet. */
1080 if (tok.type == CPP_EOF && pfile->cb.poison)
1081 (*pfile->cb.poison) (pfile);
1085 /* Mark the current header as a system header. This will suppress
1086 some categories of warnings (notably those from -pedantic). It is
1087 intended for use in system libraries that cannot be implemented in
1088 conforming C, but cannot be certain that their headers appear in a
1089 system include directory. To prevent abuse, it is rejected in the
1090 primary source file. */
1092 do_pragma_system_header (pfile)
1095 cpp_buffer *buffer = pfile->buffer;
1097 if (buffer->prev == 0)
1098 cpp_warning (pfile, "#pragma system_header ignored outside include file");
1100 cpp_make_system_header (pfile, 1, 0);
1105 /* Check the modified date of the current include file against a specified
1106 file. Issue a diagnostic, if the specified file is newer. We use this to
1107 determine if a fixed header should be refixed. */
1109 do_pragma_dependency (pfile)
1112 cpp_token header, msg;
1115 if (parse_include (pfile, &header))
1118 ordering = _cpp_compare_file_date (pfile, &header);
1120 cpp_warning (pfile, "cannot find source %s",
1121 cpp_token_as_text (pfile, &header));
1122 else if (ordering > 0)
1124 cpp_warning (pfile, "current file is older than %s",
1125 cpp_token_as_text (pfile, &header));
1126 cpp_start_lookahead (pfile);
1127 cpp_get_token (pfile, &msg);
1128 cpp_stop_lookahead (pfile, msg.type == CPP_EOF);
1129 if (msg.type != CPP_EOF)
1130 do_diagnostic (pfile, WARNING, 0);
1134 /* Check syntax is "(string-literal)". Returns 0 on success. */
1136 get__Pragma_string (pfile, string)
1142 cpp_get_token (pfile, &paren);
1143 if (paren.type != CPP_OPEN_PAREN)
1146 cpp_get_token (pfile, string);
1147 if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1150 cpp_get_token (pfile, &paren);
1151 return paren.type != CPP_CLOSE_PAREN;
1154 /* Returns a malloced buffer containing a destringized cpp_string by
1155 removing the first \ of \" and \\ sequences. */
1156 static unsigned char *
1157 destringize (in, len)
1158 const cpp_string *in;
1161 const unsigned char *src, *limit;
1162 unsigned char *dest, *result;
1164 dest = result = (unsigned char *) xmalloc (in->len);
1165 for (src = in->text, limit = src + in->len; src < limit;)
1167 /* We know there is a character following the backslash. */
1168 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1173 *len = dest - result;
1178 _cpp_do__Pragma (pfile)
1182 unsigned char *buffer;
1185 if (get__Pragma_string (pfile, &string))
1187 cpp_error (pfile, "_Pragma takes a parenthesized string literal");
1191 buffer = destringize (&string.val.str, &len);
1192 run_directive (pfile, T_PRAGMA, BUF_PRAGMA, (char *) buffer, len);
1193 free ((PTR) buffer);
1196 /* Just ignore #sccs, on systems where we define it at all. */
1197 #ifdef SCCS_DIRECTIVE
1200 cpp_reader *pfile ATTRIBUTE_UNUSED;
1211 if (! pfile->buffer->was_skipping)
1213 const cpp_hashnode *node = lex_macro_node (pfile);
1216 skip = node->type != NT_MACRO;
1222 push_conditional (pfile, skip, T_IFDEF, 0);
1230 const cpp_hashnode *node = 0;
1232 if (! pfile->buffer->was_skipping)
1234 node = lex_macro_node (pfile);
1236 skip = node->type == NT_MACRO;
1242 push_conditional (pfile, skip, T_IFNDEF, node);
1245 /* #if cooperates with parse_defined to handle multiple-include
1246 optimisations. If macro expansions or identifiers appear in the
1247 expression, we cannot treat it as a controlling conditional, since
1248 their values could change in the future. */
1255 const cpp_hashnode *cmacro = 0;
1257 if (! pfile->buffer->was_skipping)
1259 /* Controlling macro of #if ! defined () */
1260 pfile->mi_ind_cmacro = 0;
1261 skip = _cpp_parse_expr (pfile) == 0;
1262 cmacro = pfile->mi_ind_cmacro;
1265 push_conditional (pfile, skip, T_IF, cmacro);
1268 /* Flip skipping state if appropriate and continue without changing
1269 if_stack; this is so that the error message for missing #endif's
1270 etc. will point to the original #if. */
1276 cpp_buffer *buffer = pfile->buffer;
1277 struct if_stack *ifs = buffer->if_stack;
1280 cpp_error (pfile, "#else without #if");
1283 if (ifs->type == T_ELSE)
1285 cpp_error (pfile, "#else after #else");
1286 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1287 "the conditional began here");
1291 /* Buffer->was_skipping is 1 if all conditionals in this chain
1292 have been false, 2 if a conditional has been true. */
1293 if (! ifs->was_skipping && buffer->was_skipping != 2)
1294 buffer->was_skipping = ! buffer->was_skipping;
1296 /* Invalidate any controlling macro. */
1303 /* handle a #elif directive by not changing if_stack either. see the
1304 comment above do_else. */
1310 cpp_buffer *buffer = pfile->buffer;
1311 struct if_stack *ifs = buffer->if_stack;
1314 cpp_error (pfile, "#elif without #if");
1317 if (ifs->type == T_ELSE)
1319 cpp_error (pfile, "#elif after #else");
1320 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1321 "the conditional began here");
1325 /* Don't evaluate #elif if our higher level is skipping. */
1326 if (! ifs->was_skipping)
1328 /* Buffer->was_skipping is 1 if all conditionals in this
1329 chain have been false, 2 if a conditional has been true. */
1330 if (buffer->was_skipping == 1)
1331 buffer->was_skipping = ! _cpp_parse_expr (pfile);
1333 buffer->was_skipping = 2;
1335 /* Invalidate any controlling macro. */
1341 /* #endif pops the if stack and resets pfile->skipping. */
1347 cpp_buffer *buffer = pfile->buffer;
1348 struct if_stack *ifs = buffer->if_stack;
1351 cpp_error (pfile, "#endif without #if");
1354 /* If potential control macro, we go back outside again. */
1355 if (ifs->next == 0 && ifs->mi_cmacro)
1357 pfile->mi_state = MI_OUTSIDE;
1358 pfile->mi_cmacro = ifs->mi_cmacro;
1361 buffer->if_stack = ifs->next;
1362 buffer->was_skipping = ifs->was_skipping;
1363 obstack_free (pfile->buffer_ob, ifs);
1369 /* Push an if_stack entry and set pfile->skipping accordingly.
1370 If this is a #ifndef starting at the beginning of a file,
1371 CMACRO is the macro name tested by the #ifndef. */
1374 push_conditional (pfile, skip, type, cmacro)
1378 const cpp_hashnode *cmacro;
1380 struct if_stack *ifs;
1381 cpp_buffer *buffer = pfile->buffer;
1383 ifs = xobnew (pfile->buffer_ob, struct if_stack);
1384 ifs->pos = pfile->directive_pos;
1385 ifs->next = buffer->if_stack;
1386 ifs->was_skipping = buffer->was_skipping;
1388 if (pfile->mi_state == MI_OUTSIDE && pfile->mi_cmacro == 0)
1389 ifs->mi_cmacro = cmacro;
1393 buffer->was_skipping = skip;
1394 buffer->if_stack = ifs;
1397 /* Read the tokens of the answer into the macro pool. Only commit the
1398 memory if we intend it as permanent storage, i.e. the #assert case.
1399 Returns 0 on success. */
1402 parse_answer (pfile, answerp, type)
1404 struct answer **answerp;
1407 cpp_token paren, *token;
1408 struct answer *answer;
1410 if (POOL_FRONT (&pfile->macro_pool) + sizeof (struct answer) >
1411 POOL_LIMIT (&pfile->macro_pool))
1412 _cpp_next_chunk (&pfile->macro_pool, sizeof (struct answer), 0);
1413 answer = (struct answer *) POOL_FRONT (&pfile->macro_pool);
1416 /* In a conditional, it is legal to not have an open paren. We
1417 should save the following token in this case. */
1419 cpp_start_lookahead (pfile);
1420 cpp_get_token (pfile, &paren);
1422 cpp_stop_lookahead (pfile, paren.type == CPP_OPEN_PAREN);
1424 /* If not a paren, see if we're OK. */
1425 if (paren.type != CPP_OPEN_PAREN)
1427 /* In a conditional no answer is a test for any answer. It
1428 could be followed by any token. */
1432 /* #unassert with no answer is valid - it removes all answers. */
1433 if (type == T_UNASSERT && paren.type == CPP_EOF)
1436 cpp_error (pfile, "missing '(' after predicate");
1442 token = &answer->first[answer->count];
1443 /* Check we have room for the token. */
1444 if ((unsigned char *) (token + 1) >= POOL_LIMIT (&pfile->macro_pool))
1446 _cpp_next_chunk (&pfile->macro_pool, sizeof (cpp_token),
1447 (unsigned char **) &answer);
1448 token = &answer->first[answer->count];
1451 cpp_get_token (pfile, token);
1452 if (token->type == CPP_CLOSE_PAREN)
1455 if (token->type == CPP_EOF)
1457 cpp_error (pfile, "missing ')' to complete answer");
1463 if (answer->count == 0)
1465 cpp_error (pfile, "predicate's answer is empty");
1469 /* Drop whitespace at start. */
1470 answer->first->flags &= ~PREV_WHITE;
1473 if (type == T_ASSERT || type == T_UNASSERT)
1478 /* Parses an assertion, returning a pointer to the hash node of the
1479 predicate, or 0 on error. If an answer was supplied, it is placed
1480 in ANSWERP, otherwise it is set to 0. */
1481 static cpp_hashnode *
1482 parse_assertion (pfile, answerp, type)
1484 struct answer **answerp;
1487 cpp_hashnode *result = 0;
1488 cpp_token predicate;
1490 /* We don't expand predicates or answers. */
1491 pfile->state.prevent_expansion++;
1494 cpp_get_token (pfile, &predicate);
1495 if (predicate.type == CPP_EOF)
1496 cpp_error (pfile, "assertion without predicate");
1497 else if (predicate.type != CPP_NAME)
1498 cpp_error (pfile, "predicate must be an identifier");
1499 else if (parse_answer (pfile, answerp, type) == 0)
1501 unsigned int len = predicate.val.node->length;
1502 unsigned char *sym = alloca (len + 1);
1504 /* Prefix '#' to get it out of macro namespace. */
1506 memcpy (sym + 1, predicate.val.node->name, len);
1507 result = cpp_lookup (pfile, sym, len + 1);
1510 pfile->state.prevent_expansion--;
1514 /* Returns a pointer to the pointer to the answer in the answer chain,
1515 or a pointer to NULL if the answer is not in the chain. */
1516 static struct answer **
1517 find_answer (node, candidate)
1519 const struct answer *candidate;
1522 struct answer **result;
1524 for (result = &node->value.answers; *result; result = &(*result)->next)
1526 struct answer *answer = *result;
1528 if (answer->count == candidate->count)
1530 for (i = 0; i < answer->count; i++)
1531 if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1534 if (i == answer->count)
1542 /* Test an assertion within a preprocessor conditional. Returns
1543 non-zero on failure, zero on success. On success, the result of
1544 the test is written into VALUE. */
1546 _cpp_test_assertion (pfile, value)
1550 struct answer *answer;
1553 node = parse_assertion (pfile, &answer, T_IF);
1555 *value = (node->type == NT_ASSERTION &&
1556 (answer == 0 || *find_answer (node, answer) != 0));
1558 /* We don't commit the memory for the answer - it's temporary only. */
1566 struct answer *new_answer;
1569 node = parse_assertion (pfile, &new_answer, T_ASSERT);
1572 /* Place the new answer in the answer list. First check there
1573 is not a duplicate. */
1574 new_answer->next = 0;
1575 if (node->type == NT_ASSERTION)
1577 if (*find_answer (node, new_answer))
1579 cpp_warning (pfile, "\"%s\" re-asserted", node->name + 1);
1582 new_answer->next = node->value.answers;
1584 node->type = NT_ASSERTION;
1585 node->value.answers = new_answer;
1586 POOL_COMMIT (&pfile->macro_pool, (sizeof (struct answer)
1587 + (new_answer->count - 1)
1588 * sizeof (cpp_token)));
1597 struct answer *answer;
1599 node = parse_assertion (pfile, &answer, T_UNASSERT);
1600 /* It isn't an error to #unassert something that isn't asserted. */
1601 if (node && node->type == NT_ASSERTION)
1605 struct answer **p = find_answer (node, answer), *temp;
1607 /* Remove the answer from the list. */
1612 /* Did we free the last answer? */
1613 if (node->value.answers == 0)
1614 node->type = NT_VOID;
1617 _cpp_free_definition (node);
1620 /* We don't commit the memory for the answer - it's temporary only. */
1623 /* These are for -D, -U, -A. */
1625 /* Process the string STR as if it appeared as the body of a #define.
1626 If STR is just an identifier, define it with value 1.
1627 If STR has anything after the identifier, then it should
1628 be identifier=definition. */
1631 cpp_define (pfile, str)
1638 /* Copy the entire option so we can modify it.
1639 Change the first "=" in the string to a space. If there is none,
1640 tack " 1" on the end. */
1642 /* Length including the null. */
1643 count = strlen (str);
1644 buf = (char *) alloca (count + 2);
1645 memcpy (buf, str, count);
1647 p = strchr (str, '=');
1656 run_directive (pfile, T_DEFINE, BUF_CL_OPTION, buf, count);
1659 /* Slight variant of the above for use by initialize_builtins. */
1661 _cpp_define_builtin (pfile, str)
1665 run_directive (pfile, T_DEFINE, BUF_BUILTIN, str, strlen (str));
1668 /* Process MACRO as if it appeared as the body of an #undef. */
1670 cpp_undef (pfile, macro)
1674 run_directive (pfile, T_UNDEF, BUF_CL_OPTION, macro, strlen (macro));
1677 /* Process the string STR as if it appeared as the body of a #assert. */
1679 cpp_assert (pfile, str)
1683 handle_assertion (pfile, str, T_ASSERT);
1686 /* Process STR as if it appeared as the body of an #unassert. */
1688 cpp_unassert (pfile, str)
1692 handle_assertion (pfile, str, T_UNASSERT);
1695 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1697 handle_assertion (pfile, str, type)
1702 size_t count = strlen (str);
1703 const char *p = strchr (str, '=');
1707 /* Copy the entire option so we can modify it. Change the first
1708 "=" in the string to a '(', and tack a ')' on the end. */
1709 char *buf = (char *) alloca (count + 1);
1711 memcpy (buf, str, count);
1717 run_directive (pfile, type, BUF_CL_OPTION, str, count);
1720 /* The number of errors for a given reader. */
1725 return pfile->errors;
1728 /* The options structure. */
1730 cpp_get_options (pfile)
1733 return &pfile->opts;
1736 /* The callbacks structure. */
1738 cpp_get_callbacks (pfile)
1744 /* Copy the given callbacks structure to our own. */
1746 cpp_set_callbacks (pfile, cb)
1753 /* Push a new buffer on the buffer stack. Returns the new buffer; it
1754 doesn't fail. It does not generate a file change call back; that
1755 is the responsibility of the caller. */
1757 cpp_push_buffer (pfile, buffer, len, type, filename)
1759 const U_CHAR *buffer;
1761 enum cpp_buffer_type type;
1762 const char *filename;
1764 cpp_buffer *new = xobnew (pfile->buffer_ob, cpp_buffer);
1766 if (type == BUF_FAKE)
1768 /* A copy of the current buffer, just with a new name and type. */
1769 memcpy (new, pfile->buffer, sizeof (cpp_buffer));
1770 new->type = BUF_FAKE;
1774 if (type == BUF_BUILTIN)
1775 filename = _("<builtin>");
1776 else if (type == BUF_CL_OPTION)
1777 filename = _("<command line>");
1778 else if (type == BUF_PRAGMA)
1779 filename = "<_Pragma>";
1781 /* Clears, amongst other things, if_stack and mi_cmacro. */
1782 memset (new, 0, sizeof (cpp_buffer));
1784 new->line_base = new->buf = new->cur = buffer;
1785 new->rlimit = buffer + len;
1788 /* No read ahead or extra char initially. */
1789 new->read_ahead = EOF;
1790 new->extra_char = EOF;
1792 /* Preprocessed files, builtins, _Pragma and command line
1793 options don't do trigraph and escaped newline processing. */
1794 new->from_stage3 = type != BUF_FILE || CPP_OPTION (pfile, preprocessed);
1796 pfile->lexer_pos.output_line = 1;
1799 new->nominal_fname = filename;
1801 new->prev = pfile->buffer;
1803 new->include_stack_listed = 0;
1806 pfile->state.next_bol = 1;
1807 pfile->buffer_stack_depth++;
1808 pfile->buffer = new;
1813 /* If called from do_line, pops a single buffer. Otherwise pops all
1814 buffers until a real file is reached. Generates appropriate
1817 cpp_pop_buffer (pfile)
1821 struct if_stack *ifs;
1825 buffer = pfile->buffer;
1826 /* Walk back up the conditional stack till we reach its level at
1827 entry to this file, issuing error messages. */
1828 for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
1829 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1830 "unterminated #%s", dtable[ifs->type].name);
1832 if (buffer->type == BUF_FAKE)
1833 buffer->prev->cur = buffer->cur;
1834 else if (buffer->type == BUF_FILE)
1835 _cpp_pop_file_buffer (pfile, buffer);
1837 pfile->buffer = buffer->prev;
1838 pfile->buffer_stack_depth--;
1840 /* Callbacks only generated for faked or real files. */
1841 if (buffer->type != BUF_FILE && buffer->type != BUF_FAKE)
1844 /* No callback for EOF of last file. */
1848 /* do_line does its own call backs. */
1849 pfile->buffer->include_stack_listed = 0;
1850 if (pfile->directive == &dtable[T_LINE])
1853 _cpp_do_file_change (pfile, FC_LEAVE, buffer->nominal_fname,
1855 if (pfile->buffer->type == BUF_FILE)
1858 cpp_warning (pfile, "file \"%s\" entered but not left",
1859 buffer->nominal_fname);
1862 obstack_free (pfile->buffer_ob, buffer);
1863 return pfile->buffer;
1866 #define obstack_chunk_alloc xmalloc
1867 #define obstack_chunk_free free
1869 _cpp_init_stacks (pfile)
1875 pfile->buffer_ob = xnew (struct obstack);
1876 obstack_init (pfile->buffer_ob);
1878 /* Register the directives. */
1879 for (i = 0; i < N_DIRECTIVES; i++)
1881 node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
1882 node->directive_index = i + 1;
1887 _cpp_cleanup_stacks (pfile)
1890 obstack_free (pfile->buffer_ob, 0);
1891 free (pfile->buffer_ob);