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. */
29 /* Chained list of answers to an assertion. */
37 /* Stack of conditionals currently in progress
38 (including both successful and failing conditionals). */
42 struct if_stack
*next
;
43 cpp_lexer_pos pos
; /* line and column where condition started */
44 const cpp_hashnode
*mi_cmacro
;/* macro name for #ifndef around entire file */
45 bool skip_elses
; /* Can future #else / #elif be skipped? */
46 bool was_skipping
; /* If were skipping on entry. */
47 int type
; /* Most recent conditional, for diagnostics. */
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,
86 const char *, size_t));
87 static int glue_header_name
PARAMS ((cpp_reader
*, cpp_token
*));
88 static int parse_include
PARAMS ((cpp_reader
*, cpp_token
*));
89 static void push_conditional
PARAMS ((cpp_reader
*, int, int,
90 const cpp_hashnode
*));
91 static unsigned int read_flag
PARAMS ((cpp_reader
*, unsigned int));
92 static int strtoul_for_line
PARAMS ((const U_CHAR
*, unsigned int,
94 static void do_diagnostic
PARAMS ((cpp_reader
*, enum error_type
, int));
95 static cpp_hashnode
*lex_macro_node
PARAMS ((cpp_reader
*));
96 static void do_include_common
PARAMS ((cpp_reader
*, enum include_type
));
97 static void do_pragma_once
PARAMS ((cpp_reader
*));
98 static void do_pragma_poison
PARAMS ((cpp_reader
*));
99 static void do_pragma_system_header
PARAMS ((cpp_reader
*));
100 static void do_pragma_dependency
PARAMS ((cpp_reader
*));
101 static int get__Pragma_string
PARAMS ((cpp_reader
*, cpp_token
*));
102 static unsigned char *destringize
PARAMS ((const cpp_string
*,
104 static int parse_answer
PARAMS ((cpp_reader
*, struct answer
**, int));
105 static cpp_hashnode
*parse_assertion
PARAMS ((cpp_reader
*, struct answer
**,
107 static struct answer
** find_answer
PARAMS ((cpp_hashnode
*,
108 const struct answer
*));
109 static void handle_assertion
PARAMS ((cpp_reader
*, const char *, int));
111 /* This is the table of directive handlers. It is ordered by
112 frequency of occurrence; the numbers at the end are directive
113 counts from all the source code I have lying around (egcs and libc
114 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
115 pcmcia-cs-3.0.9). This is no longer important as directive lookup
116 is now O(1). All extensions other than #warning and #include_next
117 are deprecated. The name is where the extension appears to have
120 #define DIRECTIVE_TABLE \
121 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
122 D(include, T_INCLUDE, KANDR, INCL) /* 52262 */ \
123 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
124 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
125 D(if, T_IF, KANDR, COND | IF_COND) /* 18162 */ \
126 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
127 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
128 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
129 D(line, T_LINE, KANDR, IN_I) /* 2465 */ \
130 D(elif, T_ELIF, STDC89, COND) /* 610 */ \
131 D(error, T_ERROR, STDC89, 0) /* 475 */ \
132 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
133 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
134 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL) /* 19 */ \
135 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
136 D(import, T_IMPORT, EXTENSION, INCL) /* 0 ObjC */ \
137 D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
138 D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
139 SCCS_ENTRY /* 0 SVR4? */
141 /* #sccs is not always recognized. */
142 #ifdef SCCS_DIRECTIVE
143 # define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION, 0)
145 # define SCCS_ENTRY /* nothing */
148 /* Use the table to generate a series of prototypes, an enum for the
149 directive names, and an array of directive handlers. */
151 /* The directive-processing functions are declared to return int
152 instead of void, because some old compilers have trouble with
153 pointers to functions returning void. */
155 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
156 #define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
160 #define D(n, tag, o, f) tag,
168 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
169 #define D(name, t, origin, flags) \
170 { CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
171 sizeof STRINGX(name) - 1, origin, flags },
172 static const directive dtable
[] =
177 #undef DIRECTIVE_TABLE
179 #define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
181 /* Skip any remaining tokens in a directive. */
183 skip_rest_of_line (pfile
)
188 /* Discard all stacked contexts. */
189 while (pfile
->context
!= &pfile
->base_context
)
190 _cpp_pop_context (pfile
);
192 /* Sweep up all tokens remaining on the line. */
193 while (! SEEN_EOL ())
194 _cpp_lex_token (pfile
, &token
);
197 /* Ensure there are no stray tokens at the end of a directive. */
206 _cpp_lex_token (pfile
, &token
);
207 if (token
.type
!= CPP_EOF
)
208 cpp_pedwarn (pfile
, "extra tokens at end of #%s directive",
209 pfile
->directive
->name
);
213 /* Called when entering a directive, _Pragma or command-line directive. */
215 start_directive (pfile
)
218 /* Setup in-directive state. */
219 pfile
->state
.in_directive
= 1;
220 pfile
->state
.save_comments
= 0;
222 /* Some handlers need the position of the # for diagnostics. */
223 pfile
->directive_pos
= pfile
->lexer_pos
;
224 pfile
->directive_pos
.line
= pfile
->line
;
225 pfile
->directive_line
= pfile
->line
;
228 /* Called when leaving a directive, _Pragma or command-line directive. */
230 end_directive (pfile
, skip_line
)
234 /* We don't skip for an assembler #. */
237 skip_rest_of_line (pfile
);
238 if (!pfile
->keep_tokens
)
240 pfile
->cur_run
= &pfile
->base_run
;
241 pfile
->cur_token
= pfile
->base_run
.base
;
246 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
247 pfile
->state
.in_directive
= 0;
248 pfile
->state
.angled_headers
= 0;
249 pfile
->state
.line_extension
= 0;
250 pfile
->directive
= 0;
253 /* Check if a token's name matches that of a known directive. Put in
254 this file to save exporting dtable and other unneeded information. */
256 _cpp_handle_directive (pfile
, indented
)
260 const directive
*dir
= 0;
264 start_directive (pfile
);
266 /* Lex the directive name directly. */
267 _cpp_lex_token (pfile
, &dname
);
269 if (dname
.type
== CPP_NAME
)
271 unsigned int index
= dname
.val
.node
->directive_index
;
273 dir
= &dtable
[index
- 1];
275 else if (dname
.type
== CPP_NUMBER
)
277 /* # followed by a number is equivalent to #line. Do not
278 recognize this form in assembly language source files or
279 skipped conditional groups. Complain about this form if
280 we're being pedantic, but not if this is regurgitated input
281 (preprocessed or fed back in by the C++ frontend). */
282 if (! pfile
->state
.skipping
&& CPP_OPTION (pfile
, lang
) != CLK_ASM
)
284 dir
= &dtable
[T_LINE
];
285 pfile
->state
.line_extension
= 1;
286 _cpp_backup_tokens (pfile
, 1);
287 if (CPP_PEDANTIC (pfile
) && ! CPP_OPTION (pfile
, preprocessed
))
288 cpp_pedwarn (pfile
, "# followed by integer");
292 pfile
->directive
= dir
;
295 /* Make sure we lex headers correctly, whether skipping or not. */
296 pfile
->state
.angled_headers
= dir
->flags
& INCL
;
298 /* If we are rescanning preprocessed input, only directives tagged
299 with IN_I are honored, and the warnings below are suppressed. */
300 if (CPP_OPTION (pfile
, preprocessed
))
302 /* Kluge alert. In order to be sure that code like this
305 does not cause '#define foo bar' to get executed when
306 compiled with -save-temps, we recognize directives in
307 -fpreprocessed mode only if the # is in column 1 and the
308 directive name starts in column 2. This output can only
309 be generated by the directive callbacks in cppmain.c (see
310 also the special case in scan_buffer). */
311 if (dir
->flags
& IN_I
&& !indented
&& !(dname
.flags
& PREV_WHITE
))
312 (*dir
->handler
) (pfile
);
313 /* That check misses '# 123' linemarkers. Let them through too. */
314 else if (dname
.type
== CPP_NUMBER
)
315 (*dir
->handler
) (pfile
);
318 /* We don't want to process this directive. Put back the
319 tokens so caller will see them (and issue an error,
321 _cpp_backup_tokens (pfile
, 1);
327 /* Traditionally, a directive is ignored unless its # is in
328 column 1. Therefore in code intended to work with K+R
329 compilers, directives added by C89 must have their #
330 indented, and directives present in traditional C must
331 not. This is true even of directives in skipped
332 conditional blocks. */
333 if (CPP_WTRADITIONAL (pfile
))
335 if (dir
== &dtable
[T_ELIF
])
337 "suggest not using #elif in traditional C");
338 else if (indented
&& dir
->origin
== KANDR
)
340 "traditional C ignores #%s with the # indented",
342 else if (!indented
&& dir
->origin
!= KANDR
)
344 "suggest hiding #%s from traditional C with an indented #",
348 /* If we are skipping a failed conditional group, all
349 non-conditional directives are ignored. */
350 if (! pfile
->state
.skipping
|| (dir
->flags
& COND
))
352 /* Issue -pedantic warnings for extensions. */
353 if (CPP_PEDANTIC (pfile
) && dir
->origin
== EXTENSION
)
354 cpp_pedwarn (pfile
, "#%s is a GCC extension", dir
->name
);
356 /* If we have a directive that is not an opening
357 conditional, invalidate any control macro. */
358 if (! (dir
->flags
& IF_COND
))
359 pfile
->mi_valid
= false;
361 (*dir
->handler
) (pfile
);
365 else if (dname
.type
!= CPP_EOF
&& ! pfile
->state
.skipping
)
367 /* An unknown directive. Don't complain about it in assembly
368 source: we don't know where the comments are, and # may
369 introduce assembler pseudo-ops. Don't complain about invalid
370 directives in skipped conditional groups (6.10 p4). */
371 if (CPP_OPTION (pfile
, lang
) == CLK_ASM
)
373 /* Output the # and this token for the assembler. */
374 _cpp_backup_tokens (pfile
, 1);
378 cpp_error (pfile
, "invalid preprocessing directive #%s",
379 cpp_token_as_text (pfile
, &dname
));
382 if (pfile
->state
.in_directive
)
383 end_directive (pfile
, skip
);
387 /* Directive handler wrapper used by the command line option
390 run_directive (pfile
, dir_no
, buf
, count
)
396 cpp_push_buffer (pfile
, (const U_CHAR
*) buf
, count
,
397 /* from_stage3 */ true, 1);
398 start_directive (pfile
);
399 pfile
->buffer
->saved_flags
= 0; /* We don't want to recognise directives. */
400 pfile
->state
.prevent_expansion
++;
401 pfile
->directive
= &dtable
[dir_no
];
402 (void) (*pfile
->directive
->handler
) (pfile
);
403 pfile
->state
.prevent_expansion
--;
404 end_directive (pfile
, 1);
405 _cpp_pop_buffer (pfile
);
408 /* Checks for validity the macro name in #define, #undef, #ifdef and
409 #ifndef directives. */
410 static cpp_hashnode
*
411 lex_macro_node (pfile
)
417 /* Lex the macro name directly. */
418 _cpp_lex_token (pfile
, &token
);
420 /* The token immediately after #define must be an identifier. That
421 identifier may not be "defined", per C99 6.10.8p4.
422 In C++, it may not be any of the "named operators" either,
423 per C++98 [lex.digraph], [lex.key].
424 Finally, the identifier may not have been poisoned. (In that case
425 the lexer has issued the error message for us.) */
427 if (token
.type
!= CPP_NAME
)
429 if (token
.type
== CPP_EOF
)
430 cpp_error (pfile
, "no macro name given in #%s directive",
431 pfile
->directive
->name
);
432 else if (token
.flags
& NAMED_OP
)
434 "\"%s\" cannot be used as a macro name as it is an operator in C++",
435 NODE_NAME (token
.val
.node
));
437 cpp_error (pfile
, "macro names must be identifiers");
442 node
= token
.val
.node
;
443 if (node
->flags
& NODE_POISONED
)
446 if (node
== pfile
->spec_nodes
.n_defined
)
448 cpp_error (pfile
, "\"%s\" cannot be used as a macro name",
456 /* Process a #define directive. Most work is done in cppmacro.c. */
461 cpp_hashnode
*node
= lex_macro_node (pfile
);
465 if (_cpp_create_definition (pfile
, node
))
466 if (pfile
->cb
.define
)
467 (*pfile
->cb
.define
) (pfile
, pfile
->directive_line
, node
);
471 /* Handle #undef. Marks the identifier NT_VOID in the hash table. */
476 cpp_hashnode
*node
= lex_macro_node (pfile
);
478 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
479 is not currently defined as a macro name. */
480 if (node
&& node
->type
== NT_MACRO
)
483 (*pfile
->cb
.undef
) (pfile
, pfile
->directive_line
, node
);
485 if (node
->flags
& NODE_WARN
)
486 cpp_warning (pfile
, "undefining \"%s\"", NODE_NAME (node
));
488 _cpp_free_definition (node
);
493 /* Helper routine used by parse_include. Reinterpret the current line
494 as an h-char-sequence (< ... >); we are looking at the first token
495 after the <. Returns zero on success. */
497 glue_header_name (pfile
, header
)
502 unsigned char *buffer
, *token_mem
;
503 size_t len
, total_len
= 0, capacity
= 1024;
505 /* To avoid lexed tokens overwriting our glued name, we can only
506 allocate from the string pool once we've lexed everything. */
508 buffer
= (unsigned char *) xmalloc (capacity
);
511 cpp_get_token (pfile
, &token
);
513 if (token
.type
== CPP_GREATER
|| token
.type
== CPP_EOF
)
516 len
= cpp_token_len (&token
);
517 if (total_len
+ len
> capacity
)
519 capacity
= (capacity
+ len
) * 2;
520 buffer
= (unsigned char *) xrealloc (buffer
, capacity
);
523 if (token
.flags
& PREV_WHITE
)
524 buffer
[total_len
++] = ' ';
526 total_len
= cpp_spell_token (pfile
, &token
, &buffer
[total_len
]) - buffer
;
529 if (token
.type
== CPP_EOF
)
530 cpp_error (pfile
, "missing terminating > character");
533 token_mem
= _cpp_pool_alloc (&pfile
->ident_pool
, total_len
+ 1);
534 memcpy (token_mem
, buffer
, total_len
);
535 token_mem
[total_len
] = '\0';
537 header
->type
= CPP_HEADER_NAME
;
538 header
->flags
&= ~PREV_WHITE
;
539 header
->val
.str
.len
= total_len
;
540 header
->val
.str
.text
= token_mem
;
544 return token
.type
== CPP_EOF
;
547 /* Parse the header name of #include, #include_next, #import and
548 #pragma dependency. Returns zero on success. */
550 parse_include (pfile
, header
)
554 const unsigned char *dir
;
556 if (pfile
->directive
== &dtable
[T_PRAGMA
])
557 dir
= U
"pragma dependency";
559 dir
= pfile
->directive
->name
;
561 /* Allow macro expansion. */
562 cpp_get_token (pfile
, header
);
563 if (header
->type
!= CPP_STRING
&& header
->type
!= CPP_HEADER_NAME
)
565 if (header
->type
!= CPP_LESS
)
567 cpp_error (pfile
, "#%s expects \"FILENAME\" or <FILENAME>", dir
);
570 if (glue_header_name (pfile
, header
))
574 if (header
->val
.str
.len
== 0)
576 cpp_error (pfile
, "empty file name in #%s", dir
);
583 /* Handle #include, #include_next and #import. */
585 do_include_common (pfile
, type
)
587 enum include_type type
;
591 /* For #include_next, if this is the primary source file, warn and
592 use the normal search logic. */
593 if (type
== IT_INCLUDE_NEXT
&& ! pfile
->buffer
->prev
)
595 cpp_warning (pfile
, "#include_next in primary source file");
598 else if (type
== IT_IMPORT
&& CPP_OPTION (pfile
, warn_import
))
600 CPP_OPTION (pfile
, warn_import
) = 0;
602 "#import is obsolete, use an #ifndef wrapper in the header file");
605 if (!parse_include (pfile
, &header
))
607 /* Prevent #include recursion. */
608 if (pfile
->line_maps
.depth
>= CPP_STACK_MAX
)
609 cpp_fatal (pfile
, "#include nested too deeply");
613 /* Get out of macro context, if we are. */
614 skip_rest_of_line (pfile
);
615 if (pfile
->cb
.include
)
616 (*pfile
->cb
.include
) (pfile
, pfile
->directive_line
,
617 pfile
->directive
->name
, &header
);
619 _cpp_execute_include (pfile
, &header
, type
);
628 do_include_common (pfile
, IT_INCLUDE
);
635 do_include_common (pfile
, IT_IMPORT
);
639 do_include_next (pfile
)
642 do_include_common (pfile
, IT_INCLUDE_NEXT
);
645 /* Subroutine of do_line. Read possible flags after file name. LAST
646 is the last flag seen; 0 if this is the first flag. Return the flag
647 if it is valid, 0 at the end of the directive. Otherwise complain. */
650 read_flag (pfile
, last
)
656 _cpp_lex_token (pfile
, &token
);
657 if (token
.type
== CPP_NUMBER
&& token
.val
.str
.len
== 1)
659 unsigned int flag
= token
.val
.str
.text
[0] - '0';
661 if (flag
> last
&& flag
<= 4
662 && (flag
!= 4 || last
== 3)
663 && (flag
!= 2 || last
== 0))
667 if (token
.type
!= CPP_EOF
)
668 cpp_error (pfile
, "invalid flag \"%s\" in line directive",
669 cpp_token_as_text (pfile
, &token
));
673 /* Another subroutine of do_line. Convert a number in STR, of length
674 LEN, to binary; store it in NUMP, and return 0 if the number was
675 well-formed, 1 if not. Temporary, hopefully. */
677 strtoul_for_line (str
, len
, nump
)
682 unsigned long reg
= 0;
696 /* Interpret #line command.
697 Note that the filename string (if any) is treated as if it were an
698 include filename. That means no escape handling. */
705 const char *new_file
= pfile
->map
->to_file
;
706 unsigned long new_lineno
;
707 unsigned int cap
, new_sysp
= pfile
->map
->sysp
;
708 enum lc_reason reason
= LC_RENAME
;
710 /* C99 raised the minimum limit on #line numbers. */
711 cap
= CPP_OPTION (pfile
, c99
) ? 2147483647 : 32767;
713 /* #line commands expand macros. */
714 cpp_get_token (pfile
, &token
);
715 if (token
.type
!= CPP_NUMBER
716 || strtoul_for_line (token
.val
.str
.text
, token
.val
.str
.len
, &new_lineno
))
718 cpp_error (pfile
, "\"%s\" after #line is not a positive integer",
719 cpp_token_as_text (pfile
, &token
));
723 if (CPP_PEDANTIC (pfile
) && ! pfile
->state
.line_extension
724 && (new_lineno
== 0 || new_lineno
> cap
))
725 cpp_pedwarn (pfile
, "line number out of range");
727 cpp_get_token (pfile
, &token
);
728 if (token
.type
== CPP_STRING
)
730 new_file
= (const char *) token
.val
.str
.text
;
732 /* Only accept flags for the # 55 form. */
733 if (pfile
->state
.line_extension
)
738 flag
= read_flag (pfile
, 0);
742 /* Fake an include for cpp_included (). */
743 _cpp_fake_include (pfile
, new_file
);
744 flag
= read_flag (pfile
, flag
);
749 flag
= read_flag (pfile
, flag
);
754 flag
= read_flag (pfile
, flag
);
761 else if (token
.type
!= CPP_EOF
)
763 cpp_error (pfile
, "\"%s\" is not a valid filename",
764 cpp_token_as_text (pfile
, &token
));
768 skip_rest_of_line (pfile
);
769 _cpp_do_file_change (pfile
, reason
, new_file
, new_lineno
, new_sysp
);
772 /* Arrange the file_change callback. pfile->line has changed to
773 FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system
774 header, 2 for a sytem header that needs to be extern "C" protected,
775 and zero otherwise. */
777 _cpp_do_file_change (pfile
, reason
, to_file
, file_line
, sysp
)
779 enum lc_reason reason
;
781 unsigned int file_line
;
784 pfile
->map
= add_line_map (&pfile
->line_maps
, reason
, sysp
,
785 pfile
->line
, to_file
, file_line
);
787 if (pfile
->cb
.file_change
)
788 (*pfile
->cb
.file_change
) (pfile
, pfile
->map
);
792 * Report a warning or error detected by the program we are
793 * processing. Use the directive's tokens in the error message.
797 do_diagnostic (pfile
, code
, print_dir
)
799 enum error_type code
;
802 if (_cpp_begin_message (pfile
, code
, 0))
805 fprintf (stderr
, "#%s ", pfile
->directive
->name
);
806 pfile
->state
.prevent_expansion
++;
807 cpp_output_line (pfile
, stderr
);
808 pfile
->state
.prevent_expansion
--;
816 do_diagnostic (pfile
, ERROR
, 1);
823 /* We want #warning diagnostics to be emitted in system headers too. */
824 do_diagnostic (pfile
, WARNING_SYSHDR
, 1);
827 /* Report program identification. */
835 cpp_get_token (pfile
, &str
);
836 if (str
.type
!= CPP_STRING
)
837 cpp_error (pfile
, "invalid #ident");
838 else if (pfile
->cb
.ident
)
839 (*pfile
->cb
.ident
) (pfile
, pfile
->directive_line
, &str
.val
.str
);
844 /* Pragmata handling. We handle some of these, and pass the rest on
845 to the front end. C99 defines three pragmas and says that no macro
846 expansion is to be performed on them; whether or not macro
847 expansion happens for other pragmas is implementation defined.
848 This implementation never macro-expands the text after #pragma. */
850 /* Sub-handlers for the pragmas needing treatment here.
851 They return 1 if the token buffer is to be popped, 0 if not. */
852 typedef void (*pragma_cb
) PARAMS ((cpp_reader
*));
855 struct pragma_entry
*next
;
861 struct pragma_entry
*space
;
866 cpp_register_pragma (pfile
, space
, name
, handler
)
872 struct pragma_entry
**x
, *new;
878 struct pragma_entry
*p
= pfile
->pragmas
;
879 len
= strlen (space
);
882 if (p
->isnspace
&& p
->len
== len
&& !memcmp (p
->name
, space
, len
))
889 cpp_ice (pfile
, "unknown #pragma namespace %s", space
);
894 new = (struct pragma_entry
*)
895 _cpp_pool_alloc (&pfile
->macro_pool
, sizeof (struct pragma_entry
));
897 new->len
= strlen (name
);
899 new->u
.handler
= handler
;
906 cpp_register_pragma_space (pfile
, space
)
910 struct pragma_entry
*new;
911 const struct pragma_entry
*p
= pfile
->pragmas
;
912 size_t len
= strlen (space
);
916 if (p
->isnspace
&& p
->len
== len
&& !memcmp (p
->name
, space
, len
))
917 /* Multiple different callers are allowed to register the same
923 new = (struct pragma_entry
*)
924 _cpp_pool_alloc (&pfile
->macro_pool
, sizeof (struct pragma_entry
));
930 new->next
= pfile
->pragmas
;
931 pfile
->pragmas
= new;
935 _cpp_init_internal_pragmas (pfile
)
939 cpp_register_pragma (pfile
, 0, "poison", do_pragma_poison
);
940 cpp_register_pragma (pfile
, 0, "once", do_pragma_once
);
943 cpp_register_pragma_space (pfile
, "GCC");
945 cpp_register_pragma (pfile
, "GCC", "poison", do_pragma_poison
);
946 cpp_register_pragma (pfile
, "GCC", "system_header", do_pragma_system_header
);
947 cpp_register_pragma (pfile
, "GCC", "dependency", do_pragma_dependency
);
954 pragma_cb handler
= NULL
;
955 const struct pragma_entry
*p
;
957 unsigned int count
= 0;
960 pfile
->state
.prevent_expansion
++;
964 cpp_get_token (pfile
, &tok
);
965 if (tok
.type
== CPP_NAME
)
967 const cpp_hashnode
*node
= tok
.val
.node
;
968 size_t len
= NODE_LEN (node
);
972 if (strlen (p
->name
) == len
973 && !memcmp (p
->name
, NODE_NAME (node
), len
))
982 handler
= p
->u
.handler
;
990 pfile
->state
.prevent_expansion
--;
993 else if (pfile
->cb
.def_pragma
)
995 _cpp_backup_tokens (pfile
, count
);
996 (*pfile
->cb
.def_pragma
) (pfile
, pfile
->directive_line
);
1001 do_pragma_once (pfile
)
1004 cpp_warning (pfile
, "#pragma once is obsolete");
1006 if (pfile
->buffer
->prev
== NULL
)
1007 cpp_warning (pfile
, "#pragma once in main file");
1009 _cpp_never_reread (pfile
->buffer
->inc
);
1015 do_pragma_poison (pfile
)
1018 /* Poison these symbols so that all subsequent usage produces an
1023 pfile
->state
.poisoned_ok
= 1;
1026 _cpp_lex_token (pfile
, &tok
);
1027 if (tok
.type
== CPP_EOF
)
1029 if (tok
.type
!= CPP_NAME
)
1031 cpp_error (pfile
, "invalid #pragma GCC poison directive");
1036 if (hp
->flags
& NODE_POISONED
)
1039 if (hp
->type
== NT_MACRO
)
1040 cpp_warning (pfile
, "poisoning existing macro \"%s\"", NODE_NAME (hp
));
1041 _cpp_free_definition (hp
);
1042 hp
->flags
|= NODE_POISONED
| NODE_DIAGNOSTIC
;
1044 pfile
->state
.poisoned_ok
= 0;
1047 /* Mark the current header as a system header. This will suppress
1048 some categories of warnings (notably those from -pedantic). It is
1049 intended for use in system libraries that cannot be implemented in
1050 conforming C, but cannot be certain that their headers appear in a
1051 system include directory. To prevent abuse, it is rejected in the
1052 primary source file. */
1054 do_pragma_system_header (pfile
)
1057 cpp_buffer
*buffer
= pfile
->buffer
;
1059 if (buffer
->prev
== 0)
1060 cpp_warning (pfile
, "#pragma system_header ignored outside include file");
1064 skip_rest_of_line (pfile
);
1065 cpp_make_system_header (pfile
, 1, 0);
1069 /* Check the modified date of the current include file against a specified
1070 file. Issue a diagnostic, if the specified file is newer. We use this to
1071 determine if a fixed header should be refixed. */
1073 do_pragma_dependency (pfile
)
1076 cpp_token header
, msg
;
1079 if (parse_include (pfile
, &header
))
1082 ordering
= _cpp_compare_file_date (pfile
, &header
);
1084 cpp_warning (pfile
, "cannot find source %s",
1085 cpp_token_as_text (pfile
, &header
));
1086 else if (ordering
> 0)
1088 cpp_warning (pfile
, "current file is older than %s",
1089 cpp_token_as_text (pfile
, &header
));
1090 cpp_get_token (pfile
, &msg
);
1091 if (msg
.type
!= CPP_EOF
)
1093 _cpp_backup_tokens (pfile
, 1);
1094 do_diagnostic (pfile
, WARNING
, 0);
1099 /* Check syntax is "(string-literal)". Returns 0 on success. */
1101 get__Pragma_string (pfile
, string
)
1107 cpp_get_token (pfile
, &paren
);
1108 if (paren
.type
!= CPP_OPEN_PAREN
)
1111 cpp_get_token (pfile
, string
);
1112 if (string
->type
!= CPP_STRING
&& string
->type
!= CPP_WSTRING
)
1115 cpp_get_token (pfile
, &paren
);
1116 return paren
.type
!= CPP_CLOSE_PAREN
;
1119 /* Returns a malloced buffer containing a destringized cpp_string by
1120 removing the first \ of \" and \\ sequences. */
1121 static unsigned char *
1122 destringize (in
, len
)
1123 const cpp_string
*in
;
1126 const unsigned char *src
, *limit
;
1127 unsigned char *dest
, *result
;
1129 dest
= result
= (unsigned char *) xmalloc (in
->len
);
1130 for (src
= in
->text
, limit
= src
+ in
->len
; src
< limit
;)
1132 /* We know there is a character following the backslash. */
1133 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1138 *len
= dest
- result
;
1143 _cpp_do__Pragma (pfile
)
1147 unsigned char *buffer
;
1149 cpp_lexer_pos orig_pos
;
1151 orig_pos
= pfile
->lexer_pos
;
1152 if (get__Pragma_string (pfile
, &string
))
1153 cpp_error (pfile
, "_Pragma takes a parenthesized string literal");
1156 buffer
= destringize (&string
.val
.str
, &len
);
1157 run_directive (pfile
, T_PRAGMA
, (char *) buffer
, len
);
1158 free ((PTR
) buffer
);
1159 pfile
->lexer_pos
= orig_pos
;
1160 pfile
->line
= pfile
->lexer_pos
.line
;
1164 /* Just ignore #sccs, on systems where we define it at all. */
1165 #ifdef SCCS_DIRECTIVE
1168 cpp_reader
*pfile ATTRIBUTE_UNUSED
;
1179 if (! pfile
->state
.skipping
)
1181 const cpp_hashnode
*node
= lex_macro_node (pfile
);
1184 skip
= node
->type
!= NT_MACRO
;
1190 push_conditional (pfile
, skip
, T_IFDEF
, 0);
1198 const cpp_hashnode
*node
= 0;
1200 if (! pfile
->state
.skipping
)
1202 node
= lex_macro_node (pfile
);
1204 skip
= node
->type
== NT_MACRO
;
1210 push_conditional (pfile
, skip
, T_IFNDEF
, node
);
1213 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1214 pfile->mi_ind_cmacro so we can handle multiple-include
1215 optimisations. If macro expansion occurs in the expression, we
1216 cannot treat it as a controlling conditional, since the expansion
1217 could change in the future. That is handled by cpp_get_token. */
1225 if (! pfile
->state
.skipping
)
1226 skip
= _cpp_parse_expr (pfile
) == 0;
1228 push_conditional (pfile
, skip
, T_IF
, pfile
->mi_ind_cmacro
);
1231 /* Flip skipping state if appropriate and continue without changing
1232 if_stack; this is so that the error message for missing #endif's
1233 etc. will point to the original #if. */
1239 cpp_buffer
*buffer
= pfile
->buffer
;
1240 struct if_stack
*ifs
= buffer
->if_stack
;
1243 cpp_error (pfile
, "#else without #if");
1246 if (ifs
->type
== T_ELSE
)
1248 cpp_error (pfile
, "#else after #else");
1249 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1250 "the conditional began here");
1254 /* Skip any future (erroneous) #elses or #elifs. */
1255 pfile
->state
.skipping
= ifs
->skip_elses
;
1256 ifs
->skip_elses
= true;
1258 /* Invalidate any controlling macro. */
1261 /* Only check EOL if was not originally skipping. */
1262 if (!ifs
->was_skipping
)
1267 /* handle a #elif directive by not changing if_stack either. see the
1268 comment above do_else. */
1274 cpp_buffer
*buffer
= pfile
->buffer
;
1275 struct if_stack
*ifs
= buffer
->if_stack
;
1278 cpp_error (pfile
, "#elif without #if");
1281 if (ifs
->type
== T_ELSE
)
1283 cpp_error (pfile
, "#elif after #else");
1284 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1285 "the conditional began here");
1289 /* Only evaluate this if we aren't skipping elses. During
1290 evaluation, set skipping to false to get lexer warnings. */
1291 if (ifs
->skip_elses
)
1292 pfile
->state
.skipping
= 1;
1295 pfile
->state
.skipping
= 0;
1296 pfile
->state
.skipping
= ! _cpp_parse_expr (pfile
);
1297 ifs
->skip_elses
= ! pfile
->state
.skipping
;
1300 /* Invalidate any controlling macro. */
1305 /* #endif pops the if stack and resets pfile->state.skipping. */
1311 cpp_buffer
*buffer
= pfile
->buffer
;
1312 struct if_stack
*ifs
= buffer
->if_stack
;
1315 cpp_error (pfile
, "#endif without #if");
1318 /* Only check EOL if was not originally skipping. */
1319 if (!ifs
->was_skipping
)
1322 /* If potential control macro, we go back outside again. */
1323 if (ifs
->next
== 0 && ifs
->mi_cmacro
)
1325 pfile
->mi_valid
= true;
1326 pfile
->mi_cmacro
= ifs
->mi_cmacro
;
1329 buffer
->if_stack
= ifs
->next
;
1330 pfile
->state
.skipping
= ifs
->was_skipping
;
1331 obstack_free (&pfile
->buffer_ob
, ifs
);
1335 /* Push an if_stack entry and set pfile->state.skipping accordingly.
1336 If this is a #if or #ifndef, CMACRO is a potentially controlling
1337 macro - we need to check here that we are at the top of the file. */
1340 push_conditional (pfile
, skip
, type
, cmacro
)
1344 const cpp_hashnode
*cmacro
;
1346 struct if_stack
*ifs
;
1347 cpp_buffer
*buffer
= pfile
->buffer
;
1349 ifs
= xobnew (&pfile
->buffer_ob
, struct if_stack
);
1350 ifs
->pos
= pfile
->directive_pos
;
1351 ifs
->next
= buffer
->if_stack
;
1352 ifs
->skip_elses
= pfile
->state
.skipping
|| !skip
;
1353 ifs
->was_skipping
= pfile
->state
.skipping
;
1355 /* This condition is effectively a test for top-of-file. */
1356 if (pfile
->mi_valid
&& pfile
->mi_cmacro
== 0)
1357 ifs
->mi_cmacro
= cmacro
;
1361 pfile
->state
.skipping
= skip
;
1362 buffer
->if_stack
= ifs
;
1365 /* Read the tokens of the answer into the macro pool. Only commit the
1366 memory if we intend it as permanent storage, i.e. the #assert case.
1367 Returns 0 on success. */
1370 parse_answer (pfile
, answerp
, type
)
1372 struct answer
**answerp
;
1375 cpp_token paren
, *token
;
1376 struct answer
*answer
;
1378 if (POOL_FRONT (&pfile
->macro_pool
) + sizeof (struct answer
) >
1379 POOL_LIMIT (&pfile
->macro_pool
))
1380 _cpp_next_chunk (&pfile
->macro_pool
, sizeof (struct answer
), 0);
1381 answer
= (struct answer
*) POOL_FRONT (&pfile
->macro_pool
);
1384 /* In a conditional, it is legal to not have an open paren. We
1385 should save the following token in this case. */
1386 cpp_get_token (pfile
, &paren
);
1388 /* If not a paren, see if we're OK. */
1389 if (paren
.type
!= CPP_OPEN_PAREN
)
1391 /* In a conditional no answer is a test for any answer. It
1392 could be followed by any token. */
1395 _cpp_backup_tokens (pfile
, 1);
1399 /* #unassert with no answer is valid - it removes all answers. */
1400 if (type
== T_UNASSERT
&& paren
.type
== CPP_EOF
)
1403 cpp_error (pfile
, "missing '(' after predicate");
1409 token
= &answer
->first
[answer
->count
];
1410 /* Check we have room for the token. */
1411 if ((unsigned char *) (token
+ 1) >= POOL_LIMIT (&pfile
->macro_pool
))
1413 _cpp_next_chunk (&pfile
->macro_pool
, sizeof (cpp_token
),
1414 (unsigned char **) &answer
);
1415 token
= &answer
->first
[answer
->count
];
1418 cpp_get_token (pfile
, token
);
1419 if (token
->type
== CPP_CLOSE_PAREN
)
1422 if (token
->type
== CPP_EOF
)
1424 cpp_error (pfile
, "missing ')' to complete answer");
1430 if (answer
->count
== 0)
1432 cpp_error (pfile
, "predicate's answer is empty");
1436 /* Drop whitespace at start. */
1437 answer
->first
->flags
&= ~PREV_WHITE
;
1440 if (type
== T_ASSERT
|| type
== T_UNASSERT
)
1445 /* Parses an assertion, returning a pointer to the hash node of the
1446 predicate, or 0 on error. If an answer was supplied, it is placed
1447 in ANSWERP, otherwise it is set to 0. */
1448 static cpp_hashnode
*
1449 parse_assertion (pfile
, answerp
, type
)
1451 struct answer
**answerp
;
1454 cpp_hashnode
*result
= 0;
1455 cpp_token predicate
;
1457 /* We don't expand predicates or answers. */
1458 pfile
->state
.prevent_expansion
++;
1461 cpp_get_token (pfile
, &predicate
);
1462 if (predicate
.type
== CPP_EOF
)
1463 cpp_error (pfile
, "assertion without predicate");
1464 else if (predicate
.type
!= CPP_NAME
)
1465 cpp_error (pfile
, "predicate must be an identifier");
1466 else if (parse_answer (pfile
, answerp
, type
) == 0)
1468 unsigned int len
= NODE_LEN (predicate
.val
.node
);
1469 unsigned char *sym
= alloca (len
+ 1);
1471 /* Prefix '#' to get it out of macro namespace. */
1473 memcpy (sym
+ 1, NODE_NAME (predicate
.val
.node
), len
);
1474 result
= cpp_lookup (pfile
, sym
, len
+ 1);
1477 pfile
->state
.prevent_expansion
--;
1481 /* Returns a pointer to the pointer to the answer in the answer chain,
1482 or a pointer to NULL if the answer is not in the chain. */
1483 static struct answer
**
1484 find_answer (node
, candidate
)
1486 const struct answer
*candidate
;
1489 struct answer
**result
;
1491 for (result
= &node
->value
.answers
; *result
; result
= &(*result
)->next
)
1493 struct answer
*answer
= *result
;
1495 if (answer
->count
== candidate
->count
)
1497 for (i
= 0; i
< answer
->count
; i
++)
1498 if (! _cpp_equiv_tokens (&answer
->first
[i
], &candidate
->first
[i
]))
1501 if (i
== answer
->count
)
1509 /* Test an assertion within a preprocessor conditional. Returns
1510 non-zero on failure, zero on success. On success, the result of
1511 the test is written into VALUE. */
1513 _cpp_test_assertion (pfile
, value
)
1517 struct answer
*answer
;
1520 node
= parse_assertion (pfile
, &answer
, T_IF
);
1522 *value
= (node
->type
== NT_ASSERTION
&&
1523 (answer
== 0 || *find_answer (node
, answer
) != 0));
1525 /* We don't commit the memory for the answer - it's temporary only. */
1533 struct answer
*new_answer
;
1536 node
= parse_assertion (pfile
, &new_answer
, T_ASSERT
);
1539 /* Place the new answer in the answer list. First check there
1540 is not a duplicate. */
1541 new_answer
->next
= 0;
1542 if (node
->type
== NT_ASSERTION
)
1544 if (*find_answer (node
, new_answer
))
1546 cpp_warning (pfile
, "\"%s\" re-asserted", NODE_NAME (node
) + 1);
1549 new_answer
->next
= node
->value
.answers
;
1551 node
->type
= NT_ASSERTION
;
1552 node
->value
.answers
= new_answer
;
1553 POOL_COMMIT (&pfile
->macro_pool
, (sizeof (struct answer
)
1554 + (new_answer
->count
- 1)
1555 * sizeof (cpp_token
)));
1564 struct answer
*answer
;
1566 node
= parse_assertion (pfile
, &answer
, T_UNASSERT
);
1567 /* It isn't an error to #unassert something that isn't asserted. */
1568 if (node
&& node
->type
== NT_ASSERTION
)
1572 struct answer
**p
= find_answer (node
, answer
), *temp
;
1574 /* Remove the answer from the list. */
1579 /* Did we free the last answer? */
1580 if (node
->value
.answers
== 0)
1581 node
->type
= NT_VOID
;
1584 _cpp_free_definition (node
);
1587 /* We don't commit the memory for the answer - it's temporary only. */
1590 /* These are for -D, -U, -A. */
1592 /* Process the string STR as if it appeared as the body of a #define.
1593 If STR is just an identifier, define it with value 1.
1594 If STR has anything after the identifier, then it should
1595 be identifier=definition. */
1598 cpp_define (pfile
, str
)
1605 /* Copy the entire option so we can modify it.
1606 Change the first "=" in the string to a space. If there is none,
1607 tack " 1" on the end. */
1609 /* Length including the null. */
1610 count
= strlen (str
);
1611 buf
= (char *) alloca (count
+ 2);
1612 memcpy (buf
, str
, count
);
1614 p
= strchr (str
, '=');
1623 run_directive (pfile
, T_DEFINE
, buf
, count
);
1626 /* Slight variant of the above for use by initialize_builtins. */
1628 _cpp_define_builtin (pfile
, str
)
1632 run_directive (pfile
, T_DEFINE
, str
, strlen (str
));
1635 /* Process MACRO as if it appeared as the body of an #undef. */
1637 cpp_undef (pfile
, macro
)
1641 run_directive (pfile
, T_UNDEF
, macro
, strlen (macro
));
1644 /* Process the string STR as if it appeared as the body of a #assert. */
1646 cpp_assert (pfile
, str
)
1650 handle_assertion (pfile
, str
, T_ASSERT
);
1653 /* Process STR as if it appeared as the body of an #unassert. */
1655 cpp_unassert (pfile
, str
)
1659 handle_assertion (pfile
, str
, T_UNASSERT
);
1662 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1664 handle_assertion (pfile
, str
, type
)
1669 size_t count
= strlen (str
);
1670 const char *p
= strchr (str
, '=');
1674 /* Copy the entire option so we can modify it. Change the first
1675 "=" in the string to a '(', and tack a ')' on the end. */
1676 char *buf
= (char *) alloca (count
+ 1);
1678 memcpy (buf
, str
, count
);
1684 run_directive (pfile
, type
, str
, count
);
1687 /* The number of errors for a given reader. */
1692 return pfile
->errors
;
1695 /* The options structure. */
1697 cpp_get_options (pfile
)
1700 return &pfile
->opts
;
1703 /* The callbacks structure. */
1705 cpp_get_callbacks (pfile
)
1711 /* The line map set. */
1712 const struct line_maps
*
1713 cpp_get_line_maps (pfile
)
1716 return &pfile
->line_maps
;
1719 /* Copy the given callbacks structure to our own. */
1721 cpp_set_callbacks (pfile
, cb
)
1728 /* Push a new buffer on the buffer stack. Returns the new buffer; it
1729 doesn't fail. It does not generate a file change call back; that
1730 is the responsibility of the caller. */
1732 cpp_push_buffer (pfile
, buffer
, len
, from_stage3
, return_at_eof
)
1734 const U_CHAR
*buffer
;
1739 cpp_buffer
*new = xobnew (&pfile
->buffer_ob
, cpp_buffer
);
1741 /* Clears, amongst other things, if_stack and mi_cmacro. */
1742 memset (new, 0, sizeof (cpp_buffer
));
1744 new->line_base
= new->buf
= new->cur
= buffer
;
1745 new->rlimit
= buffer
+ len
;
1747 /* No read ahead or extra char initially. */
1748 new->read_ahead
= EOF
;
1749 new->extra_char
= EOF
;
1750 new->from_stage3
= from_stage3
;
1751 new->prev
= pfile
->buffer
;
1752 new->return_at_eof
= return_at_eof
;
1753 new->saved_flags
= BOL
;
1755 pfile
->buffer
= new;
1760 /* If called from do_line, pops a single buffer. Otherwise pops all
1761 buffers until a real file is reached. Generates appropriate
1764 _cpp_pop_buffer (pfile
)
1767 cpp_buffer
*buffer
= pfile
->buffer
;
1768 struct if_stack
*ifs
;
1770 /* Walk back up the conditional stack till we reach its level at
1771 entry to this file, issuing error messages. */
1772 for (ifs
= buffer
->if_stack
; ifs
; ifs
= ifs
->next
)
1773 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1774 "unterminated #%s", dtable
[ifs
->type
].name
);
1776 /* The output line can fall out of sync if we missed the final
1777 newline from the previous buffer, for example because of an
1778 unterminated comment. Similarly, skipping needs to be cleared in
1779 case of a missing #endif. */
1780 pfile
->lexer_pos
.output_line
= pfile
->line
;
1781 pfile
->state
.skipping
= 0;
1783 /* Update the reader's buffer before _cpp_do_file_change. */
1784 pfile
->buffer
= buffer
->prev
;
1787 _cpp_pop_file_buffer (pfile
, buffer
->inc
);
1789 obstack_free (&pfile
->buffer_ob
, buffer
);
1793 _cpp_init_directives (pfile
)
1799 /* Register the directives. */
1800 for (i
= 0; i
< (unsigned int) N_DIRECTIVES
; i
++)
1802 node
= cpp_lookup (pfile
, dtable
[i
].name
, dtable
[i
].length
);
1803 node
->directive_index
= i
+ 1;