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
, UC
"#", 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
= UC
"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
, UC 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
, UC 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
, UC
*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
1495 && string
->type
!= CPP_STRING32
&& string
->type
!= CPP_STRING16
)
1498 paren
= get_token_no_padding (pfile
);
1499 if (paren
->type
== CPP_EOF
)
1500 _cpp_backup_tokens (pfile
, 1);
1501 if (paren
->type
!= CPP_CLOSE_PAREN
)
1507 /* Destringize IN into a temporary buffer, by removing the first \ of
1508 \" and \\ sequences, and process the result as a #pragma directive. */
1510 destringize_and_run (cpp_reader
*pfile
, const cpp_string
*in
)
1512 const unsigned char *src
, *limit
;
1513 char *dest
, *result
;
1514 cpp_context
*saved_context
;
1515 cpp_token
*saved_cur_token
;
1516 tokenrun
*saved_cur_run
;
1519 const struct directive
*save_directive
;
1521 dest
= result
= (char *) alloca (in
->len
- 1);
1522 src
= in
->text
+ 1 + (in
->text
[0] == 'L');
1523 limit
= in
->text
+ in
->len
- 1;
1526 /* We know there is a character following the backslash. */
1527 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1533 /* Ugh; an awful kludge. We are really not set up to be lexing
1534 tokens when in the middle of a macro expansion. Use a new
1535 context to force cpp_get_token to lex, and so skip_rest_of_line
1536 doesn't go beyond the end of the text. Also, remember the
1537 current lexing position so we can return to it later.
1539 Something like line-at-a-time lexing should remove the need for
1541 saved_context
= pfile
->context
;
1542 saved_cur_token
= pfile
->cur_token
;
1543 saved_cur_run
= pfile
->cur_run
;
1545 pfile
->context
= XNEW (cpp_context
);
1546 pfile
->context
->macro
= 0;
1547 pfile
->context
->prev
= 0;
1548 pfile
->context
->next
= 0;
1550 /* Inline run_directive, since we need to delay the _cpp_pop_buffer
1551 until we've read all of the tokens that we want. */
1552 cpp_push_buffer (pfile
, (const uchar
*) result
, dest
- result
,
1553 /* from_stage3 */ true);
1554 /* ??? Antique Disgusting Hack. What does this do? */
1555 if (pfile
->buffer
->prev
)
1556 pfile
->buffer
->file
= pfile
->buffer
->prev
->file
;
1558 start_directive (pfile
);
1559 _cpp_clean_line (pfile
);
1560 save_directive
= pfile
->directive
;
1561 pfile
->directive
= &dtable
[T_PRAGMA
];
1563 end_directive (pfile
, 1);
1564 pfile
->directive
= save_directive
;
1566 /* We always insert at least one token, the directive result. It'll
1567 either be a CPP_PADDING or a CPP_PRAGMA. In the later case, we
1568 need to insert *all* of the tokens, including the CPP_PRAGMA_EOL. */
1570 /* If we're not handling the pragma internally, read all of the tokens from
1571 the string buffer now, while the string buffer is still installed. */
1572 /* ??? Note that the token buffer allocated here is leaked. It's not clear
1573 to me what the true lifespan of the tokens are. It would appear that
1574 the lifespan is the entire parse of the main input stream, in which case
1575 this may not be wrong. */
1576 if (pfile
->directive_result
.type
== CPP_PRAGMA
)
1582 toks
= XNEWVEC (cpp_token
, maxcount
);
1583 toks
[0] = pfile
->directive_result
;
1587 if (count
== maxcount
)
1589 maxcount
= maxcount
* 3 / 2;
1590 toks
= XRESIZEVEC (cpp_token
, toks
, maxcount
);
1592 toks
[count
] = *cpp_get_token (pfile
);
1593 /* Macros have been already expanded by cpp_get_token
1594 if the pragma allowed expansion. */
1595 toks
[count
++].flags
|= NO_EXPAND
;
1597 while (toks
[count
-1].type
!= CPP_PRAGMA_EOL
);
1602 toks
= XNEW (cpp_token
);
1603 toks
[0] = pfile
->directive_result
;
1605 /* If we handled the entire pragma internally, make sure we get the
1606 line number correct for the next token. */
1607 if (pfile
->cb
.line_change
)
1608 pfile
->cb
.line_change (pfile
, pfile
->cur_token
, false);
1611 /* Finish inlining run_directive. */
1612 pfile
->buffer
->file
= NULL
;
1613 _cpp_pop_buffer (pfile
);
1615 /* Reset the old macro state before ... */
1616 XDELETE (pfile
->context
);
1617 pfile
->context
= saved_context
;
1618 pfile
->cur_token
= saved_cur_token
;
1619 pfile
->cur_run
= saved_cur_run
;
1621 /* ... inserting the new tokens we collected. */
1622 _cpp_push_token_context (pfile
, NULL
, toks
, count
);
1625 /* Handle the _Pragma operator. Return 0 on error, 1 if ok. */
1627 _cpp_do__Pragma (cpp_reader
*pfile
)
1629 const cpp_token
*string
= get__Pragma_string (pfile
);
1630 pfile
->directive_result
.type
= CPP_PADDING
;
1634 destringize_and_run (pfile
, &string
->val
.str
);
1637 cpp_error (pfile
, CPP_DL_ERROR
,
1638 "_Pragma takes a parenthesized string literal");
1642 /* Handle #ifdef. */
1644 do_ifdef (cpp_reader
*pfile
)
1648 if (! pfile
->state
.skipping
)
1650 cpp_hashnode
*node
= lex_macro_node (pfile
, false);
1654 skip
= node
->type
!= NT_MACRO
;
1655 _cpp_mark_macro_used (node
);
1656 if (!(node
->flags
& NODE_USED
))
1658 node
->flags
|= NODE_USED
;
1659 if (node
->type
== NT_MACRO
)
1661 if (pfile
->cb
.used_define
)
1662 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
1666 if (pfile
->cb
.used_undef
)
1667 pfile
->cb
.used_undef (pfile
, pfile
->directive_line
, node
);
1674 push_conditional (pfile
, skip
, T_IFDEF
, 0);
1677 /* Handle #ifndef. */
1679 do_ifndef (cpp_reader
*pfile
)
1682 cpp_hashnode
*node
= 0;
1684 if (! pfile
->state
.skipping
)
1686 node
= lex_macro_node (pfile
, false);
1690 skip
= node
->type
== NT_MACRO
;
1691 _cpp_mark_macro_used (node
);
1692 if (!(node
->flags
& NODE_USED
))
1694 node
->flags
|= NODE_USED
;
1695 if (node
->type
== NT_MACRO
)
1697 if (pfile
->cb
.used_define
)
1698 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
1702 if (pfile
->cb
.used_undef
)
1703 pfile
->cb
.used_undef (pfile
, pfile
->directive_line
, node
);
1710 push_conditional (pfile
, skip
, T_IFNDEF
, node
);
1713 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1714 pfile->mi_ind_cmacro so we can handle multiple-include
1715 optimizations. If macro expansion occurs in the expression, we
1716 cannot treat it as a controlling conditional, since the expansion
1717 could change in the future. That is handled by cpp_get_token. */
1719 do_if (cpp_reader
*pfile
)
1723 if (! pfile
->state
.skipping
)
1724 skip
= _cpp_parse_expr (pfile
) == false;
1726 push_conditional (pfile
, skip
, T_IF
, pfile
->mi_ind_cmacro
);
1729 /* Flip skipping state if appropriate and continue without changing
1730 if_stack; this is so that the error message for missing #endif's
1731 etc. will point to the original #if. */
1733 do_else (cpp_reader
*pfile
)
1735 cpp_buffer
*buffer
= pfile
->buffer
;
1736 struct if_stack
*ifs
= buffer
->if_stack
;
1739 cpp_error (pfile
, CPP_DL_ERROR
, "#else without #if");
1742 if (ifs
->type
== T_ELSE
)
1744 cpp_error (pfile
, CPP_DL_ERROR
, "#else after #else");
1745 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
1746 "the conditional began here");
1750 /* Skip any future (erroneous) #elses or #elifs. */
1751 pfile
->state
.skipping
= ifs
->skip_elses
;
1752 ifs
->skip_elses
= true;
1754 /* Invalidate any controlling macro. */
1757 /* Only check EOL if was not originally skipping. */
1758 if (!ifs
->was_skipping
&& CPP_OPTION (pfile
, warn_endif_labels
))
1763 /* Handle a #elif directive by not changing if_stack either. See the
1764 comment above do_else. */
1766 do_elif (cpp_reader
*pfile
)
1768 cpp_buffer
*buffer
= pfile
->buffer
;
1769 struct if_stack
*ifs
= buffer
->if_stack
;
1772 cpp_error (pfile
, CPP_DL_ERROR
, "#elif without #if");
1775 if (ifs
->type
== T_ELSE
)
1777 cpp_error (pfile
, CPP_DL_ERROR
, "#elif after #else");
1778 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
1779 "the conditional began here");
1783 /* Only evaluate this if we aren't skipping elses. During
1784 evaluation, set skipping to false to get lexer warnings. */
1785 if (ifs
->skip_elses
)
1786 pfile
->state
.skipping
= 1;
1789 pfile
->state
.skipping
= 0;
1790 pfile
->state
.skipping
= ! _cpp_parse_expr (pfile
);
1791 ifs
->skip_elses
= ! pfile
->state
.skipping
;
1794 /* Invalidate any controlling macro. */
1799 /* #endif pops the if stack and resets pfile->state.skipping. */
1801 do_endif (cpp_reader
*pfile
)
1803 cpp_buffer
*buffer
= pfile
->buffer
;
1804 struct if_stack
*ifs
= buffer
->if_stack
;
1807 cpp_error (pfile
, CPP_DL_ERROR
, "#endif without #if");
1810 /* Only check EOL if was not originally skipping. */
1811 if (!ifs
->was_skipping
&& CPP_OPTION (pfile
, warn_endif_labels
))
1814 /* If potential control macro, we go back outside again. */
1815 if (ifs
->next
== 0 && ifs
->mi_cmacro
)
1817 pfile
->mi_valid
= true;
1818 pfile
->mi_cmacro
= ifs
->mi_cmacro
;
1821 buffer
->if_stack
= ifs
->next
;
1822 pfile
->state
.skipping
= ifs
->was_skipping
;
1823 obstack_free (&pfile
->buffer_ob
, ifs
);
1827 /* Push an if_stack entry for a preprocessor conditional, and set
1828 pfile->state.skipping to SKIP. If TYPE indicates the conditional
1829 is #if or #ifndef, CMACRO is a potentially controlling macro, and
1830 we need to check here that we are at the top of the file. */
1832 push_conditional (cpp_reader
*pfile
, int skip
, int type
,
1833 const cpp_hashnode
*cmacro
)
1835 struct if_stack
*ifs
;
1836 cpp_buffer
*buffer
= pfile
->buffer
;
1838 ifs
= XOBNEW (&pfile
->buffer_ob
, struct if_stack
);
1839 ifs
->line
= pfile
->directive_line
;
1840 ifs
->next
= buffer
->if_stack
;
1841 ifs
->skip_elses
= pfile
->state
.skipping
|| !skip
;
1842 ifs
->was_skipping
= pfile
->state
.skipping
;
1844 /* This condition is effectively a test for top-of-file. */
1845 if (pfile
->mi_valid
&& pfile
->mi_cmacro
== 0)
1846 ifs
->mi_cmacro
= cmacro
;
1850 pfile
->state
.skipping
= skip
;
1851 buffer
->if_stack
= ifs
;
1854 /* Read the tokens of the answer into the macro pool, in a directive
1855 of type TYPE. Only commit the memory if we intend it as permanent
1856 storage, i.e. the #assert case. Returns 0 on success, and sets
1857 ANSWERP to point to the answer. */
1859 parse_answer (cpp_reader
*pfile
, struct answer
**answerp
, int type
)
1861 const cpp_token
*paren
;
1862 struct answer
*answer
;
1863 unsigned int acount
;
1865 /* In a conditional, it is legal to not have an open paren. We
1866 should save the following token in this case. */
1867 paren
= cpp_get_token (pfile
);
1869 /* If not a paren, see if we're OK. */
1870 if (paren
->type
!= CPP_OPEN_PAREN
)
1872 /* In a conditional no answer is a test for any answer. It
1873 could be followed by any token. */
1876 _cpp_backup_tokens (pfile
, 1);
1880 /* #unassert with no answer is valid - it removes all answers. */
1881 if (type
== T_UNASSERT
&& paren
->type
== CPP_EOF
)
1884 cpp_error (pfile
, CPP_DL_ERROR
, "missing '(' after predicate");
1888 for (acount
= 0;; acount
++)
1891 const cpp_token
*token
= cpp_get_token (pfile
);
1894 if (token
->type
== CPP_CLOSE_PAREN
)
1897 if (token
->type
== CPP_EOF
)
1899 cpp_error (pfile
, CPP_DL_ERROR
, "missing ')' to complete answer");
1903 /* struct answer includes the space for one token. */
1904 room_needed
= (sizeof (struct answer
) + acount
* sizeof (cpp_token
));
1906 if (BUFF_ROOM (pfile
->a_buff
) < room_needed
)
1907 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (struct answer
));
1909 dest
= &((struct answer
*) BUFF_FRONT (pfile
->a_buff
))->first
[acount
];
1912 /* Drop whitespace at start, for answer equivalence purposes. */
1914 dest
->flags
&= ~PREV_WHITE
;
1919 cpp_error (pfile
, CPP_DL_ERROR
, "predicate's answer is empty");
1923 answer
= (struct answer
*) BUFF_FRONT (pfile
->a_buff
);
1924 answer
->count
= acount
;
1925 answer
->next
= NULL
;
1931 /* Parses an assertion directive of type TYPE, returning a pointer to
1932 the hash node of the predicate, or 0 on error. If an answer was
1933 supplied, it is placed in ANSWERP, otherwise it is set to 0. */
1934 static cpp_hashnode
*
1935 parse_assertion (cpp_reader
*pfile
, struct answer
**answerp
, int type
)
1937 cpp_hashnode
*result
= 0;
1938 const cpp_token
*predicate
;
1940 /* We don't expand predicates or answers. */
1941 pfile
->state
.prevent_expansion
++;
1944 predicate
= cpp_get_token (pfile
);
1945 if (predicate
->type
== CPP_EOF
)
1946 cpp_error (pfile
, CPP_DL_ERROR
, "assertion without predicate");
1947 else if (predicate
->type
!= CPP_NAME
)
1948 cpp_error (pfile
, CPP_DL_ERROR
, "predicate must be an identifier");
1949 else if (parse_answer (pfile
, answerp
, type
) == 0)
1951 unsigned int len
= NODE_LEN (predicate
->val
.node
);
1952 unsigned char *sym
= (unsigned char *) alloca (len
+ 1);
1954 /* Prefix '#' to get it out of macro namespace. */
1956 memcpy (sym
+ 1, NODE_NAME (predicate
->val
.node
), len
);
1957 result
= cpp_lookup (pfile
, sym
, len
+ 1);
1960 pfile
->state
.prevent_expansion
--;
1964 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
1965 or a pointer to NULL if the answer is not in the chain. */
1966 static struct answer
**
1967 find_answer (cpp_hashnode
*node
, const struct answer
*candidate
)
1970 struct answer
**result
;
1972 for (result
= &node
->value
.answers
; *result
; result
= &(*result
)->next
)
1974 struct answer
*answer
= *result
;
1976 if (answer
->count
== candidate
->count
)
1978 for (i
= 0; i
< answer
->count
; i
++)
1979 if (! _cpp_equiv_tokens (&answer
->first
[i
], &candidate
->first
[i
]))
1982 if (i
== answer
->count
)
1990 /* Test an assertion within a preprocessor conditional. Returns
1991 nonzero on failure, zero on success. On success, the result of
1992 the test is written into VALUE, otherwise the value 0. */
1994 _cpp_test_assertion (cpp_reader
*pfile
, unsigned int *value
)
1996 struct answer
*answer
;
1999 node
= parse_assertion (pfile
, &answer
, T_IF
);
2001 /* For recovery, an erroneous assertion expression is handled as a
2002 failing assertion. */
2006 *value
= (node
->type
== NT_ASSERTION
&&
2007 (answer
== 0 || *find_answer (node
, answer
) != 0));
2008 else if (pfile
->cur_token
[-1].type
== CPP_EOF
)
2009 _cpp_backup_tokens (pfile
, 1);
2011 /* We don't commit the memory for the answer - it's temporary only. */
2015 /* Handle #assert. */
2017 do_assert (cpp_reader
*pfile
)
2019 struct answer
*new_answer
;
2022 node
= parse_assertion (pfile
, &new_answer
, T_ASSERT
);
2027 /* Place the new answer in the answer list. First check there
2028 is not a duplicate. */
2029 new_answer
->next
= 0;
2030 if (node
->type
== NT_ASSERTION
)
2032 if (*find_answer (node
, new_answer
))
2034 cpp_error (pfile
, CPP_DL_WARNING
, "\"%s\" re-asserted",
2035 NODE_NAME (node
) + 1);
2038 new_answer
->next
= node
->value
.answers
;
2041 answer_size
= sizeof (struct answer
) + ((new_answer
->count
- 1)
2042 * sizeof (cpp_token
));
2043 /* Commit or allocate storage for the object. */
2044 if (pfile
->hash_table
->alloc_subobject
)
2046 struct answer
*temp_answer
= new_answer
;
2047 new_answer
= (struct answer
*) pfile
->hash_table
->alloc_subobject
2049 memcpy (new_answer
, temp_answer
, answer_size
);
2052 BUFF_FRONT (pfile
->a_buff
) += answer_size
;
2054 node
->type
= NT_ASSERTION
;
2055 node
->value
.answers
= new_answer
;
2060 /* Handle #unassert. */
2062 do_unassert (cpp_reader
*pfile
)
2065 struct answer
*answer
;
2067 node
= parse_assertion (pfile
, &answer
, T_UNASSERT
);
2068 /* It isn't an error to #unassert something that isn't asserted. */
2069 if (node
&& node
->type
== NT_ASSERTION
)
2073 struct answer
**p
= find_answer (node
, answer
), *temp
;
2075 /* Remove the answer from the list. */
2080 /* Did we free the last answer? */
2081 if (node
->value
.answers
== 0)
2082 node
->type
= NT_VOID
;
2087 _cpp_free_definition (node
);
2090 /* We don't commit the memory for the answer - it's temporary only. */
2093 /* These are for -D, -U, -A. */
2095 /* Process the string STR as if it appeared as the body of a #define.
2096 If STR is just an identifier, define it with value 1.
2097 If STR has anything after the identifier, then it should
2098 be identifier=definition. */
2100 cpp_define (cpp_reader
*pfile
, const char *str
)
2105 /* Copy the entire option so we can modify it.
2106 Change the first "=" in the string to a space. If there is none,
2107 tack " 1" on the end. */
2109 count
= strlen (str
);
2110 buf
= (char *) alloca (count
+ 3);
2111 memcpy (buf
, str
, count
);
2113 p
= strchr (str
, '=');
2123 run_directive (pfile
, T_DEFINE
, buf
, count
);
2127 /* Use to build macros to be run through cpp_define() as
2129 Example: cpp_define_formatted (pfile, "MACRO=%d", value); */
2132 cpp_define_formatted (cpp_reader
*pfile
, const char *fmt
, ...)
2138 vasprintf (&ptr
, fmt
, ap
);
2141 cpp_define (pfile
, ptr
);
2146 /* Slight variant of the above for use by initialize_builtins. */
2148 _cpp_define_builtin (cpp_reader
*pfile
, const char *str
)
2150 size_t len
= strlen (str
);
2151 char *buf
= (char *) alloca (len
+ 1);
2152 memcpy (buf
, str
, len
);
2154 run_directive (pfile
, T_DEFINE
, buf
, len
);
2157 /* Process MACRO as if it appeared as the body of an #undef. */
2159 cpp_undef (cpp_reader
*pfile
, const char *macro
)
2161 size_t len
= strlen (macro
);
2162 char *buf
= (char *) alloca (len
+ 1);
2163 memcpy (buf
, macro
, len
);
2165 run_directive (pfile
, T_UNDEF
, buf
, len
);
2168 /* Like lex_macro_node, but read the input from STR. */
2169 static cpp_hashnode
*
2170 lex_macro_node_from_str (cpp_reader
*pfile
, const char *str
)
2172 size_t len
= strlen (str
);
2173 uchar
*buf
= (uchar
*) alloca (len
+ 1);
2176 memcpy (buf
, str
, len
);
2178 cpp_push_buffer (pfile
, buf
, len
, true);
2179 node
= lex_macro_node (pfile
, true);
2180 _cpp_pop_buffer (pfile
);
2185 /* If STR is a defined macro, return its definition node, else return NULL. */
2187 cpp_push_definition (cpp_reader
*pfile
, const char *str
)
2189 cpp_hashnode
*node
= lex_macro_node_from_str (pfile
, str
);
2190 if (node
&& node
->type
== NT_MACRO
)
2191 return node
->value
.macro
;
2196 /* Replace a previous definition DFN of the macro STR. If DFN is NULL,
2197 then the macro should be undefined. */
2199 cpp_pop_definition (cpp_reader
*pfile
, const char *str
, cpp_macro
*dfn
)
2201 cpp_hashnode
*node
= lex_macro_node_from_str (pfile
, str
);
2205 if (pfile
->cb
.before_define
)
2206 pfile
->cb
.before_define (pfile
);
2208 if (node
->type
== NT_MACRO
)
2210 if (pfile
->cb
.undef
)
2211 pfile
->cb
.undef (pfile
, pfile
->directive_line
, node
);
2212 if (CPP_OPTION (pfile
, warn_unused_macros
))
2213 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
2215 if (node
->type
!= NT_VOID
)
2216 _cpp_free_definition (node
);
2220 node
->type
= NT_MACRO
;
2221 node
->value
.macro
= dfn
;
2222 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_")))
2223 node
->flags
|= NODE_WARN
;
2225 if (pfile
->cb
.define
)
2226 pfile
->cb
.define (pfile
, pfile
->directive_line
, node
);
2230 /* Process the string STR as if it appeared as the body of a #assert. */
2232 cpp_assert (cpp_reader
*pfile
, const char *str
)
2234 handle_assertion (pfile
, str
, T_ASSERT
);
2237 /* Process STR as if it appeared as the body of an #unassert. */
2239 cpp_unassert (cpp_reader
*pfile
, const char *str
)
2241 handle_assertion (pfile
, str
, T_UNASSERT
);
2244 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
2246 handle_assertion (cpp_reader
*pfile
, const char *str
, int type
)
2248 size_t count
= strlen (str
);
2249 const char *p
= strchr (str
, '=');
2251 /* Copy the entire option so we can modify it. Change the first
2252 "=" in the string to a '(', and tack a ')' on the end. */
2253 char *buf
= (char *) alloca (count
+ 2);
2255 memcpy (buf
, str
, count
);
2264 run_directive (pfile
, type
, str
, count
);
2267 /* The number of errors for a given reader. */
2269 cpp_errors (cpp_reader
*pfile
)
2271 return pfile
->errors
;
2274 /* The options structure. */
2276 cpp_get_options (cpp_reader
*pfile
)
2278 return &pfile
->opts
;
2281 /* The callbacks structure. */
2283 cpp_get_callbacks (cpp_reader
*pfile
)
2288 /* Copy the given callbacks structure to our own. */
2290 cpp_set_callbacks (cpp_reader
*pfile
, cpp_callbacks
*cb
)
2295 /* The dependencies structure. (Creates one if it hasn't already been.) */
2297 cpp_get_deps (cpp_reader
*pfile
)
2300 pfile
->deps
= deps_init ();
2304 /* Push a new buffer on the buffer stack. Returns the new buffer; it
2305 doesn't fail. It does not generate a file change call back; that
2306 is the responsibility of the caller. */
2308 cpp_push_buffer (cpp_reader
*pfile
, const uchar
*buffer
, size_t len
,
2311 cpp_buffer
*new_buffer
= XOBNEW (&pfile
->buffer_ob
, cpp_buffer
);
2313 /* Clears, amongst other things, if_stack and mi_cmacro. */
2314 memset (new_buffer
, 0, sizeof (cpp_buffer
));
2316 new_buffer
->next_line
= new_buffer
->buf
= buffer
;
2317 new_buffer
->rlimit
= buffer
+ len
;
2318 new_buffer
->from_stage3
= from_stage3
;
2319 new_buffer
->prev
= pfile
->buffer
;
2320 new_buffer
->need_line
= true;
2322 pfile
->buffer
= new_buffer
;
2327 /* Pops a single buffer, with a file change call-back if appropriate.
2328 Then pushes the next -include file, if any remain. */
2330 _cpp_pop_buffer (cpp_reader
*pfile
)
2332 cpp_buffer
*buffer
= pfile
->buffer
;
2333 struct _cpp_file
*inc
= buffer
->file
;
2334 struct if_stack
*ifs
;
2336 /* Walk back up the conditional stack till we reach its level at
2337 entry to this file, issuing error messages. */
2338 for (ifs
= buffer
->if_stack
; ifs
; ifs
= ifs
->next
)
2339 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
2340 "unterminated #%s", dtable
[ifs
->type
].name
);
2342 /* In case of a missing #endif. */
2343 pfile
->state
.skipping
= 0;
2345 /* _cpp_do_file_change expects pfile->buffer to be the new one. */
2346 pfile
->buffer
= buffer
->prev
;
2348 free (buffer
->notes
);
2350 /* Free the buffer object now; we may want to push a new buffer
2351 in _cpp_push_next_include_file. */
2352 obstack_free (&pfile
->buffer_ob
, buffer
);
2356 _cpp_pop_file_buffer (pfile
, inc
);
2358 _cpp_do_file_change (pfile
, LC_LEAVE
, 0, 0, 0);
2362 /* Enter all recognized directives in the hash table. */
2364 _cpp_init_directives (cpp_reader
*pfile
)
2369 for (i
= 0; i
< (unsigned int) N_DIRECTIVES
; i
++)
2371 node
= cpp_lookup (pfile
, dtable
[i
].name
, dtable
[i
].length
);
2372 node
->is_directive
= 1;
2373 node
->directive_index
= i
;