1 /* CPP Library. (Directive handling.)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4 2007, 2008 Free Software Foundation, Inc.
5 Contributed by Per Bothner, 1994-95.
6 Based on CCCP program by Paul Rubin, June 1986
7 Adapted to ANSI C, Richard Stallman, Jan 1987
9 This program is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 2, or (at your option) any
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
30 /* Stack of conditionals currently in progress
31 (including both successful and failing conditionals). */
34 struct if_stack
*next
;
35 unsigned int line
; /* Line where condition started. */
36 const cpp_hashnode
*mi_cmacro
;/* macro name for #ifndef around entire file */
37 bool skip_elses
; /* Can future #else / #elif be skipped? */
38 bool was_skipping
; /* If were skipping on entry. */
39 int type
; /* Most recent conditional for diagnostics. */
42 /* Contains a registered pragma or pragma namespace. */
43 typedef void (*pragma_cb
) (cpp_reader
*);
46 struct pragma_entry
*next
;
47 const cpp_hashnode
*pragma
; /* Name and length. */
54 struct pragma_entry
*space
;
59 /* Values for the origin field of struct directive. KANDR directives
60 come from traditional (K&R) C. STDC89 directives come from the
61 1989 C standard. EXTENSION directives are extensions. */
66 /* Values for the flags field of struct directive. COND indicates a
67 conditional; IF_COND an opening conditional. INCL means to treat
68 "..." and <...> as q-char and h-char sequences respectively. IN_I
69 means this directive should be handled even if -fpreprocessed is in
70 effect (these are the directives with callback hooks).
72 EXPAND is set on directives that are always macro-expanded. */
74 #define IF_COND (1 << 1)
77 #define EXPAND (1 << 4)
79 /* Defines one #-directive, including how to handle it. */
80 typedef void (*directive_handler
) (cpp_reader
*);
81 typedef struct directive directive
;
84 directive_handler handler
; /* Function to handle directive. */
85 const uchar
*name
; /* Name of directive. */
86 unsigned short length
; /* Length of name. */
87 unsigned char origin
; /* Origin of directive. */
88 unsigned char flags
; /* Flags describing this directive. */
91 /* Forward declarations. */
93 static void skip_rest_of_line (cpp_reader
*);
94 static void check_eol (cpp_reader
*);
95 static void start_directive (cpp_reader
*);
96 static void prepare_directive_trad (cpp_reader
*);
97 static void end_directive (cpp_reader
*, int);
98 static void directive_diagnostics (cpp_reader
*, const directive
*, int);
99 static void run_directive (cpp_reader
*, int, const char *, size_t);
100 static char *glue_header_name (cpp_reader
*);
101 static const char *parse_include (cpp_reader
*, int *, const cpp_token
***);
102 static void push_conditional (cpp_reader
*, int, int, const cpp_hashnode
*);
103 static unsigned int read_flag (cpp_reader
*, unsigned int);
104 static int strtoul_for_line (const uchar
*, unsigned int, unsigned long *);
105 static void do_diagnostic (cpp_reader
*, int, int);
106 static cpp_hashnode
*lex_macro_node (cpp_reader
*, bool);
107 static int undefine_macros (cpp_reader
*, cpp_hashnode
*, void *);
108 static void do_include_common (cpp_reader
*, enum include_type
);
109 static struct pragma_entry
*lookup_pragma_entry (struct pragma_entry
*,
110 const cpp_hashnode
*);
111 static int count_registered_pragmas (struct pragma_entry
*);
112 static char ** save_registered_pragmas (struct pragma_entry
*, char **);
113 static char ** restore_registered_pragmas (cpp_reader
*, struct pragma_entry
*,
115 static void do_pragma_once (cpp_reader
*);
116 static void do_pragma_poison (cpp_reader
*);
117 static void do_pragma_system_header (cpp_reader
*);
118 static void do_pragma_dependency (cpp_reader
*);
119 static void do_linemarker (cpp_reader
*);
120 static const cpp_token
*get_token_no_padding (cpp_reader
*);
121 static const cpp_token
*get__Pragma_string (cpp_reader
*);
122 static void destringize_and_run (cpp_reader
*, const cpp_string
*);
123 static int parse_answer (cpp_reader
*, struct answer
**, int);
124 static cpp_hashnode
*parse_assertion (cpp_reader
*, struct answer
**, int);
125 static struct answer
** find_answer (cpp_hashnode
*, const struct answer
*);
126 static void handle_assertion (cpp_reader
*, const char *, int);
128 /* This is the table of directive handlers. It is ordered by
129 frequency of occurrence; the numbers at the end are directive
130 counts from all the source code I have lying around (egcs and libc
131 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
132 pcmcia-cs-3.0.9). This is no longer important as directive lookup
133 is now O(1). All extensions other than #warning and #include_next
134 are deprecated. The name is where the extension appears to have
137 #define DIRECTIVE_TABLE \
138 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
139 D(include, T_INCLUDE, KANDR, INCL | EXPAND) /* 52262 */ \
140 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
141 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
142 D(if, T_IF, KANDR, COND | IF_COND | EXPAND) /* 18162 */ \
143 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
144 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
145 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
146 D(line, T_LINE, KANDR, EXPAND) /* 2465 */ \
147 D(elif, T_ELIF, STDC89, COND | EXPAND) /* 610 */ \
148 D(error, T_ERROR, STDC89, 0) /* 475 */ \
149 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
150 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
151 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL | EXPAND) /* 19 */ \
152 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
153 D(import, T_IMPORT, EXTENSION, INCL | EXPAND) /* 0 ObjC */ \
154 D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
155 D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
156 D(sccs, T_SCCS, EXTENSION, IN_I) /* 0 SVR4? */
158 /* #sccs is synonymous with #ident. */
159 #define do_sccs do_ident
161 /* Use the table to generate a series of prototypes, an enum for the
162 directive names, and an array of directive handlers. */
164 #define D(name, t, o, f) static void do_##name (cpp_reader *);
168 #define D(n, tag, o, f) tag,
176 #define D(name, t, origin, flags) \
177 { do_##name, (const uchar *) #name, \
178 sizeof #name - 1, origin, flags },
179 static const directive dtable
[] =
184 #undef DIRECTIVE_TABLE
186 /* Wrapper struct directive for linemarkers.
187 The origin is more or less true - the original K+R cpp
188 did use this notation in its preprocessed output. */
189 static const directive linemarker_dir
=
191 do_linemarker
, U
"#", 1, KANDR
, IN_I
194 #define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
196 /* Skip any remaining tokens in a directive. */
198 skip_rest_of_line (cpp_reader
*pfile
)
200 /* Discard all stacked contexts. */
201 while (pfile
->context
->prev
)
202 _cpp_pop_context (pfile
);
204 /* Sweep up all tokens remaining on the line. */
206 while (_cpp_lex_token (pfile
)->type
!= CPP_EOF
)
210 /* Ensure there are no stray tokens at the end of a directive. */
212 check_eol (cpp_reader
*pfile
)
214 if (! SEEN_EOL () && _cpp_lex_token (pfile
)->type
!= CPP_EOF
)
215 cpp_error (pfile
, CPP_DL_PEDWARN
, "extra tokens at end of #%s directive",
216 pfile
->directive
->name
);
219 /* Ensure there are no stray tokens other than comments at the end of
220 a directive, and gather the comments. */
221 static const cpp_token
**
222 check_eol_return_comments (cpp_reader
*pfile
)
226 const cpp_token
**buf
;
228 buf
= XNEWVEC (const cpp_token
*, capacity
);
234 const cpp_token
*tok
;
236 tok
= _cpp_lex_token (pfile
);
237 if (tok
->type
== CPP_EOF
)
239 if (tok
->type
!= CPP_COMMENT
)
240 cpp_error (pfile
, CPP_DL_PEDWARN
,
241 "extra tokens at end of #%s directive",
242 pfile
->directive
->name
);
245 if (c
+ 1 >= capacity
)
248 buf
= XRESIZEVEC (const cpp_token
*, buf
, capacity
);
259 /* Called when entering a directive, _Pragma or command-line directive. */
261 start_directive (cpp_reader
*pfile
)
263 /* Setup in-directive state. */
264 pfile
->state
.in_directive
= 1;
265 pfile
->state
.save_comments
= 0;
266 pfile
->directive_result
.type
= CPP_PADDING
;
268 /* Some handlers need the position of the # for diagnostics. */
269 pfile
->directive_line
= pfile
->line_table
->highest_line
;
272 /* Called when leaving a directive, _Pragma or command-line directive. */
274 end_directive (cpp_reader
*pfile
, int skip_line
)
276 if (pfile
->state
.in_deferred_pragma
)
278 else if (CPP_OPTION (pfile
, traditional
))
280 /* Revert change of prepare_directive_trad. */
281 pfile
->state
.prevent_expansion
--;
283 if (pfile
->directive
!= &dtable
[T_DEFINE
])
284 _cpp_remove_overlay (pfile
);
286 /* We don't skip for an assembler #. */
289 skip_rest_of_line (pfile
);
290 if (!pfile
->keep_tokens
)
292 pfile
->cur_run
= &pfile
->base_run
;
293 pfile
->cur_token
= pfile
->base_run
.base
;
298 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
299 pfile
->state
.in_directive
= 0;
300 pfile
->state
.in_expression
= 0;
301 pfile
->state
.angled_headers
= 0;
302 pfile
->directive
= 0;
305 /* Prepare to handle the directive in pfile->directive. */
307 prepare_directive_trad (cpp_reader
*pfile
)
309 if (pfile
->directive
!= &dtable
[T_DEFINE
])
311 bool no_expand
= (pfile
->directive
312 && ! (pfile
->directive
->flags
& EXPAND
));
313 bool was_skipping
= pfile
->state
.skipping
;
315 pfile
->state
.in_expression
= (pfile
->directive
== &dtable
[T_IF
]
316 || pfile
->directive
== &dtable
[T_ELIF
]);
317 if (pfile
->state
.in_expression
)
318 pfile
->state
.skipping
= false;
321 pfile
->state
.prevent_expansion
++;
322 _cpp_scan_out_logical_line (pfile
, NULL
);
324 pfile
->state
.prevent_expansion
--;
326 pfile
->state
.skipping
= was_skipping
;
327 _cpp_overlay_buffer (pfile
, pfile
->out
.base
,
328 pfile
->out
.cur
- pfile
->out
.base
);
331 /* Stop ISO C from expanding anything. */
332 pfile
->state
.prevent_expansion
++;
335 /* Output diagnostics for a directive DIR. INDENTED is nonzero if
336 the '#' was indented. */
338 directive_diagnostics (cpp_reader
*pfile
, const directive
*dir
, int indented
)
340 /* Issue -pedantic warnings for extensions. */
341 if (CPP_PEDANTIC (pfile
)
342 && ! pfile
->state
.skipping
343 && dir
->origin
== EXTENSION
)
344 cpp_error (pfile
, CPP_DL_PEDWARN
, "#%s is a GCC extension", dir
->name
);
346 /* Traditionally, a directive is ignored unless its # is in
347 column 1. Therefore in code intended to work with K+R
348 compilers, directives added by C89 must have their #
349 indented, and directives present in traditional C must not.
350 This is true even of directives in skipped conditional
351 blocks. #elif cannot be used at all. */
352 if (CPP_WTRADITIONAL (pfile
))
354 if (dir
== &dtable
[T_ELIF
])
355 cpp_error (pfile
, CPP_DL_WARNING
,
356 "suggest not using #elif in traditional C");
357 else if (indented
&& dir
->origin
== KANDR
)
358 cpp_error (pfile
, CPP_DL_WARNING
,
359 "traditional C ignores #%s with the # indented",
361 else if (!indented
&& dir
->origin
!= KANDR
)
362 cpp_error (pfile
, CPP_DL_WARNING
,
363 "suggest hiding #%s from traditional C with an indented #",
368 /* Check if we have a known directive. INDENTED is nonzero if the
369 '#' of the directive was indented. This function is in this file
370 to save unnecessarily exporting dtable etc. to lex.c. Returns
371 nonzero if the line of tokens has been handled, zero if we should
372 continue processing the line. */
374 _cpp_handle_directive (cpp_reader
*pfile
, int indented
)
376 const directive
*dir
= 0;
377 const cpp_token
*dname
;
378 bool was_parsing_args
= pfile
->state
.parsing_args
;
379 bool was_discarding_output
= pfile
->state
.discarding_output
;
382 if (was_discarding_output
)
383 pfile
->state
.prevent_expansion
= 0;
385 if (was_parsing_args
)
387 if (CPP_OPTION (pfile
, pedantic
))
388 cpp_error (pfile
, CPP_DL_PEDWARN
,
389 "embedding a directive within macro arguments is not portable");
390 pfile
->state
.parsing_args
= 0;
391 pfile
->state
.prevent_expansion
= 0;
393 start_directive (pfile
);
394 dname
= _cpp_lex_token (pfile
);
396 if (dname
->type
== CPP_NAME
)
398 if (dname
->val
.node
->is_directive
)
399 dir
= &dtable
[dname
->val
.node
->directive_index
];
401 /* We do not recognize the # followed by a number extension in
403 else if (dname
->type
== CPP_NUMBER
&& CPP_OPTION (pfile
, lang
) != CLK_ASM
)
405 dir
= &linemarker_dir
;
406 if (CPP_PEDANTIC (pfile
) && ! CPP_OPTION (pfile
, preprocessed
)
407 && ! pfile
->state
.skipping
)
408 cpp_error (pfile
, CPP_DL_PEDWARN
,
409 "style of line directive is a GCC extension");
414 /* If we have a directive that is not an opening conditional,
415 invalidate any control macro. */
416 if (! (dir
->flags
& IF_COND
))
417 pfile
->mi_valid
= false;
419 /* Kluge alert. In order to be sure that code like this
424 does not cause '#define foo bar' to get executed when
425 compiled with -save-temps, we recognize directives in
426 -fpreprocessed mode only if the # is in column 1. macro.c
427 puts a space in front of any '#' at the start of a macro.
429 We exclude the -fdirectives-only case because macro expansion
430 has not been performed yet, and block comments can cause spaces
431 to preceed the directive. */
432 if (CPP_OPTION (pfile
, preprocessed
)
433 && !CPP_OPTION (pfile
, directives_only
)
434 && (indented
|| !(dir
->flags
& IN_I
)))
441 /* In failed conditional groups, all non-conditional
442 directives are ignored. Before doing that, whether
443 skipping or not, we should lex angle-bracketed headers
444 correctly, and maybe output some diagnostics. */
445 pfile
->state
.angled_headers
= dir
->flags
& INCL
;
446 pfile
->state
.directive_wants_padding
= dir
->flags
& INCL
;
447 if (! CPP_OPTION (pfile
, preprocessed
))
448 directive_diagnostics (pfile
, dir
, indented
);
449 if (pfile
->state
.skipping
&& !(dir
->flags
& COND
))
453 else if (dname
->type
== CPP_EOF
)
454 ; /* CPP_EOF is the "null directive". */
457 /* An unknown directive. Don't complain about it in assembly
458 source: we don't know where the comments are, and # may
459 introduce assembler pseudo-ops. Don't complain about invalid
460 directives in skipped conditional groups (6.10 p4). */
461 if (CPP_OPTION (pfile
, lang
) == CLK_ASM
)
463 else if (!pfile
->state
.skipping
)
464 cpp_error (pfile
, CPP_DL_ERROR
, "invalid preprocessing directive #%s",
465 cpp_token_as_text (pfile
, dname
));
468 pfile
->directive
= dir
;
469 if (CPP_OPTION (pfile
, traditional
))
470 prepare_directive_trad (pfile
);
473 pfile
->directive
->handler (pfile
);
475 _cpp_backup_tokens (pfile
, 1);
477 end_directive (pfile
, skip
);
478 if (was_parsing_args
&& !pfile
->state
.in_deferred_pragma
)
480 /* Restore state when within macro args. */
481 pfile
->state
.parsing_args
= 2;
482 pfile
->state
.prevent_expansion
= 1;
484 if (was_discarding_output
)
485 pfile
->state
.prevent_expansion
= 1;
489 /* Directive handler wrapper used by the command line option
490 processor. BUF is \n terminated. */
492 run_directive (cpp_reader
*pfile
, int dir_no
, const char *buf
, size_t count
)
494 cpp_push_buffer (pfile
, (const uchar
*) buf
, count
,
495 /* from_stage3 */ true);
496 start_directive (pfile
);
498 /* This is a short-term fix to prevent a leading '#' being
499 interpreted as a directive. */
500 _cpp_clean_line (pfile
);
502 pfile
->directive
= &dtable
[dir_no
];
503 if (CPP_OPTION (pfile
, traditional
))
504 prepare_directive_trad (pfile
);
505 pfile
->directive
->handler (pfile
);
506 end_directive (pfile
, 1);
507 _cpp_pop_buffer (pfile
);
510 /* Checks for validity the macro name in #define, #undef, #ifdef and
511 #ifndef directives. IS_DEF_OR_UNDEF is true if this call is
512 processing a #define or #undefine directive, and false
514 static cpp_hashnode
*
515 lex_macro_node (cpp_reader
*pfile
, bool is_def_or_undef
)
517 const cpp_token
*token
= _cpp_lex_token (pfile
);
519 /* The token immediately after #define must be an identifier. That
520 identifier may not be "defined", per C99 6.10.8p4.
521 In C++, it may not be any of the "named operators" either,
522 per C++98 [lex.digraph], [lex.key].
523 Finally, the identifier may not have been poisoned. (In that case
524 the lexer has issued the error message for us.) */
526 if (token
->type
== CPP_NAME
)
528 cpp_hashnode
*node
= token
->val
.node
;
530 if (is_def_or_undef
&& node
== pfile
->spec_nodes
.n_defined
)
531 cpp_error (pfile
, CPP_DL_ERROR
,
532 "\"defined\" cannot be used as a macro name");
533 else if (! (node
->flags
& NODE_POISONED
))
536 else if (token
->flags
& NAMED_OP
)
537 cpp_error (pfile
, CPP_DL_ERROR
,
538 "\"%s\" cannot be used as a macro name as it is an operator in C++",
539 NODE_NAME (token
->val
.node
));
540 else if (token
->type
== CPP_EOF
)
541 cpp_error (pfile
, CPP_DL_ERROR
, "no macro name given in #%s directive",
542 pfile
->directive
->name
);
544 cpp_error (pfile
, CPP_DL_ERROR
, "macro names must be identifiers");
549 /* Process a #define directive. Most work is done in macro.c. */
551 do_define (cpp_reader
*pfile
)
553 cpp_hashnode
*node
= lex_macro_node (pfile
, true);
557 /* If we have been requested to expand comments into macros,
558 then re-enable saving of comments. */
559 pfile
->state
.save_comments
=
560 ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
);
562 if (pfile
->cb
.before_define
)
563 pfile
->cb
.before_define (pfile
);
565 if (_cpp_create_definition (pfile
, node
))
566 if (pfile
->cb
.define
)
567 pfile
->cb
.define (pfile
, pfile
->directive_line
, node
);
569 node
->flags
&= ~NODE_USED
;
573 /* Handle #undef. Mark the identifier NT_VOID in the hash table. */
575 do_undef (cpp_reader
*pfile
)
577 cpp_hashnode
*node
= lex_macro_node (pfile
, true);
581 if (pfile
->cb
.before_define
)
582 pfile
->cb
.before_define (pfile
);
585 pfile
->cb
.undef (pfile
, pfile
->directive_line
, node
);
587 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified
588 identifier is not currently defined as a macro name. */
589 if (node
->type
== NT_MACRO
)
591 if (node
->flags
& NODE_WARN
)
592 cpp_error (pfile
, CPP_DL_WARNING
,
593 "undefining \"%s\"", NODE_NAME (node
));
595 if (CPP_OPTION (pfile
, warn_unused_macros
))
596 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
598 _cpp_free_definition (node
);
605 /* Undefine a single macro/assertion/whatever. */
608 undefine_macros (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*h
,
609 void *data_p ATTRIBUTE_UNUSED
)
611 /* Body of _cpp_free_definition inlined here for speed.
612 Macros and assertions no longer have anything to free. */
614 h
->flags
&= ~(NODE_POISONED
|NODE_BUILTIN
|NODE_DISABLED
|NODE_USED
);
618 /* Undefine all macros and assertions. */
621 cpp_undef_all (cpp_reader
*pfile
)
623 cpp_forall_identifiers (pfile
, undefine_macros
, NULL
);
627 /* Helper routine used by parse_include. Reinterpret the current line
628 as an h-char-sequence (< ... >); we are looking at the first token
629 after the <. Returns a malloced filename. */
631 glue_header_name (cpp_reader
*pfile
)
633 const cpp_token
*token
;
635 size_t len
, total_len
= 0, capacity
= 1024;
637 /* To avoid lexed tokens overwriting our glued name, we can only
638 allocate from the string pool once we've lexed everything. */
639 buffer
= XNEWVEC (char, capacity
);
642 token
= get_token_no_padding (pfile
);
644 if (token
->type
== CPP_GREATER
)
646 if (token
->type
== CPP_EOF
)
648 cpp_error (pfile
, CPP_DL_ERROR
, "missing terminating > character");
652 len
= cpp_token_len (token
) + 2; /* Leading space, terminating \0. */
653 if (total_len
+ len
> capacity
)
655 capacity
= (capacity
+ len
) * 2;
656 buffer
= XRESIZEVEC (char, buffer
, capacity
);
659 if (token
->flags
& PREV_WHITE
)
660 buffer
[total_len
++] = ' ';
662 total_len
= (cpp_spell_token (pfile
, token
, (uchar
*) &buffer
[total_len
],
667 buffer
[total_len
] = '\0';
671 /* Returns the file name of #include, #include_next, #import and
672 #pragma dependency. The string is malloced and the caller should
673 free it. Returns NULL on error. */
675 parse_include (cpp_reader
*pfile
, int *pangle_brackets
,
676 const cpp_token
***buf
)
679 const cpp_token
*header
;
681 /* Allow macro expansion. */
682 header
= get_token_no_padding (pfile
);
683 if (header
->type
== CPP_STRING
|| header
->type
== CPP_HEADER_NAME
)
685 fname
= XNEWVEC (char, header
->val
.str
.len
- 1);
686 memcpy (fname
, header
->val
.str
.text
+ 1, header
->val
.str
.len
- 2);
687 fname
[header
->val
.str
.len
- 2] = '\0';
688 *pangle_brackets
= header
->type
== CPP_HEADER_NAME
;
690 else if (header
->type
== CPP_LESS
)
692 fname
= glue_header_name (pfile
);
693 *pangle_brackets
= 1;
697 const unsigned char *dir
;
699 if (pfile
->directive
== &dtable
[T_PRAGMA
])
700 dir
= U
"pragma dependency";
702 dir
= pfile
->directive
->name
;
703 cpp_error (pfile
, CPP_DL_ERROR
, "#%s expects \"FILENAME\" or <FILENAME>",
709 if (pfile
->directive
== &dtable
[T_PRAGMA
])
711 /* This pragma allows extra tokens after the file name. */
713 else if (buf
== NULL
|| CPP_OPTION (pfile
, discard_comments
))
717 /* If we are not discarding comments, then gather them while
718 doing the eol check. */
719 *buf
= check_eol_return_comments (pfile
);
725 /* Handle #include, #include_next and #import. */
727 do_include_common (cpp_reader
*pfile
, enum include_type type
)
731 const cpp_token
**buf
= NULL
;
733 /* Re-enable saving of comments if requested, so that the include
734 callback can dump comments which follow #include. */
735 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
737 fname
= parse_include (pfile
, &angle_brackets
, &buf
);
747 cpp_error (pfile
, CPP_DL_ERROR
, "empty filename in #%s",
748 pfile
->directive
->name
);
755 /* Prevent #include recursion. */
756 if (pfile
->line_table
->depth
>= CPP_STACK_MAX
)
757 cpp_error (pfile
, CPP_DL_ERROR
, "#include nested too deeply");
760 /* Get out of macro context, if we are. */
761 skip_rest_of_line (pfile
);
763 if (pfile
->cb
.include
)
764 pfile
->cb
.include (pfile
, pfile
->directive_line
,
765 pfile
->directive
->name
, fname
, angle_brackets
,
768 _cpp_stack_include (pfile
, fname
, angle_brackets
, type
);
777 do_include (cpp_reader
*pfile
)
779 do_include_common (pfile
, IT_INCLUDE
);
783 do_import (cpp_reader
*pfile
)
785 do_include_common (pfile
, IT_IMPORT
);
789 do_include_next (cpp_reader
*pfile
)
791 enum include_type type
= IT_INCLUDE_NEXT
;
793 /* If this is the primary source file, warn and use the normal
795 if (cpp_in_primary_file (pfile
))
797 cpp_error (pfile
, CPP_DL_WARNING
,
798 "#include_next in primary source file");
801 do_include_common (pfile
, type
);
804 /* Subroutine of do_linemarker. Read possible flags after file name.
805 LAST is the last flag seen; 0 if this is the first flag. Return the
806 flag if it is valid, 0 at the end of the directive. Otherwise
809 read_flag (cpp_reader
*pfile
, unsigned int last
)
811 const cpp_token
*token
= _cpp_lex_token (pfile
);
813 if (token
->type
== CPP_NUMBER
&& token
->val
.str
.len
== 1)
815 unsigned int flag
= token
->val
.str
.text
[0] - '0';
817 if (flag
> last
&& flag
<= 4
818 && (flag
!= 4 || last
== 3)
819 && (flag
!= 2 || last
== 0))
823 if (token
->type
!= CPP_EOF
)
824 cpp_error (pfile
, CPP_DL_ERROR
, "invalid flag \"%s\" in line directive",
825 cpp_token_as_text (pfile
, token
));
829 /* Subroutine of do_line and do_linemarker. Convert a number in STR,
830 of length LEN, to binary; store it in NUMP, and return 0 if the
831 number was well-formed, 1 if not. Temporary, hopefully. */
833 strtoul_for_line (const uchar
*str
, unsigned int len
, long unsigned int *nump
)
835 unsigned long reg
= 0;
849 /* Interpret #line command.
850 Note that the filename string (if any) is a true string constant
851 (escapes are interpreted), unlike in #line. */
853 do_line (cpp_reader
*pfile
)
855 const struct line_maps
*line_table
= pfile
->line_table
;
856 const struct line_map
*map
= &line_table
->maps
[line_table
->used
- 1];
858 /* skip_rest_of_line() may cause line table to be realloc()ed so note down
861 unsigned char map_sysp
= map
->sysp
;
862 const cpp_token
*token
;
863 const char *new_file
= map
->to_file
;
864 unsigned long new_lineno
;
866 /* C99 raised the minimum limit on #line numbers. */
867 unsigned int cap
= CPP_OPTION (pfile
, c99
) ? 2147483647 : 32767;
869 /* #line commands expand macros. */
870 token
= cpp_get_token (pfile
);
871 if (token
->type
!= CPP_NUMBER
872 || strtoul_for_line (token
->val
.str
.text
, token
->val
.str
.len
,
875 if (token
->type
== CPP_EOF
)
876 cpp_error (pfile
, CPP_DL_ERROR
, "unexpected end of file after #line");
878 cpp_error (pfile
, CPP_DL_ERROR
,
879 "\"%s\" after #line is not a positive integer",
880 cpp_token_as_text (pfile
, token
));
884 if (CPP_PEDANTIC (pfile
) && (new_lineno
== 0 || new_lineno
> cap
))
885 cpp_error (pfile
, CPP_DL_PEDWARN
, "line number out of range");
887 token
= cpp_get_token (pfile
);
888 if (token
->type
== CPP_STRING
)
890 cpp_string s
= { 0, 0 };
891 if (cpp_interpret_string_notranslate (pfile
, &token
->val
.str
, 1,
893 new_file
= (const char *)s
.text
;
896 else if (token
->type
!= CPP_EOF
)
898 cpp_error (pfile
, CPP_DL_ERROR
, "\"%s\" is not a valid filename",
899 cpp_token_as_text (pfile
, token
));
903 skip_rest_of_line (pfile
);
904 _cpp_do_file_change (pfile
, LC_RENAME
, new_file
, new_lineno
,
908 /* Interpret the # 44 "file" [flags] notation, which has slightly
909 different syntax and semantics from #line: Flags are allowed,
910 and we never complain about the line number being too big. */
912 do_linemarker (cpp_reader
*pfile
)
914 const struct line_maps
*line_table
= pfile
->line_table
;
915 const struct line_map
*map
= &line_table
->maps
[line_table
->used
- 1];
916 const cpp_token
*token
;
917 const char *new_file
= map
->to_file
;
918 unsigned long new_lineno
;
919 unsigned int new_sysp
= map
->sysp
;
920 enum lc_reason reason
= LC_RENAME
;
923 /* Back up so we can get the number again. Putting this in
924 _cpp_handle_directive risks two calls to _cpp_backup_tokens in
925 some circumstances, which can segfault. */
926 _cpp_backup_tokens (pfile
, 1);
928 /* #line commands expand macros. */
929 token
= cpp_get_token (pfile
);
930 if (token
->type
!= CPP_NUMBER
931 || strtoul_for_line (token
->val
.str
.text
, token
->val
.str
.len
,
934 /* Unlike #line, there does not seem to be a way to get an EOF
935 here. So, it should be safe to always spell the token. */
936 cpp_error (pfile
, CPP_DL_ERROR
,
937 "\"%s\" after # is not a positive integer",
938 cpp_token_as_text (pfile
, token
));
942 token
= cpp_get_token (pfile
);
943 if (token
->type
== CPP_STRING
)
945 cpp_string s
= { 0, 0 };
946 if (cpp_interpret_string_notranslate (pfile
, &token
->val
.str
,
948 new_file
= (const char *)s
.text
;
951 flag
= read_flag (pfile
, 0);
955 /* Fake an include for cpp_included (). */
956 _cpp_fake_include (pfile
, new_file
);
957 flag
= read_flag (pfile
, flag
);
962 flag
= read_flag (pfile
, flag
);
967 flag
= read_flag (pfile
, flag
);
971 pfile
->buffer
->sysp
= new_sysp
;
975 else if (token
->type
!= CPP_EOF
)
977 cpp_error (pfile
, CPP_DL_ERROR
, "\"%s\" is not a valid filename",
978 cpp_token_as_text (pfile
, token
));
982 skip_rest_of_line (pfile
);
983 _cpp_do_file_change (pfile
, reason
, new_file
, new_lineno
, new_sysp
);
986 /* Arrange the file_change callback. pfile->line has changed to
987 FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system
988 header, 2 for a system header that needs to be extern "C" protected,
989 and zero otherwise. */
991 _cpp_do_file_change (cpp_reader
*pfile
, enum lc_reason reason
,
992 const char *to_file
, unsigned int file_line
,
995 const struct line_map
*map
= linemap_add (pfile
->line_table
, reason
, sysp
,
998 linemap_line_start (pfile
->line_table
, map
->to_line
, 127);
1000 if (pfile
->cb
.file_change
)
1001 pfile
->cb
.file_change (pfile
, map
);
1004 /* Report a warning or error detected by the program we are
1005 processing. Use the directive's tokens in the error message. */
1007 do_diagnostic (cpp_reader
*pfile
, int code
, int print_dir
)
1009 if (_cpp_begin_message (pfile
, code
, pfile
->cur_token
[-1].src_loc
, 0))
1012 fprintf (stderr
, "#%s ", pfile
->directive
->name
);
1013 pfile
->state
.prevent_expansion
++;
1014 cpp_output_line (pfile
, stderr
);
1015 pfile
->state
.prevent_expansion
--;
1020 do_error (cpp_reader
*pfile
)
1022 do_diagnostic (pfile
, CPP_DL_ERROR
, 1);
1026 do_warning (cpp_reader
*pfile
)
1028 /* We want #warning diagnostics to be emitted in system headers too. */
1029 do_diagnostic (pfile
, CPP_DL_WARNING_SYSHDR
, 1);
1032 /* Report program identification. */
1034 do_ident (cpp_reader
*pfile
)
1036 const cpp_token
*str
= cpp_get_token (pfile
);
1038 if (str
->type
!= CPP_STRING
)
1039 cpp_error (pfile
, CPP_DL_ERROR
, "invalid #%s directive",
1040 pfile
->directive
->name
);
1041 else if (pfile
->cb
.ident
)
1042 pfile
->cb
.ident (pfile
, pfile
->directive_line
, &str
->val
.str
);
1047 /* Lookup a PRAGMA name in a singly-linked CHAIN. Returns the
1048 matching entry, or NULL if none is found. The returned entry could
1049 be the start of a namespace chain, or a pragma. */
1050 static struct pragma_entry
*
1051 lookup_pragma_entry (struct pragma_entry
*chain
, const cpp_hashnode
*pragma
)
1053 while (chain
&& chain
->pragma
!= pragma
)
1054 chain
= chain
->next
;
1059 /* Create and insert a blank pragma entry at the beginning of a
1060 singly-linked CHAIN. */
1061 static struct pragma_entry
*
1062 new_pragma_entry (cpp_reader
*pfile
, struct pragma_entry
**chain
)
1064 struct pragma_entry
*new_entry
;
1066 new_entry
= (struct pragma_entry
*)
1067 _cpp_aligned_alloc (pfile
, sizeof (struct pragma_entry
));
1069 memset (new_entry
, 0, sizeof (struct pragma_entry
));
1070 new_entry
->next
= *chain
;
1076 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
1077 goes in the global namespace. */
1078 static struct pragma_entry
*
1079 register_pragma_1 (cpp_reader
*pfile
, const char *space
, const char *name
,
1080 bool allow_name_expansion
)
1082 struct pragma_entry
**chain
= &pfile
->pragmas
;
1083 struct pragma_entry
*entry
;
1084 const cpp_hashnode
*node
;
1088 node
= cpp_lookup (pfile
, U space
, strlen (space
));
1089 entry
= lookup_pragma_entry (*chain
, node
);
1092 entry
= new_pragma_entry (pfile
, chain
);
1093 entry
->pragma
= node
;
1094 entry
->is_nspace
= true;
1095 entry
->allow_expansion
= allow_name_expansion
;
1097 else if (!entry
->is_nspace
)
1099 else if (entry
->allow_expansion
!= allow_name_expansion
)
1101 cpp_error (pfile
, CPP_DL_ICE
,
1102 "registering pragmas in namespace \"%s\" with mismatched "
1103 "name expansion", space
);
1106 chain
= &entry
->u
.space
;
1108 else if (allow_name_expansion
)
1110 cpp_error (pfile
, CPP_DL_ICE
,
1111 "registering pragma \"%s\" with name expansion "
1112 "and no namespace", name
);
1116 /* Check for duplicates. */
1117 node
= cpp_lookup (pfile
, U name
, strlen (name
));
1118 entry
= lookup_pragma_entry (*chain
, node
);
1121 entry
= new_pragma_entry (pfile
, chain
);
1122 entry
->pragma
= node
;
1126 if (entry
->is_nspace
)
1128 cpp_error (pfile
, CPP_DL_ICE
,
1129 "registering \"%s\" as both a pragma and a pragma namespace",
1132 cpp_error (pfile
, CPP_DL_ICE
, "#pragma %s %s is already registered",
1135 cpp_error (pfile
, CPP_DL_ICE
, "#pragma %s is already registered", name
);
1140 /* Register a cpplib internal pragma SPACE NAME with HANDLER. */
1142 register_pragma_internal (cpp_reader
*pfile
, const char *space
,
1143 const char *name
, pragma_cb handler
)
1145 struct pragma_entry
*entry
;
1147 entry
= register_pragma_1 (pfile
, space
, name
, false);
1148 entry
->is_internal
= true;
1149 entry
->u
.handler
= handler
;
1152 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
1153 goes in the global namespace. HANDLER is the handler it will call,
1154 which must be non-NULL. If ALLOW_EXPANSION is set, allow macro
1155 expansion while parsing pragma NAME. This function is exported
1158 cpp_register_pragma (cpp_reader
*pfile
, const char *space
, const char *name
,
1159 pragma_cb handler
, bool allow_expansion
)
1161 struct pragma_entry
*entry
;
1165 cpp_error (pfile
, CPP_DL_ICE
, "registering pragma with NULL handler");
1169 entry
= register_pragma_1 (pfile
, space
, name
, false);
1172 entry
->allow_expansion
= allow_expansion
;
1173 entry
->u
.handler
= handler
;
1177 /* Similarly, but create mark the pragma for deferred processing.
1178 When found, a CPP_PRAGMA token will be insertted into the stream
1179 with IDENT in the token->u.pragma slot. */
1181 cpp_register_deferred_pragma (cpp_reader
*pfile
, const char *space
,
1182 const char *name
, unsigned int ident
,
1183 bool allow_expansion
, bool allow_name_expansion
)
1185 struct pragma_entry
*entry
;
1187 entry
= register_pragma_1 (pfile
, space
, name
, allow_name_expansion
);
1190 entry
->is_deferred
= true;
1191 entry
->allow_expansion
= allow_expansion
;
1192 entry
->u
.ident
= ident
;
1196 /* Register the pragmas the preprocessor itself handles. */
1198 _cpp_init_internal_pragmas (cpp_reader
*pfile
)
1200 /* Pragmas in the global namespace. */
1201 register_pragma_internal (pfile
, 0, "once", do_pragma_once
);
1203 /* New GCC-specific pragmas should be put in the GCC namespace. */
1204 register_pragma_internal (pfile
, "GCC", "poison", do_pragma_poison
);
1205 register_pragma_internal (pfile
, "GCC", "system_header",
1206 do_pragma_system_header
);
1207 register_pragma_internal (pfile
, "GCC", "dependency", do_pragma_dependency
);
1210 /* Return the number of registered pragmas in PE. */
1213 count_registered_pragmas (struct pragma_entry
*pe
)
1216 for (; pe
!= NULL
; pe
= pe
->next
)
1219 ct
+= count_registered_pragmas (pe
->u
.space
);
1225 /* Save into SD the names of the registered pragmas referenced by PE,
1226 and return a pointer to the next free space in SD. */
1229 save_registered_pragmas (struct pragma_entry
*pe
, char **sd
)
1231 for (; pe
!= NULL
; pe
= pe
->next
)
1234 sd
= save_registered_pragmas (pe
->u
.space
, sd
);
1235 *sd
++ = (char *) xmemdup (HT_STR (&pe
->pragma
->ident
),
1236 HT_LEN (&pe
->pragma
->ident
),
1237 HT_LEN (&pe
->pragma
->ident
) + 1);
1242 /* Return a newly-allocated array which saves the names of the
1243 registered pragmas. */
1246 _cpp_save_pragma_names (cpp_reader
*pfile
)
1248 int ct
= count_registered_pragmas (pfile
->pragmas
);
1249 char **result
= XNEWVEC (char *, ct
);
1250 (void) save_registered_pragmas (pfile
->pragmas
, result
);
1254 /* Restore from SD the names of the registered pragmas referenced by PE,
1255 and return a pointer to the next unused name in SD. */
1258 restore_registered_pragmas (cpp_reader
*pfile
, struct pragma_entry
*pe
,
1261 for (; pe
!= NULL
; pe
= pe
->next
)
1264 sd
= restore_registered_pragmas (pfile
, pe
->u
.space
, sd
);
1265 pe
->pragma
= cpp_lookup (pfile
, U
*sd
, strlen (*sd
));
1272 /* Restore the names of the registered pragmas from SAVED. */
1275 _cpp_restore_pragma_names (cpp_reader
*pfile
, char **saved
)
1277 (void) restore_registered_pragmas (pfile
, pfile
->pragmas
, saved
);
1281 /* Pragmata handling. We handle some, and pass the rest on to the
1282 front end. C99 defines three pragmas and says that no macro
1283 expansion is to be performed on them; whether or not macro
1284 expansion happens for other pragmas is implementation defined.
1285 This implementation allows for a mix of both, since GCC did not
1286 traditionally macro expand its (few) pragmas, whereas OpenMP
1287 specifies that macro expansion should happen. */
1289 do_pragma (cpp_reader
*pfile
)
1291 const struct pragma_entry
*p
= NULL
;
1292 const cpp_token
*token
, *pragma_token
= pfile
->cur_token
;
1294 unsigned int count
= 1;
1296 pfile
->state
.prevent_expansion
++;
1298 token
= cpp_get_token (pfile
);
1300 if (token
->type
== CPP_NAME
)
1302 p
= lookup_pragma_entry (pfile
->pragmas
, token
->val
.node
);
1303 if (p
&& p
->is_nspace
)
1305 bool allow_name_expansion
= p
->allow_expansion
;
1306 if (allow_name_expansion
)
1307 pfile
->state
.prevent_expansion
--;
1308 token
= cpp_get_token (pfile
);
1309 if (token
->type
== CPP_NAME
)
1310 p
= lookup_pragma_entry (p
->u
.space
, token
->val
.node
);
1313 if (allow_name_expansion
)
1314 pfile
->state
.prevent_expansion
++;
1323 pfile
->directive_result
.src_loc
= pragma_token
->src_loc
;
1324 pfile
->directive_result
.type
= CPP_PRAGMA
;
1325 pfile
->directive_result
.flags
= pragma_token
->flags
;
1326 pfile
->directive_result
.val
.pragma
= p
->u
.ident
;
1327 pfile
->state
.in_deferred_pragma
= true;
1328 pfile
->state
.pragma_allow_expansion
= p
->allow_expansion
;
1329 if (!p
->allow_expansion
)
1330 pfile
->state
.prevent_expansion
++;
1334 /* Since the handler below doesn't get the line number, that
1335 it might need for diagnostics, make sure it has the right
1336 numbers in place. */
1337 if (pfile
->cb
.line_change
)
1338 (*pfile
->cb
.line_change
) (pfile
, pragma_token
, false);
1339 if (p
->allow_expansion
)
1340 pfile
->state
.prevent_expansion
--;
1341 (*p
->u
.handler
) (pfile
);
1342 if (p
->allow_expansion
)
1343 pfile
->state
.prevent_expansion
++;
1346 else if (pfile
->cb
.def_pragma
)
1348 if (count
== 1 || pfile
->context
->prev
== NULL
)
1349 _cpp_backup_tokens (pfile
, count
);
1352 /* Invalid name comes from macro expansion, _cpp_backup_tokens
1353 won't allow backing 2 tokens. */
1354 /* ??? The token buffer is leaked. Perhaps if def_pragma hook
1355 reads both tokens, we could perhaps free it, but if it doesn't,
1356 we don't know the exact lifespan. */
1357 cpp_token
*toks
= XNEWVEC (cpp_token
, 2);
1359 toks
[0].flags
|= NO_EXPAND
;
1361 toks
[1].flags
|= NO_EXPAND
;
1362 _cpp_push_token_context (pfile
, NULL
, toks
, 2);
1364 pfile
->cb
.def_pragma (pfile
, pfile
->directive_line
);
1367 pfile
->state
.prevent_expansion
--;
1370 /* Handle #pragma once. */
1372 do_pragma_once (cpp_reader
*pfile
)
1374 if (cpp_in_primary_file (pfile
))
1375 cpp_error (pfile
, CPP_DL_WARNING
, "#pragma once in main file");
1378 _cpp_mark_file_once_only (pfile
, pfile
->buffer
->file
);
1381 /* Handle #pragma GCC poison, to poison one or more identifiers so
1382 that the lexer produces a hard error for each subsequent usage. */
1384 do_pragma_poison (cpp_reader
*pfile
)
1386 const cpp_token
*tok
;
1389 pfile
->state
.poisoned_ok
= 1;
1392 tok
= _cpp_lex_token (pfile
);
1393 if (tok
->type
== CPP_EOF
)
1395 if (tok
->type
!= CPP_NAME
)
1397 cpp_error (pfile
, CPP_DL_ERROR
,
1398 "invalid #pragma GCC poison directive");
1403 if (hp
->flags
& NODE_POISONED
)
1406 if (hp
->type
== NT_MACRO
)
1407 cpp_error (pfile
, CPP_DL_WARNING
, "poisoning existing macro \"%s\"",
1409 _cpp_free_definition (hp
);
1410 hp
->flags
|= NODE_POISONED
| NODE_DIAGNOSTIC
;
1412 pfile
->state
.poisoned_ok
= 0;
1415 /* Mark the current header as a system header. This will suppress
1416 some categories of warnings (notably those from -pedantic). It is
1417 intended for use in system libraries that cannot be implemented in
1418 conforming C, but cannot be certain that their headers appear in a
1419 system include directory. To prevent abuse, it is rejected in the
1420 primary source file. */
1422 do_pragma_system_header (cpp_reader
*pfile
)
1424 if (cpp_in_primary_file (pfile
))
1425 cpp_error (pfile
, CPP_DL_WARNING
,
1426 "#pragma system_header ignored outside include file");
1430 skip_rest_of_line (pfile
);
1431 cpp_make_system_header (pfile
, 1, 0);
1435 /* Check the modified date of the current include file against a specified
1436 file. Issue a diagnostic, if the specified file is newer. We use this to
1437 determine if a fixed header should be refixed. */
1439 do_pragma_dependency (cpp_reader
*pfile
)
1442 int angle_brackets
, ordering
;
1444 fname
= parse_include (pfile
, &angle_brackets
, NULL
);
1448 ordering
= _cpp_compare_file_date (pfile
, fname
, angle_brackets
);
1450 cpp_error (pfile
, CPP_DL_WARNING
, "cannot find source file %s", fname
);
1451 else if (ordering
> 0)
1453 cpp_error (pfile
, CPP_DL_WARNING
,
1454 "current file is older than %s", fname
);
1455 if (cpp_get_token (pfile
)->type
!= CPP_EOF
)
1457 _cpp_backup_tokens (pfile
, 1);
1458 do_diagnostic (pfile
, CPP_DL_WARNING
, 0);
1462 free ((void *) fname
);
1465 /* Get a token but skip padding. */
1466 static const cpp_token
*
1467 get_token_no_padding (cpp_reader
*pfile
)
1471 const cpp_token
*result
= cpp_get_token (pfile
);
1472 if (result
->type
!= CPP_PADDING
)
1477 /* Check syntax is "(string-literal)". Returns the string on success,
1478 or NULL on failure. */
1479 static const cpp_token
*
1480 get__Pragma_string (cpp_reader
*pfile
)
1482 const cpp_token
*string
;
1483 const cpp_token
*paren
;
1485 paren
= get_token_no_padding (pfile
);
1486 if (paren
->type
== CPP_EOF
)
1487 _cpp_backup_tokens (pfile
, 1);
1488 if (paren
->type
!= CPP_OPEN_PAREN
)
1491 string
= get_token_no_padding (pfile
);
1492 if (string
->type
== CPP_EOF
)
1493 _cpp_backup_tokens (pfile
, 1);
1494 if (string
->type
!= CPP_STRING
&& string
->type
!= CPP_WSTRING
)
1497 paren
= get_token_no_padding (pfile
);
1498 if (paren
->type
== CPP_EOF
)
1499 _cpp_backup_tokens (pfile
, 1);
1500 if (paren
->type
!= CPP_CLOSE_PAREN
)
1506 /* Destringize IN into a temporary buffer, by removing the first \ of
1507 \" and \\ sequences, and process the result as a #pragma directive. */
1509 destringize_and_run (cpp_reader
*pfile
, const cpp_string
*in
)
1511 const unsigned char *src
, *limit
;
1512 char *dest
, *result
;
1513 cpp_context
*saved_context
;
1514 cpp_token
*saved_cur_token
;
1515 tokenrun
*saved_cur_run
;
1518 const struct directive
*save_directive
;
1520 dest
= result
= (char *) alloca (in
->len
- 1);
1521 src
= in
->text
+ 1 + (in
->text
[0] == 'L');
1522 limit
= in
->text
+ in
->len
- 1;
1525 /* We know there is a character following the backslash. */
1526 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1532 /* Ugh; an awful kludge. We are really not set up to be lexing
1533 tokens when in the middle of a macro expansion. Use a new
1534 context to force cpp_get_token to lex, and so skip_rest_of_line
1535 doesn't go beyond the end of the text. Also, remember the
1536 current lexing position so we can return to it later.
1538 Something like line-at-a-time lexing should remove the need for
1540 saved_context
= pfile
->context
;
1541 saved_cur_token
= pfile
->cur_token
;
1542 saved_cur_run
= pfile
->cur_run
;
1544 pfile
->context
= XNEW (cpp_context
);
1545 pfile
->context
->macro
= 0;
1546 pfile
->context
->prev
= 0;
1547 pfile
->context
->next
= 0;
1549 /* Inline run_directive, since we need to delay the _cpp_pop_buffer
1550 until we've read all of the tokens that we want. */
1551 cpp_push_buffer (pfile
, (const uchar
*) result
, dest
- result
,
1552 /* from_stage3 */ true);
1553 /* ??? Antique Disgusting Hack. What does this do? */
1554 if (pfile
->buffer
->prev
)
1555 pfile
->buffer
->file
= pfile
->buffer
->prev
->file
;
1557 start_directive (pfile
);
1558 _cpp_clean_line (pfile
);
1559 save_directive
= pfile
->directive
;
1560 pfile
->directive
= &dtable
[T_PRAGMA
];
1562 end_directive (pfile
, 1);
1563 pfile
->directive
= save_directive
;
1565 /* We always insert at least one token, the directive result. It'll
1566 either be a CPP_PADDING or a CPP_PRAGMA. In the later case, we
1567 need to insert *all* of the tokens, including the CPP_PRAGMA_EOL. */
1569 /* If we're not handling the pragma internally, read all of the tokens from
1570 the string buffer now, while the string buffer is still installed. */
1571 /* ??? Note that the token buffer allocated here is leaked. It's not clear
1572 to me what the true lifespan of the tokens are. It would appear that
1573 the lifespan is the entire parse of the main input stream, in which case
1574 this may not be wrong. */
1575 if (pfile
->directive_result
.type
== CPP_PRAGMA
)
1581 toks
= XNEWVEC (cpp_token
, maxcount
);
1582 toks
[0] = pfile
->directive_result
;
1586 if (count
== maxcount
)
1588 maxcount
= maxcount
* 3 / 2;
1589 toks
= XRESIZEVEC (cpp_token
, toks
, maxcount
);
1591 toks
[count
] = *cpp_get_token (pfile
);
1592 /* Macros have been already expanded by cpp_get_token
1593 if the pragma allowed expansion. */
1594 toks
[count
++].flags
|= NO_EXPAND
;
1596 while (toks
[count
-1].type
!= CPP_PRAGMA_EOL
);
1601 toks
= XNEW (cpp_token
);
1602 toks
[0] = pfile
->directive_result
;
1604 /* If we handled the entire pragma internally, make sure we get the
1605 line number correct for the next token. */
1606 if (pfile
->cb
.line_change
)
1607 pfile
->cb
.line_change (pfile
, pfile
->cur_token
, false);
1610 /* Finish inlining run_directive. */
1611 pfile
->buffer
->file
= NULL
;
1612 _cpp_pop_buffer (pfile
);
1614 /* Reset the old macro state before ... */
1615 XDELETE (pfile
->context
);
1616 pfile
->context
= saved_context
;
1617 pfile
->cur_token
= saved_cur_token
;
1618 pfile
->cur_run
= saved_cur_run
;
1620 /* ... inserting the new tokens we collected. */
1621 _cpp_push_token_context (pfile
, NULL
, toks
, count
);
1624 /* Handle the _Pragma operator. Return 0 on error, 1 if ok. */
1626 _cpp_do__Pragma (cpp_reader
*pfile
)
1628 const cpp_token
*string
= get__Pragma_string (pfile
);
1629 pfile
->directive_result
.type
= CPP_PADDING
;
1633 destringize_and_run (pfile
, &string
->val
.str
);
1636 cpp_error (pfile
, CPP_DL_ERROR
,
1637 "_Pragma takes a parenthesized string literal");
1641 /* Handle #ifdef. */
1643 do_ifdef (cpp_reader
*pfile
)
1647 if (! pfile
->state
.skipping
)
1649 cpp_hashnode
*node
= lex_macro_node (pfile
, false);
1653 skip
= node
->type
!= NT_MACRO
;
1654 _cpp_mark_macro_used (node
);
1655 if (!(node
->flags
& NODE_USED
))
1657 node
->flags
|= NODE_USED
;
1658 if (node
->type
== NT_MACRO
)
1660 if (pfile
->cb
.used_define
)
1661 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
1665 if (pfile
->cb
.used_undef
)
1666 pfile
->cb
.used_undef (pfile
, pfile
->directive_line
, node
);
1673 push_conditional (pfile
, skip
, T_IFDEF
, 0);
1676 /* Handle #ifndef. */
1678 do_ifndef (cpp_reader
*pfile
)
1681 cpp_hashnode
*node
= 0;
1683 if (! pfile
->state
.skipping
)
1685 node
= lex_macro_node (pfile
, false);
1689 skip
= node
->type
== NT_MACRO
;
1690 _cpp_mark_macro_used (node
);
1691 if (!(node
->flags
& NODE_USED
))
1693 node
->flags
|= NODE_USED
;
1694 if (node
->type
== NT_MACRO
)
1696 if (pfile
->cb
.used_define
)
1697 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
1701 if (pfile
->cb
.used_undef
)
1702 pfile
->cb
.used_undef (pfile
, pfile
->directive_line
, node
);
1709 push_conditional (pfile
, skip
, T_IFNDEF
, node
);
1712 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1713 pfile->mi_ind_cmacro so we can handle multiple-include
1714 optimizations. If macro expansion occurs in the expression, we
1715 cannot treat it as a controlling conditional, since the expansion
1716 could change in the future. That is handled by cpp_get_token. */
1718 do_if (cpp_reader
*pfile
)
1722 if (! pfile
->state
.skipping
)
1723 skip
= _cpp_parse_expr (pfile
) == false;
1725 push_conditional (pfile
, skip
, T_IF
, pfile
->mi_ind_cmacro
);
1728 /* Flip skipping state if appropriate and continue without changing
1729 if_stack; this is so that the error message for missing #endif's
1730 etc. will point to the original #if. */
1732 do_else (cpp_reader
*pfile
)
1734 cpp_buffer
*buffer
= pfile
->buffer
;
1735 struct if_stack
*ifs
= buffer
->if_stack
;
1738 cpp_error (pfile
, CPP_DL_ERROR
, "#else without #if");
1741 if (ifs
->type
== T_ELSE
)
1743 cpp_error (pfile
, CPP_DL_ERROR
, "#else after #else");
1744 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
1745 "the conditional began here");
1749 /* Skip any future (erroneous) #elses or #elifs. */
1750 pfile
->state
.skipping
= ifs
->skip_elses
;
1751 ifs
->skip_elses
= true;
1753 /* Invalidate any controlling macro. */
1756 /* Only check EOL if was not originally skipping. */
1757 if (!ifs
->was_skipping
&& CPP_OPTION (pfile
, warn_endif_labels
))
1762 /* Handle a #elif directive by not changing if_stack either. See the
1763 comment above do_else. */
1765 do_elif (cpp_reader
*pfile
)
1767 cpp_buffer
*buffer
= pfile
->buffer
;
1768 struct if_stack
*ifs
= buffer
->if_stack
;
1771 cpp_error (pfile
, CPP_DL_ERROR
, "#elif without #if");
1774 if (ifs
->type
== T_ELSE
)
1776 cpp_error (pfile
, CPP_DL_ERROR
, "#elif after #else");
1777 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
1778 "the conditional began here");
1782 /* Only evaluate this if we aren't skipping elses. During
1783 evaluation, set skipping to false to get lexer warnings. */
1784 if (ifs
->skip_elses
)
1785 pfile
->state
.skipping
= 1;
1788 pfile
->state
.skipping
= 0;
1789 pfile
->state
.skipping
= ! _cpp_parse_expr (pfile
);
1790 ifs
->skip_elses
= ! pfile
->state
.skipping
;
1793 /* Invalidate any controlling macro. */
1798 /* #endif pops the if stack and resets pfile->state.skipping. */
1800 do_endif (cpp_reader
*pfile
)
1802 cpp_buffer
*buffer
= pfile
->buffer
;
1803 struct if_stack
*ifs
= buffer
->if_stack
;
1806 cpp_error (pfile
, CPP_DL_ERROR
, "#endif without #if");
1809 /* Only check EOL if was not originally skipping. */
1810 if (!ifs
->was_skipping
&& CPP_OPTION (pfile
, warn_endif_labels
))
1813 /* If potential control macro, we go back outside again. */
1814 if (ifs
->next
== 0 && ifs
->mi_cmacro
)
1816 pfile
->mi_valid
= true;
1817 pfile
->mi_cmacro
= ifs
->mi_cmacro
;
1820 buffer
->if_stack
= ifs
->next
;
1821 pfile
->state
.skipping
= ifs
->was_skipping
;
1822 obstack_free (&pfile
->buffer_ob
, ifs
);
1826 /* Push an if_stack entry for a preprocessor conditional, and set
1827 pfile->state.skipping to SKIP. If TYPE indicates the conditional
1828 is #if or #ifndef, CMACRO is a potentially controlling macro, and
1829 we need to check here that we are at the top of the file. */
1831 push_conditional (cpp_reader
*pfile
, int skip
, int type
,
1832 const cpp_hashnode
*cmacro
)
1834 struct if_stack
*ifs
;
1835 cpp_buffer
*buffer
= pfile
->buffer
;
1837 ifs
= XOBNEW (&pfile
->buffer_ob
, struct if_stack
);
1838 ifs
->line
= pfile
->directive_line
;
1839 ifs
->next
= buffer
->if_stack
;
1840 ifs
->skip_elses
= pfile
->state
.skipping
|| !skip
;
1841 ifs
->was_skipping
= pfile
->state
.skipping
;
1843 /* This condition is effectively a test for top-of-file. */
1844 if (pfile
->mi_valid
&& pfile
->mi_cmacro
== 0)
1845 ifs
->mi_cmacro
= cmacro
;
1849 pfile
->state
.skipping
= skip
;
1850 buffer
->if_stack
= ifs
;
1853 /* Read the tokens of the answer into the macro pool, in a directive
1854 of type TYPE. Only commit the memory if we intend it as permanent
1855 storage, i.e. the #assert case. Returns 0 on success, and sets
1856 ANSWERP to point to the answer. */
1858 parse_answer (cpp_reader
*pfile
, struct answer
**answerp
, int type
)
1860 const cpp_token
*paren
;
1861 struct answer
*answer
;
1862 unsigned int acount
;
1864 /* In a conditional, it is legal to not have an open paren. We
1865 should save the following token in this case. */
1866 paren
= cpp_get_token (pfile
);
1868 /* If not a paren, see if we're OK. */
1869 if (paren
->type
!= CPP_OPEN_PAREN
)
1871 /* In a conditional no answer is a test for any answer. It
1872 could be followed by any token. */
1875 _cpp_backup_tokens (pfile
, 1);
1879 /* #unassert with no answer is valid - it removes all answers. */
1880 if (type
== T_UNASSERT
&& paren
->type
== CPP_EOF
)
1883 cpp_error (pfile
, CPP_DL_ERROR
, "missing '(' after predicate");
1887 for (acount
= 0;; acount
++)
1890 const cpp_token
*token
= cpp_get_token (pfile
);
1893 if (token
->type
== CPP_CLOSE_PAREN
)
1896 if (token
->type
== CPP_EOF
)
1898 cpp_error (pfile
, CPP_DL_ERROR
, "missing ')' to complete answer");
1902 /* struct answer includes the space for one token. */
1903 room_needed
= (sizeof (struct answer
) + acount
* sizeof (cpp_token
));
1905 if (BUFF_ROOM (pfile
->a_buff
) < room_needed
)
1906 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (struct answer
));
1908 dest
= &((struct answer
*) BUFF_FRONT (pfile
->a_buff
))->first
[acount
];
1911 /* Drop whitespace at start, for answer equivalence purposes. */
1913 dest
->flags
&= ~PREV_WHITE
;
1918 cpp_error (pfile
, CPP_DL_ERROR
, "predicate's answer is empty");
1922 answer
= (struct answer
*) BUFF_FRONT (pfile
->a_buff
);
1923 answer
->count
= acount
;
1924 answer
->next
= NULL
;
1930 /* Parses an assertion directive of type TYPE, returning a pointer to
1931 the hash node of the predicate, or 0 on error. If an answer was
1932 supplied, it is placed in ANSWERP, otherwise it is set to 0. */
1933 static cpp_hashnode
*
1934 parse_assertion (cpp_reader
*pfile
, struct answer
**answerp
, int type
)
1936 cpp_hashnode
*result
= 0;
1937 const cpp_token
*predicate
;
1939 /* We don't expand predicates or answers. */
1940 pfile
->state
.prevent_expansion
++;
1943 predicate
= cpp_get_token (pfile
);
1944 if (predicate
->type
== CPP_EOF
)
1945 cpp_error (pfile
, CPP_DL_ERROR
, "assertion without predicate");
1946 else if (predicate
->type
!= CPP_NAME
)
1947 cpp_error (pfile
, CPP_DL_ERROR
, "predicate must be an identifier");
1948 else if (parse_answer (pfile
, answerp
, type
) == 0)
1950 unsigned int len
= NODE_LEN (predicate
->val
.node
);
1951 unsigned char *sym
= (unsigned char *) alloca (len
+ 1);
1953 /* Prefix '#' to get it out of macro namespace. */
1955 memcpy (sym
+ 1, NODE_NAME (predicate
->val
.node
), len
);
1956 result
= cpp_lookup (pfile
, sym
, len
+ 1);
1959 pfile
->state
.prevent_expansion
--;
1963 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
1964 or a pointer to NULL if the answer is not in the chain. */
1965 static struct answer
**
1966 find_answer (cpp_hashnode
*node
, const struct answer
*candidate
)
1969 struct answer
**result
;
1971 for (result
= &node
->value
.answers
; *result
; result
= &(*result
)->next
)
1973 struct answer
*answer
= *result
;
1975 if (answer
->count
== candidate
->count
)
1977 for (i
= 0; i
< answer
->count
; i
++)
1978 if (! _cpp_equiv_tokens (&answer
->first
[i
], &candidate
->first
[i
]))
1981 if (i
== answer
->count
)
1989 /* Test an assertion within a preprocessor conditional. Returns
1990 nonzero on failure, zero on success. On success, the result of
1991 the test is written into VALUE, otherwise the value 0. */
1993 _cpp_test_assertion (cpp_reader
*pfile
, unsigned int *value
)
1995 struct answer
*answer
;
1998 node
= parse_assertion (pfile
, &answer
, T_IF
);
2000 /* For recovery, an erroneous assertion expression is handled as a
2001 failing assertion. */
2005 *value
= (node
->type
== NT_ASSERTION
&&
2006 (answer
== 0 || *find_answer (node
, answer
) != 0));
2007 else if (pfile
->cur_token
[-1].type
== CPP_EOF
)
2008 _cpp_backup_tokens (pfile
, 1);
2010 /* We don't commit the memory for the answer - it's temporary only. */
2014 /* Handle #assert. */
2016 do_assert (cpp_reader
*pfile
)
2018 struct answer
*new_answer
;
2021 node
= parse_assertion (pfile
, &new_answer
, T_ASSERT
);
2026 /* Place the new answer in the answer list. First check there
2027 is not a duplicate. */
2028 new_answer
->next
= 0;
2029 if (node
->type
== NT_ASSERTION
)
2031 if (*find_answer (node
, new_answer
))
2033 cpp_error (pfile
, CPP_DL_WARNING
, "\"%s\" re-asserted",
2034 NODE_NAME (node
) + 1);
2037 new_answer
->next
= node
->value
.answers
;
2040 answer_size
= sizeof (struct answer
) + ((new_answer
->count
- 1)
2041 * sizeof (cpp_token
));
2042 /* Commit or allocate storage for the object. */
2043 if (pfile
->hash_table
->alloc_subobject
)
2045 struct answer
*temp_answer
= new_answer
;
2046 new_answer
= (struct answer
*) pfile
->hash_table
->alloc_subobject
2048 memcpy (new_answer
, temp_answer
, answer_size
);
2051 BUFF_FRONT (pfile
->a_buff
) += answer_size
;
2053 node
->type
= NT_ASSERTION
;
2054 node
->value
.answers
= new_answer
;
2059 /* Handle #unassert. */
2061 do_unassert (cpp_reader
*pfile
)
2064 struct answer
*answer
;
2066 node
= parse_assertion (pfile
, &answer
, T_UNASSERT
);
2067 /* It isn't an error to #unassert something that isn't asserted. */
2068 if (node
&& node
->type
== NT_ASSERTION
)
2072 struct answer
**p
= find_answer (node
, answer
), *temp
;
2074 /* Remove the answer from the list. */
2079 /* Did we free the last answer? */
2080 if (node
->value
.answers
== 0)
2081 node
->type
= NT_VOID
;
2086 _cpp_free_definition (node
);
2089 /* We don't commit the memory for the answer - it's temporary only. */
2092 /* These are for -D, -U, -A. */
2094 /* Process the string STR as if it appeared as the body of a #define.
2095 If STR is just an identifier, define it with value 1.
2096 If STR has anything after the identifier, then it should
2097 be identifier=definition. */
2099 cpp_define (cpp_reader
*pfile
, const char *str
)
2104 /* Copy the entire option so we can modify it.
2105 Change the first "=" in the string to a space. If there is none,
2106 tack " 1" on the end. */
2108 count
= strlen (str
);
2109 buf
= (char *) alloca (count
+ 3);
2110 memcpy (buf
, str
, count
);
2112 p
= strchr (str
, '=');
2122 run_directive (pfile
, T_DEFINE
, buf
, count
);
2125 /* Slight variant of the above for use by initialize_builtins. */
2127 _cpp_define_builtin (cpp_reader
*pfile
, const char *str
)
2129 size_t len
= strlen (str
);
2130 char *buf
= (char *) alloca (len
+ 1);
2131 memcpy (buf
, str
, len
);
2133 run_directive (pfile
, T_DEFINE
, buf
, len
);
2136 /* Process MACRO as if it appeared as the body of an #undef. */
2138 cpp_undef (cpp_reader
*pfile
, const char *macro
)
2140 size_t len
= strlen (macro
);
2141 char *buf
= (char *) alloca (len
+ 1);
2142 memcpy (buf
, macro
, len
);
2144 run_directive (pfile
, T_UNDEF
, buf
, len
);
2147 /* Like lex_macro_node, but read the input from STR. */
2148 static cpp_hashnode
*
2149 lex_macro_node_from_str (cpp_reader
*pfile
, const char *str
)
2151 size_t len
= strlen (str
);
2152 uchar
*buf
= (uchar
*) alloca (len
+ 1);
2155 memcpy (buf
, str
, len
);
2157 cpp_push_buffer (pfile
, buf
, len
, true);
2158 node
= lex_macro_node (pfile
, true);
2159 _cpp_pop_buffer (pfile
);
2164 /* If STR is a defined macro, return its definition node, else return NULL. */
2166 cpp_push_definition (cpp_reader
*pfile
, const char *str
)
2168 cpp_hashnode
*node
= lex_macro_node_from_str (pfile
, str
);
2169 if (node
&& node
->type
== NT_MACRO
)
2170 return node
->value
.macro
;
2175 /* Replace a previous definition DFN of the macro STR. If DFN is NULL,
2176 then the macro should be undefined. */
2178 cpp_pop_definition (cpp_reader
*pfile
, const char *str
, cpp_macro
*dfn
)
2180 cpp_hashnode
*node
= lex_macro_node_from_str (pfile
, str
);
2184 if (pfile
->cb
.before_define
)
2185 pfile
->cb
.before_define (pfile
);
2187 if (node
->type
== NT_MACRO
)
2189 if (pfile
->cb
.undef
)
2190 pfile
->cb
.undef (pfile
, pfile
->directive_line
, node
);
2191 if (CPP_OPTION (pfile
, warn_unused_macros
))
2192 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
2194 if (node
->type
!= NT_VOID
)
2195 _cpp_free_definition (node
);
2199 node
->type
= NT_MACRO
;
2200 node
->value
.macro
= dfn
;
2201 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_")))
2202 node
->flags
|= NODE_WARN
;
2204 if (pfile
->cb
.define
)
2205 pfile
->cb
.define (pfile
, pfile
->directive_line
, node
);
2209 /* Process the string STR as if it appeared as the body of a #assert. */
2211 cpp_assert (cpp_reader
*pfile
, const char *str
)
2213 handle_assertion (pfile
, str
, T_ASSERT
);
2216 /* Process STR as if it appeared as the body of an #unassert. */
2218 cpp_unassert (cpp_reader
*pfile
, const char *str
)
2220 handle_assertion (pfile
, str
, T_UNASSERT
);
2223 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
2225 handle_assertion (cpp_reader
*pfile
, const char *str
, int type
)
2227 size_t count
= strlen (str
);
2228 const char *p
= strchr (str
, '=');
2230 /* Copy the entire option so we can modify it. Change the first
2231 "=" in the string to a '(', and tack a ')' on the end. */
2232 char *buf
= (char *) alloca (count
+ 2);
2234 memcpy (buf
, str
, count
);
2243 run_directive (pfile
, type
, str
, count
);
2246 /* The number of errors for a given reader. */
2248 cpp_errors (cpp_reader
*pfile
)
2250 return pfile
->errors
;
2253 /* The options structure. */
2255 cpp_get_options (cpp_reader
*pfile
)
2257 return &pfile
->opts
;
2260 /* The callbacks structure. */
2262 cpp_get_callbacks (cpp_reader
*pfile
)
2267 /* Copy the given callbacks structure to our own. */
2269 cpp_set_callbacks (cpp_reader
*pfile
, cpp_callbacks
*cb
)
2274 /* The dependencies structure. (Creates one if it hasn't already been.) */
2276 cpp_get_deps (cpp_reader
*pfile
)
2279 pfile
->deps
= deps_init ();
2283 /* Push a new buffer on the buffer stack. Returns the new buffer; it
2284 doesn't fail. It does not generate a file change call back; that
2285 is the responsibility of the caller. */
2287 cpp_push_buffer (cpp_reader
*pfile
, const uchar
*buffer
, size_t len
,
2290 cpp_buffer
*new_buffer
= XOBNEW (&pfile
->buffer_ob
, cpp_buffer
);
2292 /* Clears, amongst other things, if_stack and mi_cmacro. */
2293 memset (new_buffer
, 0, sizeof (cpp_buffer
));
2295 new_buffer
->next_line
= new_buffer
->buf
= buffer
;
2296 new_buffer
->rlimit
= buffer
+ len
;
2297 new_buffer
->from_stage3
= from_stage3
;
2298 new_buffer
->prev
= pfile
->buffer
;
2299 new_buffer
->need_line
= true;
2301 pfile
->buffer
= new_buffer
;
2306 /* Pops a single buffer, with a file change call-back if appropriate.
2307 Then pushes the next -include file, if any remain. */
2309 _cpp_pop_buffer (cpp_reader
*pfile
)
2311 cpp_buffer
*buffer
= pfile
->buffer
;
2312 struct _cpp_file
*inc
= buffer
->file
;
2313 struct if_stack
*ifs
;
2315 /* Walk back up the conditional stack till we reach its level at
2316 entry to this file, issuing error messages. */
2317 for (ifs
= buffer
->if_stack
; ifs
; ifs
= ifs
->next
)
2318 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
2319 "unterminated #%s", dtable
[ifs
->type
].name
);
2321 /* In case of a missing #endif. */
2322 pfile
->state
.skipping
= 0;
2324 /* _cpp_do_file_change expects pfile->buffer to be the new one. */
2325 pfile
->buffer
= buffer
->prev
;
2327 free (buffer
->notes
);
2329 /* Free the buffer object now; we may want to push a new buffer
2330 in _cpp_push_next_include_file. */
2331 obstack_free (&pfile
->buffer_ob
, buffer
);
2335 _cpp_pop_file_buffer (pfile
, inc
);
2337 _cpp_do_file_change (pfile
, LC_LEAVE
, 0, 0, 0);
2341 /* Enter all recognized directives in the hash table. */
2343 _cpp_init_directives (cpp_reader
*pfile
)
2348 for (i
= 0; i
< (unsigned int) N_DIRECTIVES
; i
++)
2350 node
= cpp_lookup (pfile
, dtable
[i
].name
, dtable
[i
].length
);
2351 node
->is_directive
= 1;
2352 node
->directive_index
= i
;