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 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,
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, so that e.g.
251 __VA_ARGS__ in the rest of the directive doesn't warn. */
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
->state
.line_extension
= 0;
264 pfile
->directive
= 0;
267 /* Check if a token's name matches that of a known directive. Put in
268 this file to save exporting dtable and other unneeded information. */
270 _cpp_handle_directive (pfile
, indented
)
274 cpp_buffer
*buffer
= pfile
->buffer
;
275 const directive
*dir
= 0;
279 start_directive (pfile
);
281 /* Lex the directive name directly. */
282 _cpp_lex_token (pfile
, &dname
);
284 if (dname
.type
== CPP_NAME
)
286 unsigned int index
= dname
.val
.node
->directive_index
;
288 dir
= &dtable
[index
- 1];
290 else if (dname
.type
== CPP_NUMBER
)
292 /* # followed by a number is equivalent to #line. Do not
293 recognize this form in assembly language source files or
294 skipped conditional groups. Complain about this form if
295 we're being pedantic, but not if this is regurgitated input
296 (preprocessed or fed back in by the C++ frontend). */
297 if (! buffer
->was_skipping
&& CPP_OPTION (pfile
, lang
) != CLK_ASM
)
299 dir
= &dtable
[T_LINE
];
300 pfile
->state
.line_extension
= 1;
301 _cpp_push_token (pfile
, &dname
, &pfile
->directive_pos
);
302 if (CPP_PEDANTIC (pfile
) && buffer
->inc
303 && ! CPP_OPTION (pfile
, preprocessed
))
304 cpp_pedwarn (pfile
, "# followed by integer");
308 pfile
->directive
= dir
;
311 /* Make sure we lex headers correctly, whether skipping or not. */
312 pfile
->state
.angled_headers
= dir
->flags
& INCL
;
314 /* If we are rescanning preprocessed input, only directives tagged
315 with IN_I are honored, and the warnings below are suppressed. */
316 if (! CPP_OPTION (pfile
, preprocessed
) || dir
->flags
& IN_I
)
318 /* Traditionally, a directive is ignored unless its # is in
319 column 1. Therefore in code intended to work with K+R
320 compilers, directives added by C89 must have their #
321 indented, and directives present in traditional C must
322 not. This is true even of directives in skipped
323 conditional blocks. */
324 if (CPP_WTRADITIONAL (pfile
))
326 if (indented
&& dir
->origin
== KANDR
)
328 "traditional C ignores #%s with the # indented",
330 else if (!indented
&& dir
->origin
!= KANDR
)
332 "suggest hiding #%s from traditional C with an indented #",
336 /* If we are skipping a failed conditional group, all
337 non-conditional directives are ignored. */
338 if (! buffer
->was_skipping
|| (dir
->flags
& COND
))
340 /* Issue -pedantic warnings for extensions. */
341 if (CPP_PEDANTIC (pfile
) && dir
->origin
== EXTENSION
)
342 cpp_pedwarn (pfile
, "#%s is a GCC extension", dir
->name
);
344 /* If we have a directive that is not an opening
345 conditional, invalidate any control macro. */
346 if (! (dir
->flags
& IF_COND
))
347 pfile
->mi_state
= MI_FAILED
;
349 (*dir
->handler
) (pfile
);
353 else if (dname
.type
!= CPP_EOF
&& ! pfile
->skipping
)
355 /* An unknown directive. Don't complain about it in assembly
356 source: we don't know where the comments are, and # may
357 introduce assembler pseudo-ops. Don't complain about invalid
358 directives in skipped conditional groups (6.10 p4). */
359 if (CPP_OPTION (pfile
, lang
) == CLK_ASM
)
361 /* Output the # and lookahead token for the assembler. */
362 _cpp_push_token (pfile
, &dname
, &pfile
->directive_pos
);
366 cpp_error (pfile
, "invalid preprocessing directive #%s",
367 cpp_token_as_text (pfile
, &dname
));
370 end_directive (pfile
, skip
);
374 /* Directive handler wrapper used by the command line option
377 run_directive (pfile
, dir_no
, buf
, count
, name
)
384 unsigned int output_line
= pfile
->lexer_pos
.output_line
;
385 cpp_buffer
*buffer
= cpp_push_buffer (pfile
, (const U_CHAR
*) buf
, count
);
389 const struct directive
*dir
= &dtable
[dir_no
];
392 buffer
->nominal_fname
= name
;
394 buffer
->nominal_fname
= _("<command line>");
396 /* For _Pragma, the text is passed through preprocessing stage 3
397 only, i.e. no trigraphs, no escaped newline removal, and no
398 macro expansion. Do the same for command-line directives. */
399 buffer
->from_stage3
= 1;
401 if (dir_no
== T_PRAGMA
)
403 /* A kludge to avoid line markers for _Pragma. */
404 pfile
->lexer_pos
.output_line
= output_line
;
405 /* Avoid interpretation of directives in a _Pragma string. */
406 pfile
->state
.next_bol
= 0;
409 start_directive (pfile
);
410 pfile
->state
.prevent_expansion
++;
411 (void) (*dir
->handler
) (pfile
);
412 pfile
->state
.prevent_expansion
--;
414 end_directive (pfile
, 1);
416 cpp_pop_buffer (pfile
);
420 /* Checks for validity the macro name in #define, #undef, #ifdef and
421 #ifndef directives. */
422 static cpp_hashnode
*
423 lex_macro_node (pfile
)
428 /* Lex the macro name directly. */
429 _cpp_lex_token (pfile
, &token
);
431 /* The token immediately after #define must be an identifier. That
432 identifier is not allowed to be "defined". See predefined macro
433 names (6.10.8.4). In C++, it is not allowed to be any of the
434 <iso646.h> macro names (which are keywords in C++) either. */
436 if (token
.type
!= CPP_NAME
)
438 if (token
.type
== CPP_EOF
)
439 cpp_error (pfile
, "no macro name given in #%s directive",
440 pfile
->directive
->name
);
441 else if (token
.flags
& NAMED_OP
)
443 "\"%s\" cannot be used as a macro name as it is an operator in C++",
444 token
.val
.node
->name
);
446 cpp_error (pfile
, "macro names must be identifiers");
450 cpp_hashnode
*node
= token
.val
.node
;
452 /* In Objective C, some keywords begin with '@', but general
453 identifiers do not, and you're not allowed to #define them. */
454 if (node
== pfile
->spec_nodes
.n_defined
|| node
->name
[0] == '@')
455 cpp_error (pfile
, "\"%s\" cannot be used as a macro name", node
->name
);
456 else if (!(node
->flags
& NODE_POISONED
))
463 /* Process a #define directive. Most work is done in cppmacro.c. */
468 cpp_hashnode
*node
= lex_macro_node (pfile
);
472 /* Use the permanent pool for storage. */
473 pfile
->string_pool
= &pfile
->ident_pool
;
475 if (_cpp_create_definition (pfile
, node
))
476 if (pfile
->cb
.define
)
477 (*pfile
->cb
.define
) (pfile
, node
);
479 /* Revert to the temporary pool. */
480 pfile
->string_pool
= &pfile
->temp_string_pool
;
484 /* Handle #undef. Marks the identifier NT_VOID in the hash table. */
489 cpp_hashnode
*node
= lex_macro_node (pfile
);
491 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
492 is not currently defined as a macro name. */
493 if (node
&& node
->type
== NT_MACRO
)
496 (*pfile
->cb
.undef
) (pfile
, node
);
498 if (node
->flags
& NODE_BUILTIN
)
499 cpp_warning (pfile
, "undefining \"%s\"", node
->name
);
501 _cpp_free_definition (node
);
506 /* Helper routine used by parse_include. Reinterpret the current line
507 as an h-char-sequence (< ... >); we are looking at the first token
508 after the <. Returns zero on success. */
510 glue_header_name (pfile
, header
)
515 unsigned char *buffer
, *token_mem
;
516 size_t len
, total_len
= 0, capacity
= 1024;
518 /* To avoid lexed tokens overwriting our glued name, we can only
519 allocate from the string pool once we've lexed everything. */
521 buffer
= (unsigned char *) xmalloc (capacity
);
524 cpp_get_token (pfile
, &token
);
526 if (token
.type
== CPP_GREATER
|| token
.type
== CPP_EOF
)
529 len
= cpp_token_len (&token
);
530 if (total_len
+ len
> capacity
)
532 capacity
= (capacity
+ len
) * 2;
533 buffer
= (unsigned char *) xrealloc (buffer
, capacity
);
536 if (token
.flags
& PREV_WHITE
)
537 buffer
[total_len
++] = ' ';
539 total_len
= cpp_spell_token (pfile
, &token
, &buffer
[total_len
]) - buffer
;
542 if (token
.type
== CPP_EOF
)
543 cpp_error (pfile
, "missing terminating > character");
546 token_mem
= _cpp_pool_alloc (pfile
->string_pool
, total_len
);
547 memcpy (token_mem
, buffer
, total_len
);
549 header
->type
= CPP_HEADER_NAME
;
550 header
->flags
&= ~PREV_WHITE
;
551 header
->val
.str
.len
= total_len
;
552 header
->val
.str
.text
= token_mem
;
556 return token
.type
== CPP_EOF
;
559 /* Parse the header name of #include, #include_next, #import and
560 #pragma dependency. Returns zero on success. */
562 parse_include (pfile
, header
)
566 int is_pragma
= pfile
->directive
== &dtable
[T_PRAGMA
];
567 const unsigned char *dir
;
570 dir
= U
"pragma dependency";
572 dir
= pfile
->directive
->name
;
574 /* Allow macro expansion. */
575 cpp_get_token (pfile
, header
);
576 if (header
->type
!= CPP_STRING
&& header
->type
!= CPP_HEADER_NAME
)
578 if (header
->type
!= CPP_LESS
)
580 cpp_error (pfile
, "#%s expects \"FILENAME\" or <FILENAME>", dir
);
583 if (glue_header_name (pfile
, header
))
587 if (header
->val
.str
.len
== 0)
589 cpp_error (pfile
, "empty file name in #%s", dir
);
596 /* Get out of macro context, if we are. */
597 skip_rest_of_line (pfile
);
598 if (pfile
->cb
.include
)
599 (*pfile
->cb
.include
) (pfile
, dir
, header
);
611 if (!parse_include (pfile
, &header
))
612 _cpp_execute_include (pfile
, &header
, 0, 0);
621 if (!pfile
->import_warning
&& CPP_OPTION (pfile
, warn_import
))
623 pfile
->import_warning
= 1;
625 "#import is obsolete, use an #ifndef wrapper in the header file");
628 if (!parse_include (pfile
, &header
))
629 _cpp_execute_include (pfile
, &header
, 1, 0);
633 do_include_next (pfile
)
638 if (!parse_include (pfile
, &header
))
639 _cpp_execute_include (pfile
, &header
, 0, 1);
642 /* Subroutine of do_line. Read possible flags after file name. LAST
643 is the last flag seen; 0 if this is the first flag. Return the flag
644 if it is valid, 0 at the end of the directive. Otherwise complain. */
647 read_flag (pfile
, last
)
653 _cpp_lex_token (pfile
, &token
);
654 if (token
.type
== CPP_NUMBER
&& token
.val
.str
.len
== 1)
656 unsigned int flag
= token
.val
.str
.text
[0] - '0';
658 if (flag
> last
&& flag
<= 4
659 && (flag
!= 4 || last
== 3)
660 && (flag
!= 2 || last
== 0))
664 if (token
.type
!= CPP_EOF
)
665 cpp_error (pfile
, "invalid flag \"%s\" in line directive",
666 cpp_token_as_text (pfile
, &token
));
670 /* Another subroutine of do_line. Convert a number in STR, of length
671 LEN, to binary; store it in NUMP, and return 0 if the number was
672 well-formed, 1 if not. Temporary, hopefully. */
674 strtoul_for_line (str
, len
, nump
)
679 unsigned long reg
= 0;
693 /* Interpret #line command.
694 Note that the filename string (if any) is treated as if it were an
695 include filename. That means no escape handling. */
701 cpp_buffer
*buffer
= pfile
->buffer
;
702 const char *filename
= buffer
->nominal_fname
;
703 unsigned int lineno
= buffer
->lineno
;
704 enum cpp_fc_reason reason
= FC_RENAME
;
705 unsigned long new_lineno
;
709 /* C99 raised the minimum limit on #line numbers. */
710 cap
= CPP_OPTION (pfile
, c99
) ? 2147483647 : 32767;
712 /* #line commands expand macros. */
713 cpp_get_token (pfile
, &token
);
714 if (token
.type
!= CPP_NUMBER
715 || strtoul_for_line (token
.val
.str
.text
, token
.val
.str
.len
, &new_lineno
))
717 cpp_error (pfile
, "\"%s\" after #line is not a positive integer",
718 cpp_token_as_text (pfile
, &token
));
722 if (CPP_PEDANTIC (pfile
) && (new_lineno
== 0 || new_lineno
> cap
))
723 cpp_pedwarn (pfile
, "line number out of range");
725 cpp_get_token (pfile
, &token
);
726 if (token
.type
== CPP_STRING
)
731 /* FIXME: memory leak. */
732 len
= token
.val
.str
.len
;
733 fname
= xmalloc (len
+ 1);
734 memcpy (fname
, token
.val
.str
.text
, len
);
737 _cpp_simplify_pathname (fname
);
738 buffer
->nominal_fname
= fname
;
740 if (! pfile
->state
.line_extension
)
744 int flag
= 0, sysp
= 0;
746 flag
= read_flag (pfile
, flag
);
750 flag
= read_flag (pfile
, flag
);
755 flag
= read_flag (pfile
, flag
);
760 flag
= read_flag (pfile
, flag
);
762 sysp
= 2, read_flag (pfile
, flag
);
765 cpp_make_system_header (pfile
, sysp
, sysp
== 2);
768 else if (token
.type
!= CPP_EOF
)
770 cpp_error (pfile
, "\"%s\" is not a valid filename",
771 cpp_token_as_text (pfile
, &token
));
775 /* Our line number is incremented after the directive is processed. */
776 buffer
->lineno
= new_lineno
- 1;
777 _cpp_do_file_change (pfile
, reason
, filename
, lineno
);
780 /* Arrange the file_change callback. The assumption is that the
781 current buffer's lineno is one less than the next line. */
783 _cpp_do_file_change (pfile
, reason
, from_file
, from_lineno
)
785 enum cpp_fc_reason reason
;
786 const char *from_file
;
787 unsigned int from_lineno
;
789 if (pfile
->cb
.change_file
)
792 cpp_buffer
*buffer
= pfile
->buffer
;
795 fc
.from
.filename
= from_file
;
796 fc
.from
.lineno
= from_lineno
;
797 fc
.to
.filename
= buffer
->nominal_fname
;
798 fc
.to
.lineno
= buffer
->lineno
+ 1;
799 fc
.sysp
= buffer
->sysp
;
800 fc
.externc
= CPP_OPTION (pfile
, cplusplus
) && buffer
->sysp
== 2;
801 pfile
->cb
.change_file (pfile
, &fc
);
806 * Report a warning or error detected by the program we are
807 * processing. Use the directive's tokens in the error message.
811 do_diagnostic (pfile
, code
, print_dir
)
813 enum error_type code
;
816 if (_cpp_begin_message (pfile
, code
, NULL
, 0))
819 fprintf (stderr
, "#%s ", pfile
->directive
->name
);
820 pfile
->state
.prevent_expansion
++;
821 cpp_output_line (pfile
, stderr
);
822 pfile
->state
.prevent_expansion
--;
830 do_diagnostic (pfile
, ERROR
, 1);
837 do_diagnostic (pfile
, WARNING
, 1);
840 /* Report program identification. */
848 cpp_get_token (pfile
, &str
);
849 if (str
.type
!= CPP_STRING
)
850 cpp_error (pfile
, "invalid #ident");
851 else if (pfile
->cb
.ident
)
852 (*pfile
->cb
.ident
) (pfile
, &str
.val
.str
);
857 /* Pragmata handling. We handle some of these, and pass the rest on
858 to the front end. C99 defines three pragmas and says that no macro
859 expansion is to be performed on them; whether or not macro
860 expansion happens for other pragmas is implementation defined.
861 This implementation never macro-expands the text after #pragma. */
863 /* Sub-handlers for the pragmas needing treatment here.
864 They return 1 if the token buffer is to be popped, 0 if not. */
867 struct pragma_entry
*next
;
872 void (*handler
) PARAMS ((cpp_reader
*));
873 struct pragma_entry
*space
;
878 cpp_register_pragma (pfile
, space
, name
, handler
)
882 void (*handler
) PARAMS ((cpp_reader
*));
884 struct pragma_entry
**x
, *new;
890 struct pragma_entry
*p
= pfile
->pragmas
;
891 len
= strlen (space
);
894 if (p
->isnspace
&& p
->len
== len
&& !memcmp (p
->name
, space
, len
))
901 cpp_ice (pfile
, "unknown #pragma namespace %s", space
);
906 new = xnew (struct pragma_entry
);
908 new->len
= strlen (name
);
910 new->u
.handler
= handler
;
917 cpp_register_pragma_space (pfile
, space
)
921 struct pragma_entry
*new;
922 const struct pragma_entry
*p
= pfile
->pragmas
;
923 size_t len
= strlen (space
);
927 if (p
->isnspace
&& p
->len
== len
&& !memcmp (p
->name
, space
, len
))
928 /* Multiple different callers are allowed to register the same
934 new = xnew (struct pragma_entry
);
940 new->next
= pfile
->pragmas
;
941 pfile
->pragmas
= new;
945 _cpp_init_internal_pragmas (pfile
)
949 cpp_register_pragma (pfile
, 0, "poison", do_pragma_poison
);
950 cpp_register_pragma (pfile
, 0, "once", do_pragma_once
);
953 cpp_register_pragma_space (pfile
, "GCC");
955 cpp_register_pragma (pfile
, "GCC", "poison", do_pragma_poison
);
956 cpp_register_pragma (pfile
, "GCC", "system_header", do_pragma_system_header
);
957 cpp_register_pragma (pfile
, "GCC", "dependency", do_pragma_dependency
);
964 const struct pragma_entry
*p
;
966 const cpp_hashnode
*node
;
972 pfile
->state
.prevent_expansion
++;
973 cpp_start_lookahead (pfile
);
976 cpp_get_token (pfile
, &tok
);
977 if (tok
.type
== CPP_NAME
)
984 if (strlen (p
->name
) == len
&& !memcmp (p
->name
, name
, len
))
993 (*p
->u
.handler
) (pfile
);
1002 cpp_stop_lookahead (pfile
, drop
);
1003 pfile
->state
.prevent_expansion
--;
1005 if (!drop
&& pfile
->cb
.def_pragma
)
1006 (*pfile
->cb
.def_pragma
) (pfile
);
1010 do_pragma_once (pfile
)
1013 cpp_warning (pfile
, "#pragma once is obsolete");
1015 if (pfile
->buffer
->prev
== NULL
)
1016 cpp_warning (pfile
, "#pragma once in main file");
1018 _cpp_never_reread (pfile
->buffer
->inc
);
1024 do_pragma_poison (pfile
)
1027 /* Poison these symbols so that all subsequent usage produces an
1032 pfile
->state
.poisoned_ok
= 1;
1035 _cpp_lex_token (pfile
, &tok
);
1036 if (tok
.type
== CPP_EOF
)
1038 if (tok
.type
!= CPP_NAME
)
1040 cpp_error (pfile
, "invalid #pragma GCC poison directive");
1045 if (hp
->flags
& NODE_POISONED
)
1048 if (hp
->type
== NT_MACRO
)
1049 cpp_warning (pfile
, "poisoning existing macro \"%s\"", hp
->name
);
1050 _cpp_free_definition (hp
);
1051 hp
->flags
|= NODE_POISONED
| NODE_DIAGNOSTIC
;
1053 pfile
->state
.poisoned_ok
= 0;
1055 #if 0 /* Doesn't quite work yet. */
1056 if (tok
.type
== CPP_EOF
&& pfile
->cb
.poison
)
1057 (*pfile
->cb
.poison
) (pfile
);
1061 /* Mark the current header as a system header. This will suppress
1062 some categories of warnings (notably those from -pedantic). It is
1063 intended for use in system libraries that cannot be implemented in
1064 conforming C, but cannot be certain that their headers appear in a
1065 system include directory. To prevent abuse, it is rejected in the
1066 primary source file. */
1068 do_pragma_system_header (pfile
)
1071 cpp_buffer
*buffer
= pfile
->buffer
;
1073 if (buffer
->prev
== 0)
1074 cpp_warning (pfile
, "#pragma system_header ignored outside include file");
1076 cpp_make_system_header (pfile
, 1, 0);
1081 /* Check the modified date of the current include file against a specified
1082 file. Issue a diagnostic, if the specified file is newer. We use this to
1083 determine if a fixed header should be refixed. */
1085 do_pragma_dependency (pfile
)
1088 cpp_token header
, msg
;
1091 if (parse_include (pfile
, &header
))
1094 ordering
= _cpp_compare_file_date (pfile
, &header
);
1096 cpp_warning (pfile
, "cannot find source %s",
1097 cpp_token_as_text (pfile
, &header
));
1098 else if (ordering
> 0)
1100 cpp_warning (pfile
, "current file is older than %s",
1101 cpp_token_as_text (pfile
, &header
));
1102 cpp_start_lookahead (pfile
);
1103 cpp_get_token (pfile
, &msg
);
1104 cpp_stop_lookahead (pfile
, msg
.type
== CPP_EOF
);
1105 if (msg
.type
!= CPP_EOF
)
1106 do_diagnostic (pfile
, WARNING
, 0);
1110 /* Check syntax is "(string-literal)". Returns 0 on success. */
1112 get__Pragma_string (pfile
, string
)
1118 cpp_get_token (pfile
, &paren
);
1119 if (paren
.type
!= CPP_OPEN_PAREN
)
1122 cpp_get_token (pfile
, string
);
1123 if (string
->type
!= CPP_STRING
&& string
->type
!= CPP_WSTRING
)
1126 cpp_get_token (pfile
, &paren
);
1127 return paren
.type
!= CPP_CLOSE_PAREN
;
1130 /* Returns a malloced buffer containing a destringized cpp_string by
1131 removing the first \ of \" and \\ sequences. */
1132 static unsigned char *
1133 destringize (in
, len
)
1134 const cpp_string
*in
;
1137 const unsigned char *src
, *limit
;
1138 unsigned char *dest
, *result
;
1140 dest
= result
= (unsigned char *) xmalloc (in
->len
);
1141 for (src
= in
->text
, limit
= src
+ in
->len
; src
< limit
;)
1143 /* We know there is a character following the backslash. */
1144 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1149 *len
= dest
- result
;
1154 _cpp_do__Pragma (pfile
)
1158 unsigned char *buffer
;
1161 if (get__Pragma_string (pfile
, &string
))
1163 cpp_error (pfile
, "_Pragma takes a parenthesized string literal");
1167 buffer
= destringize (&string
.val
.str
, &len
);
1168 run_directive (pfile
, T_PRAGMA
, (char *) buffer
, len
, _("<_Pragma>"));
1169 free ((PTR
) buffer
);
1172 /* Just ignore #sccs, on systems where we define it at all. */
1173 #ifdef SCCS_DIRECTIVE
1176 cpp_reader
*pfile ATTRIBUTE_UNUSED
;
1187 if (! pfile
->buffer
->was_skipping
)
1189 const cpp_hashnode
*node
= lex_macro_node (pfile
);
1192 skip
= node
->type
!= NT_MACRO
;
1198 push_conditional (pfile
, skip
, T_IFDEF
, 0);
1206 const cpp_hashnode
*node
= 0;
1208 if (! pfile
->buffer
->was_skipping
)
1210 node
= lex_macro_node (pfile
);
1212 skip
= node
->type
== NT_MACRO
;
1218 push_conditional (pfile
, skip
, T_IFNDEF
, node
);
1221 /* #if cooperates with parse_defined to handle multiple-include
1222 optimisations. If macro expansions or identifiers appear in the
1223 expression, we cannot treat it as a controlling conditional, since
1224 their values could change in the future. */
1231 const cpp_hashnode
*cmacro
= 0;
1233 if (! pfile
->buffer
->was_skipping
)
1235 /* Controlling macro of #if ! defined () */
1236 pfile
->mi_ind_cmacro
= 0;
1237 skip
= _cpp_parse_expr (pfile
) == 0;
1238 cmacro
= pfile
->mi_ind_cmacro
;
1241 push_conditional (pfile
, skip
, T_IF
, cmacro
);
1244 /* Flip skipping state if appropriate and continue without changing
1245 if_stack; this is so that the error message for missing #endif's
1246 etc. will point to the original #if. */
1252 cpp_buffer
*buffer
= pfile
->buffer
;
1253 struct if_stack
*ifs
= buffer
->if_stack
;
1256 cpp_error (pfile
, "#else without #if");
1259 if (ifs
->type
== T_ELSE
)
1261 cpp_error (pfile
, "#else after #else");
1262 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1263 "the conditional began here");
1267 /* Buffer->was_skipping is 1 if all conditionals in this chain
1268 have been false, 2 if a conditional has been true. */
1269 if (! ifs
->was_skipping
&& buffer
->was_skipping
!= 2)
1270 buffer
->was_skipping
= ! buffer
->was_skipping
;
1272 /* Invalidate any controlling macro. */
1279 /* handle a #elif directive by not changing if_stack either. see the
1280 comment above do_else. */
1286 cpp_buffer
*buffer
= pfile
->buffer
;
1287 struct if_stack
*ifs
= buffer
->if_stack
;
1290 cpp_error (pfile
, "#elif without #if");
1293 if (ifs
->type
== T_ELSE
)
1295 cpp_error (pfile
, "#elif after #else");
1296 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1297 "the conditional began here");
1301 /* Don't evaluate #elif if our higher level is skipping. */
1302 if (! ifs
->was_skipping
)
1304 /* Buffer->was_skipping is 1 if all conditionals in this
1305 chain have been false, 2 if a conditional has been true. */
1306 if (buffer
->was_skipping
== 1)
1307 buffer
->was_skipping
= ! _cpp_parse_expr (pfile
);
1309 buffer
->was_skipping
= 2;
1311 /* Invalidate any controlling macro. */
1317 /* #endif pops the if stack and resets pfile->skipping. */
1323 cpp_buffer
*buffer
= pfile
->buffer
;
1324 struct if_stack
*ifs
= buffer
->if_stack
;
1327 cpp_error (pfile
, "#endif without #if");
1330 /* If potential control macro, we go back outside again. */
1331 if (ifs
->next
== 0 && ifs
->mi_cmacro
)
1333 pfile
->mi_state
= MI_OUTSIDE
;
1334 pfile
->mi_cmacro
= ifs
->mi_cmacro
;
1337 buffer
->if_stack
= ifs
->next
;
1338 buffer
->was_skipping
= ifs
->was_skipping
;
1339 obstack_free (pfile
->buffer_ob
, ifs
);
1345 /* Push an if_stack entry and set pfile->skipping accordingly.
1346 If this is a #ifndef starting at the beginning of a file,
1347 CMACRO is the macro name tested by the #ifndef. */
1350 push_conditional (pfile
, skip
, type
, cmacro
)
1354 const cpp_hashnode
*cmacro
;
1356 struct if_stack
*ifs
;
1357 cpp_buffer
*buffer
= pfile
->buffer
;
1359 ifs
= xobnew (pfile
->buffer_ob
, struct if_stack
);
1360 ifs
->pos
= pfile
->directive_pos
;
1361 ifs
->next
= buffer
->if_stack
;
1362 ifs
->was_skipping
= buffer
->was_skipping
;
1364 if (pfile
->mi_state
== MI_OUTSIDE
&& pfile
->mi_cmacro
== 0)
1365 ifs
->mi_cmacro
= cmacro
;
1369 buffer
->was_skipping
= skip
;
1370 buffer
->if_stack
= ifs
;
1373 /* Read the tokens of the answer into the macro pool. Only commit the
1374 memory if we intend it as permanent storage, i.e. the #assert case.
1375 Returns 0 on success. */
1378 parse_answer (pfile
, answerp
, type
)
1380 struct answer
**answerp
;
1383 cpp_token paren
, *token
;
1384 struct answer
*answer
;
1386 if (POOL_FRONT (&pfile
->macro_pool
) + sizeof (struct answer
) >
1387 POOL_LIMIT (&pfile
->macro_pool
))
1388 _cpp_next_chunk (&pfile
->macro_pool
, sizeof (struct answer
), 0);
1389 answer
= (struct answer
*) POOL_FRONT (&pfile
->macro_pool
);
1392 /* In a conditional, it is legal to not have an open paren. We
1393 should save the following token in this case. */
1395 cpp_start_lookahead (pfile
);
1396 cpp_get_token (pfile
, &paren
);
1398 cpp_stop_lookahead (pfile
, paren
.type
== CPP_OPEN_PAREN
);
1400 /* If not a paren, see if we're OK. */
1401 if (paren
.type
!= CPP_OPEN_PAREN
)
1403 /* In a conditional no answer is a test for any answer. It
1404 could be followed by any token. */
1408 /* #unassert with no answer is valid - it removes all answers. */
1409 if (type
== T_UNASSERT
&& paren
.type
== CPP_EOF
)
1412 cpp_error (pfile
, "missing '(' after predicate");
1418 token
= &answer
->first
[answer
->count
];
1419 /* Check we have room for the token. */
1420 if ((unsigned char *) (token
+ 1) >= POOL_LIMIT (&pfile
->macro_pool
))
1422 _cpp_next_chunk (&pfile
->macro_pool
, sizeof (cpp_token
),
1423 (unsigned char **) &answer
);
1424 token
= &answer
->first
[answer
->count
];
1427 cpp_get_token (pfile
, token
);
1428 if (token
->type
== CPP_CLOSE_PAREN
)
1431 if (token
->type
== CPP_EOF
)
1433 cpp_error (pfile
, "missing ')' to complete answer");
1439 if (answer
->count
== 0)
1441 cpp_error (pfile
, "predicate's answer is empty");
1445 /* Drop whitespace at start. */
1446 answer
->first
->flags
&= ~PREV_WHITE
;
1449 if (type
== T_ASSERT
|| type
== T_UNASSERT
)
1454 /* Parses an assertion, returning a pointer to the hash node of the
1455 predicate, or 0 on error. If an answer was supplied, it is placed
1456 in ANSWERP, otherwise it is set to 0. */
1457 static cpp_hashnode
*
1458 parse_assertion (pfile
, answerp
, type
)
1460 struct answer
**answerp
;
1463 cpp_hashnode
*result
= 0;
1464 cpp_token predicate
;
1466 /* We don't expand predicates or answers. */
1467 pfile
->state
.prevent_expansion
++;
1469 /* Use the permanent pool for storage (for the answers). */
1470 pfile
->string_pool
= &pfile
->ident_pool
;
1473 cpp_get_token (pfile
, &predicate
);
1474 if (predicate
.type
== CPP_EOF
)
1475 cpp_error (pfile
, "assertion without predicate");
1476 else if (predicate
.type
!= CPP_NAME
)
1477 cpp_error (pfile
, "predicate must be an identifier");
1478 else if (parse_answer (pfile
, answerp
, type
) == 0)
1480 unsigned int len
= predicate
.val
.node
->length
;
1481 unsigned char *sym
= alloca (len
+ 1);
1483 /* Prefix '#' to get it out of macro namespace. */
1485 memcpy (sym
+ 1, predicate
.val
.node
->name
, len
);
1486 result
= cpp_lookup (pfile
, sym
, len
+ 1);
1489 pfile
->string_pool
= &pfile
->temp_string_pool
;
1490 pfile
->state
.prevent_expansion
--;
1494 /* Returns a pointer to the pointer to the answer in the answer chain,
1495 or a pointer to NULL if the answer is not in the chain. */
1496 static struct answer
**
1497 find_answer (node
, candidate
)
1499 const struct answer
*candidate
;
1502 struct answer
**result
;
1504 for (result
= &node
->value
.answers
; *result
; result
= &(*result
)->next
)
1506 struct answer
*answer
= *result
;
1508 if (answer
->count
== candidate
->count
)
1510 for (i
= 0; i
< answer
->count
; i
++)
1511 if (! _cpp_equiv_tokens (&answer
->first
[i
], &candidate
->first
[i
]))
1514 if (i
== answer
->count
)
1522 /* Test an assertion within a preprocessor conditional. Returns
1523 non-zero on failure, zero on success. On success, the result of
1524 the test is written into VALUE. */
1526 _cpp_test_assertion (pfile
, value
)
1530 struct answer
*answer
;
1533 node
= parse_assertion (pfile
, &answer
, T_IF
);
1535 *value
= (node
->type
== NT_ASSERTION
&&
1536 (answer
== 0 || *find_answer (node
, answer
) != 0));
1538 /* We don't commit the memory for the answer - it's temporary only. */
1546 struct answer
*new_answer
;
1549 node
= parse_assertion (pfile
, &new_answer
, T_ASSERT
);
1552 /* Place the new answer in the answer list. First check there
1553 is not a duplicate. */
1554 new_answer
->next
= 0;
1555 if (node
->type
== NT_ASSERTION
)
1557 if (*find_answer (node
, new_answer
))
1559 cpp_warning (pfile
, "\"%s\" re-asserted", node
->name
+ 1);
1562 new_answer
->next
= node
->value
.answers
;
1564 node
->type
= NT_ASSERTION
;
1565 node
->value
.answers
= new_answer
;
1566 POOL_COMMIT (&pfile
->macro_pool
, (sizeof (struct answer
)
1567 + (new_answer
->count
- 1)
1568 * sizeof (cpp_token
)));
1577 struct answer
*answer
;
1579 node
= parse_assertion (pfile
, &answer
, T_UNASSERT
);
1580 /* It isn't an error to #unassert something that isn't asserted. */
1581 if (node
&& node
->type
== NT_ASSERTION
)
1585 struct answer
**p
= find_answer (node
, answer
), *temp
;
1587 /* Remove the answer from the list. */
1592 /* Did we free the last answer? */
1593 if (node
->value
.answers
== 0)
1594 node
->type
= NT_VOID
;
1597 _cpp_free_definition (node
);
1600 /* We don't commit the memory for the answer - it's temporary only. */
1603 /* These are for -D, -U, -A. */
1605 /* Process the string STR as if it appeared as the body of a #define.
1606 If STR is just an identifier, define it with value 1.
1607 If STR has anything after the identifier, then it should
1608 be identifier=definition. */
1611 cpp_define (pfile
, str
)
1618 /* Copy the entire option so we can modify it.
1619 Change the first "=" in the string to a space. If there is none,
1620 tack " 1" on the end. */
1622 /* Length including the null. */
1623 count
= strlen (str
);
1624 buf
= (char *) alloca (count
+ 2);
1625 memcpy (buf
, str
, count
);
1627 p
= strchr (str
, '=');
1636 run_directive (pfile
, T_DEFINE
, buf
, count
, 0);
1639 /* Slight variant of the above for use by initialize_builtins, which (a)
1640 knows how to set up the buffer itself, (b) needs a different "filename"
1643 _cpp_define_builtin (pfile
, str
)
1647 run_directive (pfile
, T_DEFINE
, str
, strlen (str
), _("<builtin>"));
1650 /* Process MACRO as if it appeared as the body of an #undef. */
1652 cpp_undef (pfile
, macro
)
1656 run_directive (pfile
, T_UNDEF
, macro
, strlen (macro
), 0);
1659 /* Process the string STR as if it appeared as the body of a #assert. */
1661 cpp_assert (pfile
, str
)
1665 handle_assertion (pfile
, str
, T_ASSERT
);
1668 /* Process STR as if it appeared as the body of an #unassert. */
1670 cpp_unassert (pfile
, str
)
1674 handle_assertion (pfile
, str
, T_UNASSERT
);
1677 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1679 handle_assertion (pfile
, str
, type
)
1684 size_t count
= strlen (str
);
1685 const char *p
= strchr (str
, '=');
1689 /* Copy the entire option so we can modify it. Change the first
1690 "=" in the string to a '(', and tack a ')' on the end. */
1691 char *buf
= (char *) alloca (count
+ 1);
1693 memcpy (buf
, str
, count
);
1699 run_directive (pfile
, type
, str
, count
, 0);
1702 /* Push a new buffer on the buffer stack. Buffer can be NULL, but
1703 then LEN should be 0. Returns the new buffer; it doesn't fail. */
1706 cpp_push_buffer (pfile
, buffer
, len
)
1708 const U_CHAR
*buffer
;
1711 cpp_buffer
*new = xobnew (pfile
->buffer_ob
, cpp_buffer
);
1713 /* Clears, amongst other things, if_stack and mi_cmacro. */
1714 memset (new, 0, sizeof (cpp_buffer
));
1715 new->line_base
= new->buf
= new->cur
= buffer
;
1716 new->rlimit
= buffer
+ len
;
1717 new->prev
= pfile
->buffer
;
1719 /* Preprocessed files don't do trigraph and escaped newline processing. */
1720 new->from_stage3
= CPP_OPTION (pfile
, preprocessed
);
1721 /* No read ahead or extra char initially. */
1722 new->read_ahead
= EOF
;
1723 new->extra_char
= EOF
;
1725 pfile
->state
.next_bol
= 1;
1726 pfile
->buffer_stack_depth
++;
1727 pfile
->lexer_pos
.output_line
= 1;
1729 pfile
->buffer
= new;
1734 cpp_pop_buffer (pfile
)
1737 cpp_buffer
*buffer
= pfile
->buffer
;
1738 const char *filename
= buffer
->nominal_fname
;
1739 unsigned int lineno
= buffer
->lineno
;
1740 struct if_stack
*ifs
= buffer
->if_stack
;
1741 int wfb
= (buffer
->inc
!= 0);
1743 /* Walk back up the conditional stack till we reach its level at
1744 entry to this file, issuing error messages. */
1745 for (ifs
= buffer
->if_stack
; ifs
; ifs
= ifs
->next
)
1746 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1747 "unterminated #%s", dtable
[ifs
->type
].name
);
1750 _cpp_pop_file_buffer (pfile
, buffer
);
1752 pfile
->buffer
= buffer
->prev
;
1753 obstack_free (pfile
->buffer_ob
, buffer
);
1754 pfile
->buffer_stack_depth
--;
1756 if (pfile
->buffer
&& wfb
)
1757 _cpp_do_file_change (pfile
, FC_LEAVE
, filename
, lineno
);
1759 return pfile
->buffer
;
1762 #define obstack_chunk_alloc xmalloc
1763 #define obstack_chunk_free free
1765 _cpp_init_stacks (pfile
)
1771 pfile
->buffer_ob
= xnew (struct obstack
);
1772 obstack_init (pfile
->buffer_ob
);
1774 /* Register the directives. */
1775 for (i
= 1; i
< N_DIRECTIVES
; i
++)
1777 node
= cpp_lookup (pfile
, dtable
[i
- 1].name
, dtable
[i
- 1].length
);
1778 node
->directive_index
= i
;
1783 _cpp_cleanup_stacks (pfile
)
1786 obstack_free (pfile
->buffer_ob
, 0);
1787 free (pfile
->buffer_ob
);