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_pos
.line
= pfile
->line
;
230 pfile
->directive_line
= pfile
->line
;
232 /* Don't save directive tokens for external clients. */
233 pfile
->la_saved
= pfile
->la_write
;
237 /* Called when leaving a directive, _Pragma or command-line directive. */
239 end_directive (pfile
, skip_line
)
243 /* We don't skip for an assembler #. */
246 skip_rest_of_line (pfile
);
247 /* "Accept" the newline now. */
252 pfile
->la_write
= pfile
->la_saved
;
253 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
254 pfile
->state
.in_directive
= 0;
255 pfile
->state
.angled_headers
= 0;
256 pfile
->state
.line_extension
= 0;
257 pfile
->directive
= 0;
260 /* Check if a token's name matches that of a known directive. Put in
261 this file to save exporting dtable and other unneeded information. */
263 _cpp_handle_directive (pfile
, indented
)
267 const directive
*dir
= 0;
271 start_directive (pfile
);
273 /* Lex the directive name directly. */
274 _cpp_lex_token (pfile
, &dname
);
276 if (dname
.type
== CPP_NAME
)
278 unsigned int index
= dname
.val
.node
->directive_index
;
280 dir
= &dtable
[index
- 1];
282 else if (dname
.type
== CPP_NUMBER
)
284 /* # followed by a number is equivalent to #line. Do not
285 recognize this form in assembly language source files or
286 skipped conditional groups. Complain about this form if
287 we're being pedantic, but not if this is regurgitated input
288 (preprocessed or fed back in by the C++ frontend). */
289 if (! pfile
->state
.skipping
&& CPP_OPTION (pfile
, lang
) != CLK_ASM
)
291 dir
= &dtable
[T_LINE
];
292 pfile
->state
.line_extension
= 1;
293 _cpp_push_token (pfile
, &dname
, &pfile
->directive_pos
);
294 if (CPP_PEDANTIC (pfile
) && ! CPP_OPTION (pfile
, preprocessed
))
295 cpp_pedwarn (pfile
, "# followed by integer");
299 pfile
->directive
= dir
;
302 /* Make sure we lex headers correctly, whether skipping or not. */
303 pfile
->state
.angled_headers
= dir
->flags
& INCL
;
305 /* If we are rescanning preprocessed input, only directives tagged
306 with IN_I are honored, and the warnings below are suppressed. */
307 if (CPP_OPTION (pfile
, preprocessed
))
309 /* Kluge alert. In order to be sure that code like this
312 does not cause '#define foo bar' to get executed when
313 compiled with -save-temps, we recognize directives in
314 -fpreprocessed mode only if the # is in column 1 and the
315 directive name starts in column 2. This output can only
316 be generated by the directive callbacks in cppmain.c (see
317 also the special case in scan_buffer). */
318 if (dir
->flags
& IN_I
&& !indented
&& !(dname
.flags
& PREV_WHITE
))
319 (*dir
->handler
) (pfile
);
320 /* That check misses '# 123' linemarkers. Let them through too. */
321 else if (dname
.type
== CPP_NUMBER
)
322 (*dir
->handler
) (pfile
);
325 /* We don't want to process this directive. Put back the
326 tokens so caller will see them (and issue an error,
328 _cpp_push_token (pfile
, &dname
, &pfile
->directive_pos
);
334 /* Traditionally, a directive is ignored unless its # is in
335 column 1. Therefore in code intended to work with K+R
336 compilers, directives added by C89 must have their #
337 indented, and directives present in traditional C must
338 not. This is true even of directives in skipped
339 conditional blocks. */
340 if (CPP_WTRADITIONAL (pfile
))
342 if (dir
== &dtable
[T_ELIF
])
344 "suggest not using #elif in traditional C");
345 else if (indented
&& dir
->origin
== KANDR
)
347 "traditional C ignores #%s with the # indented",
349 else if (!indented
&& dir
->origin
!= KANDR
)
351 "suggest hiding #%s from traditional C with an indented #",
355 /* If we are skipping a failed conditional group, all
356 non-conditional directives are ignored. */
357 if (! pfile
->state
.skipping
|| (dir
->flags
& COND
))
359 /* Issue -pedantic warnings for extensions. */
360 if (CPP_PEDANTIC (pfile
) && dir
->origin
== EXTENSION
)
361 cpp_pedwarn (pfile
, "#%s is a GCC extension", dir
->name
);
363 /* If we have a directive that is not an opening
364 conditional, invalidate any control macro. */
365 if (! (dir
->flags
& IF_COND
))
366 pfile
->mi_valid
= false;
368 (*dir
->handler
) (pfile
);
372 else if (dname
.type
!= CPP_EOF
&& ! pfile
->state
.skipping
)
374 /* An unknown directive. Don't complain about it in assembly
375 source: we don't know where the comments are, and # may
376 introduce assembler pseudo-ops. Don't complain about invalid
377 directives in skipped conditional groups (6.10 p4). */
378 if (CPP_OPTION (pfile
, lang
) == CLK_ASM
)
380 /* Output the # and lookahead token for the assembler. */
381 _cpp_push_token (pfile
, &dname
, &pfile
->directive_pos
);
385 cpp_error (pfile
, "invalid preprocessing directive #%s",
386 cpp_token_as_text (pfile
, &dname
));
389 if (pfile
->state
.in_directive
)
390 end_directive (pfile
, skip
);
394 /* Directive handler wrapper used by the command line option
397 run_directive (pfile
, dir_no
, type
, buf
, count
)
400 enum cpp_buffer_type type
;
406 buffer
= cpp_push_buffer (pfile
, (const U_CHAR
*) buf
, count
, type
, 1);
407 start_directive (pfile
);
408 pfile
->state
.prevent_expansion
++;
409 pfile
->directive
= &dtable
[dir_no
];
410 (void) (*pfile
->directive
->handler
) (pfile
);
411 pfile
->state
.prevent_expansion
--;
413 end_directive (pfile
, 1);
414 _cpp_pop_buffer (pfile
);
417 /* Checks for validity the macro name in #define, #undef, #ifdef and
418 #ifndef directives. */
419 static cpp_hashnode
*
420 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 may not be "defined", per C99 6.10.8p4.
431 In C++, it may not be any of the "named operators" either,
432 per C++98 [lex.digraph], [lex.key].
433 Finally, the identifier may not have been poisoned. (In that case
434 the lexer has issued the error message for us.) */
436 if (token
.type
!= CPP_NAME
)
438 if (token
.type
== CPP_EOF
)
439 cpp_error (pfile
, "no macro name given in #%s directive",
440 pfile
->directive
->name
);
441 else if (token
.flags
& NAMED_OP
)
443 "\"%s\" cannot be used as a macro name as it is an operator in C++",
444 NODE_NAME (token
.val
.node
));
446 cpp_error (pfile
, "macro names must be identifiers");
451 node
= token
.val
.node
;
452 if (node
->flags
& NODE_POISONED
)
455 if (node
== pfile
->spec_nodes
.n_defined
)
457 cpp_error (pfile
, "\"%s\" cannot be used as a macro name",
465 /* Process a #define directive. Most work is done in cppmacro.c. */
470 cpp_hashnode
*node
= lex_macro_node (pfile
);
474 if (_cpp_create_definition (pfile
, node
))
475 if (pfile
->cb
.define
)
476 (*pfile
->cb
.define
) (pfile
, pfile
->directive_line
, node
);
480 /* Handle #undef. Marks the identifier NT_VOID in the hash table. */
485 cpp_hashnode
*node
= lex_macro_node (pfile
);
487 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
488 is not currently defined as a macro name. */
489 if (node
&& node
->type
== NT_MACRO
)
492 (*pfile
->cb
.undef
) (pfile
, pfile
->directive_line
, node
);
494 if (node
->flags
& NODE_WARN
)
495 cpp_warning (pfile
, "undefining \"%s\"", NODE_NAME (node
));
497 _cpp_free_definition (node
);
502 /* Helper routine used by parse_include. Reinterpret the current line
503 as an h-char-sequence (< ... >); we are looking at the first token
504 after the <. Returns zero on success. */
506 glue_header_name (pfile
, header
)
511 unsigned char *buffer
, *token_mem
;
512 size_t len
, total_len
= 0, capacity
= 1024;
514 /* To avoid lexed tokens overwriting our glued name, we can only
515 allocate from the string pool once we've lexed everything. */
517 buffer
= (unsigned char *) xmalloc (capacity
);
520 cpp_get_token (pfile
, &token
);
522 if (token
.type
== CPP_GREATER
|| token
.type
== CPP_EOF
)
525 len
= cpp_token_len (&token
);
526 if (total_len
+ len
> capacity
)
528 capacity
= (capacity
+ len
) * 2;
529 buffer
= (unsigned char *) xrealloc (buffer
, capacity
);
532 if (token
.flags
& PREV_WHITE
)
533 buffer
[total_len
++] = ' ';
535 total_len
= cpp_spell_token (pfile
, &token
, &buffer
[total_len
]) - buffer
;
538 if (token
.type
== CPP_EOF
)
539 cpp_error (pfile
, "missing terminating > character");
542 token_mem
= _cpp_pool_alloc (&pfile
->ident_pool
, total_len
+ 1);
543 memcpy (token_mem
, buffer
, total_len
);
544 token_mem
[total_len
] = '\0';
546 header
->type
= CPP_HEADER_NAME
;
547 header
->flags
&= ~PREV_WHITE
;
548 header
->val
.str
.len
= total_len
;
549 header
->val
.str
.text
= token_mem
;
553 return token
.type
== CPP_EOF
;
556 /* Parse the header name of #include, #include_next, #import and
557 #pragma dependency. Returns zero on success. */
559 parse_include (pfile
, header
)
563 const unsigned char *dir
;
565 if (pfile
->directive
== &dtable
[T_PRAGMA
])
566 dir
= U
"pragma dependency";
568 dir
= pfile
->directive
->name
;
570 /* Allow macro expansion. */
571 cpp_get_token (pfile
, header
);
572 if (header
->type
!= CPP_STRING
&& header
->type
!= CPP_HEADER_NAME
)
574 if (header
->type
!= CPP_LESS
)
576 cpp_error (pfile
, "#%s expects \"FILENAME\" or <FILENAME>", dir
);
579 if (glue_header_name (pfile
, header
))
583 if (header
->val
.str
.len
== 0)
585 cpp_error (pfile
, "empty file name in #%s", dir
);
592 /* Handle #include, #include_next and #import. */
594 do_include_common (pfile
, type
)
596 enum include_type type
;
600 /* For #include_next, if this is the primary source file, warn and
601 use the normal search logic. */
602 if (type
== IT_INCLUDE_NEXT
&& ! pfile
->buffer
->prev
)
604 cpp_warning (pfile
, "#include_next in primary source file");
607 else if (type
== IT_IMPORT
&& CPP_OPTION (pfile
, warn_import
))
609 CPP_OPTION (pfile
, warn_import
) = 0;
611 "#import is obsolete, use an #ifndef wrapper in the header file");
614 if (!parse_include (pfile
, &header
))
616 /* Prevent #include recursion. */
617 if (pfile
->line_maps
.depth
>= CPP_STACK_MAX
)
618 cpp_fatal (pfile
, "#include nested too deeply");
622 /* Get out of macro context, if we are. */
623 end_directive (pfile
, 1);
624 if (pfile
->cb
.include
)
625 (*pfile
->cb
.include
) (pfile
, pfile
->directive_line
,
626 pfile
->directive
->name
, &header
);
628 _cpp_execute_include (pfile
, &header
, type
);
637 do_include_common (pfile
, IT_INCLUDE
);
644 do_include_common (pfile
, IT_IMPORT
);
648 do_include_next (pfile
)
651 do_include_common (pfile
, IT_INCLUDE_NEXT
);
654 /* Subroutine of do_line. Read possible flags after file name. LAST
655 is the last flag seen; 0 if this is the first flag. Return the flag
656 if it is valid, 0 at the end of the directive. Otherwise complain. */
659 read_flag (pfile
, last
)
665 _cpp_lex_token (pfile
, &token
);
666 if (token
.type
== CPP_NUMBER
&& token
.val
.str
.len
== 1)
668 unsigned int flag
= token
.val
.str
.text
[0] - '0';
670 if (flag
> last
&& flag
<= 4
671 && (flag
!= 4 || last
== 3)
672 && (flag
!= 2 || last
== 0))
676 if (token
.type
!= CPP_EOF
)
677 cpp_error (pfile
, "invalid flag \"%s\" in line directive",
678 cpp_token_as_text (pfile
, &token
));
682 /* Another subroutine of do_line. Convert a number in STR, of length
683 LEN, to binary; store it in NUMP, and return 0 if the number was
684 well-formed, 1 if not. Temporary, hopefully. */
686 strtoul_for_line (str
, len
, nump
)
691 unsigned long reg
= 0;
705 /* Interpret #line command.
706 Note that the filename string (if any) is treated as if it were an
707 include filename. That means no escape handling. */
714 const char *new_file
= pfile
->map
->to_file
;
715 unsigned long new_lineno
;
716 unsigned int cap
, new_sysp
= pfile
->map
->sysp
;
717 enum lc_reason reason
= LC_RENAME
;
719 /* C99 raised the minimum limit on #line numbers. */
720 cap
= CPP_OPTION (pfile
, c99
) ? 2147483647 : 32767;
722 /* #line commands expand macros. */
723 cpp_get_token (pfile
, &token
);
724 if (token
.type
!= CPP_NUMBER
725 || strtoul_for_line (token
.val
.str
.text
, token
.val
.str
.len
, &new_lineno
))
727 cpp_error (pfile
, "\"%s\" after #line is not a positive integer",
728 cpp_token_as_text (pfile
, &token
));
732 if (CPP_PEDANTIC (pfile
) && ! pfile
->state
.line_extension
733 && (new_lineno
== 0 || new_lineno
> cap
))
734 cpp_pedwarn (pfile
, "line number out of range");
736 cpp_get_token (pfile
, &token
);
737 if (token
.type
== CPP_STRING
)
739 new_file
= (const char *) token
.val
.str
.text
;
741 /* Only accept flags for the # 55 form. */
742 if (pfile
->state
.line_extension
)
747 flag
= read_flag (pfile
, 0);
751 /* Fake an include for cpp_included (). */
752 _cpp_fake_include (pfile
, new_file
);
753 flag
= read_flag (pfile
, flag
);
758 flag
= read_flag (pfile
, flag
);
763 flag
= read_flag (pfile
, flag
);
770 else if (token
.type
!= CPP_EOF
)
772 cpp_error (pfile
, "\"%s\" is not a valid filename",
773 cpp_token_as_text (pfile
, &token
));
777 end_directive (pfile
, 1);
778 _cpp_do_file_change (pfile
, reason
, new_file
, new_lineno
, new_sysp
);
781 /* Arrange the file_change callback. pfile->line has changed to
782 FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system
783 header, 2 for a sytem header that needs to be extern "C" protected,
784 and zero otherwise. */
786 _cpp_do_file_change (pfile
, reason
, to_file
, file_line
, sysp
)
788 enum lc_reason reason
;
790 unsigned int file_line
;
793 pfile
->map
= add_line_map (&pfile
->line_maps
, reason
, sysp
,
794 pfile
->line
, to_file
, file_line
);
796 if (pfile
->cb
.file_change
)
797 (*pfile
->cb
.file_change
) (pfile
, pfile
->map
);
801 * Report a warning or error detected by the program we are
802 * processing. Use the directive's tokens in the error message.
806 do_diagnostic (pfile
, code
, print_dir
)
808 enum error_type code
;
811 if (_cpp_begin_message (pfile
, code
, 0))
814 fprintf (stderr
, "#%s ", pfile
->directive
->name
);
815 pfile
->state
.prevent_expansion
++;
816 cpp_output_line (pfile
, stderr
);
817 pfile
->state
.prevent_expansion
--;
825 do_diagnostic (pfile
, ERROR
, 1);
832 /* We want #warning diagnostics to be emitted in system headers too. */
833 do_diagnostic (pfile
, WARNING_SYSHDR
, 1);
836 /* Report program identification. */
844 cpp_get_token (pfile
, &str
);
845 if (str
.type
!= CPP_STRING
)
846 cpp_error (pfile
, "invalid #ident");
847 else if (pfile
->cb
.ident
)
848 (*pfile
->cb
.ident
) (pfile
, pfile
->directive_line
, &str
.val
.str
);
853 /* Pragmata handling. We handle some of these, and pass the rest on
854 to the front end. C99 defines three pragmas and says that no macro
855 expansion is to be performed on them; whether or not macro
856 expansion happens for other pragmas is implementation defined.
857 This implementation never macro-expands the text after #pragma. */
859 /* Sub-handlers for the pragmas needing treatment here.
860 They return 1 if the token buffer is to be popped, 0 if not. */
861 typedef void (*pragma_cb
) PARAMS ((cpp_reader
*));
864 struct pragma_entry
*next
;
870 struct pragma_entry
*space
;
875 cpp_register_pragma (pfile
, space
, name
, handler
)
881 struct pragma_entry
**x
, *new;
887 struct pragma_entry
*p
= pfile
->pragmas
;
888 len
= strlen (space
);
891 if (p
->isnspace
&& p
->len
== len
&& !memcmp (p
->name
, space
, len
))
898 cpp_ice (pfile
, "unknown #pragma namespace %s", space
);
903 new = (struct pragma_entry
*)
904 _cpp_pool_alloc (&pfile
->macro_pool
, sizeof (struct pragma_entry
));
906 new->len
= strlen (name
);
908 new->u
.handler
= handler
;
915 cpp_register_pragma_space (pfile
, space
)
919 struct pragma_entry
*new;
920 const struct pragma_entry
*p
= pfile
->pragmas
;
921 size_t len
= strlen (space
);
925 if (p
->isnspace
&& p
->len
== len
&& !memcmp (p
->name
, space
, len
))
926 /* Multiple different callers are allowed to register the same
932 new = (struct pragma_entry
*)
933 _cpp_pool_alloc (&pfile
->macro_pool
, sizeof (struct pragma_entry
));
939 new->next
= pfile
->pragmas
;
940 pfile
->pragmas
= new;
944 _cpp_init_internal_pragmas (pfile
)
948 cpp_register_pragma (pfile
, 0, "poison", do_pragma_poison
);
949 cpp_register_pragma (pfile
, 0, "once", do_pragma_once
);
952 cpp_register_pragma_space (pfile
, "GCC");
954 cpp_register_pragma (pfile
, "GCC", "poison", do_pragma_poison
);
955 cpp_register_pragma (pfile
, "GCC", "system_header", do_pragma_system_header
);
956 cpp_register_pragma (pfile
, "GCC", "dependency", do_pragma_dependency
);
963 pragma_cb handler
= NULL
;
964 const struct pragma_entry
*p
;
968 pfile
->state
.prevent_expansion
++;
969 cpp_start_lookahead (pfile
);
972 cpp_get_token (pfile
, &tok
);
973 if (tok
.type
== CPP_NAME
)
975 const cpp_hashnode
*node
= tok
.val
.node
;
976 size_t len
= NODE_LEN (node
);
980 if (strlen (p
->name
) == len
981 && !memcmp (p
->name
, NODE_NAME (node
), len
))
990 handler
= p
->u
.handler
;
998 cpp_stop_lookahead (pfile
, handler
!= NULL
);
999 pfile
->state
.prevent_expansion
--;
1003 else if (pfile
->cb
.def_pragma
)
1004 (*pfile
->cb
.def_pragma
) (pfile
, pfile
->directive_line
);
1008 do_pragma_once (pfile
)
1011 cpp_warning (pfile
, "#pragma once is obsolete");
1013 if (pfile
->buffer
->prev
== NULL
)
1014 cpp_warning (pfile
, "#pragma once in main file");
1016 _cpp_never_reread (pfile
->buffer
->inc
);
1022 do_pragma_poison (pfile
)
1025 /* Poison these symbols so that all subsequent usage produces an
1030 pfile
->state
.poisoned_ok
= 1;
1033 _cpp_lex_token (pfile
, &tok
);
1034 if (tok
.type
== CPP_EOF
)
1036 if (tok
.type
!= CPP_NAME
)
1038 cpp_error (pfile
, "invalid #pragma GCC poison directive");
1043 if (hp
->flags
& NODE_POISONED
)
1046 if (hp
->type
== NT_MACRO
)
1047 cpp_warning (pfile
, "poisoning existing macro \"%s\"", NODE_NAME (hp
));
1048 _cpp_free_definition (hp
);
1049 hp
->flags
|= NODE_POISONED
| NODE_DIAGNOSTIC
;
1051 pfile
->state
.poisoned_ok
= 0;
1054 /* Mark the current header as a system header. This will suppress
1055 some categories of warnings (notably those from -pedantic). It is
1056 intended for use in system libraries that cannot be implemented in
1057 conforming C, but cannot be certain that their headers appear in a
1058 system include directory. To prevent abuse, it is rejected in the
1059 primary source file. */
1061 do_pragma_system_header (pfile
)
1064 cpp_buffer
*buffer
= pfile
->buffer
;
1066 if (buffer
->prev
== 0)
1067 cpp_warning (pfile
, "#pragma system_header ignored outside include file");
1071 end_directive (pfile
, 1);
1072 cpp_make_system_header (pfile
, 1, 0);
1076 /* Check the modified date of the current include file against a specified
1077 file. Issue a diagnostic, if the specified file is newer. We use this to
1078 determine if a fixed header should be refixed. */
1080 do_pragma_dependency (pfile
)
1083 cpp_token header
, msg
;
1086 if (parse_include (pfile
, &header
))
1089 ordering
= _cpp_compare_file_date (pfile
, &header
);
1091 cpp_warning (pfile
, "cannot find source %s",
1092 cpp_token_as_text (pfile
, &header
));
1093 else if (ordering
> 0)
1095 cpp_warning (pfile
, "current file is older than %s",
1096 cpp_token_as_text (pfile
, &header
));
1097 cpp_start_lookahead (pfile
);
1098 cpp_get_token (pfile
, &msg
);
1099 cpp_stop_lookahead (pfile
, msg
.type
== CPP_EOF
);
1100 if (msg
.type
!= CPP_EOF
)
1101 do_diagnostic (pfile
, WARNING
, 0);
1105 /* Check syntax is "(string-literal)". Returns 0 on success. */
1107 get__Pragma_string (pfile
, string
)
1113 cpp_get_token (pfile
, &paren
);
1114 if (paren
.type
!= CPP_OPEN_PAREN
)
1117 cpp_get_token (pfile
, string
);
1118 if (string
->type
!= CPP_STRING
&& string
->type
!= CPP_WSTRING
)
1121 cpp_get_token (pfile
, &paren
);
1122 return paren
.type
!= CPP_CLOSE_PAREN
;
1125 /* Returns a malloced buffer containing a destringized cpp_string by
1126 removing the first \ of \" and \\ sequences. */
1127 static unsigned char *
1128 destringize (in
, len
)
1129 const cpp_string
*in
;
1132 const unsigned char *src
, *limit
;
1133 unsigned char *dest
, *result
;
1135 dest
= result
= (unsigned char *) xmalloc (in
->len
);
1136 for (src
= in
->text
, limit
= src
+ in
->len
; src
< limit
;)
1138 /* We know there is a character following the backslash. */
1139 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1144 *len
= dest
- result
;
1149 _cpp_do__Pragma (pfile
)
1153 unsigned char *buffer
;
1155 cpp_lexer_pos orig_pos
;
1157 orig_pos
= pfile
->lexer_pos
;
1158 if (get__Pragma_string (pfile
, &string
))
1159 cpp_error (pfile
, "_Pragma takes a parenthesized string literal");
1162 buffer
= destringize (&string
.val
.str
, &len
);
1163 run_directive (pfile
, T_PRAGMA
, BUF_PRAGMA
, (char *) buffer
, len
);
1164 free ((PTR
) buffer
);
1165 pfile
->lexer_pos
= orig_pos
;
1166 pfile
->line
= pfile
->lexer_pos
.line
;
1170 /* Just ignore #sccs, on systems where we define it at all. */
1171 #ifdef SCCS_DIRECTIVE
1174 cpp_reader
*pfile ATTRIBUTE_UNUSED
;
1185 if (! pfile
->state
.skipping
)
1187 const cpp_hashnode
*node
= lex_macro_node (pfile
);
1190 skip
= node
->type
!= NT_MACRO
;
1196 push_conditional (pfile
, skip
, T_IFDEF
, 0);
1204 const cpp_hashnode
*node
= 0;
1206 if (! pfile
->state
.skipping
)
1208 node
= lex_macro_node (pfile
);
1210 skip
= node
->type
== NT_MACRO
;
1216 push_conditional (pfile
, skip
, T_IFNDEF
, node
);
1219 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1220 pfile->mi_ind_cmacro so we can handle multiple-include
1221 optimisations. If macro expansion occurs in the expression, we
1222 cannot treat it as a controlling conditional, since the expansion
1223 could change in the future. That is handled by cpp_get_token. */
1231 if (! pfile
->state
.skipping
)
1232 skip
= _cpp_parse_expr (pfile
) == 0;
1234 push_conditional (pfile
, skip
, T_IF
, pfile
->mi_ind_cmacro
);
1237 /* Flip skipping state if appropriate and continue without changing
1238 if_stack; this is so that the error message for missing #endif's
1239 etc. will point to the original #if. */
1245 cpp_buffer
*buffer
= pfile
->buffer
;
1246 struct if_stack
*ifs
= buffer
->if_stack
;
1249 cpp_error (pfile
, "#else without #if");
1252 if (ifs
->type
== T_ELSE
)
1254 cpp_error (pfile
, "#else after #else");
1255 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1256 "the conditional began here");
1260 /* Skip any future (erroneous) #elses or #elifs. */
1261 pfile
->state
.skipping
= ifs
->skip_elses
;
1262 ifs
->skip_elses
= true;
1264 /* Invalidate any controlling macro. */
1267 /* Only check EOL if was not originally skipping. */
1268 if (!ifs
->was_skipping
)
1273 /* handle a #elif directive by not changing if_stack either. see the
1274 comment above do_else. */
1280 cpp_buffer
*buffer
= pfile
->buffer
;
1281 struct if_stack
*ifs
= buffer
->if_stack
;
1284 cpp_error (pfile
, "#elif without #if");
1287 if (ifs
->type
== T_ELSE
)
1289 cpp_error (pfile
, "#elif after #else");
1290 cpp_error_with_line (pfile
, ifs
->pos
.line
, ifs
->pos
.col
,
1291 "the conditional began here");
1295 /* Only evaluate this if we aren't skipping elses. During
1296 evaluation, set skipping to false to get lexer warnings. */
1297 if (ifs
->skip_elses
)
1298 pfile
->state
.skipping
= 1;
1301 pfile
->state
.skipping
= 0;
1302 pfile
->state
.skipping
= ! _cpp_parse_expr (pfile
);
1303 ifs
->skip_elses
= ! pfile
->state
.skipping
;
1306 /* Invalidate any controlling macro. */
1311 /* #endif pops the if stack and resets pfile->state.skipping. */
1317 cpp_buffer
*buffer
= pfile
->buffer
;
1318 struct if_stack
*ifs
= buffer
->if_stack
;
1321 cpp_error (pfile
, "#endif without #if");
1324 /* Only check EOL if was not originally skipping. */
1325 if (!ifs
->was_skipping
)
1328 /* If potential control macro, we go back outside again. */
1329 if (ifs
->next
== 0 && ifs
->mi_cmacro
)
1331 pfile
->mi_valid
= true;
1332 pfile
->mi_cmacro
= ifs
->mi_cmacro
;
1335 buffer
->if_stack
= ifs
->next
;
1336 pfile
->state
.skipping
= ifs
->was_skipping
;
1337 obstack_free (&pfile
->buffer_ob
, ifs
);
1341 /* Push an if_stack entry and set pfile->state.skipping accordingly.
1342 If this is a #if or #ifndef, CMACRO is a potentially controlling
1343 macro - we need to check here that we are at the top of the file. */
1346 push_conditional (pfile
, skip
, type
, cmacro
)
1350 const cpp_hashnode
*cmacro
;
1352 struct if_stack
*ifs
;
1353 cpp_buffer
*buffer
= pfile
->buffer
;
1355 ifs
= xobnew (&pfile
->buffer_ob
, struct if_stack
);
1356 ifs
->pos
= pfile
->directive_pos
;
1357 ifs
->next
= buffer
->if_stack
;
1358 ifs
->skip_elses
= pfile
->state
.skipping
|| !skip
;
1359 ifs
->was_skipping
= pfile
->state
.skipping
;
1361 /* This condition is effectively a test for top-of-file. */
1362 if (pfile
->mi_valid
&& pfile
->mi_cmacro
== 0)
1363 ifs
->mi_cmacro
= cmacro
;
1367 pfile
->state
.skipping
= skip
;
1368 buffer
->if_stack
= ifs
;
1371 /* Read the tokens of the answer into the macro pool. Only commit the
1372 memory if we intend it as permanent storage, i.e. the #assert case.
1373 Returns 0 on success. */
1376 parse_answer (pfile
, answerp
, type
)
1378 struct answer
**answerp
;
1381 cpp_token paren
, *token
;
1382 struct answer
*answer
;
1384 if (POOL_FRONT (&pfile
->macro_pool
) + sizeof (struct answer
) >
1385 POOL_LIMIT (&pfile
->macro_pool
))
1386 _cpp_next_chunk (&pfile
->macro_pool
, sizeof (struct answer
), 0);
1387 answer
= (struct answer
*) POOL_FRONT (&pfile
->macro_pool
);
1390 /* In a conditional, it is legal to not have an open paren. We
1391 should save the following token in this case. */
1393 cpp_start_lookahead (pfile
);
1394 cpp_get_token (pfile
, &paren
);
1396 cpp_stop_lookahead (pfile
, paren
.type
== CPP_OPEN_PAREN
);
1398 /* If not a paren, see if we're OK. */
1399 if (paren
.type
!= CPP_OPEN_PAREN
)
1401 /* In a conditional no answer is a test for any answer. It
1402 could be followed by any token. */
1406 /* #unassert with no answer is valid - it removes all answers. */
1407 if (type
== T_UNASSERT
&& paren
.type
== CPP_EOF
)
1410 cpp_error (pfile
, "missing '(' after predicate");
1416 token
= &answer
->first
[answer
->count
];
1417 /* Check we have room for the token. */
1418 if ((unsigned char *) (token
+ 1) >= POOL_LIMIT (&pfile
->macro_pool
))
1420 _cpp_next_chunk (&pfile
->macro_pool
, sizeof (cpp_token
),
1421 (unsigned char **) &answer
);
1422 token
= &answer
->first
[answer
->count
];
1425 cpp_get_token (pfile
, token
);
1426 if (token
->type
== CPP_CLOSE_PAREN
)
1429 if (token
->type
== CPP_EOF
)
1431 cpp_error (pfile
, "missing ')' to complete answer");
1437 if (answer
->count
== 0)
1439 cpp_error (pfile
, "predicate's answer is empty");
1443 /* Drop whitespace at start. */
1444 answer
->first
->flags
&= ~PREV_WHITE
;
1447 if (type
== T_ASSERT
|| type
== T_UNASSERT
)
1452 /* Parses an assertion, returning a pointer to the hash node of the
1453 predicate, or 0 on error. If an answer was supplied, it is placed
1454 in ANSWERP, otherwise it is set to 0. */
1455 static cpp_hashnode
*
1456 parse_assertion (pfile
, answerp
, type
)
1458 struct answer
**answerp
;
1461 cpp_hashnode
*result
= 0;
1462 cpp_token predicate
;
1464 /* We don't expand predicates or answers. */
1465 pfile
->state
.prevent_expansion
++;
1468 cpp_get_token (pfile
, &predicate
);
1469 if (predicate
.type
== CPP_EOF
)
1470 cpp_error (pfile
, "assertion without predicate");
1471 else if (predicate
.type
!= CPP_NAME
)
1472 cpp_error (pfile
, "predicate must be an identifier");
1473 else if (parse_answer (pfile
, answerp
, type
) == 0)
1475 unsigned int len
= NODE_LEN (predicate
.val
.node
);
1476 unsigned char *sym
= alloca (len
+ 1);
1478 /* Prefix '#' to get it out of macro namespace. */
1480 memcpy (sym
+ 1, NODE_NAME (predicate
.val
.node
), len
);
1481 result
= cpp_lookup (pfile
, sym
, len
+ 1);
1484 pfile
->state
.prevent_expansion
--;
1488 /* Returns a pointer to the pointer to the answer in the answer chain,
1489 or a pointer to NULL if the answer is not in the chain. */
1490 static struct answer
**
1491 find_answer (node
, candidate
)
1493 const struct answer
*candidate
;
1496 struct answer
**result
;
1498 for (result
= &node
->value
.answers
; *result
; result
= &(*result
)->next
)
1500 struct answer
*answer
= *result
;
1502 if (answer
->count
== candidate
->count
)
1504 for (i
= 0; i
< answer
->count
; i
++)
1505 if (! _cpp_equiv_tokens (&answer
->first
[i
], &candidate
->first
[i
]))
1508 if (i
== answer
->count
)
1516 /* Test an assertion within a preprocessor conditional. Returns
1517 non-zero on failure, zero on success. On success, the result of
1518 the test is written into VALUE. */
1520 _cpp_test_assertion (pfile
, value
)
1524 struct answer
*answer
;
1527 node
= parse_assertion (pfile
, &answer
, T_IF
);
1529 *value
= (node
->type
== NT_ASSERTION
&&
1530 (answer
== 0 || *find_answer (node
, answer
) != 0));
1532 /* We don't commit the memory for the answer - it's temporary only. */
1540 struct answer
*new_answer
;
1543 node
= parse_assertion (pfile
, &new_answer
, T_ASSERT
);
1546 /* Place the new answer in the answer list. First check there
1547 is not a duplicate. */
1548 new_answer
->next
= 0;
1549 if (node
->type
== NT_ASSERTION
)
1551 if (*find_answer (node
, new_answer
))
1553 cpp_warning (pfile
, "\"%s\" re-asserted", NODE_NAME (node
) + 1);
1556 new_answer
->next
= node
->value
.answers
;
1558 node
->type
= NT_ASSERTION
;
1559 node
->value
.answers
= new_answer
;
1560 POOL_COMMIT (&pfile
->macro_pool
, (sizeof (struct answer
)
1561 + (new_answer
->count
- 1)
1562 * sizeof (cpp_token
)));
1571 struct answer
*answer
;
1573 node
= parse_assertion (pfile
, &answer
, T_UNASSERT
);
1574 /* It isn't an error to #unassert something that isn't asserted. */
1575 if (node
&& node
->type
== NT_ASSERTION
)
1579 struct answer
**p
= find_answer (node
, answer
), *temp
;
1581 /* Remove the answer from the list. */
1586 /* Did we free the last answer? */
1587 if (node
->value
.answers
== 0)
1588 node
->type
= NT_VOID
;
1591 _cpp_free_definition (node
);
1594 /* We don't commit the memory for the answer - it's temporary only. */
1597 /* These are for -D, -U, -A. */
1599 /* Process the string STR as if it appeared as the body of a #define.
1600 If STR is just an identifier, define it with value 1.
1601 If STR has anything after the identifier, then it should
1602 be identifier=definition. */
1605 cpp_define (pfile
, str
)
1612 /* Copy the entire option so we can modify it.
1613 Change the first "=" in the string to a space. If there is none,
1614 tack " 1" on the end. */
1616 /* Length including the null. */
1617 count
= strlen (str
);
1618 buf
= (char *) alloca (count
+ 2);
1619 memcpy (buf
, str
, count
);
1621 p
= strchr (str
, '=');
1630 run_directive (pfile
, T_DEFINE
, BUF_CL_OPTION
, buf
, count
);
1633 /* Slight variant of the above for use by initialize_builtins. */
1635 _cpp_define_builtin (pfile
, str
)
1639 run_directive (pfile
, T_DEFINE
, BUF_BUILTIN
, str
, strlen (str
));
1642 /* Process MACRO as if it appeared as the body of an #undef. */
1644 cpp_undef (pfile
, macro
)
1648 run_directive (pfile
, T_UNDEF
, BUF_CL_OPTION
, macro
, strlen (macro
));
1651 /* Process the string STR as if it appeared as the body of a #assert. */
1653 cpp_assert (pfile
, str
)
1657 handle_assertion (pfile
, str
, T_ASSERT
);
1660 /* Process STR as if it appeared as the body of an #unassert. */
1662 cpp_unassert (pfile
, str
)
1666 handle_assertion (pfile
, str
, T_UNASSERT
);
1669 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1671 handle_assertion (pfile
, str
, type
)
1676 size_t count
= strlen (str
);
1677 const char *p
= strchr (str
, '=');
1681 /* Copy the entire option so we can modify it. Change the first
1682 "=" in the string to a '(', and tack a ')' on the end. */
1683 char *buf
= (char *) alloca (count
+ 1);
1685 memcpy (buf
, str
, count
);
1691 run_directive (pfile
, type
, BUF_CL_OPTION
, str
, count
);
1694 /* The number of errors for a given reader. */
1699 return pfile
->errors
;
1702 /* The options structure. */
1704 cpp_get_options (pfile
)
1707 return &pfile
->opts
;
1710 /* The callbacks structure. */
1712 cpp_get_callbacks (pfile
)
1718 /* The line map set. */
1719 const struct line_maps
*
1720 cpp_get_line_maps (pfile
)
1723 return &pfile
->line_maps
;
1726 /* Copy the given callbacks structure to our own. */
1728 cpp_set_callbacks (pfile
, cb
)
1735 /* Push a new buffer on the buffer stack. Returns the new buffer; it
1736 doesn't fail. It does not generate a file change call back; that
1737 is the responsibility of the caller. */
1739 cpp_push_buffer (pfile
, buffer
, len
, type
, return_at_eof
)
1741 const U_CHAR
*buffer
;
1743 enum cpp_buffer_type type
;
1746 cpp_buffer
*new = xobnew (&pfile
->buffer_ob
, cpp_buffer
);
1748 /* Clears, amongst other things, if_stack and mi_cmacro. */
1749 memset (new, 0, sizeof (cpp_buffer
));
1751 new->line_base
= new->buf
= new->cur
= buffer
;
1752 new->rlimit
= buffer
+ len
;
1754 /* No read ahead or extra char initially. */
1755 new->read_ahead
= EOF
;
1756 new->extra_char
= EOF
;
1758 /* Preprocessed files, builtins, _Pragma and command line
1759 options don't do trigraph and escaped newline processing. */
1760 new->from_stage3
= type
!= BUF_FILE
|| CPP_OPTION (pfile
, preprocessed
);
1763 new->prev
= pfile
->buffer
;
1765 new->return_at_eof
= return_at_eof
;
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
;
1791 if (buffer
->type
== BUF_FILE
)
1793 /* Callbacks are not generated for popping the main file. */
1795 _cpp_do_file_change (pfile
, LC_LEAVE
, 0, 0, 0);
1797 _cpp_pop_file_buffer (pfile
, buffer
);
1800 obstack_free (&pfile
->buffer_ob
, buffer
);
1802 /* The output line can fall out of sync if we missed the final
1803 newline from the previous buffer, for example because of an
1804 unterminated comment. Similarly, skipping needs to be cleared in
1805 case of a missing #endif. */
1806 pfile
->lexer_pos
.output_line
= pfile
->line
;
1807 pfile
->state
.skipping
= 0;
1811 _cpp_init_directives (pfile
)
1817 /* Register the directives. */
1818 for (i
= 0; i
< (unsigned int) N_DIRECTIVES
; i
++)
1820 node
= cpp_lookup (pfile
, dtable
[i
].name
, dtable
[i
].length
);
1821 node
->directive_index
= i
+ 1;