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,
87 const char *, size_t));
88 static int glue_header_name PARAMS ((cpp_reader *, cpp_token *));
89 static int parse_include PARAMS ((cpp_reader *, cpp_token *));
90 static void push_conditional PARAMS ((cpp_reader *, int, int,
91 const cpp_hashnode *));
92 static unsigned int read_flag PARAMS ((cpp_reader *, unsigned int));
93 static int strtoul_for_line PARAMS ((const U_CHAR *, unsigned int,
95 static void do_diagnostic PARAMS ((cpp_reader *, enum error_type, int));
96 static cpp_hashnode *lex_macro_node PARAMS ((cpp_reader *));
97 static void do_include_common PARAMS ((cpp_reader *, enum include_type));
98 static void do_pragma_once PARAMS ((cpp_reader *));
99 static void do_pragma_poison PARAMS ((cpp_reader *));
100 static void do_pragma_system_header PARAMS ((cpp_reader *));
101 static void do_pragma_dependency PARAMS ((cpp_reader *));
102 static int get__Pragma_string PARAMS ((cpp_reader *, cpp_token *));
103 static unsigned char *destringize PARAMS ((const cpp_string *,
105 static int parse_answer PARAMS ((cpp_reader *, struct answer **, int));
106 static cpp_hashnode *parse_assertion PARAMS ((cpp_reader *, struct answer **,
108 static struct answer ** find_answer PARAMS ((cpp_hashnode *,
109 const struct answer *));
110 static void handle_assertion PARAMS ((cpp_reader *, const char *, int));
112 /* This is the table of directive handlers. It is ordered by
113 frequency of occurrence; the numbers at the end are directive
114 counts from all the source code I have lying around (egcs and libc
115 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
116 pcmcia-cs-3.0.9). This is no longer important as directive lookup
117 is now O(1). All extensions other than #warning and #include_next
118 are deprecated. The name is where the extension appears to have
121 #define DIRECTIVE_TABLE \
122 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
123 D(include, T_INCLUDE, KANDR, INCL) /* 52262 */ \
124 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
125 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
126 D(if, T_IF, KANDR, COND | IF_COND) /* 18162 */ \
127 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
128 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
129 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
130 D(line, T_LINE, KANDR, IN_I) /* 2465 */ \
131 D(elif, T_ELIF, STDC89, COND) /* 610 */ \
132 D(error, T_ERROR, STDC89, 0) /* 475 */ \
133 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
134 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
135 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL) /* 19 */ \
136 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
137 D(import, T_IMPORT, EXTENSION, INCL) /* 0 ObjC */ \
138 D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
139 D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
140 SCCS_ENTRY /* 0 SVR4? */
142 /* #sccs is not always recognized. */
143 #ifdef SCCS_DIRECTIVE
144 # define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION, 0)
146 # define SCCS_ENTRY /* nothing */
149 /* Use the table to generate a series of prototypes, an enum for the
150 directive names, and an array of directive handlers. */
152 /* The directive-processing functions are declared to return int
153 instead of void, because some old compilers have trouble with
154 pointers to functions returning void. */
156 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
157 #define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
161 #define D(n, tag, o, f) tag,
169 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
170 #define D(name, t, origin, flags) \
171 { CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
172 sizeof STRINGX(name) - 1, origin, flags },
173 static const directive dtable[] =
178 #undef DIRECTIVE_TABLE
180 #define SEEN_EOL() (pfile->lexer_pos.output_line > pfile->line)
182 /* Skip any remaining tokens in a directive. */
184 skip_rest_of_line (pfile)
189 /* Discard all input lookaheads. */
190 while (pfile->la_read)
191 _cpp_release_lookahead (pfile);
193 /* Discard all stacked contexts. */
194 while (pfile->context != &pfile->base_context)
195 _cpp_pop_context (pfile);
197 /* Sweep up all tokens remaining on the line. */
198 while (! SEEN_EOL ())
199 _cpp_lex_token (pfile, &token);
202 /* Ensure there are no stray tokens at the end of a directive. */
211 _cpp_lex_token (pfile, &token);
212 if (token.type != CPP_EOF)
213 cpp_pedwarn (pfile, "extra tokens at end of #%s directive",
214 pfile->directive->name);
218 /* Called when entering a directive, _Pragma or command-line directive. */
220 start_directive (pfile)
223 /* Setup in-directive state. */
224 pfile->state.in_directive = 1;
225 pfile->state.save_comments = 0;
227 /* Some handlers need the position of the # for diagnostics. */
228 pfile->directive_pos = pfile->lexer_pos;
229 pfile->directive_line = pfile->line;
231 /* Don't save directive tokens for external clients. */
232 pfile->la_saved = pfile->la_write;
236 /* Called when leaving a directive, _Pragma or command-line directive. */
238 end_directive (pfile, skip_line)
242 /* We don't skip for an assembler #. */
245 skip_rest_of_line (pfile);
246 /* "Accept" the newline now. */
251 pfile->la_write = pfile->la_saved;
252 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
253 pfile->state.in_directive = 0;
254 pfile->state.angled_headers = 0;
255 pfile->state.line_extension = 0;
256 pfile->directive = 0;
259 /* Check if a token's name matches that of a known directive. Put in
260 this file to save exporting dtable and other unneeded information. */
262 _cpp_handle_directive (pfile, indented)
266 const directive *dir = 0;
270 start_directive (pfile);
272 /* Lex the directive name directly. */
273 _cpp_lex_token (pfile, &dname);
275 if (dname.type == CPP_NAME)
277 unsigned int index = dname.val.node->directive_index;
279 dir = &dtable[index - 1];
281 else if (dname.type == CPP_NUMBER)
283 /* # followed by a number is equivalent to #line. Do not
284 recognize this form in assembly language source files or
285 skipped conditional groups. Complain about this form if
286 we're being pedantic, but not if this is regurgitated input
287 (preprocessed or fed back in by the C++ frontend). */
288 if (! pfile->state.skipping && CPP_OPTION (pfile, lang) != CLK_ASM)
290 dir = &dtable[T_LINE];
291 pfile->state.line_extension = 1;
292 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
293 if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed))
294 cpp_pedwarn (pfile, "# followed by integer");
298 pfile->directive = dir;
301 /* Make sure we lex headers correctly, whether skipping or not. */
302 pfile->state.angled_headers = dir->flags & INCL;
304 /* If we are rescanning preprocessed input, only directives tagged
305 with IN_I are honored, and the warnings below are suppressed. */
306 if (CPP_OPTION (pfile, preprocessed))
308 /* Kluge alert. In order to be sure that code like this
311 does not cause '#define foo bar' to get executed when
312 compiled with -save-temps, we recognize directives in
313 -fpreprocessed mode only if the # is in column 1 and the
314 directive name starts in column 2. This output can only
315 be generated by the directive callbacks in cppmain.c (see
316 also the special case in scan_buffer). */
317 if (dir->flags & IN_I && !indented && !(dname.flags & PREV_WHITE))
318 (*dir->handler) (pfile);
319 /* That check misses '# 123' linemarkers. Let them through too. */
320 else if (dname.type == CPP_NUMBER)
321 (*dir->handler) (pfile);
324 /* We don't want to process this directive. Put back the
325 tokens so caller will see them (and issue an error,
327 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
333 /* Traditionally, a directive is ignored unless its # is in
334 column 1. Therefore in code intended to work with K+R
335 compilers, directives added by C89 must have their #
336 indented, and directives present in traditional C must
337 not. This is true even of directives in skipped
338 conditional blocks. */
339 if (CPP_WTRADITIONAL (pfile))
341 if (dir == &dtable[T_ELIF])
343 "suggest not using #elif in traditional C");
344 else if (indented && dir->origin == KANDR)
346 "traditional C ignores #%s with the # indented",
348 else if (!indented && dir->origin != KANDR)
350 "suggest hiding #%s from traditional C with an indented #",
354 /* If we are skipping a failed conditional group, all
355 non-conditional directives are ignored. */
356 if (! pfile->state.skipping || (dir->flags & COND))
358 /* Issue -pedantic warnings for extensions. */
359 if (CPP_PEDANTIC (pfile) && dir->origin == EXTENSION)
360 cpp_pedwarn (pfile, "#%s is a GCC extension", dir->name);
362 /* If we have a directive that is not an opening
363 conditional, invalidate any control macro. */
364 if (! (dir->flags & IF_COND))
365 pfile->mi_valid = false;
367 (*dir->handler) (pfile);
371 else if (dname.type != CPP_EOF && ! pfile->state.skipping)
373 /* An unknown directive. Don't complain about it in assembly
374 source: we don't know where the comments are, and # may
375 introduce assembler pseudo-ops. Don't complain about invalid
376 directives in skipped conditional groups (6.10 p4). */
377 if (CPP_OPTION (pfile, lang) == CLK_ASM)
379 /* Output the # and lookahead token for the assembler. */
380 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
384 cpp_error (pfile, "invalid preprocessing directive #%s",
385 cpp_token_as_text (pfile, &dname));
388 if (pfile->state.in_directive)
389 end_directive (pfile, skip);
393 /* Directive handler wrapper used by the command line option
396 run_directive (pfile, dir_no, type, buf, count)
399 enum cpp_buffer_type type;
405 buffer = cpp_push_buffer (pfile, (const U_CHAR *) buf, count, type, 1);
406 start_directive (pfile);
407 pfile->state.prevent_expansion++;
408 pfile->directive = &dtable[dir_no];
409 (void) (*pfile->directive->handler) (pfile);
410 pfile->state.prevent_expansion--;
412 end_directive (pfile, 1);
413 _cpp_pop_buffer (pfile);
416 /* Checks for validity the macro name in #define, #undef, #ifdef and
417 #ifndef directives. */
418 static cpp_hashnode *
419 lex_macro_node (pfile)
425 /* Lex the macro name directly. */
426 _cpp_lex_token (pfile, &token);
428 /* The token immediately after #define must be an identifier. That
429 identifier may not be "defined", per C99 6.10.8p4.
430 In C++, it may not be any of the "named operators" either,
431 per C++98 [lex.digraph], [lex.key].
432 Finally, the identifier may not have been poisoned. (In that case
433 the lexer has issued the error message for us.) */
435 if (token.type != CPP_NAME)
437 if (token.type == CPP_EOF)
438 cpp_error (pfile, "no macro name given in #%s directive",
439 pfile->directive->name);
440 else if (token.flags & NAMED_OP)
442 "\"%s\" cannot be used as a macro name as it is an operator in C++",
443 NODE_NAME (token.val.node));
445 cpp_error (pfile, "macro names must be identifiers");
450 node = token.val.node;
451 if (node->flags & NODE_POISONED)
454 if (node == pfile->spec_nodes.n_defined)
456 cpp_error (pfile, "\"%s\" cannot be used as a macro name",
464 /* Process a #define directive. Most work is done in cppmacro.c. */
469 cpp_hashnode *node = lex_macro_node (pfile);
473 if (_cpp_create_definition (pfile, node))
474 if (pfile->cb.define)
475 (*pfile->cb.define) (pfile, pfile->directive_line, node);
479 /* Handle #undef. Marks the identifier NT_VOID in the hash table. */
484 cpp_hashnode *node = lex_macro_node (pfile);
486 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
487 is not currently defined as a macro name. */
488 if (node && node->type == NT_MACRO)
491 (*pfile->cb.undef) (pfile, pfile->directive_line, node);
493 if (node->flags & NODE_WARN)
494 cpp_warning (pfile, "undefining \"%s\"", NODE_NAME (node));
496 _cpp_free_definition (node);
501 /* Helper routine used by parse_include. Reinterpret the current line
502 as an h-char-sequence (< ... >); we are looking at the first token
503 after the <. Returns zero on success. */
505 glue_header_name (pfile, header)
510 unsigned char *buffer, *token_mem;
511 size_t len, total_len = 0, capacity = 1024;
513 /* To avoid lexed tokens overwriting our glued name, we can only
514 allocate from the string pool once we've lexed everything. */
516 buffer = (unsigned char *) xmalloc (capacity);
519 cpp_get_token (pfile, &token);
521 if (token.type == CPP_GREATER || token.type == CPP_EOF)
524 len = cpp_token_len (&token);
525 if (total_len + len > capacity)
527 capacity = (capacity + len) * 2;
528 buffer = (unsigned char *) xrealloc (buffer, capacity);
531 if (token.flags & PREV_WHITE)
532 buffer[total_len++] = ' ';
534 total_len = cpp_spell_token (pfile, &token, &buffer[total_len]) - buffer;
537 if (token.type == CPP_EOF)
538 cpp_error (pfile, "missing terminating > character");
541 token_mem = _cpp_pool_alloc (&pfile->ident_pool, total_len + 1);
542 memcpy (token_mem, buffer, total_len);
543 token_mem[total_len] = '\0';
545 header->type = CPP_HEADER_NAME;
546 header->flags &= ~PREV_WHITE;
547 header->val.str.len = total_len;
548 header->val.str.text = token_mem;
552 return token.type == CPP_EOF;
555 /* Parse the header name of #include, #include_next, #import and
556 #pragma dependency. Returns zero on success. */
558 parse_include (pfile, header)
562 const unsigned char *dir;
564 if (pfile->directive == &dtable[T_PRAGMA])
565 dir = U"pragma dependency";
567 dir = pfile->directive->name;
569 /* Allow macro expansion. */
570 cpp_get_token (pfile, header);
571 if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
573 if (header->type != CPP_LESS)
575 cpp_error (pfile, "#%s expects \"FILENAME\" or <FILENAME>", dir);
578 if (glue_header_name (pfile, header))
582 if (header->val.str.len == 0)
584 cpp_error (pfile, "empty file name in #%s", dir);
591 /* Handle #include, #include_next and #import. */
593 do_include_common (pfile, type)
595 enum include_type type;
599 /* For #include_next, if this is the primary source file, warn and
600 use the normal search logic. */
601 if (type == IT_INCLUDE_NEXT && ! pfile->buffer->prev)
603 cpp_warning (pfile, "#include_next in primary source file");
606 else if (type == IT_IMPORT && CPP_OPTION (pfile, warn_import))
608 CPP_OPTION (pfile, warn_import) = 0;
610 "#import is obsolete, use an #ifndef wrapper in the header file");
613 if (!parse_include (pfile, &header))
615 /* Prevent #include recursion. */
616 if (pfile->buffer_stack_depth >= CPP_STACK_MAX)
617 cpp_fatal (pfile, "#include nested too deeply");
621 /* Get out of macro context, if we are. */
622 end_directive (pfile, 1);
623 if (pfile->cb.include)
624 (*pfile->cb.include) (pfile, pfile->directive_line,
625 pfile->directive->name, &header);
627 _cpp_execute_include (pfile, &header, type);
636 do_include_common (pfile, IT_INCLUDE);
643 do_include_common (pfile, IT_IMPORT);
647 do_include_next (pfile)
650 do_include_common (pfile, IT_INCLUDE_NEXT);
653 /* Subroutine of do_line. Read possible flags after file name. LAST
654 is the last flag seen; 0 if this is the first flag. Return the flag
655 if it is valid, 0 at the end of the directive. Otherwise complain. */
658 read_flag (pfile, last)
664 _cpp_lex_token (pfile, &token);
665 if (token.type == CPP_NUMBER && token.val.str.len == 1)
667 unsigned int flag = token.val.str.text[0] - '0';
669 if (flag > last && flag <= 4
670 && (flag != 4 || last == 3)
671 && (flag != 2 || last == 0))
675 if (token.type != CPP_EOF)
676 cpp_error (pfile, "invalid flag \"%s\" in line directive",
677 cpp_token_as_text (pfile, &token));
681 /* Another subroutine of do_line. Convert a number in STR, of length
682 LEN, to binary; store it in NUMP, and return 0 if the number was
683 well-formed, 1 if not. Temporary, hopefully. */
685 strtoul_for_line (str, len, nump)
690 unsigned long reg = 0;
704 /* Interpret #line command.
705 Note that the filename string (if any) is treated as if it were an
706 include filename. That means no escape handling. */
713 const char *new_file = pfile->map->to_file;
714 unsigned long new_lineno;
715 unsigned int cap, new_sysp = pfile->map->sysp;
716 enum lc_reason reason = LC_RENAME;
718 /* C99 raised the minimum limit on #line numbers. */
719 cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
721 /* #line commands expand macros. */
722 cpp_get_token (pfile, &token);
723 if (token.type != CPP_NUMBER
724 || strtoul_for_line (token.val.str.text, token.val.str.len, &new_lineno))
726 cpp_error (pfile, "\"%s\" after #line is not a positive integer",
727 cpp_token_as_text (pfile, &token));
731 if (CPP_PEDANTIC (pfile) && ! pfile->state.line_extension
732 && (new_lineno == 0 || new_lineno > cap))
733 cpp_pedwarn (pfile, "line number out of range");
735 cpp_get_token (pfile, &token);
736 if (token.type == CPP_STRING)
738 new_file = (const char *) token.val.str.text;
740 /* Only accept flags for the # 55 form. */
741 if (pfile->state.line_extension)
746 flag = read_flag (pfile, 0);
750 /* Fake an include for cpp_included (). */
751 _cpp_fake_include (pfile, new_file);
752 flag = read_flag (pfile, flag);
757 flag = read_flag (pfile, flag);
762 flag = read_flag (pfile, flag);
769 else if (token.type != CPP_EOF)
771 cpp_error (pfile, "\"%s\" is not a valid filename",
772 cpp_token_as_text (pfile, &token));
776 end_directive (pfile, 1);
777 _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp);
780 /* Arrange the file_change callback. pfile->line has changed to
781 FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system
782 header, 2 for a sytem header that needs to be extern "C" protected,
783 and zero otherwise. */
785 _cpp_do_file_change (pfile, reason, to_file, file_line, sysp)
787 enum lc_reason reason;
789 unsigned int file_line;
792 pfile->map = add_line_map (&pfile->line_maps, reason, sysp,
793 pfile->line, to_file, file_line);
795 if (pfile->cb.file_change)
796 (*pfile->cb.file_change) (pfile, pfile->map);
800 * Report a warning or error detected by the program we are
801 * processing. Use the directive's tokens in the error message.
805 do_diagnostic (pfile, code, print_dir)
807 enum error_type code;
810 if (_cpp_begin_message (pfile, code, 0))
813 fprintf (stderr, "#%s ", pfile->directive->name);
814 pfile->state.prevent_expansion++;
815 cpp_output_line (pfile, stderr);
816 pfile->state.prevent_expansion--;
824 do_diagnostic (pfile, ERROR, 1);
831 /* We want #warning diagnostics to be emitted in system headers too. */
832 do_diagnostic (pfile, WARNING_SYSHDR, 1);
835 /* Report program identification. */
843 cpp_get_token (pfile, &str);
844 if (str.type != CPP_STRING)
845 cpp_error (pfile, "invalid #ident");
846 else if (pfile->cb.ident)
847 (*pfile->cb.ident) (pfile, pfile->directive_line, &str.val.str);
852 /* Pragmata handling. We handle some of these, and pass the rest on
853 to the front end. C99 defines three pragmas and says that no macro
854 expansion is to be performed on them; whether or not macro
855 expansion happens for other pragmas is implementation defined.
856 This implementation never macro-expands the text after #pragma. */
858 /* Sub-handlers for the pragmas needing treatment here.
859 They return 1 if the token buffer is to be popped, 0 if not. */
860 typedef void (*pragma_cb) PARAMS ((cpp_reader *));
863 struct pragma_entry *next;
869 struct pragma_entry *space;
874 cpp_register_pragma (pfile, space, name, handler)
880 struct pragma_entry **x, *new;
886 struct pragma_entry *p = pfile->pragmas;
887 len = strlen (space);
890 if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
897 cpp_ice (pfile, "unknown #pragma namespace %s", space);
902 new = (struct pragma_entry *)
903 _cpp_pool_alloc (&pfile->macro_pool, sizeof (struct pragma_entry));
905 new->len = strlen (name);
907 new->u.handler = handler;
914 cpp_register_pragma_space (pfile, space)
918 struct pragma_entry *new;
919 const struct pragma_entry *p = pfile->pragmas;
920 size_t len = strlen (space);
924 if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
925 /* Multiple different callers are allowed to register the same
931 new = (struct pragma_entry *)
932 _cpp_pool_alloc (&pfile->macro_pool, sizeof (struct pragma_entry));
938 new->next = pfile->pragmas;
939 pfile->pragmas = new;
943 _cpp_init_internal_pragmas (pfile)
947 cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
948 cpp_register_pragma (pfile, 0, "once", do_pragma_once);
951 cpp_register_pragma_space (pfile, "GCC");
953 cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
954 cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
955 cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
962 pragma_cb handler = NULL;
963 const struct pragma_entry *p;
967 pfile->state.prevent_expansion++;
968 cpp_start_lookahead (pfile);
971 cpp_get_token (pfile, &tok);
972 if (tok.type == CPP_NAME)
974 const cpp_hashnode *node = tok.val.node;
975 size_t len = NODE_LEN (node);
979 if (strlen (p->name) == len
980 && !memcmp (p->name, NODE_NAME (node), len))
989 handler = p->u.handler;
997 cpp_stop_lookahead (pfile, handler != NULL);
998 pfile->state.prevent_expansion--;
1002 else if (pfile->cb.def_pragma)
1003 (*pfile->cb.def_pragma) (pfile, pfile->directive_line);
1007 do_pragma_once (pfile)
1010 cpp_warning (pfile, "#pragma once is obsolete");
1012 if (pfile->buffer->prev == NULL)
1013 cpp_warning (pfile, "#pragma once in main file");
1015 _cpp_never_reread (pfile->buffer->inc);
1021 do_pragma_poison (pfile)
1024 /* Poison these symbols so that all subsequent usage produces an
1029 pfile->state.poisoned_ok = 1;
1032 _cpp_lex_token (pfile, &tok);
1033 if (tok.type == CPP_EOF)
1035 if (tok.type != CPP_NAME)
1037 cpp_error (pfile, "invalid #pragma GCC poison directive");
1042 if (hp->flags & NODE_POISONED)
1045 if (hp->type == NT_MACRO)
1046 cpp_warning (pfile, "poisoning existing macro \"%s\"", NODE_NAME (hp));
1047 _cpp_free_definition (hp);
1048 hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1050 pfile->state.poisoned_ok = 0;
1053 /* Mark the current header as a system header. This will suppress
1054 some categories of warnings (notably those from -pedantic). It is
1055 intended for use in system libraries that cannot be implemented in
1056 conforming C, but cannot be certain that their headers appear in a
1057 system include directory. To prevent abuse, it is rejected in the
1058 primary source file. */
1060 do_pragma_system_header (pfile)
1063 cpp_buffer *buffer = pfile->buffer;
1065 if (buffer->prev == 0)
1066 cpp_warning (pfile, "#pragma system_header ignored outside include file");
1070 end_directive (pfile, 1);
1071 cpp_make_system_header (pfile, 1, 0);
1075 /* Check the modified date of the current include file against a specified
1076 file. Issue a diagnostic, if the specified file is newer. We use this to
1077 determine if a fixed header should be refixed. */
1079 do_pragma_dependency (pfile)
1082 cpp_token header, msg;
1085 if (parse_include (pfile, &header))
1088 ordering = _cpp_compare_file_date (pfile, &header);
1090 cpp_warning (pfile, "cannot find source %s",
1091 cpp_token_as_text (pfile, &header));
1092 else if (ordering > 0)
1094 cpp_warning (pfile, "current file is older than %s",
1095 cpp_token_as_text (pfile, &header));
1096 cpp_start_lookahead (pfile);
1097 cpp_get_token (pfile, &msg);
1098 cpp_stop_lookahead (pfile, msg.type == CPP_EOF);
1099 if (msg.type != CPP_EOF)
1100 do_diagnostic (pfile, WARNING, 0);
1104 /* Check syntax is "(string-literal)". Returns 0 on success. */
1106 get__Pragma_string (pfile, string)
1112 cpp_get_token (pfile, &paren);
1113 if (paren.type != CPP_OPEN_PAREN)
1116 cpp_get_token (pfile, string);
1117 if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1120 cpp_get_token (pfile, &paren);
1121 return paren.type != CPP_CLOSE_PAREN;
1124 /* Returns a malloced buffer containing a destringized cpp_string by
1125 removing the first \ of \" and \\ sequences. */
1126 static unsigned char *
1127 destringize (in, len)
1128 const cpp_string *in;
1131 const unsigned char *src, *limit;
1132 unsigned char *dest, *result;
1134 dest = result = (unsigned char *) xmalloc (in->len);
1135 for (src = in->text, limit = src + in->len; src < limit;)
1137 /* We know there is a character following the backslash. */
1138 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1143 *len = dest - result;
1148 _cpp_do__Pragma (pfile)
1152 unsigned char *buffer;
1154 cpp_lexer_pos orig_pos;
1156 orig_pos = pfile->lexer_pos;
1157 if (get__Pragma_string (pfile, &string))
1158 cpp_error (pfile, "_Pragma takes a parenthesized string literal");
1161 buffer = destringize (&string.val.str, &len);
1162 run_directive (pfile, T_PRAGMA, BUF_PRAGMA, (char *) buffer, len);
1163 free ((PTR) buffer);
1164 pfile->lexer_pos = orig_pos;
1165 pfile->line = pfile->lexer_pos.line;
1169 /* Just ignore #sccs, on systems where we define it at all. */
1170 #ifdef SCCS_DIRECTIVE
1173 cpp_reader *pfile ATTRIBUTE_UNUSED;
1184 if (! pfile->state.skipping)
1186 const cpp_hashnode *node = lex_macro_node (pfile);
1189 skip = node->type != NT_MACRO;
1195 push_conditional (pfile, skip, T_IFDEF, 0);
1203 const cpp_hashnode *node = 0;
1205 if (! pfile->state.skipping)
1207 node = lex_macro_node (pfile);
1209 skip = node->type == NT_MACRO;
1215 push_conditional (pfile, skip, T_IFNDEF, node);
1218 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1219 pfile->mi_ind_cmacro so we can handle multiple-include
1220 optimisations. If macro expansion occurs in the expression, we
1221 cannot treat it as a controlling conditional, since the expansion
1222 could change in the future. That is handled by cpp_get_token. */
1230 if (! pfile->state.skipping)
1231 skip = _cpp_parse_expr (pfile) == 0;
1233 push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
1236 /* Flip skipping state if appropriate and continue without changing
1237 if_stack; this is so that the error message for missing #endif's
1238 etc. will point to the original #if. */
1244 cpp_buffer *buffer = pfile->buffer;
1245 struct if_stack *ifs = buffer->if_stack;
1248 cpp_error (pfile, "#else without #if");
1251 if (ifs->type == T_ELSE)
1253 cpp_error (pfile, "#else after #else");
1254 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1255 "the conditional began here");
1259 /* Skip any future (erroneous) #elses or #elifs. */
1260 pfile->state.skipping = ifs->skip_elses;
1261 ifs->skip_elses = true;
1263 /* Invalidate any controlling macro. */
1266 /* Only check EOL if was not originally skipping. */
1267 if (!ifs->was_skipping)
1272 /* handle a #elif directive by not changing if_stack either. see the
1273 comment above do_else. */
1279 cpp_buffer *buffer = pfile->buffer;
1280 struct if_stack *ifs = buffer->if_stack;
1283 cpp_error (pfile, "#elif without #if");
1286 if (ifs->type == T_ELSE)
1288 cpp_error (pfile, "#elif after #else");
1289 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1290 "the conditional began here");
1294 /* Only evaluate this if we aren't skipping elses. During
1295 evaluation, set skipping to false to get lexer warnings. */
1296 if (ifs->skip_elses)
1297 pfile->state.skipping = 1;
1300 pfile->state.skipping = 0;
1301 pfile->state.skipping = ! _cpp_parse_expr (pfile);
1302 ifs->skip_elses = ! pfile->state.skipping;
1305 /* Invalidate any controlling macro. */
1310 /* #endif pops the if stack and resets pfile->state.skipping. */
1316 cpp_buffer *buffer = pfile->buffer;
1317 struct if_stack *ifs = buffer->if_stack;
1320 cpp_error (pfile, "#endif without #if");
1323 /* Only check EOL if was not originally skipping. */
1324 if (!ifs->was_skipping)
1327 /* If potential control macro, we go back outside again. */
1328 if (ifs->next == 0 && ifs->mi_cmacro)
1330 pfile->mi_valid = true;
1331 pfile->mi_cmacro = ifs->mi_cmacro;
1334 buffer->if_stack = ifs->next;
1335 pfile->state.skipping = ifs->was_skipping;
1336 obstack_free (&pfile->buffer_ob, ifs);
1340 /* Push an if_stack entry and set pfile->state.skipping accordingly.
1341 If this is a #if or #ifndef, CMACRO is a potentially controlling
1342 macro - we need to check here that we are at the top of the file. */
1345 push_conditional (pfile, skip, type, cmacro)
1349 const cpp_hashnode *cmacro;
1351 struct if_stack *ifs;
1352 cpp_buffer *buffer = pfile->buffer;
1354 ifs = xobnew (&pfile->buffer_ob, struct if_stack);
1355 ifs->pos = pfile->directive_pos;
1356 ifs->next = buffer->if_stack;
1357 ifs->skip_elses = pfile->state.skipping || !skip;
1358 ifs->was_skipping = pfile->state.skipping;
1360 /* This condition is effectively a test for top-of-file. */
1361 if (pfile->mi_valid && pfile->mi_cmacro == 0)
1362 ifs->mi_cmacro = cmacro;
1366 pfile->state.skipping = skip;
1367 buffer->if_stack = ifs;
1370 /* Read the tokens of the answer into the macro pool. Only commit the
1371 memory if we intend it as permanent storage, i.e. the #assert case.
1372 Returns 0 on success. */
1375 parse_answer (pfile, answerp, type)
1377 struct answer **answerp;
1380 cpp_token paren, *token;
1381 struct answer *answer;
1383 if (POOL_FRONT (&pfile->macro_pool) + sizeof (struct answer) >
1384 POOL_LIMIT (&pfile->macro_pool))
1385 _cpp_next_chunk (&pfile->macro_pool, sizeof (struct answer), 0);
1386 answer = (struct answer *) POOL_FRONT (&pfile->macro_pool);
1389 /* In a conditional, it is legal to not have an open paren. We
1390 should save the following token in this case. */
1392 cpp_start_lookahead (pfile);
1393 cpp_get_token (pfile, &paren);
1395 cpp_stop_lookahead (pfile, paren.type == CPP_OPEN_PAREN);
1397 /* If not a paren, see if we're OK. */
1398 if (paren.type != CPP_OPEN_PAREN)
1400 /* In a conditional no answer is a test for any answer. It
1401 could be followed by any token. */
1405 /* #unassert with no answer is valid - it removes all answers. */
1406 if (type == T_UNASSERT && paren.type == CPP_EOF)
1409 cpp_error (pfile, "missing '(' after predicate");
1415 token = &answer->first[answer->count];
1416 /* Check we have room for the token. */
1417 if ((unsigned char *) (token + 1) >= POOL_LIMIT (&pfile->macro_pool))
1419 _cpp_next_chunk (&pfile->macro_pool, sizeof (cpp_token),
1420 (unsigned char **) &answer);
1421 token = &answer->first[answer->count];
1424 cpp_get_token (pfile, token);
1425 if (token->type == CPP_CLOSE_PAREN)
1428 if (token->type == CPP_EOF)
1430 cpp_error (pfile, "missing ')' to complete answer");
1436 if (answer->count == 0)
1438 cpp_error (pfile, "predicate's answer is empty");
1442 /* Drop whitespace at start. */
1443 answer->first->flags &= ~PREV_WHITE;
1446 if (type == T_ASSERT || type == T_UNASSERT)
1451 /* Parses an assertion, returning a pointer to the hash node of the
1452 predicate, or 0 on error. If an answer was supplied, it is placed
1453 in ANSWERP, otherwise it is set to 0. */
1454 static cpp_hashnode *
1455 parse_assertion (pfile, answerp, type)
1457 struct answer **answerp;
1460 cpp_hashnode *result = 0;
1461 cpp_token predicate;
1463 /* We don't expand predicates or answers. */
1464 pfile->state.prevent_expansion++;
1467 cpp_get_token (pfile, &predicate);
1468 if (predicate.type == CPP_EOF)
1469 cpp_error (pfile, "assertion without predicate");
1470 else if (predicate.type != CPP_NAME)
1471 cpp_error (pfile, "predicate must be an identifier");
1472 else if (parse_answer (pfile, answerp, type) == 0)
1474 unsigned int len = NODE_LEN (predicate.val.node);
1475 unsigned char *sym = alloca (len + 1);
1477 /* Prefix '#' to get it out of macro namespace. */
1479 memcpy (sym + 1, NODE_NAME (predicate.val.node), len);
1480 result = cpp_lookup (pfile, sym, len + 1);
1483 pfile->state.prevent_expansion--;
1487 /* Returns a pointer to the pointer to the answer in the answer chain,
1488 or a pointer to NULL if the answer is not in the chain. */
1489 static struct answer **
1490 find_answer (node, candidate)
1492 const struct answer *candidate;
1495 struct answer **result;
1497 for (result = &node->value.answers; *result; result = &(*result)->next)
1499 struct answer *answer = *result;
1501 if (answer->count == candidate->count)
1503 for (i = 0; i < answer->count; i++)
1504 if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1507 if (i == answer->count)
1515 /* Test an assertion within a preprocessor conditional. Returns
1516 non-zero on failure, zero on success. On success, the result of
1517 the test is written into VALUE. */
1519 _cpp_test_assertion (pfile, value)
1523 struct answer *answer;
1526 node = parse_assertion (pfile, &answer, T_IF);
1528 *value = (node->type == NT_ASSERTION &&
1529 (answer == 0 || *find_answer (node, answer) != 0));
1531 /* We don't commit the memory for the answer - it's temporary only. */
1539 struct answer *new_answer;
1542 node = parse_assertion (pfile, &new_answer, T_ASSERT);
1545 /* Place the new answer in the answer list. First check there
1546 is not a duplicate. */
1547 new_answer->next = 0;
1548 if (node->type == NT_ASSERTION)
1550 if (*find_answer (node, new_answer))
1552 cpp_warning (pfile, "\"%s\" re-asserted", NODE_NAME (node) + 1);
1555 new_answer->next = node->value.answers;
1557 node->type = NT_ASSERTION;
1558 node->value.answers = new_answer;
1559 POOL_COMMIT (&pfile->macro_pool, (sizeof (struct answer)
1560 + (new_answer->count - 1)
1561 * sizeof (cpp_token)));
1570 struct answer *answer;
1572 node = parse_assertion (pfile, &answer, T_UNASSERT);
1573 /* It isn't an error to #unassert something that isn't asserted. */
1574 if (node && node->type == NT_ASSERTION)
1578 struct answer **p = find_answer (node, answer), *temp;
1580 /* Remove the answer from the list. */
1585 /* Did we free the last answer? */
1586 if (node->value.answers == 0)
1587 node->type = NT_VOID;
1590 _cpp_free_definition (node);
1593 /* We don't commit the memory for the answer - it's temporary only. */
1596 /* These are for -D, -U, -A. */
1598 /* Process the string STR as if it appeared as the body of a #define.
1599 If STR is just an identifier, define it with value 1.
1600 If STR has anything after the identifier, then it should
1601 be identifier=definition. */
1604 cpp_define (pfile, str)
1611 /* Copy the entire option so we can modify it.
1612 Change the first "=" in the string to a space. If there is none,
1613 tack " 1" on the end. */
1615 /* Length including the null. */
1616 count = strlen (str);
1617 buf = (char *) alloca (count + 2);
1618 memcpy (buf, str, count);
1620 p = strchr (str, '=');
1629 run_directive (pfile, T_DEFINE, BUF_CL_OPTION, buf, count);
1632 /* Slight variant of the above for use by initialize_builtins. */
1634 _cpp_define_builtin (pfile, str)
1638 run_directive (pfile, T_DEFINE, BUF_BUILTIN, str, strlen (str));
1641 /* Process MACRO as if it appeared as the body of an #undef. */
1643 cpp_undef (pfile, macro)
1647 run_directive (pfile, T_UNDEF, BUF_CL_OPTION, macro, strlen (macro));
1650 /* Process the string STR as if it appeared as the body of a #assert. */
1652 cpp_assert (pfile, str)
1656 handle_assertion (pfile, str, T_ASSERT);
1659 /* Process STR as if it appeared as the body of an #unassert. */
1661 cpp_unassert (pfile, str)
1665 handle_assertion (pfile, str, T_UNASSERT);
1668 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1670 handle_assertion (pfile, str, type)
1675 size_t count = strlen (str);
1676 const char *p = strchr (str, '=');
1680 /* Copy the entire option so we can modify it. Change the first
1681 "=" in the string to a '(', and tack a ')' on the end. */
1682 char *buf = (char *) alloca (count + 1);
1684 memcpy (buf, str, count);
1690 run_directive (pfile, type, BUF_CL_OPTION, str, count);
1693 /* The number of errors for a given reader. */
1698 return pfile->errors;
1701 /* The options structure. */
1703 cpp_get_options (pfile)
1706 return &pfile->opts;
1709 /* The callbacks structure. */
1711 cpp_get_callbacks (pfile)
1717 /* The line map set. */
1718 const struct line_maps *
1719 cpp_get_line_maps (pfile)
1722 return &pfile->line_maps;
1725 /* Copy the given callbacks structure to our own. */
1727 cpp_set_callbacks (pfile, cb)
1734 /* Push a new buffer on the buffer stack. Returns the new buffer; it
1735 doesn't fail. It does not generate a file change call back; that
1736 is the responsibility of the caller. */
1738 cpp_push_buffer (pfile, buffer, len, type, return_at_eof)
1740 const U_CHAR *buffer;
1742 enum cpp_buffer_type type;
1745 cpp_buffer *new = xobnew (&pfile->buffer_ob, cpp_buffer);
1747 /* Clears, amongst other things, if_stack and mi_cmacro. */
1748 memset (new, 0, sizeof (cpp_buffer));
1750 new->line_base = new->buf = new->cur = buffer;
1751 new->rlimit = buffer + len;
1753 /* No read ahead or extra char initially. */
1754 new->read_ahead = EOF;
1755 new->extra_char = EOF;
1757 /* Preprocessed files, builtins, _Pragma and command line
1758 options don't do trigraph and escaped newline processing. */
1759 new->from_stage3 = type != BUF_FILE || CPP_OPTION (pfile, preprocessed);
1762 new->prev = pfile->buffer;
1764 new->return_at_eof = return_at_eof;
1766 pfile->buffer_stack_depth++;
1767 pfile->buffer = new;
1772 /* If called from do_line, pops a single buffer. Otherwise pops all
1773 buffers until a real file is reached. Generates appropriate
1776 _cpp_pop_buffer (pfile)
1779 cpp_buffer *buffer = pfile->buffer;
1780 struct if_stack *ifs;
1782 /* Walk back up the conditional stack till we reach its level at
1783 entry to this file, issuing error messages. */
1784 for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
1785 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1786 "unterminated #%s", dtable[ifs->type].name);
1788 /* Update the reader's buffer before _cpp_do_file_change. */
1789 pfile->buffer = buffer->prev;
1790 pfile->buffer_stack_depth--;
1792 if (buffer->type == BUF_FILE)
1794 /* Callbacks are not generated for popping the main file. */
1796 _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
1798 _cpp_pop_file_buffer (pfile, buffer);
1801 obstack_free (&pfile->buffer_ob, buffer);
1803 /* The output line can fall out of sync if we missed the final
1804 newline from the previous buffer, for example because of an
1805 unterminated comment. Similarly, skipping needs to be cleared in
1806 case of a missing #endif. */
1807 pfile->lexer_pos.output_line = pfile->line;
1808 pfile->state.skipping = 0;
1812 _cpp_init_directives (pfile)
1818 /* Register the directives. */
1819 for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
1821 node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
1822 node->directive_index = i + 1;