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 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,
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 int read_line_number PARAMS ((cpp_reader *, 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,
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 pfile->state.prevent_expansion++;
198 while (!pfile->state.next_bol)
199 _cpp_lex_token (pfile, &token);
200 pfile->state.prevent_expansion--;
203 /* Ensure there are no stray tokens at the end of a directive. */
208 if (!pfile->state.next_bol)
212 _cpp_lex_token (pfile, &token);
213 if (token.type != CPP_EOF)
214 cpp_pedwarn (pfile, "extra tokens at end of #%s directive",
215 pfile->directive->name);
219 /* Called when entering a directive, _Pragma or command-line directive. */
221 start_directive (pfile)
224 cpp_buffer *buffer = pfile->buffer;
226 /* Setup in-directive state. */
227 pfile->state.in_directive = 1;
228 pfile->state.save_comments = 0;
230 /* Some handlers need the position of the # for diagnostics. */
231 pfile->directive_pos = pfile->lexer_pos;
233 /* Don't save directive tokens for external clients. */
234 pfile->la_saved = pfile->la_write;
237 /* Turn off skipping. */
238 buffer->was_skipping = pfile->skipping;
242 /* Called when leaving a directive, _Pragma or command-line directive. */
244 end_directive (pfile, skip_line)
248 cpp_buffer *buffer = pfile->buffer;
250 /* Restore pfile->skipping before skip_rest_of_line. This avoids
251 warning about poisoned identifiers in skipped #error lines. */
252 pfile->skipping = buffer->was_skipping;
254 /* We don't skip for an assembler #. */
256 skip_rest_of_line (pfile);
259 pfile->la_write = pfile->la_saved;
260 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
261 pfile->state.in_directive = 0;
262 pfile->state.angled_headers = 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 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
300 if (CPP_PEDANTIC (pfile) && buffer->inc
301 && ! 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 && ! pfile->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, buf, count, name)
382 unsigned int output_line = pfile->lexer_pos.output_line;
383 cpp_buffer *buffer = cpp_push_buffer (pfile, (const U_CHAR *) buf, count);
387 const struct directive *dir = &dtable[dir_no];
390 buffer->nominal_fname = name;
392 buffer->nominal_fname = _("<command line>");
394 /* For _Pragma, the text is passed through preprocessing stage 3
395 only, i.e. no trigraphs, no escaped newline removal, and no
396 macro expansion. Do the same for command-line directives. */
397 buffer->from_stage3 = 1;
399 if (dir_no == T_PRAGMA)
401 /* A kludge to avoid line markers for _Pragma. */
402 pfile->lexer_pos.output_line = output_line;
403 /* Avoid interpretation of directives in a _Pragma string. */
404 pfile->state.next_bol = 0;
407 start_directive (pfile);
408 pfile->state.prevent_expansion++;
409 (void) (*dir->handler) (pfile);
410 pfile->state.prevent_expansion--;
412 end_directive (pfile, 1);
414 cpp_pop_buffer (pfile);
418 /* Checks for validity the macro name in #define, #undef, #ifdef and
419 #ifndef directives. */
420 static cpp_hashnode *
421 lex_macro_node (pfile)
426 /* Lex the macro name directly. */
427 _cpp_lex_token (pfile, &token);
429 /* The token immediately after #define must be an identifier. That
430 identifier is not allowed to be "defined". See predefined macro
431 names (6.10.8.4). In C++, it is not allowed to be any of the
432 <iso646.h> macro names (which are keywords in C++) either. */
434 if (token.type != CPP_NAME)
436 if (token.type == CPP_EOF)
437 cpp_error (pfile, "no macro name given in #%s directive",
438 pfile->directive->name);
439 else if (token.flags & NAMED_OP)
441 "\"%s\" cannot be used as a macro name as it is an operator in C++",
442 token.val.node->name);
444 cpp_error (pfile, "macro names must be identifiers");
448 cpp_hashnode *node = token.val.node;
450 /* In Objective C, some keywords begin with '@', but general
451 identifiers do not, and you're not allowed to #define them. */
452 if (node == pfile->spec_nodes.n_defined || node->name[0] == '@')
453 cpp_error (pfile, "\"%s\" cannot be used as a macro name", node->name);
454 else if (!(node->flags & NODE_POISONED))
461 /* Process a #define directive. Most work is done in cppmacro.c. */
466 cpp_hashnode *node = lex_macro_node (pfile);
470 /* Use the permanent pool for storage. */
471 pfile->string_pool = &pfile->ident_pool;
473 if (_cpp_create_definition (pfile, node))
474 if (pfile->cb.define)
475 (*pfile->cb.define) (pfile, node);
477 /* Revert to the temporary pool. */
478 pfile->string_pool = &pfile->temp_string_pool;
482 /* Handle #undef. Marks the identifier NT_VOID in the hash table. */
487 cpp_hashnode *node = lex_macro_node (pfile);
489 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
490 is not currently defined as a macro name. */
491 if (node && node->type == NT_MACRO)
494 (*pfile->cb.undef) (pfile, node);
496 if (node->flags & NODE_BUILTIN)
497 cpp_warning (pfile, "undefining \"%s\"", node->name);
499 _cpp_free_definition (node);
504 /* Helper routine used by parse_include. Reinterpret the current line
505 as an h-char-sequence (< ... >); we are looking at the first token
506 after the <. Returns zero on success. */
508 glue_header_name (pfile, header)
513 unsigned char *buffer, *token_mem;
514 size_t len, total_len = 0, capacity = 1024;
516 /* To avoid lexed tokens overwriting our glued name, we can only
517 allocate from the string pool once we've lexed everything. */
519 buffer = (unsigned char *) xmalloc (capacity);
522 cpp_get_token (pfile, &token);
524 if (token.type == CPP_GREATER || token.type == CPP_EOF)
527 len = cpp_token_len (&token);
528 if (total_len + len > capacity)
530 capacity = (capacity + len) * 2;
531 buffer = (unsigned char *) xrealloc (buffer, capacity);
534 if (token.flags & PREV_WHITE)
535 buffer[total_len++] = ' ';
537 total_len = cpp_spell_token (pfile, &token, &buffer[total_len]) - buffer;
540 if (token.type == CPP_EOF)
541 cpp_error (pfile, "missing terminating > character");
544 token_mem = _cpp_pool_alloc (pfile->string_pool, total_len);
545 memcpy (token_mem, buffer, total_len);
547 header->type = CPP_HEADER_NAME;
548 header->flags &= ~PREV_WHITE;
549 header->val.str.len = total_len;
550 header->val.str.text = token_mem;
554 return token.type == CPP_EOF;
557 /* Parse the header name of #include, #include_next, #import and
558 #pragma dependency. Returns zero on success. */
560 parse_include (pfile, header)
564 int is_pragma = pfile->directive == &dtable[T_PRAGMA];
565 const unsigned char *dir;
568 dir = U"pragma dependency";
570 dir = pfile->directive->name;
572 /* Allow macro expansion. */
573 cpp_get_token (pfile, header);
574 if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
576 if (header->type != CPP_LESS)
578 cpp_error (pfile, "#%s expects \"FILENAME\" or <FILENAME>", dir);
581 if (glue_header_name (pfile, header))
585 if (header->val.str.len == 0)
587 cpp_error (pfile, "empty file name in #%s", dir);
594 /* Get out of macro context, if we are. */
595 skip_rest_of_line (pfile);
596 if (pfile->cb.include)
597 (*pfile->cb.include) (pfile, dir, header);
609 if (!parse_include (pfile, &header))
610 _cpp_execute_include (pfile, &header, 0, 0);
619 if (!pfile->import_warning && CPP_OPTION (pfile, warn_import))
621 pfile->import_warning = 1;
623 "#import is obsolete, use an #ifndef wrapper in the header file");
626 if (!parse_include (pfile, &header))
627 _cpp_execute_include (pfile, &header, 1, 0);
631 do_include_next (pfile)
635 struct file_name_list *search_start = 0;
637 if (parse_include (pfile, &header))
640 /* For #include_next, skip in the search path past the dir in which
641 the current file was found. If this is the last directory in the
642 search path, don't include anything. If the current file was
643 specified with an absolute path, use the normal search logic. If
644 this is the primary source file, use the normal search logic and
645 generate a warning. */
646 if (CPP_PREV_BUFFER (CPP_BUFFER (pfile)))
648 if (CPP_BUFFER (pfile)->inc->foundhere)
650 search_start = CPP_BUFFER (pfile)->inc->foundhere->next;
656 cpp_warning (pfile, "#include_next in primary source file");
658 _cpp_execute_include (pfile, &header, 0, search_start);
661 /* Subroutine of do_line. Read next token from PFILE without adding it to
662 the output buffer. If it is a number between 1 and 4, store it in *NUM
663 and return 1; otherwise, return 0 and complain if we aren't at the end
667 read_line_number (pfile, num)
674 _cpp_lex_token (pfile, &token);
675 if (token.type == CPP_NUMBER && token.val.str.len == 1)
677 val = token.val.str.text[0] - '1';
685 if (token.type != CPP_EOF)
686 cpp_error (pfile, "invalid format #line");
690 /* Another subroutine of do_line. Convert a number in STR, of length
691 LEN, to binary; store it in NUMP, and return 0 if the number was
692 well-formed, 1 if not. Temporary, hopefully. */
694 strtoul_for_line (str, len, nump)
699 unsigned long reg = 0;
713 /* Interpret #line command.
714 Note that the filename string (if any) is treated as if it were an
715 include filename. That means no escape handling. */
721 cpp_buffer *buffer = pfile->buffer;
722 const char *filename = buffer->nominal_fname;
723 unsigned int lineno = buffer->lineno;
724 enum cpp_fc_reason reason = (enum cpp_fc_reason) -1;
725 unsigned long new_lineno;
729 /* C99 raised the minimum limit on #line numbers. */
730 cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
732 /* #line commands expand macros. */
733 cpp_get_token (pfile, &token);
734 if (token.type != CPP_NUMBER
735 || strtoul_for_line (token.val.str.text, token.val.str.len, &new_lineno))
737 cpp_error (pfile, "\"%s\" after #line is not a positive integer",
738 cpp_token_as_text (pfile, &token));
742 if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
743 cpp_pedwarn (pfile, "line number out of range");
745 cpp_get_token (pfile, &token);
746 if (token.type == CPP_STRING)
750 int action_number = 0;
752 len = token.val.str.len;
753 fname = alloca (len + 1);
754 memcpy (fname, token.val.str.text, len);
757 if (strcmp (fname, buffer->nominal_fname))
760 if (!strcmp (fname, buffer->inc->name))
761 buffer->nominal_fname = buffer->inc->name;
763 buffer->nominal_fname = _cpp_fake_include (pfile, fname);
766 if (read_line_number (pfile, &action_number) != 0)
768 if (! CPP_OPTION (pfile, preprocessed) && CPP_PEDANTIC (pfile))
769 cpp_pedwarn (pfile, "extra tokens at end of #line directive");
771 if (action_number == 1)
774 cpp_make_system_header (pfile, buffer, 0);
775 read_line_number (pfile, &action_number);
777 else if (action_number == 2)
780 cpp_make_system_header (pfile, buffer, 0);
781 read_line_number (pfile, &action_number);
783 if (action_number == 3)
785 cpp_make_system_header (pfile, buffer, 1);
786 read_line_number (pfile, &action_number);
788 if (action_number == 4)
790 cpp_make_system_header (pfile, buffer, 2);
791 read_line_number (pfile, &action_number);
797 else if (token.type != CPP_EOF)
799 cpp_error (pfile, "\"%s\" is not a valid filename",
800 cpp_token_as_text (pfile, &token));
804 /* Our line number is incremented after the directive is processed. */
805 buffer->lineno = new_lineno - 1;
806 if (reason != (enum cpp_fc_reason) -1)
807 _cpp_do_file_change (pfile, reason, filename, lineno);
810 /* Arrange the file_change callback. The assumption is that the
811 current buffer's lineno is one less than the next line. */
813 _cpp_do_file_change (pfile, reason, from_file, from_lineno)
815 enum cpp_fc_reason reason;
816 const char *from_file;
817 unsigned int from_lineno;
819 if (pfile->cb.change_file)
822 cpp_buffer *buffer = pfile->buffer;
825 fc.from.filename = from_file;
826 fc.from.lineno = from_lineno;
827 fc.to.filename = buffer->nominal_fname;
828 fc.to.lineno = buffer->lineno + 1;
829 fc.sysp = buffer->inc->sysp;
830 fc.externc = CPP_OPTION (pfile, cplusplus) && buffer->inc->sysp == 2;
831 pfile->cb.change_file (pfile, &fc);
836 * Report a warning or error detected by the program we are
837 * processing. Use the directive's tokens in the error message.
841 do_diagnostic (pfile, code, print_dir)
843 enum error_type code;
846 if (_cpp_begin_message (pfile, code, NULL, 0))
849 fprintf (stderr, "#%s ", pfile->directive->name);
850 pfile->state.prevent_expansion++;
851 cpp_output_line (pfile, stderr);
852 pfile->state.prevent_expansion--;
860 do_diagnostic (pfile, ERROR, 1);
867 do_diagnostic (pfile, WARNING, 1);
870 /* Report program identification. */
878 cpp_get_token (pfile, &str);
879 if (str.type != CPP_STRING)
880 cpp_error (pfile, "invalid #ident");
881 else if (pfile->cb.ident)
882 (*pfile->cb.ident) (pfile, &str.val.str);
887 /* Pragmata handling. We handle some of these, and pass the rest on
888 to the front end. C99 defines three pragmas and says that no macro
889 expansion is to be performed on them; whether or not macro
890 expansion happens for other pragmas is implementation defined.
891 This implementation never macro-expands the text after #pragma. */
893 /* Sub-handlers for the pragmas needing treatment here.
894 They return 1 if the token buffer is to be popped, 0 if not. */
897 struct pragma_entry *next;
902 void (*handler) PARAMS ((cpp_reader *));
903 struct pragma_entry *space;
908 cpp_register_pragma (pfile, space, name, handler)
912 void (*handler) PARAMS ((cpp_reader *));
914 struct pragma_entry **x, *new;
920 struct pragma_entry *p = pfile->pragmas;
921 len = strlen (space);
924 if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
931 cpp_ice (pfile, "unknown #pragma namespace %s", space);
936 new = xnew (struct pragma_entry);
938 new->len = strlen (name);
940 new->u.handler = handler;
947 cpp_register_pragma_space (pfile, space)
951 struct pragma_entry *new;
952 const struct pragma_entry *p = pfile->pragmas;
953 size_t len = strlen (space);
957 if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
958 /* Multiple different callers are allowed to register the same
964 new = xnew (struct pragma_entry);
970 new->next = pfile->pragmas;
971 pfile->pragmas = new;
975 _cpp_init_internal_pragmas (pfile)
979 cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
980 cpp_register_pragma (pfile, 0, "once", do_pragma_once);
983 cpp_register_pragma_space (pfile, "GCC");
985 cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
986 cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
987 cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
994 const struct pragma_entry *p;
996 const cpp_hashnode *node;
1002 pfile->state.prevent_expansion++;
1003 cpp_start_lookahead (pfile);
1006 cpp_get_token (pfile, &tok);
1007 if (tok.type == CPP_NAME)
1009 node = tok.val.node;
1014 if (strlen (p->name) == len && !memcmp (p->name, name, len))
1023 (*p->u.handler) (pfile);
1032 cpp_stop_lookahead (pfile, drop);
1033 pfile->state.prevent_expansion--;
1035 if (!drop && pfile->cb.def_pragma)
1036 (*pfile->cb.def_pragma) (pfile);
1040 do_pragma_once (pfile)
1043 cpp_buffer *ip = CPP_BUFFER (pfile);
1045 cpp_warning (pfile, "#pragma once is obsolete");
1047 if (CPP_PREV_BUFFER (ip) == NULL)
1048 cpp_warning (pfile, "#pragma once in main file");
1050 ip->inc->cmacro = NEVER_REREAD;
1056 do_pragma_poison (pfile)
1059 /* Poison these symbols so that all subsequent usage produces an
1064 pfile->state.poisoned_ok = 1;
1067 _cpp_lex_token (pfile, &tok);
1068 if (tok.type == CPP_EOF)
1070 if (tok.type != CPP_NAME)
1072 cpp_error (pfile, "invalid #pragma GCC poison directive");
1077 if (hp->flags & NODE_POISONED)
1080 if (hp->type == NT_MACRO)
1081 cpp_warning (pfile, "poisoning existing macro \"%s\"", hp->name);
1082 _cpp_free_definition (hp);
1083 hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1085 pfile->state.poisoned_ok = 0;
1087 #if 0 /* Doesn't quite work yet. */
1088 if (tok.type == CPP_EOF && pfile->cb.poison)
1089 (*pfile->cb.poison) (pfile);
1093 /* Mark the current header as a system header. This will suppress
1094 some categories of warnings (notably those from -pedantic). It is
1095 intended for use in system libraries that cannot be implemented in
1096 conforming C, but cannot be certain that their headers appear in a
1097 system include directory. To prevent abuse, it is rejected in the
1098 primary source file. */
1100 do_pragma_system_header (pfile)
1103 cpp_buffer *ip = CPP_BUFFER (pfile);
1104 if (CPP_PREV_BUFFER (ip) == NULL)
1105 cpp_warning (pfile, "#pragma system_header outside include file");
1107 cpp_make_system_header (pfile, ip, 1);
1112 /* Check the modified date of the current include file against a specified
1113 file. Issue a diagnostic, if the specified file is newer. We use this to
1114 determine if a fixed header should be refixed. */
1116 do_pragma_dependency (pfile)
1119 cpp_token header, msg;
1122 if (parse_include (pfile, &header))
1125 ordering = _cpp_compare_file_date (pfile, &header);
1127 cpp_warning (pfile, "cannot find source %s",
1128 cpp_token_as_text (pfile, &header));
1129 else if (ordering > 0)
1131 cpp_warning (pfile, "current file is older than %s",
1132 cpp_token_as_text (pfile, &header));
1133 cpp_start_lookahead (pfile);
1134 cpp_get_token (pfile, &msg);
1135 cpp_stop_lookahead (pfile, msg.type == CPP_EOF);
1136 if (msg.type != CPP_EOF)
1137 do_diagnostic (pfile, WARNING, 0);
1141 /* Check syntax is "(string-literal)". Returns 0 on success. */
1143 get__Pragma_string (pfile, string)
1149 cpp_get_token (pfile, &paren);
1150 if (paren.type != CPP_OPEN_PAREN)
1153 cpp_get_token (pfile, string);
1154 if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1157 cpp_get_token (pfile, &paren);
1158 return paren.type != CPP_CLOSE_PAREN;
1161 /* Returns a malloced buffer containing a destringized cpp_string by
1162 removing the first \ of \" and \\ sequences. */
1163 static unsigned char *
1164 destringize (in, len)
1165 const cpp_string *in;
1168 const unsigned char *src, *limit;
1169 unsigned char *dest, *result;
1171 dest = result = (unsigned char *) xmalloc (in->len);
1172 for (src = in->text, limit = src + in->len; src < limit;)
1174 /* We know there is a character following the backslash. */
1175 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1180 *len = dest - result;
1185 _cpp_do__Pragma (pfile)
1189 unsigned char *buffer;
1192 if (get__Pragma_string (pfile, &string))
1194 cpp_error (pfile, "_Pragma takes a parenthesized string literal");
1198 buffer = destringize (&string.val.str, &len);
1199 run_directive (pfile, T_PRAGMA, (char *) buffer, len, _("<_Pragma>"));
1200 free ((PTR) buffer);
1203 /* Just ignore #sccs, on systems where we define it at all. */
1204 #ifdef SCCS_DIRECTIVE
1207 cpp_reader *pfile ATTRIBUTE_UNUSED;
1218 if (! pfile->buffer->was_skipping)
1220 const cpp_hashnode *node = lex_macro_node (pfile);
1223 skip = node->type != NT_MACRO;
1226 push_conditional (pfile, skip, T_IFDEF, 0);
1234 const cpp_hashnode *node = 0;
1236 if (! pfile->buffer->was_skipping)
1238 node = lex_macro_node (pfile);
1240 skip = node->type == NT_MACRO;
1243 push_conditional (pfile, skip, T_IFNDEF, node);
1246 /* #if cooperates with parse_defined to handle multiple-include
1247 optimisations. If macro expansions or identifiers appear in the
1248 expression, we cannot treat it as a controlling conditional, since
1249 their values could change in the future. */
1256 const cpp_hashnode *cmacro = 0;
1258 if (! pfile->buffer->was_skipping)
1260 /* Controlling macro of #if ! defined () */
1261 pfile->mi_ind_cmacro = 0;
1262 skip = _cpp_parse_expr (pfile) == 0;
1263 cmacro = pfile->mi_ind_cmacro;
1266 push_conditional (pfile, skip, T_IF, cmacro);
1269 /* Flip skipping state if appropriate and continue without changing
1270 if_stack; this is so that the error message for missing #endif's
1271 etc. will point to the original #if. */
1277 cpp_buffer *buffer = pfile->buffer;
1278 struct if_stack *ifs = buffer->if_stack;
1281 cpp_error (pfile, "#else without #if");
1284 if (ifs->type == T_ELSE)
1286 cpp_error (pfile, "#else after #else");
1287 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1288 "the conditional began here");
1292 /* Buffer->was_skipping is 1 if all conditionals in this chain
1293 have been false, 2 if a conditional has been true. */
1294 if (! ifs->was_skipping && buffer->was_skipping != 2)
1295 buffer->was_skipping = ! buffer->was_skipping;
1297 /* Invalidate any controlling macro. */
1304 /* handle a #elif directive by not changing if_stack either. see the
1305 comment above do_else. */
1311 cpp_buffer *buffer = pfile->buffer;
1312 struct if_stack *ifs = buffer->if_stack;
1315 cpp_error (pfile, "#elif without #if");
1318 if (ifs->type == T_ELSE)
1320 cpp_error (pfile, "#elif after #else");
1321 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1322 "the conditional began here");
1326 /* Don't evaluate #elif if our higher level is skipping. */
1327 if (! ifs->was_skipping)
1329 /* Buffer->was_skipping is 1 if all conditionals in this
1330 chain have been false, 2 if a conditional has been true. */
1331 if (buffer->was_skipping == 1)
1332 buffer->was_skipping = ! _cpp_parse_expr (pfile);
1334 buffer->was_skipping = 2;
1336 /* Invalidate any controlling macro. */
1342 /* #endif pops the if stack and resets pfile->skipping. */
1348 cpp_buffer *buffer = pfile->buffer;
1349 struct if_stack *ifs = buffer->if_stack;
1352 cpp_error (pfile, "#endif without #if");
1355 /* If potential control macro, we go back outside again. */
1356 if (ifs->next == 0 && ifs->mi_cmacro)
1358 pfile->mi_state = MI_OUTSIDE;
1359 pfile->mi_cmacro = ifs->mi_cmacro;
1362 buffer->if_stack = ifs->next;
1363 buffer->was_skipping = ifs->was_skipping;
1364 obstack_free (pfile->buffer_ob, ifs);
1370 /* Push an if_stack entry and set pfile->skipping accordingly.
1371 If this is a #ifndef starting at the beginning of a file,
1372 CMACRO is the macro name tested by the #ifndef. */
1375 push_conditional (pfile, skip, type, cmacro)
1379 const cpp_hashnode *cmacro;
1381 struct if_stack *ifs;
1382 cpp_buffer *buffer = pfile->buffer;
1384 ifs = xobnew (pfile->buffer_ob, struct if_stack);
1385 ifs->pos = pfile->directive_pos;
1386 ifs->next = buffer->if_stack;
1387 ifs->was_skipping = buffer->was_skipping;
1389 if (pfile->mi_state == MI_OUTSIDE && pfile->mi_cmacro == 0)
1390 ifs->mi_cmacro = cmacro;
1394 buffer->was_skipping = skip;
1395 buffer->if_stack = ifs;
1398 /* Read the tokens of the answer into the macro pool. Only commit the
1399 memory if we intend it as permanent storage, i.e. the #assert case.
1400 Returns 0 on success. */
1403 parse_answer (pfile, answerp, type)
1405 struct answer **answerp;
1408 cpp_token paren, *token;
1409 struct answer *answer;
1411 if (POOL_FRONT (&pfile->macro_pool) + sizeof (struct answer) >
1412 POOL_LIMIT (&pfile->macro_pool))
1413 _cpp_next_chunk (&pfile->macro_pool, sizeof (struct answer), 0);
1414 answer = (struct answer *) POOL_FRONT (&pfile->macro_pool);
1417 /* In a conditional, it is legal to not have an open paren. We
1418 should save the following token in this case. */
1420 cpp_start_lookahead (pfile);
1421 cpp_get_token (pfile, &paren);
1423 cpp_stop_lookahead (pfile, paren.type == CPP_OPEN_PAREN);
1425 /* If not a paren, see if we're OK. */
1426 if (paren.type != CPP_OPEN_PAREN)
1428 /* In a conditional no answer is a test for any answer. It
1429 could be followed by any token. */
1433 /* #unassert with no answer is valid - it removes all answers. */
1434 if (type == T_UNASSERT && paren.type == CPP_EOF)
1437 cpp_error (pfile, "missing '(' after predicate");
1443 token = &answer->first[answer->count];
1444 /* Check we have room for the token. */
1445 if ((unsigned char *) (token + 1) >= POOL_LIMIT (&pfile->macro_pool))
1447 _cpp_next_chunk (&pfile->macro_pool, sizeof (cpp_token),
1448 (unsigned char **) &answer);
1449 token = &answer->first[answer->count];
1452 cpp_get_token (pfile, token);
1453 if (token->type == CPP_CLOSE_PAREN)
1456 if (token->type == CPP_EOF)
1458 cpp_error (pfile, "missing ')' to complete answer");
1464 if (answer->count == 0)
1466 cpp_error (pfile, "predicate's answer is empty");
1470 /* Drop whitespace at start. */
1471 answer->first->flags &= ~PREV_WHITE;
1474 if (type == T_ASSERT || type == T_UNASSERT)
1479 /* Parses an assertion, returning a pointer to the hash node of the
1480 predicate, or 0 on error. If an answer was supplied, it is placed
1481 in ANSWERP, otherwise it is set to 0. */
1482 static cpp_hashnode *
1483 parse_assertion (pfile, answerp, type)
1485 struct answer **answerp;
1488 cpp_hashnode *result = 0;
1489 cpp_token predicate;
1491 /* We don't expand predicates or answers. */
1492 pfile->state.prevent_expansion++;
1494 /* Use the permanent pool for storage (for the answers). */
1495 pfile->string_pool = &pfile->ident_pool;
1498 cpp_get_token (pfile, &predicate);
1499 if (predicate.type == CPP_EOF)
1500 cpp_error (pfile, "assertion without predicate");
1501 else if (predicate.type != CPP_NAME)
1502 cpp_error (pfile, "predicate must be an identifier");
1503 else if (parse_answer (pfile, answerp, type) == 0)
1505 unsigned int len = predicate.val.node->length;
1506 unsigned char *sym = alloca (len + 1);
1508 /* Prefix '#' to get it out of macro namespace. */
1510 memcpy (sym + 1, predicate.val.node->name, len);
1511 result = cpp_lookup (pfile, sym, len + 1);
1514 pfile->string_pool = &pfile->temp_string_pool;
1515 pfile->state.prevent_expansion--;
1519 /* Returns a pointer to the pointer to the answer in the answer chain,
1520 or a pointer to NULL if the answer is not in the chain. */
1521 static struct answer **
1522 find_answer (node, candidate)
1524 const struct answer *candidate;
1527 struct answer **result;
1529 for (result = &node->value.answers; *result; result = &(*result)->next)
1531 struct answer *answer = *result;
1533 if (answer->count == candidate->count)
1535 for (i = 0; i < answer->count; i++)
1536 if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1539 if (i == answer->count)
1547 /* Test an assertion within a preprocessor conditional. Returns
1548 non-zero on failure, zero on success. On success, the result of
1549 the test is written into VALUE. */
1551 _cpp_test_assertion (pfile, value)
1555 struct answer *answer;
1558 node = parse_assertion (pfile, &answer, T_IF);
1560 *value = (node->type == NT_ASSERTION &&
1561 (answer == 0 || *find_answer (node, answer) != 0));
1563 /* We don't commit the memory for the answer - it's temporary only. */
1571 struct answer *new_answer;
1574 node = parse_assertion (pfile, &new_answer, T_ASSERT);
1577 /* Place the new answer in the answer list. First check there
1578 is not a duplicate. */
1579 new_answer->next = 0;
1580 if (node->type == NT_ASSERTION)
1582 if (*find_answer (node, new_answer))
1584 cpp_warning (pfile, "\"%s\" re-asserted", node->name + 1);
1587 new_answer->next = node->value.answers;
1589 node->type = NT_ASSERTION;
1590 node->value.answers = new_answer;
1591 POOL_COMMIT (&pfile->macro_pool, (sizeof (struct answer)
1592 + (new_answer->count - 1)
1593 * sizeof (cpp_token)));
1602 struct answer *answer;
1604 node = parse_assertion (pfile, &answer, T_UNASSERT);
1605 /* It isn't an error to #unassert something that isn't asserted. */
1606 if (node && node->type == NT_ASSERTION)
1610 struct answer **p = find_answer (node, answer), *temp;
1612 /* Remove the answer from the list. */
1617 /* Did we free the last answer? */
1618 if (node->value.answers == 0)
1619 node->type = NT_VOID;
1622 _cpp_free_definition (node);
1625 /* We don't commit the memory for the answer - it's temporary only. */
1628 /* These are for -D, -U, -A. */
1630 /* Process the string STR as if it appeared as the body of a #define.
1631 If STR is just an identifier, define it with value 1.
1632 If STR has anything after the identifier, then it should
1633 be identifier=definition. */
1636 cpp_define (pfile, str)
1643 /* Copy the entire option so we can modify it.
1644 Change the first "=" in the string to a space. If there is none,
1645 tack " 1" on the end. */
1647 /* Length including the null. */
1648 count = strlen (str);
1649 buf = (char *) alloca (count + 2);
1650 memcpy (buf, str, count);
1652 p = strchr (str, '=');
1661 run_directive (pfile, T_DEFINE, buf, count, 0);
1664 /* Slight variant of the above for use by initialize_builtins, which (a)
1665 knows how to set up the buffer itself, (b) needs a different "filename"
1668 _cpp_define_builtin (pfile, str)
1672 run_directive (pfile, T_DEFINE, str, strlen (str), _("<builtin>"));
1675 /* Process MACRO as if it appeared as the body of an #undef. */
1677 cpp_undef (pfile, macro)
1681 run_directive (pfile, T_UNDEF, macro, strlen (macro), 0);
1684 /* Process the string STR as if it appeared as the body of a #assert. */
1686 cpp_assert (pfile, str)
1690 handle_assertion (pfile, str, T_ASSERT);
1693 /* Process STR as if it appeared as the body of an #unassert. */
1695 cpp_unassert (pfile, str)
1699 handle_assertion (pfile, str, T_UNASSERT);
1702 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1704 handle_assertion (pfile, str, type)
1709 size_t count = strlen (str);
1710 const char *p = strchr (str, '=');
1714 /* Copy the entire option so we can modify it. Change the first
1715 "=" in the string to a '(', and tack a ')' on the end. */
1716 char *buf = (char *) alloca (count + 1);
1718 memcpy (buf, str, count);
1724 run_directive (pfile, type, str, count, 0);
1727 /* Allocate a new cpp_buffer for PFILE, and push it on the input
1728 buffer stack. If BUFFER != NULL, then use the LENGTH characters in
1729 BUFFER as the new input buffer. Return the new buffer, or NULL on
1733 cpp_push_buffer (pfile, buffer, length)
1735 const U_CHAR *buffer;
1738 cpp_buffer *buf = CPP_BUFFER (pfile);
1740 if (++pfile->buffer_stack_depth == CPP_STACK_MAX)
1742 cpp_fatal (pfile, "#include nested too deeply");
1746 new = xobnew (pfile->buffer_ob, cpp_buffer);
1747 /* Clears, amongst other things, if_stack and mi_cmacro. */
1748 memset (new, 0, sizeof (cpp_buffer));
1750 pfile->lexer_pos.output_line = 1;
1751 new->line_base = new->buf = new->cur = buffer;
1752 new->rlimit = buffer + length;
1755 /* Preprocessed files don't do trigraph and escaped newline processing. */
1756 new->from_stage3 = CPP_OPTION (pfile, preprocessed);
1757 /* No read ahead or extra char initially. */
1758 new->read_ahead = EOF;
1759 new->extra_char = EOF;
1760 pfile->state.next_bol = 1;
1762 CPP_BUFFER (pfile) = new;
1767 cpp_pop_buffer (pfile)
1770 cpp_buffer *buffer = pfile->buffer;
1771 const char *filename = buffer->nominal_fname;
1772 unsigned int lineno = buffer->lineno;
1773 struct if_stack *ifs = buffer->if_stack;
1774 int wfb = (buffer->inc != 0);
1776 /* Walk back up the conditional stack till we reach its level at
1777 entry to this file, issuing error messages. */
1778 for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
1779 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1780 "unterminated #%s", dtable[ifs->type].name);
1783 _cpp_pop_file_buffer (pfile, buffer);
1785 pfile->buffer = buffer->prev;
1786 obstack_free (pfile->buffer_ob, buffer);
1787 pfile->buffer_stack_depth--;
1789 if (pfile->buffer && wfb)
1790 _cpp_do_file_change (pfile, FC_LEAVE, filename, lineno);
1792 return pfile->buffer;
1795 #define obstack_chunk_alloc xmalloc
1796 #define obstack_chunk_free free
1798 _cpp_init_stacks (pfile)
1804 pfile->buffer_ob = xnew (struct obstack);
1805 obstack_init (pfile->buffer_ob);
1807 /* Register the directives. */
1808 for (i = 1; i < N_DIRECTIVES; i++)
1810 node = cpp_lookup (pfile, dtable[i - 1].name, dtable[i - 1].length);
1811 node->directive_index = i;
1816 _cpp_cleanup_stacks (pfile)
1819 obstack_free (pfile->buffer_ob, 0);
1820 free (pfile->buffer_ob);