1 /* CPP Library. (Directive handling.)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 Free Software Foundation, Inc.
4 Contributed by Per Bothner, 1994-95.
5 Based on CCCP program by Paul Rubin, June 1986
6 Adapted to ANSI C, Richard Stallman, Jan 1987
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
30 /* Chained list of answers to an assertion. */
38 /* Stack of conditionals currently in progress
39 (including both successful and failing conditionals). */
43 struct if_stack *next;
44 cpp_lexer_pos pos; /* line and column where condition started */
45 const cpp_hashnode *mi_cmacro;/* macro name for #ifndef around entire file */
46 unsigned char was_skipping; /* Value of pfile->skipping before this if. */
47 int type; /* type of last directive seen in this group */
50 /* Values for the origin field of struct directive. KANDR directives
51 come from traditional (K&R) C. STDC89 directives come from the
52 1989 C standard. EXTENSION directives are extensions. */
57 /* Values for the flags field of struct directive. COND indicates a
58 conditional; IF_COND an opening conditional. INCL means to treat
59 "..." and <...> as q-char and h-char sequences respectively. IN_I
60 means this directive should be handled even if -fpreprocessed is in
61 effect (these are the directives with callback hooks). */
63 #define IF_COND (1 << 1)
67 /* Defines one #-directive, including how to handle it. */
68 typedef void (*directive_handler) PARAMS ((cpp_reader *));
69 typedef struct directive directive;
72 directive_handler handler; /* Function to handle directive. */
73 const U_CHAR *name; /* Name of directive. */
74 unsigned short length; /* Length of name. */
75 unsigned char origin; /* Origin of directive. */
76 unsigned char flags; /* Flags describing this directive. */
79 /* Forward declarations. */
81 static void skip_rest_of_line PARAMS ((cpp_reader *));
82 static void check_eol PARAMS ((cpp_reader *));
83 static void start_directive PARAMS ((cpp_reader *));
84 static void end_directive PARAMS ((cpp_reader *, int));
85 static void run_directive PARAMS ((cpp_reader *, int,
87 const char *, size_t));
88 static int glue_header_name PARAMS ((cpp_reader *, cpp_token *));
89 static int parse_include PARAMS ((cpp_reader *, cpp_token *));
90 static void push_conditional PARAMS ((cpp_reader *, int, int,
91 const cpp_hashnode *));
92 static unsigned int read_flag PARAMS ((cpp_reader *, unsigned int));
93 static int strtoul_for_line PARAMS ((const U_CHAR *, unsigned int,
95 static void do_diagnostic PARAMS ((cpp_reader *, enum error_type, int));
96 static cpp_hashnode *lex_macro_node PARAMS ((cpp_reader *));
97 static void do_include_common PARAMS ((cpp_reader *, enum include_type));
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, STDC89, 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))
316 /* Kluge alert. In order to be sure that code like this
319 does not cause '#define foo bar' to get executed when
320 compiled with -save-temps, we recognize directives in
321 -fpreprocessed mode only if the # is in column 1 and the
322 directive name starts in column 2. This output can only
323 be generated by the directive callbacks in cppmain.c (see
324 also the special case in scan_buffer). */
325 if (dir->flags & IN_I && !indented && !(dname.flags & PREV_WHITE))
326 (*dir->handler) (pfile);
327 /* That check misses '# 123' linemarkers. Let them through too. */
328 else if (dname.type == CPP_NUMBER)
329 (*dir->handler) (pfile);
332 /* We don't want to process this directive. Put back the
333 tokens so caller will see them (and issue an error,
335 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
341 /* Traditionally, a directive is ignored unless its # is in
342 column 1. Therefore in code intended to work with K+R
343 compilers, directives added by C89 must have their #
344 indented, and directives present in traditional C must
345 not. This is true even of directives in skipped
346 conditional blocks. */
347 if (CPP_WTRADITIONAL (pfile))
349 if (dir == &dtable[T_ELIF])
351 "suggest not using #elif in traditional C");
352 else if (indented && dir->origin == KANDR)
354 "traditional C ignores #%s with the # indented",
356 else if (!indented && dir->origin != KANDR)
358 "suggest hiding #%s from traditional C with an indented #",
362 /* If we are skipping a failed conditional group, all
363 non-conditional directives are ignored. */
364 if (! buffer->was_skipping || (dir->flags & COND))
366 /* Issue -pedantic warnings for extensions. */
367 if (CPP_PEDANTIC (pfile) && dir->origin == EXTENSION)
368 cpp_pedwarn (pfile, "#%s is a GCC extension", dir->name);
370 /* If we have a directive that is not an opening
371 conditional, invalidate any control macro. */
372 if (! (dir->flags & IF_COND))
373 pfile->mi_state = MI_FAILED;
375 (*dir->handler) (pfile);
379 else if (dname.type != CPP_EOF && ! buffer->was_skipping)
381 /* An unknown directive. Don't complain about it in assembly
382 source: we don't know where the comments are, and # may
383 introduce assembler pseudo-ops. Don't complain about invalid
384 directives in skipped conditional groups (6.10 p4). */
385 if (CPP_OPTION (pfile, lang) == CLK_ASM)
387 /* Output the # and lookahead token for the assembler. */
388 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
392 cpp_error (pfile, "invalid preprocessing directive #%s",
393 cpp_token_as_text (pfile, &dname));
396 end_directive (pfile, skip);
400 /* Directive handler wrapper used by the command line option
403 run_directive (pfile, dir_no, type, buf, count)
406 enum cpp_buffer_type type;
410 unsigned int output_line = pfile->lexer_pos.output_line;
413 buffer = cpp_push_buffer (pfile, (const U_CHAR *) buf, count, type, 0);
415 if (dir_no == T_PRAGMA)
417 /* A kludge to avoid line markers for _Pragma. */
418 pfile->lexer_pos.output_line = output_line;
419 /* Avoid interpretation of directives in a _Pragma string. */
420 pfile->state.next_bol = 0;
423 start_directive (pfile);
424 pfile->state.prevent_expansion++;
425 pfile->directive = &dtable[dir_no];
426 (void) (*pfile->directive->handler) (pfile);
427 pfile->state.prevent_expansion--;
429 end_directive (pfile, 1);
431 cpp_pop_buffer (pfile);
434 /* Checks for validity the macro name in #define, #undef, #ifdef and
435 #ifndef directives. */
436 static cpp_hashnode *
437 lex_macro_node (pfile)
442 /* Lex the macro name directly. */
443 _cpp_lex_token (pfile, &token);
445 /* The token immediately after #define must be an identifier. That
446 identifier is not allowed to be "defined". See predefined macro
447 names (6.10.8.4). In C++, it is not allowed to be any of the
448 <iso646.h> macro names (which are keywords in C++) either. */
450 if (token.type != CPP_NAME)
452 if (token.type == CPP_EOF)
453 cpp_error (pfile, "no macro name given in #%s directive",
454 pfile->directive->name);
455 else if (token.flags & NAMED_OP)
457 "\"%s\" cannot be used as a macro name as it is an operator in C++",
458 NODE_NAME (token.val.node));
460 cpp_error (pfile, "macro names must be identifiers");
464 cpp_hashnode *node = token.val.node;
466 /* In Objective C, some keywords begin with '@', but general
467 identifiers do not, and you're not allowed to #define them. */
468 if (node == pfile->spec_nodes.n_defined || NODE_NAME (node)[0] == '@')
469 cpp_error (pfile, "\"%s\" cannot be used as a macro name",
471 else if (!(node->flags & NODE_POISONED))
478 /* Process a #define directive. Most work is done in cppmacro.c. */
483 cpp_hashnode *node = lex_macro_node (pfile);
487 if (_cpp_create_definition (pfile, node))
488 if (pfile->cb.define)
489 (*pfile->cb.define) (pfile, node);
493 /* Handle #undef. Marks the identifier NT_VOID in the hash table. */
498 cpp_hashnode *node = lex_macro_node (pfile);
500 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
501 is not currently defined as a macro name. */
502 if (node && node->type == NT_MACRO)
505 (*pfile->cb.undef) (pfile, node);
507 if (node->flags & NODE_WARN)
508 cpp_warning (pfile, "undefining \"%s\"", NODE_NAME (node));
510 _cpp_free_definition (node);
515 /* Helper routine used by parse_include. Reinterpret the current line
516 as an h-char-sequence (< ... >); we are looking at the first token
517 after the <. Returns zero on success. */
519 glue_header_name (pfile, header)
524 unsigned char *buffer, *token_mem;
525 size_t len, total_len = 0, capacity = 1024;
527 /* To avoid lexed tokens overwriting our glued name, we can only
528 allocate from the string pool once we've lexed everything. */
530 buffer = (unsigned char *) xmalloc (capacity);
533 cpp_get_token (pfile, &token);
535 if (token.type == CPP_GREATER || token.type == CPP_EOF)
538 len = cpp_token_len (&token);
539 if (total_len + len > capacity)
541 capacity = (capacity + len) * 2;
542 buffer = (unsigned char *) xrealloc (buffer, capacity);
545 if (token.flags & PREV_WHITE)
546 buffer[total_len++] = ' ';
548 total_len = cpp_spell_token (pfile, &token, &buffer[total_len]) - buffer;
551 if (token.type == CPP_EOF)
552 cpp_error (pfile, "missing terminating > character");
555 token_mem = _cpp_pool_alloc (&pfile->ident_pool, total_len + 1);
556 memcpy (token_mem, buffer, total_len);
557 token_mem[total_len] = '\0';
559 header->type = CPP_HEADER_NAME;
560 header->flags &= ~PREV_WHITE;
561 header->val.str.len = total_len;
562 header->val.str.text = token_mem;
566 return token.type == CPP_EOF;
569 /* Parse the header name of #include, #include_next, #import and
570 #pragma dependency. Returns zero on success. */
572 parse_include (pfile, header)
576 int is_pragma = pfile->directive == &dtable[T_PRAGMA];
577 const unsigned char *dir;
580 dir = U"pragma dependency";
582 dir = pfile->directive->name;
584 /* Allow macro expansion. */
585 cpp_get_token (pfile, header);
586 if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
588 if (header->type != CPP_LESS)
590 cpp_error (pfile, "#%s expects \"FILENAME\" or <FILENAME>", dir);
593 if (glue_header_name (pfile, header))
597 if (header->val.str.len == 0)
599 cpp_error (pfile, "empty file name in #%s", dir);
606 /* Get out of macro context, if we are. */
607 skip_rest_of_line (pfile);
608 if (pfile->cb.include)
609 (*pfile->cb.include) (pfile, dir, header);
615 /* Handle #include, #include_next and #import. */
617 do_include_common (pfile, type)
619 enum include_type type;
623 if (!parse_include (pfile, &header))
625 /* Prevent #include recursion. */
626 if (pfile->buffer_stack_depth >= CPP_STACK_MAX)
627 cpp_fatal (pfile, "#include nested too deeply");
628 else if (pfile->context->prev)
629 cpp_ice (pfile, "attempt to push file buffer with contexts stacked");
632 /* For #include_next, if this is the primary source file,
633 warn and use the normal search logic. */
634 if (type == IT_INCLUDE_NEXT && ! pfile->buffer->prev)
636 cpp_warning (pfile, "#include_next in primary source file");
640 _cpp_execute_include (pfile, &header, type);
649 do_include_common (pfile, IT_INCLUDE);
656 if (!pfile->import_warning && CPP_OPTION (pfile, warn_import))
658 pfile->import_warning = 1;
660 "#import is obsolete, use an #ifndef wrapper in the header file");
663 do_include_common (pfile, IT_IMPORT);
667 do_include_next (pfile)
670 do_include_common (pfile, IT_INCLUDE_NEXT);
673 /* Subroutine of do_line. Read possible flags after file name. LAST
674 is the last flag seen; 0 if this is the first flag. Return the flag
675 if it is valid, 0 at the end of the directive. Otherwise complain. */
678 read_flag (pfile, last)
684 _cpp_lex_token (pfile, &token);
685 if (token.type == CPP_NUMBER && token.val.str.len == 1)
687 unsigned int flag = token.val.str.text[0] - '0';
689 if (flag > last && flag <= 4
690 && (flag != 4 || last == 3)
691 && (flag != 2 || last == 0))
695 if (token.type != CPP_EOF)
696 cpp_error (pfile, "invalid flag \"%s\" in line directive",
697 cpp_token_as_text (pfile, &token));
701 /* Another subroutine of do_line. Convert a number in STR, of length
702 LEN, to binary; store it in NUMP, and return 0 if the number was
703 well-formed, 1 if not. Temporary, hopefully. */
705 strtoul_for_line (str, len, nump)
710 unsigned long reg = 0;
724 /* Interpret #line command.
725 Note that the filename string (if any) is treated as if it were an
726 include filename. That means no escape handling. */
732 cpp_buffer *buffer = pfile->buffer;
733 const char *filename = buffer->nominal_fname;
734 unsigned int lineno = buffer->lineno;
735 enum cpp_fc_reason reason = FC_RENAME;
736 unsigned long new_lineno;
740 /* C99 raised the minimum limit on #line numbers. */
741 cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
743 /* #line commands expand macros. */
744 cpp_get_token (pfile, &token);
745 if (token.type != CPP_NUMBER
746 || strtoul_for_line (token.val.str.text, token.val.str.len, &new_lineno))
748 cpp_error (pfile, "\"%s\" after #line is not a positive integer",
749 cpp_token_as_text (pfile, &token));
753 if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
754 cpp_pedwarn (pfile, "line number out of range");
756 cpp_get_token (pfile, &token);
757 if (token.type == CPP_STRING)
759 const char *fname = (const char *) token.val.str.text;
761 /* Only accept flags for the # 55 form. */
762 if (! pfile->state.line_extension)
766 int flag = 0, sysp = 0;
768 flag = read_flag (pfile, flag);
772 flag = read_flag (pfile, flag);
777 flag = read_flag (pfile, flag);
782 flag = read_flag (pfile, flag);
784 sysp = 2, read_flag (pfile, flag);
787 if (reason == FC_ENTER)
789 /* Fake a buffer stack for diagnostics. */
790 cpp_push_buffer (pfile, 0, 0, BUF_FAKE, fname);
791 /* Fake an include for cpp_included. */
792 _cpp_fake_include (pfile, fname);
793 buffer = pfile->buffer;
795 else if (reason == FC_LEAVE)
797 if (buffer->type != BUF_FAKE)
798 cpp_warning (pfile, "file \"%s\" left but not entered",
799 buffer->nominal_fname);
802 cpp_pop_buffer (pfile);
803 buffer = pfile->buffer;
804 #ifdef ENABLE_CHECKING
805 if (strcmp (buffer->nominal_fname, fname))
806 cpp_warning (pfile, "expected to return to file \"%s\"",
807 buffer->nominal_fname);
808 if (buffer->lineno + 1 != new_lineno)
809 cpp_warning (pfile, "expected to return to line number %u",
811 if (buffer->sysp != sysp)
812 cpp_warning (pfile, "header flags for \"%s\" have changed",
813 buffer->nominal_fname);
819 buffer->nominal_fname = fname;
821 else if (token.type != CPP_EOF)
823 cpp_error (pfile, "\"%s\" is not a valid filename",
824 cpp_token_as_text (pfile, &token));
828 /* Our line number is incremented after the directive is processed. */
829 buffer->lineno = new_lineno - 1;
830 _cpp_do_file_change (pfile, reason, filename, lineno);
833 /* Arrange the file_change callback. */
835 _cpp_do_file_change (pfile, reason, from_file, from_lineno)
837 enum cpp_fc_reason reason;
838 const char *from_file;
839 unsigned int from_lineno;
841 if (pfile->cb.file_change)
844 cpp_buffer *buffer = pfile->buffer;
847 fc.to.filename = buffer->nominal_fname;
848 fc.to.lineno = buffer->lineno + 1;
849 fc.sysp = buffer->sysp;
850 fc.externc = CPP_OPTION (pfile, cplusplus) && buffer->sysp == 2;
852 /* Caller doesn't need to handle FC_ENTER. */
853 if (reason == FC_ENTER)
857 from_file = buffer->prev->nominal_fname;
858 from_lineno = buffer->prev->lineno;
863 /* Special case for file "foo.i" with "# 1 foo.c" on first line. */
864 else if (reason == FC_RENAME && ! buffer->prev
865 && pfile->directive_pos.line == 1)
868 fc.from.filename = from_file;
869 fc.from.lineno = from_lineno;
870 pfile->cb.file_change (pfile, &fc);
875 * Report a warning or error detected by the program we are
876 * processing. Use the directive's tokens in the error message.
880 do_diagnostic (pfile, code, print_dir)
882 enum error_type code;
885 if (_cpp_begin_message (pfile, code, NULL, 0))
888 fprintf (stderr, "#%s ", pfile->directive->name);
889 pfile->state.prevent_expansion++;
890 cpp_output_line (pfile, stderr);
891 pfile->state.prevent_expansion--;
899 do_diagnostic (pfile, ERROR, 1);
906 /* We want #warning diagnostics to be emitted in system headers too. */
907 do_diagnostic (pfile, WARNING_SYSHDR, 1);
910 /* Report program identification. */
918 cpp_get_token (pfile, &str);
919 if (str.type != CPP_STRING)
920 cpp_error (pfile, "invalid #ident");
921 else if (pfile->cb.ident)
922 (*pfile->cb.ident) (pfile, &str.val.str);
927 /* Pragmata handling. We handle some of these, and pass the rest on
928 to the front end. C99 defines three pragmas and says that no macro
929 expansion is to be performed on them; whether or not macro
930 expansion happens for other pragmas is implementation defined.
931 This implementation never macro-expands the text after #pragma. */
933 /* Sub-handlers for the pragmas needing treatment here.
934 They return 1 if the token buffer is to be popped, 0 if not. */
937 struct pragma_entry *next;
942 void (*handler) PARAMS ((cpp_reader *));
943 struct pragma_entry *space;
948 cpp_register_pragma (pfile, space, name, handler)
952 void (*handler) PARAMS ((cpp_reader *));
954 struct pragma_entry **x, *new;
960 struct pragma_entry *p = pfile->pragmas;
961 len = strlen (space);
964 if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
971 cpp_ice (pfile, "unknown #pragma namespace %s", space);
976 new = xnew (struct pragma_entry);
978 new->len = strlen (name);
980 new->u.handler = handler;
987 cpp_register_pragma_space (pfile, space)
991 struct pragma_entry *new;
992 const struct pragma_entry *p = pfile->pragmas;
993 size_t len = strlen (space);
997 if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
998 /* Multiple different callers are allowed to register the same
1004 new = xnew (struct pragma_entry);
1010 new->next = pfile->pragmas;
1011 pfile->pragmas = new;
1015 _cpp_init_internal_pragmas (pfile)
1019 cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
1020 cpp_register_pragma (pfile, 0, "once", do_pragma_once);
1023 cpp_register_pragma_space (pfile, "GCC");
1025 cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
1026 cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
1027 cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
1034 const struct pragma_entry *p;
1039 pfile->state.prevent_expansion++;
1040 cpp_start_lookahead (pfile);
1043 cpp_get_token (pfile, &tok);
1044 if (tok.type == CPP_NAME)
1046 const cpp_hashnode *node = tok.val.node;
1047 size_t len = NODE_LEN (node);
1051 if (strlen (p->name) == len
1052 && !memcmp (p->name, NODE_NAME (node), len))
1061 (*p->u.handler) (pfile);
1070 cpp_stop_lookahead (pfile, drop);
1071 pfile->state.prevent_expansion--;
1073 if (!drop && pfile->cb.def_pragma)
1074 (*pfile->cb.def_pragma) (pfile);
1078 do_pragma_once (pfile)
1081 cpp_warning (pfile, "#pragma once is obsolete");
1083 if (pfile->buffer->prev == NULL)
1084 cpp_warning (pfile, "#pragma once in main file");
1086 _cpp_never_reread (pfile->buffer->inc);
1092 do_pragma_poison (pfile)
1095 /* Poison these symbols so that all subsequent usage produces an
1100 pfile->state.poisoned_ok = 1;
1103 _cpp_lex_token (pfile, &tok);
1104 if (tok.type == CPP_EOF)
1106 if (tok.type != CPP_NAME)
1108 cpp_error (pfile, "invalid #pragma GCC poison directive");
1113 if (hp->flags & NODE_POISONED)
1116 if (hp->type == NT_MACRO)
1117 cpp_warning (pfile, "poisoning existing macro \"%s\"", NODE_NAME (hp));
1118 _cpp_free_definition (hp);
1119 hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1121 pfile->state.poisoned_ok = 0;
1123 #if 0 /* Doesn't quite work yet. */
1124 if (tok.type == CPP_EOF && pfile->cb.poison)
1125 (*pfile->cb.poison) (pfile);
1129 /* Mark the current header as a system header. This will suppress
1130 some categories of warnings (notably those from -pedantic). It is
1131 intended for use in system libraries that cannot be implemented in
1132 conforming C, but cannot be certain that their headers appear in a
1133 system include directory. To prevent abuse, it is rejected in the
1134 primary source file. */
1136 do_pragma_system_header (pfile)
1139 cpp_buffer *buffer = pfile->buffer;
1141 if (buffer->prev == 0)
1142 cpp_warning (pfile, "#pragma system_header ignored outside include file");
1144 cpp_make_system_header (pfile, 1, 0);
1149 /* Check the modified date of the current include file against a specified
1150 file. Issue a diagnostic, if the specified file is newer. We use this to
1151 determine if a fixed header should be refixed. */
1153 do_pragma_dependency (pfile)
1156 cpp_token header, msg;
1159 if (parse_include (pfile, &header))
1162 ordering = _cpp_compare_file_date (pfile, &header);
1164 cpp_warning (pfile, "cannot find source %s",
1165 cpp_token_as_text (pfile, &header));
1166 else if (ordering > 0)
1168 cpp_warning (pfile, "current file is older than %s",
1169 cpp_token_as_text (pfile, &header));
1170 cpp_start_lookahead (pfile);
1171 cpp_get_token (pfile, &msg);
1172 cpp_stop_lookahead (pfile, msg.type == CPP_EOF);
1173 if (msg.type != CPP_EOF)
1174 do_diagnostic (pfile, WARNING, 0);
1178 /* Check syntax is "(string-literal)". Returns 0 on success. */
1180 get__Pragma_string (pfile, string)
1186 cpp_get_token (pfile, &paren);
1187 if (paren.type != CPP_OPEN_PAREN)
1190 cpp_get_token (pfile, string);
1191 if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1194 cpp_get_token (pfile, &paren);
1195 return paren.type != CPP_CLOSE_PAREN;
1198 /* Returns a malloced buffer containing a destringized cpp_string by
1199 removing the first \ of \" and \\ sequences. */
1200 static unsigned char *
1201 destringize (in, len)
1202 const cpp_string *in;
1205 const unsigned char *src, *limit;
1206 unsigned char *dest, *result;
1208 dest = result = (unsigned char *) xmalloc (in->len);
1209 for (src = in->text, limit = src + in->len; src < limit;)
1211 /* We know there is a character following the backslash. */
1212 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1217 *len = dest - result;
1222 _cpp_do__Pragma (pfile)
1226 unsigned char *buffer;
1229 if (get__Pragma_string (pfile, &string))
1231 cpp_error (pfile, "_Pragma takes a parenthesized string literal");
1235 buffer = destringize (&string.val.str, &len);
1236 run_directive (pfile, T_PRAGMA, BUF_PRAGMA, (char *) buffer, len);
1237 free ((PTR) buffer);
1240 /* Just ignore #sccs, on systems where we define it at all. */
1241 #ifdef SCCS_DIRECTIVE
1244 cpp_reader *pfile ATTRIBUTE_UNUSED;
1255 if (! pfile->buffer->was_skipping)
1257 const cpp_hashnode *node = lex_macro_node (pfile);
1260 skip = node->type != NT_MACRO;
1266 push_conditional (pfile, skip, T_IFDEF, 0);
1274 const cpp_hashnode *node = 0;
1276 if (! pfile->buffer->was_skipping)
1278 node = lex_macro_node (pfile);
1280 skip = node->type == NT_MACRO;
1286 push_conditional (pfile, skip, T_IFNDEF, node);
1289 /* #if cooperates with parse_defined to handle multiple-include
1290 optimisations. If macro expansions or identifiers appear in the
1291 expression, we cannot treat it as a controlling conditional, since
1292 their values could change in the future. */
1299 const cpp_hashnode *cmacro = 0;
1301 if (! pfile->buffer->was_skipping)
1303 /* Controlling macro of #if ! defined () */
1304 pfile->mi_ind_cmacro = 0;
1305 skip = _cpp_parse_expr (pfile) == 0;
1306 cmacro = pfile->mi_ind_cmacro;
1309 push_conditional (pfile, skip, T_IF, cmacro);
1312 /* Flip skipping state if appropriate and continue without changing
1313 if_stack; this is so that the error message for missing #endif's
1314 etc. will point to the original #if. */
1320 cpp_buffer *buffer = pfile->buffer;
1321 struct if_stack *ifs = buffer->if_stack;
1324 cpp_error (pfile, "#else without #if");
1327 if (ifs->type == T_ELSE)
1329 cpp_error (pfile, "#else after #else");
1330 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1331 "the conditional began here");
1335 /* Buffer->was_skipping is 1 if all conditionals in this chain
1336 have been false, 2 if a conditional has been true. */
1337 if (! ifs->was_skipping && buffer->was_skipping != 2)
1338 buffer->was_skipping = ! buffer->was_skipping;
1340 /* Invalidate any controlling macro. */
1347 /* handle a #elif directive by not changing if_stack either. see the
1348 comment above do_else. */
1354 cpp_buffer *buffer = pfile->buffer;
1355 struct if_stack *ifs = buffer->if_stack;
1358 cpp_error (pfile, "#elif without #if");
1361 if (ifs->type == T_ELSE)
1363 cpp_error (pfile, "#elif after #else");
1364 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1365 "the conditional began here");
1369 /* Don't evaluate #elif if our higher level is skipping. */
1370 if (! ifs->was_skipping)
1372 /* Buffer->was_skipping is 1 if all conditionals in this
1373 chain have been false, 2 if a conditional has been true. */
1374 if (buffer->was_skipping == 1)
1375 buffer->was_skipping = ! _cpp_parse_expr (pfile);
1377 buffer->was_skipping = 2;
1379 /* Invalidate any controlling macro. */
1385 /* #endif pops the if stack and resets pfile->skipping. */
1391 cpp_buffer *buffer = pfile->buffer;
1392 struct if_stack *ifs = buffer->if_stack;
1395 cpp_error (pfile, "#endif without #if");
1398 /* If potential control macro, we go back outside again. */
1399 if (ifs->next == 0 && ifs->mi_cmacro)
1401 pfile->mi_state = MI_OUTSIDE;
1402 pfile->mi_cmacro = ifs->mi_cmacro;
1405 buffer->if_stack = ifs->next;
1406 buffer->was_skipping = ifs->was_skipping;
1407 obstack_free (&pfile->buffer_ob, ifs);
1413 /* Push an if_stack entry and set pfile->skipping accordingly.
1414 If this is a #ifndef starting at the beginning of a file,
1415 CMACRO is the macro name tested by the #ifndef. */
1418 push_conditional (pfile, skip, type, cmacro)
1422 const cpp_hashnode *cmacro;
1424 struct if_stack *ifs;
1425 cpp_buffer *buffer = pfile->buffer;
1427 ifs = xobnew (&pfile->buffer_ob, struct if_stack);
1428 ifs->pos = pfile->directive_pos;
1429 ifs->next = buffer->if_stack;
1430 ifs->was_skipping = buffer->was_skipping;
1432 if (pfile->mi_state == MI_OUTSIDE && pfile->mi_cmacro == 0)
1433 ifs->mi_cmacro = cmacro;
1437 buffer->was_skipping = skip;
1438 buffer->if_stack = ifs;
1441 /* Read the tokens of the answer into the macro pool. Only commit the
1442 memory if we intend it as permanent storage, i.e. the #assert case.
1443 Returns 0 on success. */
1446 parse_answer (pfile, answerp, type)
1448 struct answer **answerp;
1451 cpp_token paren, *token;
1452 struct answer *answer;
1454 if (POOL_FRONT (&pfile->macro_pool) + sizeof (struct answer) >
1455 POOL_LIMIT (&pfile->macro_pool))
1456 _cpp_next_chunk (&pfile->macro_pool, sizeof (struct answer), 0);
1457 answer = (struct answer *) POOL_FRONT (&pfile->macro_pool);
1460 /* In a conditional, it is legal to not have an open paren. We
1461 should save the following token in this case. */
1463 cpp_start_lookahead (pfile);
1464 cpp_get_token (pfile, &paren);
1466 cpp_stop_lookahead (pfile, paren.type == CPP_OPEN_PAREN);
1468 /* If not a paren, see if we're OK. */
1469 if (paren.type != CPP_OPEN_PAREN)
1471 /* In a conditional no answer is a test for any answer. It
1472 could be followed by any token. */
1476 /* #unassert with no answer is valid - it removes all answers. */
1477 if (type == T_UNASSERT && paren.type == CPP_EOF)
1480 cpp_error (pfile, "missing '(' after predicate");
1486 token = &answer->first[answer->count];
1487 /* Check we have room for the token. */
1488 if ((unsigned char *) (token + 1) >= POOL_LIMIT (&pfile->macro_pool))
1490 _cpp_next_chunk (&pfile->macro_pool, sizeof (cpp_token),
1491 (unsigned char **) &answer);
1492 token = &answer->first[answer->count];
1495 cpp_get_token (pfile, token);
1496 if (token->type == CPP_CLOSE_PAREN)
1499 if (token->type == CPP_EOF)
1501 cpp_error (pfile, "missing ')' to complete answer");
1507 if (answer->count == 0)
1509 cpp_error (pfile, "predicate's answer is empty");
1513 /* Drop whitespace at start. */
1514 answer->first->flags &= ~PREV_WHITE;
1517 if (type == T_ASSERT || type == T_UNASSERT)
1522 /* Parses an assertion, returning a pointer to the hash node of the
1523 predicate, or 0 on error. If an answer was supplied, it is placed
1524 in ANSWERP, otherwise it is set to 0. */
1525 static cpp_hashnode *
1526 parse_assertion (pfile, answerp, type)
1528 struct answer **answerp;
1531 cpp_hashnode *result = 0;
1532 cpp_token predicate;
1534 /* We don't expand predicates or answers. */
1535 pfile->state.prevent_expansion++;
1538 cpp_get_token (pfile, &predicate);
1539 if (predicate.type == CPP_EOF)
1540 cpp_error (pfile, "assertion without predicate");
1541 else if (predicate.type != CPP_NAME)
1542 cpp_error (pfile, "predicate must be an identifier");
1543 else if (parse_answer (pfile, answerp, type) == 0)
1545 unsigned int len = NODE_LEN (predicate.val.node);
1546 unsigned char *sym = alloca (len + 1);
1548 /* Prefix '#' to get it out of macro namespace. */
1550 memcpy (sym + 1, NODE_NAME (predicate.val.node), len);
1551 result = cpp_lookup (pfile, sym, len + 1);
1554 pfile->state.prevent_expansion--;
1558 /* Returns a pointer to the pointer to the answer in the answer chain,
1559 or a pointer to NULL if the answer is not in the chain. */
1560 static struct answer **
1561 find_answer (node, candidate)
1563 const struct answer *candidate;
1566 struct answer **result;
1568 for (result = &node->value.answers; *result; result = &(*result)->next)
1570 struct answer *answer = *result;
1572 if (answer->count == candidate->count)
1574 for (i = 0; i < answer->count; i++)
1575 if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1578 if (i == answer->count)
1586 /* Test an assertion within a preprocessor conditional. Returns
1587 non-zero on failure, zero on success. On success, the result of
1588 the test is written into VALUE. */
1590 _cpp_test_assertion (pfile, value)
1594 struct answer *answer;
1597 node = parse_assertion (pfile, &answer, T_IF);
1599 *value = (node->type == NT_ASSERTION &&
1600 (answer == 0 || *find_answer (node, answer) != 0));
1602 /* We don't commit the memory for the answer - it's temporary only. */
1610 struct answer *new_answer;
1613 node = parse_assertion (pfile, &new_answer, T_ASSERT);
1616 /* Place the new answer in the answer list. First check there
1617 is not a duplicate. */
1618 new_answer->next = 0;
1619 if (node->type == NT_ASSERTION)
1621 if (*find_answer (node, new_answer))
1623 cpp_warning (pfile, "\"%s\" re-asserted", NODE_NAME (node) + 1);
1626 new_answer->next = node->value.answers;
1628 node->type = NT_ASSERTION;
1629 node->value.answers = new_answer;
1630 POOL_COMMIT (&pfile->macro_pool, (sizeof (struct answer)
1631 + (new_answer->count - 1)
1632 * sizeof (cpp_token)));
1641 struct answer *answer;
1643 node = parse_assertion (pfile, &answer, T_UNASSERT);
1644 /* It isn't an error to #unassert something that isn't asserted. */
1645 if (node && node->type == NT_ASSERTION)
1649 struct answer **p = find_answer (node, answer), *temp;
1651 /* Remove the answer from the list. */
1656 /* Did we free the last answer? */
1657 if (node->value.answers == 0)
1658 node->type = NT_VOID;
1661 _cpp_free_definition (node);
1664 /* We don't commit the memory for the answer - it's temporary only. */
1667 /* These are for -D, -U, -A. */
1669 /* Process the string STR as if it appeared as the body of a #define.
1670 If STR is just an identifier, define it with value 1.
1671 If STR has anything after the identifier, then it should
1672 be identifier=definition. */
1675 cpp_define (pfile, str)
1682 /* Copy the entire option so we can modify it.
1683 Change the first "=" in the string to a space. If there is none,
1684 tack " 1" on the end. */
1686 /* Length including the null. */
1687 count = strlen (str);
1688 buf = (char *) alloca (count + 2);
1689 memcpy (buf, str, count);
1691 p = strchr (str, '=');
1700 run_directive (pfile, T_DEFINE, BUF_CL_OPTION, buf, count);
1703 /* Slight variant of the above for use by initialize_builtins. */
1705 _cpp_define_builtin (pfile, str)
1709 run_directive (pfile, T_DEFINE, BUF_BUILTIN, str, strlen (str));
1712 /* Process MACRO as if it appeared as the body of an #undef. */
1714 cpp_undef (pfile, macro)
1718 run_directive (pfile, T_UNDEF, BUF_CL_OPTION, macro, strlen (macro));
1721 /* Process the string STR as if it appeared as the body of a #assert. */
1723 cpp_assert (pfile, str)
1727 handle_assertion (pfile, str, T_ASSERT);
1730 /* Process STR as if it appeared as the body of an #unassert. */
1732 cpp_unassert (pfile, str)
1736 handle_assertion (pfile, str, T_UNASSERT);
1739 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1741 handle_assertion (pfile, str, type)
1746 size_t count = strlen (str);
1747 const char *p = strchr (str, '=');
1751 /* Copy the entire option so we can modify it. Change the first
1752 "=" in the string to a '(', and tack a ')' on the end. */
1753 char *buf = (char *) alloca (count + 1);
1755 memcpy (buf, str, count);
1761 run_directive (pfile, type, BUF_CL_OPTION, str, count);
1764 /* The number of errors for a given reader. */
1769 return pfile->errors;
1772 /* The options structure. */
1774 cpp_get_options (pfile)
1777 return &pfile->opts;
1780 /* The callbacks structure. */
1782 cpp_get_callbacks (pfile)
1788 /* Copy the given callbacks structure to our own. */
1790 cpp_set_callbacks (pfile, cb)
1797 /* Push a new buffer on the buffer stack. Returns the new buffer; it
1798 doesn't fail. It does not generate a file change call back; that
1799 is the responsibility of the caller. */
1801 cpp_push_buffer (pfile, buffer, len, type, filename)
1803 const U_CHAR *buffer;
1805 enum cpp_buffer_type type;
1806 const char *filename;
1808 cpp_buffer *new = xobnew (&pfile->buffer_ob, cpp_buffer);
1810 if (type == BUF_FAKE)
1812 /* A copy of the current buffer, just with a new name and type. */
1813 memcpy (new, pfile->buffer, sizeof (cpp_buffer));
1814 new->type = BUF_FAKE;
1818 if (type == BUF_BUILTIN)
1819 filename = _("<builtin>");
1820 else if (type == BUF_CL_OPTION)
1821 filename = _("<command line>");
1822 else if (type == BUF_PRAGMA)
1823 filename = "<_Pragma>";
1825 /* Clears, amongst other things, if_stack and mi_cmacro. */
1826 memset (new, 0, sizeof (cpp_buffer));
1828 new->line_base = new->buf = new->cur = buffer;
1829 new->rlimit = buffer + len;
1832 /* No read ahead or extra char initially. */
1833 new->read_ahead = EOF;
1834 new->extra_char = EOF;
1836 /* Preprocessed files, builtins, _Pragma and command line
1837 options don't do trigraph and escaped newline processing. */
1838 new->from_stage3 = type != BUF_FILE || CPP_OPTION (pfile, preprocessed);
1840 pfile->lexer_pos.output_line = 1;
1843 if (*filename == '\0')
1844 new->nominal_fname = _("<stdin>");
1846 new->nominal_fname = filename;
1848 new->prev = pfile->buffer;
1850 new->include_stack_listed = 0;
1853 pfile->state.next_bol = 1;
1854 pfile->buffer_stack_depth++;
1855 pfile->buffer = new;
1860 /* If called from do_line, pops a single buffer. Otherwise pops all
1861 buffers until a real file is reached. Generates appropriate
1864 cpp_pop_buffer (pfile)
1868 struct if_stack *ifs;
1872 buffer = pfile->buffer;
1873 /* Walk back up the conditional stack till we reach its level at
1874 entry to this file, issuing error messages. */
1875 for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
1876 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1877 "unterminated #%s", dtable[ifs->type].name);
1879 if (buffer->type == BUF_FAKE)
1880 buffer->prev->cur = buffer->cur;
1881 else if (buffer->type == BUF_FILE)
1882 _cpp_pop_file_buffer (pfile, buffer);
1884 pfile->buffer = buffer->prev;
1885 pfile->buffer_stack_depth--;
1887 /* Callbacks only generated for faked or real files. */
1888 if (buffer->type != BUF_FILE && buffer->type != BUF_FAKE)
1891 /* No callback for EOF of last file. */
1895 /* do_line does its own call backs. */
1896 pfile->buffer->include_stack_listed = 0;
1897 if (pfile->directive == &dtable[T_LINE])
1900 _cpp_do_file_change (pfile, FC_LEAVE, buffer->nominal_fname,
1902 if (pfile->buffer->type == BUF_FILE)
1905 cpp_warning (pfile, "file \"%s\" entered but not left",
1906 buffer->nominal_fname);
1909 obstack_free (&pfile->buffer_ob, buffer);
1910 return pfile->buffer;
1914 _cpp_init_directives (pfile)
1920 /* Register the directives. */
1921 for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
1923 node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
1924 node->directive_index = i + 1;