1 /* CPP Library. (Directive handling.)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 Free Software Foundation, Inc.
4 Contributed by Per Bothner, 1994-95.
5 Based on CCCP program by Paul Rubin, June 1986
6 Adapted to ANSI C, Richard Stallman, Jan 1987
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
31 /* Chained list of answers to an assertion. */
39 /* Stack of conditionals currently in progress
40 (including both successful and failing conditionals). */
44 struct if_stack
*next
;
45 cpp_lexer_pos pos
; /* line and column where condition started */
46 const cpp_hashnode
*mi_cmacro
;/* macro name for #ifndef around entire file */
47 unsigned char was_skipping
; /* Value of pfile->skipping before this if. */
48 int type
; /* type of last directive seen in this group */
51 /* Values for the origin field of struct directive. KANDR directives
52 come from traditional (K&R) C. STDC89 directives come from the
53 1989 C standard. EXTENSION directives are extensions. */
58 /* Values for the flags field of struct directive. COND indicates a
59 conditional; IF_COND an opening conditional. INCL means to treat
60 "..." and <...> as q-char and h-char sequences respectively. IN_I
61 means this directive should be handled even if -fpreprocessed is in
62 effect (these are the directives with callback hooks). */
64 #define IF_COND (1 << 1)
68 /* Defines one #-directive, including how to handle it. */
69 typedef void (*directive_handler
) PARAMS ((cpp_reader
*));
70 typedef struct directive directive
;
73 directive_handler handler
; /* Function to handle directive. */
74 const U_CHAR
*name
; /* Name of directive. */
75 unsigned short length
; /* Length of name. */
76 unsigned char origin
; /* Origin of directive. */
77 unsigned char flags
; /* Flags describing this directive. */
80 /* Forward declarations. */
82 static void skip_rest_of_line
PARAMS ((cpp_reader
*));
83 static void check_eol
PARAMS ((cpp_reader
*));
84 static void start_directive
PARAMS ((cpp_reader
*));
85 static void end_directive
PARAMS ((cpp_reader
*, int));
86 static void run_directive
PARAMS ((cpp_reader
*, int,
89 static int glue_header_name
PARAMS ((cpp_reader
*, cpp_token
*));
90 static int parse_include
PARAMS ((cpp_reader
*, cpp_token
*));
91 static void push_conditional
PARAMS ((cpp_reader
*, int, int,
92 const cpp_hashnode
*));
93 static int read_line_number
PARAMS ((cpp_reader
*, int *));
94 static int strtoul_for_line
PARAMS ((const U_CHAR
*, unsigned int,
96 static void do_diagnostic
PARAMS ((cpp_reader
*, enum error_type
, int));
97 static cpp_hashnode
*lex_macro_node
PARAMS ((cpp_reader
*));
98 static void do_pragma_once
PARAMS ((cpp_reader
*));
99 static void do_pragma_poison
PARAMS ((cpp_reader
*));
100 static void do_pragma_system_header
PARAMS ((cpp_reader
*));
101 static void do_pragma_dependency
PARAMS ((cpp_reader
*));
102 static int get__Pragma_string
PARAMS ((cpp_reader
*, cpp_token
*));
103 static unsigned char *destringize
PARAMS ((const cpp_string
*,
105 static int parse_answer
PARAMS ((cpp_reader
*, struct answer
**, int));
106 static cpp_hashnode
*parse_assertion
PARAMS ((cpp_reader
*, struct answer
**,
108 static struct answer
** find_answer
PARAMS ((cpp_hashnode
*,
109 const struct answer
*));
110 static void handle_assertion
PARAMS ((cpp_reader
*, const char *, int));
112 /* This is the table of directive handlers. It is ordered by
113 frequency of occurrence; the numbers at the end are directive
114 counts from all the source code I have lying around (egcs and libc
115 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
116 pcmcia-cs-3.0.9). This is no longer important as directive lookup
117 is now O(1). All extensions other than #warning and #include_next
118 are deprecated. The name is where the extension appears to have
121 #define DIRECTIVE_TABLE \
122 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
123 D(include, T_INCLUDE, KANDR, INCL) /* 52262 */ \
124 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
125 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
126 D(if, T_IF, KANDR, COND | IF_COND) /* 18162 */ \
127 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
128 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
129 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
130 D(line, T_LINE, KANDR, IN_I) /* 2465 */ \
131 D(elif, T_ELIF, KANDR, COND) /* 610 */ \
132 D(error, T_ERROR, STDC89, 0) /* 475 */ \
133 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
134 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
135 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL) /* 19 */ \
136 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
137 D(import, T_IMPORT, EXTENSION, INCL) /* 0 ObjC */ \
138 D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
139 D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
140 SCCS_ENTRY /* 0 SVR4? */
142 /* #sccs is not always recognized. */
143 #ifdef SCCS_DIRECTIVE
144 # define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION, 0)
146 # define SCCS_ENTRY /* nothing */
149 /* Use the table to generate a series of prototypes, an enum for the
150 directive names, and an array of directive handlers. */
152 /* The directive-processing functions are declared to return int
153 instead of void, because some old compilers have trouble with
154 pointers to functions returning void. */
156 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
157 #define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
161 #define D(n, tag, o, f) tag,
170 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
171 #define D(name, t, origin, flags) \
172 { CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
173 sizeof STRINGX(name) - 1, origin, flags },
174 static const directive dtable
[] =
179 #undef DIRECTIVE_TABLE
181 /* Skip any remaining tokens in a directive. */
183 skip_rest_of_line (pfile
)
188 /* Discard all input lookaheads. */
189 while (pfile
->la_read
)
190 _cpp_release_lookahead (pfile
);
192 /* Discard all stacked contexts. */
193 while (pfile
->context
!= &pfile
->base_context
)
194 _cpp_pop_context (pfile
);
196 /* Sweep up all tokens remaining on the line. */
197 pfile
->state
.prevent_expansion
++;
198 while (!pfile
->state
.next_bol
)
199 _cpp_lex_token (pfile
, &token
);
200 pfile
->state
.prevent_expansion
--;
203 /* Ensure there are no stray tokens at the end of a directive. */
208 if (!pfile
->state
.next_bol
)
212 _cpp_lex_token (pfile
, &token
);
213 if (token
.type
!= CPP_EOF
)
214 cpp_pedwarn (pfile
, "extra tokens at end of #%s directive",
215 pfile
->directive
->name
);
219 /* Called when entering a directive, _Pragma or command-line directive. */
221 start_directive (pfile
)
224 cpp_buffer
*buffer
= pfile
->buffer
;
226 /* Setup in-directive state. */
227 pfile
->state
.in_directive
= 1;
228 pfile
->state
.save_comments
= 0;
230 /* Some handlers need the position of the # for diagnostics. */
231 pfile
->directive_pos
= pfile
->lexer_pos
;
233 /* Don't save directive tokens for external clients. */
234 pfile
->la_saved
= pfile
->la_write
;
237 /* Turn off skipping. */
238 buffer
->was_skipping
= pfile
->skipping
;
242 /* Called when leaving a directive, _Pragma or command-line directive. */
244 end_directive (pfile
, skip_line
)
248 cpp_buffer
*buffer
= pfile
->buffer
;
250 /* Restore pfile->skipping before skip_rest_of_line. This avoids
251 warning about poisoned identifiers in skipped #error lines. */
252 pfile
->skipping
= buffer
->was_skipping
;
254 /* We don't skip for an assembler #. */
256 skip_rest_of_line (pfile
);
259 pfile
->la_write
= pfile
->la_saved
;
260 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
261 pfile
->state
.in_directive
= 0;
262 pfile
->state
.angled_headers
= 0;
263 pfile
->directive
= 0;
266 /* Check if a token's name matches that of a known directive. Put in
267 this file to save exporting dtable and other unneeded information. */
269 _cpp_handle_directive (pfile
, indented
)
273 cpp_buffer
*buffer
= pfile
->buffer
;
274 const directive
*dir
= 0;
278 start_directive (pfile
);
280 /* Lex the directive name directly. */
281 _cpp_lex_token (pfile
, &dname
);
283 if (dname
.type
== CPP_NAME
)
285 unsigned int index
= dname
.val
.node
->directive_index
;
287 dir
= &dtable
[index
- 1];
289 else if (dname
.type
== CPP_NUMBER
)
291 /* # followed by a number is equivalent to #line. Do not
292 recognize this form in assembly language source files or
293 skipped conditional groups. Complain about this form if
294 we're being pedantic, but not if this is regurgitated input
295 (preprocessed or fed back in by the C++ frontend). */
296 if (! buffer
->was_skipping
&& !CPP_OPTION (pfile
, lang_asm
))
298 dir
= &dtable
[T_LINE
];
299 _cpp_push_token (pfile
, &dname
, &pfile
->directive_pos
);
300 if (CPP_PEDANTIC (pfile
) && buffer
->inc
301 && ! CPP_OPTION (pfile
, preprocessed
))
302 cpp_pedwarn (pfile
, "# followed by integer");
306 pfile
->directive
= dir
;
309 /* Make sure we lex headers correctly, whether skipping or not. */
310 pfile
->state
.angled_headers
= dir
->flags
& INCL
;
312 /* If we are rescanning preprocessed input, only directives tagged
313 with IN_I are honored, and the warnings below are suppressed. */
314 if (! CPP_OPTION (pfile
, preprocessed
) || dir
->flags
& IN_I
)
316 /* Traditionally, a directive is ignored unless its # is in
317 column 1. Therefore in code intended to work with K+R
318 compilers, directives added by C89 must have their #
319 indented, and directives present in traditional C must
320 not. This is true even of directives in skipped
321 conditional blocks. */
322 if (CPP_WTRADITIONAL (pfile
))
324 if (indented
&& dir
->origin
== KANDR
)
326 "traditional C ignores #%s with the # indented",
328 else if (!indented
&& dir
->origin
!= KANDR
)
330 "suggest hiding #%s from traditional C with an indented #",
334 /* If we are skipping a failed conditional group, all
335 non-conditional directives are ignored. */
336 if (! buffer
->was_skipping
|| (dir
->flags
& COND
))
338 /* Issue -pedantic warnings for extensions. */
339 if (CPP_PEDANTIC (pfile
) && dir
->origin
== EXTENSION
)
340 cpp_pedwarn (pfile
, "#%s is a GCC extension", dir
->name
);
342 /* If we have a directive that is not an opening
343 conditional, invalidate any control macro. */
344 if (! (dir
->flags
& IF_COND
))
345 pfile
->mi_state
= MI_FAILED
;
347 (*dir
->handler
) (pfile
);
351 else if (dname
.type
!= CPP_EOF
&& ! pfile
->skipping
)
353 /* An unknown directive. Don't complain about it in assembly
354 source: we don't know where the comments are, and # may
355 introduce assembler pseudo-ops. Don't complain about invalid
356 directives in skipped conditional groups (6.10 p4). */
357 if (CPP_OPTION (pfile
, lang_asm
))
359 /* Output the # and lookahead token for the assembler. */
360 _cpp_push_token (pfile
, &dname
, &pfile
->directive_pos
);
364 cpp_error (pfile
, "invalid preprocessing directive #%s",
365 cpp_token_as_text (pfile
, &dname
));
368 end_directive (pfile
, skip
);
372 /* Directive handler wrapper used by the command line option
375 run_directive (pfile
, dir_no
, buf
, count
, name
)
382 unsigned int output_line
= pfile
->lexer_pos
.output_line
;
383 cpp_buffer
*buffer
= cpp_push_buffer (pfile
, (const U_CHAR
*) buf
, count
);
387 const struct directive
*dir
= &dtable
[dir_no
];
390 buffer
->nominal_fname
= name
;
392 buffer
->nominal_fname
= _("<command line>");
394 /* For _Pragma, the text is passed through preprocessing stage 3
395 only, i.e. no trigraphs, no escaped newline removal, and no
396 macro expansion. Do the same for command-line directives. */
397 buffer
->from_stage3
= 1;
399 if (dir_no
== T_PRAGMA
)
401 /* A kludge to avoid line markers for _Pragma. */
402 pfile
->lexer_pos
.output_line
= output_line
;
403 /* Avoid interpretation of directives in a _Pragma string. */
404 pfile
->state
.next_bol
= 0;
407 start_directive (pfile
);
408 pfile
->state
.prevent_expansion
++;
409 (void) (*dir
->handler
) (pfile
);
410 pfile
->state
.prevent_expansion
--;
412 end_directive (pfile
, 1);
414 cpp_pop_buffer (pfile
);
418 /* Checks for validity the macro name in #define, #undef, #ifdef and
419 #ifndef directives. */
420 static cpp_hashnode
*
421 lex_macro_node (pfile
)
426 /* Lex the macro name directly. */
427 _cpp_lex_token (pfile
, &token
);
429 /* The token immediately after #define must be an identifier. That
430 identifier is not allowed to be "defined". See predefined macro
431 names (6.10.8.4). In C++, it is not allowed to be any of the
432 <iso646.h> macro names (which are keywords in C++) either. */
434 if (token
.type
!= CPP_NAME
)
436 if (token
.type
== CPP_EOF
)
437 cpp_error (pfile
, "no macro name given in #%s directive",
438 pfile
->directive
->name
);
439 else if (token
.flags
& NAMED_OP
)
441 "\"%s\" cannot be used as a macro name as it is an operator in C++",
442 token
.val
.node
->name
);
444 cpp_error (pfile
, "macro names must be identifiers");
448 cpp_hashnode
*node
= token
.val
.node
;
450 /* In Objective C, some keywords begin with '@', but general
451 identifiers do not, and you're not allowed to #define them. */
452 if (node
== pfile
->spec_nodes
.n_defined
|| node
->name
[0] == '@')
453 cpp_error (pfile
, "\"%s\" cannot be used as a macro name", node
->name
);
454 else if (!(node
->flags
& NODE_POISONED
))
461 /* Process a #define directive. Most work is done in cppmacro.c. */
466 cpp_hashnode
*node
= lex_macro_node (pfile
);
470 /* Use the permanent pool for storage. */
471 pfile
->string_pool
= &pfile
->ident_pool
;
473 if (_cpp_create_definition (pfile
, node
))
474 if (pfile
->cb
.define
)
475 (*pfile
->cb
.define
) (pfile
, node
);
477 /* Revert to the temporary pool. */
478 pfile
->string_pool
= &pfile
->temp_string_pool
;
482 /* Handle #undef. Marks the identifier NT_VOID in the hash table. */
487 cpp_hashnode
*node
= lex_macro_node (pfile
);
489 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
490 is not currently defined as a macro name. */
491 if (node
&& node
->type
== NT_MACRO
)
494 (*pfile
->cb
.undef
) (pfile
, node
);
496 if (node
->flags
& NODE_BUILTIN
)
497 cpp_warning (pfile
, "undefining \"%s\"", node
->name
);
499 _cpp_free_definition (node
);
504 /* Helper routine used by parse_include. Reinterpret the current line
505 as an h-char-sequence (< ... >); we are looking at the first token
506 after the <. Returns zero on success. */
508 glue_header_name (pfile
, header
)
513 unsigned char *buffer
, *token_mem
;
514 size_t len
, total_len
= 0, capacity
= 1024;
516 /* To avoid lexed tokens overwriting our glued name, we can only
517 allocate from the string pool once we've lexed everything. */
519 buffer
= (unsigned char *) xmalloc (capacity
);
522 cpp_get_token (pfile
, &token
);
524 if (token
.type
== CPP_GREATER
|| token
.type
== CPP_EOF
)
527 len
= cpp_token_len (&token
);
528 if (total_len
+ len
> capacity
)
530 capacity
= (capacity
+ len
) * 2;
531 buffer
= (unsigned char *) xrealloc (buffer
, capacity
);
534 if (token
.flags
& PREV_WHITE
)
535 buffer
[total_len
++] = ' ';
537 total_len
= cpp_spell_token (pfile
, &token
, &buffer
[total_len
]) - buffer
;
540 if (token
.type
== CPP_EOF
)
541 cpp_error (pfile
, "missing terminating > character");
544 token_mem
= _cpp_pool_alloc (pfile
->string_pool
, total_len
);
545 memcpy (token_mem
, buffer
, total_len
);
547 header
->type
= CPP_HEADER_NAME
;
548 header
->flags
&= ~PREV_WHITE
;
549 header
->val
.str
.len
= total_len
;
550 header
->val
.str
.text
= token_mem
;
554 return token
.type
== CPP_EOF
;
557 /* Parse the header name of #include, #include_next, #import and
558 #pragma dependency. Returns zero on success. */
560 parse_include (pfile
, header
)
564 int is_pragma
= pfile
->directive
== &dtable
[T_PRAGMA
];
565 const unsigned char *dir
;
568 dir
= U
"pragma dependency";
570 dir
= pfile
->directive
->name
;
572 /* Allow macro expansion. */
573 cpp_get_token (pfile
, header
);
574 if (header
->type
!= CPP_STRING
&& header
->type
!= CPP_HEADER_NAME
)
576 if (header
->type
!= CPP_LESS
)
578 cpp_error (pfile
, "#%s expects \"FILENAME\" or <FILENAME>", dir
);
581 if (glue_header_name (pfile
, header
))
585 if (header
->val
.str
.len
== 0)
587 cpp_error (pfile
, "empty file name in #%s", dir
);
594 /* Get out of macro context, if we are. */
595 skip_rest_of_line (pfile
);
596 if (pfile
->cb
.include
)
597 (*pfile
->cb
.include
) (pfile
, dir
, header
);
609 if (!parse_include (pfile
, &header
))
610 _cpp_execute_include (pfile
, &header
, 0, 0);
619 if (!pfile
->import_warning
&& CPP_OPTION (pfile
, warn_import
))
621 pfile
->import_warning
= 1;
623 "#import is obsolete, use an #ifndef wrapper in the header file");
626 if (!parse_include (pfile
, &header
))
627 _cpp_execute_include (pfile
, &header
, 1, 0);
631 do_include_next (pfile
)
635 struct file_name_list
*search_start
= 0;
637 if (parse_include (pfile
, &header
))
640 /* For #include_next, skip in the search path past the dir in which
641 the current file was found. If this is the last directory in the
642 search path, don't include anything. If the current file was
643 specified with an absolute path, use the normal search logic. If
644 this is the primary source file, use the normal search logic and
645 generate a warning. */
646 if (CPP_PREV_BUFFER (CPP_BUFFER (pfile
)))
648 if (CPP_BUFFER (pfile
)->inc
->foundhere
)
650 search_start
= CPP_BUFFER (pfile
)->inc
->foundhere
->next
;
656 cpp_warning (pfile
, "#include_next in primary source file");
658 _cpp_execute_include (pfile
, &header
, 0, search_start
);
661 /* Subroutine of do_line. Read next token from PFILE without adding it to
662 the output buffer. If it is a number between 1 and 4, store it in *NUM
663 and return 1; otherwise, return 0 and complain if we aren't at the end
667 read_line_number (pfile
, num
)
674 _cpp_lex_token (pfile
, &token
);
675 if (token
.type
== CPP_NUMBER
&& token
.val
.str
.len
== 1)
677 val
= token
.val
.str
.text
[0] - '1';
685 if (token
.type
!= CPP_EOF
)
686 cpp_error (pfile
, "invalid format #line");
690 /* Another subroutine of do_line. Convert a number in STR, of length
691 LEN, to binary; store it in NUMP, and return 0 if the number was
692 well-formed, 1 if not. Temporary, hopefully. */
694 strtoul_for_line (str
, len
, nump
)
699 unsigned long reg
= 0;
713 /* Interpret #line command.
714 Note that the filename string (if any) is treated as if it were an
715 include filename. That means no escape handling. */
721 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
722 unsigned long new_lineno
;
723 /* C99 raised the minimum limit on #line numbers. */
724 unsigned int cap
= CPP_OPTION (pfile
, c99
) ? 2147483647 : 32767;
725 int enter
= 0, leave
= 0, rename
= 0;
728 /* #line commands expand macros. */
729 cpp_get_token (pfile
, &token
);
730 if (token
.type
!= CPP_NUMBER
731 || strtoul_for_line (token
.val
.str
.text
, token
.val
.str
.len
, &new_lineno
))
733 cpp_error (pfile
, "\"%s\" after #line is not a positive integer",
734 cpp_token_as_text (pfile
, &token
));
738 if (CPP_PEDANTIC (pfile
) && (new_lineno
== 0 || new_lineno
> cap
))
739 cpp_pedwarn (pfile
, "line number out of range");
741 cpp_get_token (pfile
, &token
);
743 if (token
.type
!= CPP_EOF
)
747 int action_number
= 0;
749 if (token
.type
!= CPP_STRING
)
751 cpp_error (pfile
, "\"%s\" is not a valid filename",
752 cpp_token_as_text (pfile
, &token
));
756 len
= token
.val
.str
.len
;
757 fname
= alloca (len
+ 1);
758 memcpy (fname
, token
.val
.str
.text
, len
);
761 if (strcmp (fname
, ip
->nominal_fname
))
764 if (!strcmp (fname
, ip
->inc
->name
))
765 ip
->nominal_fname
= ip
->inc
->name
;
767 ip
->nominal_fname
= _cpp_fake_include (pfile
, fname
);
770 if (read_line_number (pfile
, &action_number
) != 0)
772 if (! CPP_OPTION (pfile
, preprocessed
) && CPP_PEDANTIC (pfile
))
773 cpp_pedwarn (pfile
, "extra tokens at end of #line directive");
775 if (action_number
== 1)
778 cpp_make_system_header (pfile
, ip
, 0);
779 read_line_number (pfile
, &action_number
);
781 else if (action_number
== 2)
784 cpp_make_system_header (pfile
, ip
, 0);
785 read_line_number (pfile
, &action_number
);
787 if (action_number
== 3)
789 cpp_make_system_header (pfile
, ip
, 1);
790 read_line_number (pfile
, &action_number
);
792 if (action_number
== 4)
794 cpp_make_system_header (pfile
, ip
, 2);
795 read_line_number (pfile
, &action_number
);
801 /* Our line number is incremented after the directive is processed. */
802 ip
->lineno
= new_lineno
- 1;
803 pfile
->lexer_pos
.output_line
= ip
->lineno
;
804 if (enter
&& pfile
->cb
.enter_file
)
805 (*pfile
->cb
.enter_file
) (pfile
);
806 if (leave
&& pfile
->cb
.leave_file
)
807 (*pfile
->cb
.leave_file
) (pfile
);
808 if (rename
&& pfile
->cb
.rename_file
)
809 (*pfile
->cb
.rename_file
) (pfile
);
813 * Report a warning or error detected by the program we are
814 * processing. Use the directive's tokens in the error message.
818 do_diagnostic (pfile
, code
, print_dir
)
820 enum error_type code
;
823 if (_cpp_begin_message (pfile
, code
, NULL
, 0))
826 fprintf (stderr
, "#%s ", pfile
->directive
->name
);
827 pfile
->state
.prevent_expansion
++;
828 cpp_output_line (pfile
, stderr
);
829 pfile
->state
.prevent_expansion
--;
837 do_diagnostic (pfile
, ERROR
, 1);
844 do_diagnostic (pfile
, WARNING
, 1);
847 /* Report program identification. */
855 cpp_get_token (pfile
, &str
);
856 if (str
.type
!= CPP_STRING
)
857 cpp_error (pfile
, "invalid #ident");
858 else if (pfile
->cb
.ident
)
859 (*pfile
->cb
.ident
) (pfile
, &str
.val
.str
);
864 /* Pragmata handling. We handle some of these, and pass the rest on
865 to the front end. C99 defines three pragmas and says that no macro
866 expansion is to be performed on them; whether or not macro
867 expansion happens for other pragmas is implementation defined.
868 This implementation never macro-expands the text after #pragma. */
870 /* Sub-handlers for the pragmas needing treatment here.
871 They return 1 if the token buffer is to be popped, 0 if not. */
874 struct pragma_entry
*next
;
879 void (*handler
) PARAMS ((cpp_reader
*));
880 struct pragma_entry
*space
;
885 cpp_register_pragma (pfile
, space
, name
, handler
)
889 void (*handler
) PARAMS ((cpp_reader
*));
891 struct pragma_entry
**x
, *new;
897 struct pragma_entry
*p
= pfile
->pragmas
;
898 len
= strlen (space
);
901 if (p
->isnspace
&& p
->len
== len
&& !memcmp (p
->name
, space
, len
))
908 cpp_ice (pfile
, "unknown #pragma namespace %s", space
);
913 new = xnew (struct pragma_entry
);
915 new->len
= strlen (name
);
917 new->u
.handler
= handler
;
924 cpp_register_pragma_space (pfile
, space
)
928 struct pragma_entry
*new;
929 const struct pragma_entry
*p
= pfile
->pragmas
;
930 size_t len
= strlen (space
);
934 if (p
->isnspace
&& p
->len
== len
&& !memcmp (p
->name
, space
, len
))
935 /* Multiple different callers are allowed to register the same
941 new = xnew (struct pragma_entry
);
947 new->next
= pfile
->pragmas
;
948 pfile
->pragmas
= new;
952 _cpp_init_internal_pragmas (pfile
)
956 cpp_register_pragma (pfile
, 0, "poison", do_pragma_poison
);
957 cpp_register_pragma (pfile
, 0, "once", do_pragma_once
);
960 cpp_register_pragma_space (pfile
, "GCC");
962 cpp_register_pragma (pfile
, "GCC", "poison", do_pragma_poison
);
963 cpp_register_pragma (pfile
, "GCC", "system_header", do_pragma_system_header
);
964 cpp_register_pragma (pfile
, "GCC", "dependency", do_pragma_dependency
);
971 const struct pragma_entry
*p
;
973 const cpp_hashnode
*node
;
979 pfile
->state
.prevent_expansion
++;
980 cpp_start_lookahead (pfile
);
983 cpp_get_token (pfile
, &tok
);
984 if (tok
.type
== CPP_NAME
)
991 if (strlen (p
->name
) == len
&& !memcmp (p
->name
, name
, len
))
1000 (*p
->u
.handler
) (pfile
);
1009 cpp_stop_lookahead (pfile
, drop
);
1010 pfile
->state
.prevent_expansion
--;
1012 if (!drop
&& pfile
->cb
.def_pragma
)
1013 (*pfile
->cb
.def_pragma
) (pfile
);
1017 do_pragma_once (pfile
)
1020 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
1022 cpp_warning (pfile
, "#pragma once is obsolete");
1024 if (CPP_PREV_BUFFER (ip
) == NULL
)
1025 cpp_warning (pfile
, "#pragma once in main file");
1027 ip
->inc
->cmacro
= NEVER_REREAD
;
1033 do_pragma_poison (pfile
)
1036 /* Poison these symbols so that all subsequent usage produces an
1041 pfile
->state
.poisoned_ok
= 1;
1044 _cpp_lex_token (pfile
, &tok
);
1045 if (tok
.type
== CPP_EOF
)
1047 if (tok
.type
!= CPP_NAME
)
1049 cpp_error (pfile
, "invalid #pragma GCC poison directive");
1054 if (hp
->flags
& NODE_POISONED
)
1057 if (hp
->type
== NT_MACRO
)
1058 cpp_warning (pfile
, "poisoning existing macro \"%s\"", hp
->name
);
1059 _cpp_free_definition (hp
);
1060 hp
->flags
|= NODE_POISONED
| NODE_DIAGNOSTIC
;
1062 pfile
->state
.poisoned_ok
= 0;
1064 #if 0 /* Doesn't quite work yet. */
1065 if (tok
.type
== CPP_EOF
&& pfile
->cb
.poison
)
1066 (*pfile
->cb
.poison
) (pfile
);
1070 /* Mark the current header as a system header. This will suppress
1071 some categories of warnings (notably those from -pedantic). It is
1072 intended for use in system libraries that cannot be implemented in
1073 conforming C, but cannot be certain that their headers appear in a
1074 system include directory. To prevent abuse, it is rejected in the
1075 primary source file. */
1077 do_pragma_system_header (pfile
)
1080 cpp_buffer
*ip
= CPP_BUFFER (pfile
);
1081 if (CPP_PREV_BUFFER (ip
) == NULL
)
1082 cpp_warning (pfile
, "#pragma system_header outside include file");
1084 cpp_make_system_header (pfile
, ip
, 1);
1089 /* Check the modified date of the current include file against a specified
1090 file. Issue a diagnostic, if the specified file is newer. We use this to
1091 determine if a fixed header should be refixed. */
1093 do_pragma_dependency (pfile
)
1096 cpp_token header
, msg
;
1099 if (parse_include (pfile
, &header
))
1102 ordering
= _cpp_compare_file_date (pfile
, &header
);
1104 cpp_warning (pfile
, "cannot find source %s",
1105 cpp_token_as_text (pfile
, &header
));
1106 else if (ordering
> 0)
1108 cpp_warning (pfile
, "current file is older than %s",
1109 cpp_token_as_text (pfile
, &header
));
1110 cpp_start_lookahead (pfile
);
1111 cpp_get_token (pfile
, &msg
);
1112 cpp_stop_lookahead (pfile
, msg
.type
== CPP_EOF
);
1113 if (msg
.type
!= CPP_EOF
)
1114 do_diagnostic (pfile
, WARNING
, 0);
1118 /* Check syntax is "(string-literal)". Returns 0 on success. */
1120 get__Pragma_string (pfile
, string
)
1126 cpp_get_token (pfile
, &paren
);
1127 if (paren
.type
!= CPP_OPEN_PAREN
)
1130 cpp_get_token (pfile
, string
);
1131 if (string
->type
!= CPP_STRING
&& string
->type
!= CPP_WSTRING
)
1134 cpp_get_token (pfile
, &paren
);
1135 return paren
.type
!= CPP_CLOSE_PAREN
;
1138 /* Returns a malloced buffer containing a destringized cpp_string by
1139 removing the first \ of \" and \\ sequences. */
1140 static unsigned char *
1141 destringize (in
, len
)
1142 const cpp_string
*in
;
1145 const unsigned char *src
, *limit
;
1146 unsigned char *dest
, *result
;
1148 dest
= result
= (unsigned char *) xmalloc (in
->len
);
1149 for (src
= in
->text
, limit
= src
+ in
->len
; src
< limit
;)
1151 /* We know there is a character following the backslash. */
1152 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1157 *len
= dest
- result
;
1162 _cpp_do__Pragma (pfile
)
1166 unsigned char *buffer
;
1169 if (get__Pragma_string (pfile
, &string
))
1171 cpp_error (pfile
, "_Pragma takes a parenthesized string literal");
1175 buffer
= destringize (&string
.val
.str
, &len
);
1176 run_directive (pfile
, T_PRAGMA
, (char *) buffer
, len
, _("<_Pragma>"));
1177 free ((PTR
) buffer
);
1180 /* Just ignore #sccs, on systems where we define it at all. */
1181 #ifdef SCCS_DIRECTIVE
1184 cpp_reader
*pfile ATTRIBUTE_UNUSED
;
1195 if (! pfile
->buffer
->was_skipping
)
1197 const cpp_hashnode
*node
= lex_macro_node (pfile
);
1200 skip
= node
->type
!= NT_MACRO
;
1203 push_conditional (pfile
, skip
, T_IFDEF
, 0);
1211 const cpp_hashnode
*node
= 0;
1213 if (! pfile
->buffer
->was_skipping
)
1215 node
= lex_macro_node (pfile
);
1217 skip
= node
->type
== NT_MACRO
;
1220 push_conditional (pfile
, skip
, T_IFNDEF
, node
);
1223 /* #if cooperates with parse_defined to handle multiple-include
1224 optimisations. If macro expansions or identifiers appear in the
1225 expression, we cannot treat it as a controlling conditional, since
1226 their values could change in the future. */
1233 const cpp_hashnode
*cmacro
= 0;
1235 if (! pfile
->buffer
->was_skipping
)
1237 /* Controlling macro of #if ! defined () */
1238 pfile
->mi_ind_cmacro
= 0;
1239 skip
= _cpp_parse_expr (pfile
) == 0;
1240 cmacro
= pfile
->mi_ind_cmacro
;
1243 push_conditional (pfile
, skip
, T_IF
, cmacro
);
1246 /* Flip skipping state if appropriate and continue without changing
1247 if_stack; this is so that the error message for missing #endif's
1248 etc. will point to the original #if. */
1254 cpp_buffer
*buffer
= pfile
->buffer
;
1255 struct if_stack
*ifs
= buffer
->if_stack
;
1258 cpp_error (pfile
, "#else without #if");
1261 if (ifs
->type
== T_ELSE
)
1263 cpp_error (pfile
, "#else after #else");
1264 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1265 "the conditional began here");
1269 /* Buffer->was_skipping is 1 if all conditionals in this chain
1270 have been false, 2 if a conditional has been true. */
1271 if (! ifs
->was_skipping
&& buffer
->was_skipping
!= 2)
1272 buffer
->was_skipping
= ! buffer
->was_skipping
;
1274 /* Invalidate any controlling macro. */
1281 /* handle a #elif directive by not changing if_stack either. see the
1282 comment above do_else. */
1288 cpp_buffer
*buffer
= pfile
->buffer
;
1289 struct if_stack
*ifs
= buffer
->if_stack
;
1292 cpp_error (pfile
, "#elif without #if");
1295 if (ifs
->type
== T_ELSE
)
1297 cpp_error (pfile
, "#elif after #else");
1298 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1299 "the conditional began here");
1303 /* Don't evaluate #elif if our higher level is skipping. */
1304 if (! ifs
->was_skipping
)
1306 /* Buffer->was_skipping is 1 if all conditionals in this
1307 chain have been false, 2 if a conditional has been true. */
1308 if (buffer
->was_skipping
== 1)
1309 buffer
->was_skipping
= ! _cpp_parse_expr (pfile
);
1311 buffer
->was_skipping
= 2;
1313 /* Invalidate any controlling macro. */
1319 /* #endif pops the if stack and resets pfile->skipping. */
1325 cpp_buffer
*buffer
= pfile
->buffer
;
1326 struct if_stack
*ifs
= buffer
->if_stack
;
1329 cpp_error (pfile
, "#endif without #if");
1332 /* If potential control macro, we go back outside again. */
1333 if (ifs
->next
== 0 && ifs
->mi_cmacro
)
1335 pfile
->mi_state
= MI_OUTSIDE
;
1336 pfile
->mi_cmacro
= ifs
->mi_cmacro
;
1339 buffer
->if_stack
= ifs
->next
;
1340 buffer
->was_skipping
= ifs
->was_skipping
;
1341 obstack_free (pfile
->buffer_ob
, ifs
);
1347 /* Push an if_stack entry and set pfile->skipping accordingly.
1348 If this is a #ifndef starting at the beginning of a file,
1349 CMACRO is the macro name tested by the #ifndef. */
1352 push_conditional (pfile
, skip
, type
, cmacro
)
1356 const cpp_hashnode
*cmacro
;
1358 struct if_stack
*ifs
;
1359 cpp_buffer
*buffer
= pfile
->buffer
;
1361 ifs
= xobnew (pfile
->buffer_ob
, struct if_stack
);
1362 ifs
->pos
= pfile
->directive_pos
;
1363 ifs
->next
= buffer
->if_stack
;
1364 ifs
->was_skipping
= buffer
->was_skipping
;
1366 if (pfile
->mi_state
== MI_OUTSIDE
&& pfile
->mi_cmacro
== 0)
1367 ifs
->mi_cmacro
= cmacro
;
1371 buffer
->was_skipping
= skip
;
1372 buffer
->if_stack
= ifs
;
1375 /* Read the tokens of the answer into the macro pool. Only commit the
1376 memory if we intend it as permanent storage, i.e. the #assert case.
1377 Returns 0 on success. */
1380 parse_answer (pfile
, answerp
, type
)
1382 struct answer
**answerp
;
1385 cpp_token paren
, *token
;
1386 struct answer
*answer
;
1388 if (POOL_FRONT (&pfile
->macro_pool
) + sizeof (struct answer
) >
1389 POOL_LIMIT (&pfile
->macro_pool
))
1390 _cpp_next_chunk (&pfile
->macro_pool
, sizeof (struct answer
), 0);
1391 answer
= (struct answer
*) POOL_FRONT (&pfile
->macro_pool
);
1394 /* In a conditional, it is legal to not have an open paren. We
1395 should save the following token in this case. */
1397 cpp_start_lookahead (pfile
);
1398 cpp_get_token (pfile
, &paren
);
1400 cpp_stop_lookahead (pfile
, paren
.type
== CPP_OPEN_PAREN
);
1402 /* If not a paren, see if we're OK. */
1403 if (paren
.type
!= CPP_OPEN_PAREN
)
1405 /* In a conditional no answer is a test for any answer. It
1406 could be followed by any token. */
1410 /* #unassert with no answer is valid - it removes all answers. */
1411 if (type
== T_UNASSERT
&& paren
.type
== CPP_EOF
)
1414 cpp_error (pfile
, "missing '(' after predicate");
1420 token
= &answer
->first
[answer
->count
];
1421 /* Check we have room for the token. */
1422 if ((unsigned char *) (token
+ 1) >= POOL_LIMIT (&pfile
->macro_pool
))
1424 _cpp_next_chunk (&pfile
->macro_pool
, sizeof (cpp_token
),
1425 (unsigned char **) &answer
);
1426 token
= &answer
->first
[answer
->count
];
1429 cpp_get_token (pfile
, token
);
1430 if (token
->type
== CPP_CLOSE_PAREN
)
1433 if (token
->type
== CPP_EOF
)
1435 cpp_error (pfile
, "missing ')' to complete answer");
1441 if (answer
->count
== 0)
1443 cpp_error (pfile
, "predicate's answer is empty");
1447 /* Drop whitespace at start. */
1448 answer
->first
->flags
&= ~PREV_WHITE
;
1451 if (type
== T_ASSERT
|| type
== T_UNASSERT
)
1456 /* Parses an assertion, returning a pointer to the hash node of the
1457 predicate, or 0 on error. If an answer was supplied, it is placed
1458 in ANSWERP, otherwise it is set to 0. */
1459 static cpp_hashnode
*
1460 parse_assertion (pfile
, answerp
, type
)
1462 struct answer
**answerp
;
1465 cpp_hashnode
*result
= 0;
1466 cpp_token predicate
;
1468 /* We don't expand predicates or answers. */
1469 pfile
->state
.prevent_expansion
++;
1471 /* Use the permanent pool for storage (for the answers). */
1472 pfile
->string_pool
= &pfile
->ident_pool
;
1475 cpp_get_token (pfile
, &predicate
);
1476 if (predicate
.type
== CPP_EOF
)
1477 cpp_error (pfile
, "assertion without predicate");
1478 else if (predicate
.type
!= CPP_NAME
)
1479 cpp_error (pfile
, "predicate must be an identifier");
1480 else if (parse_answer (pfile
, answerp
, type
) == 0)
1482 unsigned int len
= predicate
.val
.node
->length
;
1483 unsigned char *sym
= alloca (len
+ 1);
1485 /* Prefix '#' to get it out of macro namespace. */
1487 memcpy (sym
+ 1, predicate
.val
.node
->name
, len
);
1488 result
= cpp_lookup (pfile
, sym
, len
+ 1);
1491 pfile
->string_pool
= &pfile
->temp_string_pool
;
1492 pfile
->state
.prevent_expansion
--;
1496 /* Returns a pointer to the pointer to the answer in the answer chain,
1497 or a pointer to NULL if the answer is not in the chain. */
1498 static struct answer
**
1499 find_answer (node
, candidate
)
1501 const struct answer
*candidate
;
1504 struct answer
**result
;
1506 for (result
= &node
->value
.answers
; *result
; result
= &(*result
)->next
)
1508 struct answer
*answer
= *result
;
1510 if (answer
->count
== candidate
->count
)
1512 for (i
= 0; i
< answer
->count
; i
++)
1513 if (! _cpp_equiv_tokens (&answer
->first
[i
], &candidate
->first
[i
]))
1516 if (i
== answer
->count
)
1524 /* Test an assertion within a preprocessor conditional. Returns
1525 non-zero on failure, zero on success. On success, the result of
1526 the test is written into VALUE. */
1528 _cpp_test_assertion (pfile
, value
)
1532 struct answer
*answer
;
1535 node
= parse_assertion (pfile
, &answer
, T_IF
);
1537 *value
= (node
->type
== NT_ASSERTION
&&
1538 (answer
== 0 || *find_answer (node
, answer
) != 0));
1540 /* We don't commit the memory for the answer - it's temporary only. */
1548 struct answer
*new_answer
;
1551 node
= parse_assertion (pfile
, &new_answer
, T_ASSERT
);
1554 /* Place the new answer in the answer list. First check there
1555 is not a duplicate. */
1556 new_answer
->next
= 0;
1557 if (node
->type
== NT_ASSERTION
)
1559 if (*find_answer (node
, new_answer
))
1561 cpp_warning (pfile
, "\"%s\" re-asserted", node
->name
+ 1);
1564 new_answer
->next
= node
->value
.answers
;
1566 node
->type
= NT_ASSERTION
;
1567 node
->value
.answers
= new_answer
;
1568 POOL_COMMIT (&pfile
->macro_pool
, (sizeof (struct answer
)
1569 + (new_answer
->count
- 1)
1570 * sizeof (cpp_token
)));
1579 struct answer
*answer
;
1581 node
= parse_assertion (pfile
, &answer
, T_UNASSERT
);
1582 /* It isn't an error to #unassert something that isn't asserted. */
1583 if (node
&& node
->type
== NT_ASSERTION
)
1587 struct answer
**p
= find_answer (node
, answer
), *temp
;
1589 /* Remove the answer from the list. */
1594 /* Did we free the last answer? */
1595 if (node
->value
.answers
== 0)
1596 node
->type
= NT_VOID
;
1599 _cpp_free_definition (node
);
1602 /* We don't commit the memory for the answer - it's temporary only. */
1605 /* These are for -D, -U, -A. */
1607 /* Process the string STR as if it appeared as the body of a #define.
1608 If STR is just an identifier, define it with value 1.
1609 If STR has anything after the identifier, then it should
1610 be identifier=definition. */
1613 cpp_define (pfile
, str
)
1620 /* Copy the entire option so we can modify it.
1621 Change the first "=" in the string to a space. If there is none,
1622 tack " 1" on the end. */
1624 /* Length including the null. */
1625 count
= strlen (str
);
1626 buf
= (char *) alloca (count
+ 2);
1627 memcpy (buf
, str
, count
);
1629 p
= strchr (str
, '=');
1638 run_directive (pfile
, T_DEFINE
, buf
, count
, 0);
1641 /* Slight variant of the above for use by initialize_builtins, which (a)
1642 knows how to set up the buffer itself, (b) needs a different "filename"
1645 _cpp_define_builtin (pfile
, str
)
1649 run_directive (pfile
, T_DEFINE
, str
, strlen (str
), _("<builtin>"));
1652 /* Process MACRO as if it appeared as the body of an #undef. */
1654 cpp_undef (pfile
, macro
)
1658 run_directive (pfile
, T_UNDEF
, macro
, strlen (macro
), 0);
1661 /* Process the string STR as if it appeared as the body of a #assert. */
1663 cpp_assert (pfile
, str
)
1667 handle_assertion (pfile
, str
, T_ASSERT
);
1670 /* Process STR as if it appeared as the body of an #unassert. */
1672 cpp_unassert (pfile
, str
)
1676 handle_assertion (pfile
, str
, T_UNASSERT
);
1679 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1681 handle_assertion (pfile
, str
, type
)
1686 size_t count
= strlen (str
);
1687 const char *p
= strchr (str
, '=');
1691 /* Copy the entire option so we can modify it. Change the first
1692 "=" in the string to a '(', and tack a ')' on the end. */
1693 char *buf
= (char *) alloca (count
+ 1);
1695 memcpy (buf
, str
, count
);
1701 run_directive (pfile
, type
, str
, count
, 0);
1704 /* Allocate a new cpp_buffer for PFILE, and push it on the input
1705 buffer stack. If BUFFER != NULL, then use the LENGTH characters in
1706 BUFFER as the new input buffer. Return the new buffer, or NULL on
1710 cpp_push_buffer (pfile
, buffer
, length
)
1712 const U_CHAR
*buffer
;
1715 cpp_buffer
*buf
= CPP_BUFFER (pfile
);
1717 if (++pfile
->buffer_stack_depth
== CPP_STACK_MAX
)
1719 cpp_fatal (pfile
, "#include nested too deeply");
1723 new = xobnew (pfile
->buffer_ob
, cpp_buffer
);
1724 /* Clears, amongst other things, if_stack and mi_cmacro. */
1725 memset (new, 0, sizeof (cpp_buffer
));
1727 pfile
->lexer_pos
.output_line
= 1;
1728 new->line_base
= new->buf
= new->cur
= buffer
;
1729 new->rlimit
= buffer
+ length
;
1732 /* Preprocessed files don't do trigraph and escaped newline processing. */
1733 new->from_stage3
= CPP_OPTION (pfile
, preprocessed
);
1734 /* No read ahead or extra char initially. */
1735 new->read_ahead
= EOF
;
1736 new->extra_char
= EOF
;
1737 pfile
->state
.next_bol
= 1;
1739 CPP_BUFFER (pfile
) = new;
1744 cpp_pop_buffer (pfile
)
1747 cpp_buffer
*buffer
= pfile
->buffer
;
1748 struct if_stack
*ifs
= buffer
->if_stack
;
1751 /* Walk back up the conditional stack till we reach its level at
1752 entry to this file, issuing error messages. */
1753 for (ifs
= buffer
->if_stack
; ifs
; ifs
= ifs
->next
)
1754 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1755 "unterminated #%s", dtable
[ifs
->type
].name
);
1757 wfb
= (buffer
->inc
!= 0);
1759 _cpp_pop_file_buffer (pfile
, buffer
);
1761 pfile
->buffer
= buffer
->prev
;
1762 obstack_free (pfile
->buffer_ob
, buffer
);
1763 pfile
->buffer_stack_depth
--;
1765 if (pfile
->buffer
&& wfb
&& pfile
->cb
.leave_file
)
1766 (*pfile
->cb
.leave_file
) (pfile
);
1768 return pfile
->buffer
;
1771 #define obstack_chunk_alloc xmalloc
1772 #define obstack_chunk_free free
1774 _cpp_init_stacks (pfile
)
1780 pfile
->buffer_ob
= xnew (struct obstack
);
1781 obstack_init (pfile
->buffer_ob
);
1783 /* Register the directives. */
1784 for (i
= 1; i
< N_DIRECTIVES
; i
++)
1786 node
= cpp_lookup (pfile
, dtable
[i
- 1].name
, dtable
[i
- 1].length
);
1787 node
->directive_index
= i
;
1792 _cpp_cleanup_stacks (pfile
)
1795 obstack_free (pfile
->buffer_ob
, 0);
1796 free (pfile
->buffer_ob
);