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 linenum_type 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)
78 #define DEPRECATED (1 << 5)
80 /* Defines one #-directive, including how to handle it. */
81 typedef void (*directive_handler
) (cpp_reader
*);
82 typedef struct directive directive
;
85 directive_handler handler
; /* Function to handle directive. */
86 const uchar
*name
; /* Name of directive. */
87 unsigned short length
; /* Length of name. */
88 unsigned char origin
; /* Origin of directive. */
89 unsigned char flags
; /* Flags describing this directive. */
92 /* Forward declarations. */
94 static void skip_rest_of_line (cpp_reader
*);
95 static void check_eol (cpp_reader
*);
96 static void start_directive (cpp_reader
*);
97 static void prepare_directive_trad (cpp_reader
*);
98 static void end_directive (cpp_reader
*, int);
99 static void directive_diagnostics (cpp_reader
*, const directive
*, int);
100 static void run_directive (cpp_reader
*, int, const char *, size_t);
101 static char *glue_header_name (cpp_reader
*);
102 static const char *parse_include (cpp_reader
*, int *, const cpp_token
***);
103 static void push_conditional (cpp_reader
*, int, int, const cpp_hashnode
*);
104 static unsigned int read_flag (cpp_reader
*, unsigned int);
105 static bool strtolinenum (const uchar
*, size_t, linenum_type
*, bool *);
106 static void do_diagnostic (cpp_reader
*, int, int);
107 static cpp_hashnode
*lex_macro_node (cpp_reader
*, bool);
108 static int undefine_macros (cpp_reader
*, cpp_hashnode
*, void *);
109 static void do_include_common (cpp_reader
*, enum include_type
);
110 static struct pragma_entry
*lookup_pragma_entry (struct pragma_entry
*,
111 const cpp_hashnode
*);
112 static int count_registered_pragmas (struct pragma_entry
*);
113 static char ** save_registered_pragmas (struct pragma_entry
*, char **);
114 static char ** restore_registered_pragmas (cpp_reader
*, struct pragma_entry
*,
116 static void do_pragma_once (cpp_reader
*);
117 static void do_pragma_poison (cpp_reader
*);
118 static void do_pragma_system_header (cpp_reader
*);
119 static void do_pragma_dependency (cpp_reader
*);
120 static void do_linemarker (cpp_reader
*);
121 static const cpp_token
*get_token_no_padding (cpp_reader
*);
122 static const cpp_token
*get__Pragma_string (cpp_reader
*);
123 static void destringize_and_run (cpp_reader
*, const cpp_string
*);
124 static int parse_answer (cpp_reader
*, struct answer
**, int);
125 static cpp_hashnode
*parse_assertion (cpp_reader
*, struct answer
**, int);
126 static struct answer
** find_answer (cpp_hashnode
*, const struct answer
*);
127 static void handle_assertion (cpp_reader
*, const char *, int);
129 /* This is the table of directive handlers. It is ordered by
130 frequency of occurrence; the numbers at the end are directive
131 counts from all the source code I have lying around (egcs and libc
132 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
133 pcmcia-cs-3.0.9). This is no longer important as directive lookup
134 is now O(1). All extensions other than #warning, #include_next,
135 and #import are deprecated. The name is where the extension
136 appears to have come from. */
138 #define DIRECTIVE_TABLE \
139 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
140 D(include, T_INCLUDE, KANDR, INCL | EXPAND) /* 52262 */ \
141 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
142 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
143 D(if, T_IF, KANDR, COND | IF_COND | EXPAND) /* 18162 */ \
144 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
145 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
146 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
147 D(line, T_LINE, KANDR, EXPAND) /* 2465 */ \
148 D(elif, T_ELIF, STDC89, COND | EXPAND) /* 610 */ \
149 D(error, T_ERROR, STDC89, 0) /* 475 */ \
150 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
151 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
152 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL | EXPAND) /* 19 */ \
153 D(ident, T_IDENT, EXTENSION, IN_I | DEPRECATED) /* 11 */ \
154 D(import, T_IMPORT, EXTENSION, INCL | EXPAND) /* 0 ObjC */ \
155 D(assert, T_ASSERT, EXTENSION, DEPRECATED) /* 0 SVR4 */ \
156 D(unassert, T_UNASSERT, EXTENSION, DEPRECATED) /* 0 SVR4 */ \
157 D(sccs, T_SCCS, EXTENSION, IN_I | DEPRECATED) /* 0 SVR4? */
159 /* #sccs is synonymous with #ident. */
160 #define do_sccs do_ident
162 /* Use the table to generate a series of prototypes, an enum for the
163 directive names, and an array of directive handlers. */
165 #define D(name, t, o, f) static void do_##name (cpp_reader *);
169 #define D(n, tag, o, f) tag,
177 #define D(name, t, origin, flags) \
178 { do_##name, (const uchar *) #name, \
179 sizeof #name - 1, origin, flags },
180 static const directive dtable
[] =
185 #undef DIRECTIVE_TABLE
187 /* Wrapper struct directive for linemarkers.
188 The origin is more or less true - the original K+R cpp
189 did use this notation in its preprocessed output. */
190 static const directive linemarker_dir
=
192 do_linemarker
, UC
"#", 1, KANDR
, IN_I
195 #define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
197 /* Skip any remaining tokens in a directive. */
199 skip_rest_of_line (cpp_reader
*pfile
)
201 /* Discard all stacked contexts. */
202 while (pfile
->context
->prev
)
203 _cpp_pop_context (pfile
);
205 /* Sweep up all tokens remaining on the line. */
207 while (_cpp_lex_token (pfile
)->type
!= CPP_EOF
)
211 /* Ensure there are no stray tokens at the end of a directive. */
213 check_eol (cpp_reader
*pfile
)
215 if (! SEEN_EOL () && _cpp_lex_token (pfile
)->type
!= CPP_EOF
)
216 cpp_error (pfile
, CPP_DL_PEDWARN
, "extra tokens at end of #%s directive",
217 pfile
->directive
->name
);
220 /* Ensure there are no stray tokens other than comments at the end of
221 a directive, and gather the comments. */
222 static const cpp_token
**
223 check_eol_return_comments (cpp_reader
*pfile
)
227 const cpp_token
**buf
;
229 buf
= XNEWVEC (const cpp_token
*, capacity
);
235 const cpp_token
*tok
;
237 tok
= _cpp_lex_token (pfile
);
238 if (tok
->type
== CPP_EOF
)
240 if (tok
->type
!= CPP_COMMENT
)
241 cpp_error (pfile
, CPP_DL_PEDWARN
,
242 "extra tokens at end of #%s directive",
243 pfile
->directive
->name
);
246 if (c
+ 1 >= capacity
)
249 buf
= XRESIZEVEC (const cpp_token
*, buf
, capacity
);
260 /* Called when entering a directive, _Pragma or command-line directive. */
262 start_directive (cpp_reader
*pfile
)
264 /* Setup in-directive state. */
265 pfile
->state
.in_directive
= 1;
266 pfile
->state
.save_comments
= 0;
267 pfile
->directive_result
.type
= CPP_PADDING
;
269 /* Some handlers need the position of the # for diagnostics. */
270 pfile
->directive_line
= pfile
->line_table
->highest_line
;
273 /* Called when leaving a directive, _Pragma or command-line directive. */
275 end_directive (cpp_reader
*pfile
, int skip_line
)
277 if (pfile
->state
.in_deferred_pragma
)
279 else if (CPP_OPTION (pfile
, traditional
))
281 /* Revert change of prepare_directive_trad. */
282 pfile
->state
.prevent_expansion
--;
284 if (pfile
->directive
!= &dtable
[T_DEFINE
])
285 _cpp_remove_overlay (pfile
);
287 /* We don't skip for an assembler #. */
290 skip_rest_of_line (pfile
);
291 if (!pfile
->keep_tokens
)
293 pfile
->cur_run
= &pfile
->base_run
;
294 pfile
->cur_token
= pfile
->base_run
.base
;
299 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
300 pfile
->state
.in_directive
= 0;
301 pfile
->state
.in_expression
= 0;
302 pfile
->state
.angled_headers
= 0;
303 pfile
->directive
= 0;
306 /* Prepare to handle the directive in pfile->directive. */
308 prepare_directive_trad (cpp_reader
*pfile
)
310 if (pfile
->directive
!= &dtable
[T_DEFINE
])
312 bool no_expand
= (pfile
->directive
313 && ! (pfile
->directive
->flags
& EXPAND
));
314 bool was_skipping
= pfile
->state
.skipping
;
316 pfile
->state
.in_expression
= (pfile
->directive
== &dtable
[T_IF
]
317 || pfile
->directive
== &dtable
[T_ELIF
]);
318 if (pfile
->state
.in_expression
)
319 pfile
->state
.skipping
= false;
322 pfile
->state
.prevent_expansion
++;
323 _cpp_scan_out_logical_line (pfile
, NULL
);
325 pfile
->state
.prevent_expansion
--;
327 pfile
->state
.skipping
= was_skipping
;
328 _cpp_overlay_buffer (pfile
, pfile
->out
.base
,
329 pfile
->out
.cur
- pfile
->out
.base
);
332 /* Stop ISO C from expanding anything. */
333 pfile
->state
.prevent_expansion
++;
336 /* Output diagnostics for a directive DIR. INDENTED is nonzero if
337 the '#' was indented. */
339 directive_diagnostics (cpp_reader
*pfile
, const directive
*dir
, int indented
)
341 /* Issue -pedantic or deprecated warnings for extensions. We let
342 -pedantic take precedence if both are applicable. */
343 if (! pfile
->state
.skipping
)
345 if (dir
->origin
== EXTENSION
346 && !(dir
== &dtable
[T_IMPORT
] && CPP_OPTION (pfile
, objc
))
347 && CPP_PEDANTIC (pfile
))
348 cpp_error (pfile
, CPP_DL_PEDWARN
, "#%s is a GCC extension", dir
->name
);
349 else if (((dir
->flags
& DEPRECATED
) != 0
350 || (dir
== &dtable
[T_IMPORT
] && !CPP_OPTION (pfile
, objc
)))
351 && CPP_OPTION (pfile
, warn_deprecated
))
352 cpp_error (pfile
, CPP_DL_WARNING
, "#%s is a deprecated GCC extension",
356 /* Traditionally, a directive is ignored unless its # is in
357 column 1. Therefore in code intended to work with K+R
358 compilers, directives added by C89 must have their #
359 indented, and directives present in traditional C must not.
360 This is true even of directives in skipped conditional
361 blocks. #elif cannot be used at all. */
362 if (CPP_WTRADITIONAL (pfile
))
364 if (dir
== &dtable
[T_ELIF
])
365 cpp_error (pfile
, CPP_DL_WARNING
,
366 "suggest not using #elif in traditional C");
367 else if (indented
&& dir
->origin
== KANDR
)
368 cpp_error (pfile
, CPP_DL_WARNING
,
369 "traditional C ignores #%s with the # indented",
371 else if (!indented
&& dir
->origin
!= KANDR
)
372 cpp_error (pfile
, CPP_DL_WARNING
,
373 "suggest hiding #%s from traditional C with an indented #",
378 /* Check if we have a known directive. INDENTED is nonzero if the
379 '#' of the directive was indented. This function is in this file
380 to save unnecessarily exporting dtable etc. to lex.c. Returns
381 nonzero if the line of tokens has been handled, zero if we should
382 continue processing the line. */
384 _cpp_handle_directive (cpp_reader
*pfile
, int indented
)
386 const directive
*dir
= 0;
387 const cpp_token
*dname
;
388 bool was_parsing_args
= pfile
->state
.parsing_args
;
389 bool was_discarding_output
= pfile
->state
.discarding_output
;
392 if (was_discarding_output
)
393 pfile
->state
.prevent_expansion
= 0;
395 if (was_parsing_args
)
397 if (CPP_OPTION (pfile
, pedantic
))
398 cpp_error (pfile
, CPP_DL_PEDWARN
,
399 "embedding a directive within macro arguments is not portable");
400 pfile
->state
.parsing_args
= 0;
401 pfile
->state
.prevent_expansion
= 0;
403 start_directive (pfile
);
404 dname
= _cpp_lex_token (pfile
);
406 if (dname
->type
== CPP_NAME
)
408 if (dname
->val
.node
->is_directive
)
409 dir
= &dtable
[dname
->val
.node
->directive_index
];
411 /* We do not recognize the # followed by a number extension in
413 else if (dname
->type
== CPP_NUMBER
&& CPP_OPTION (pfile
, lang
) != CLK_ASM
)
415 dir
= &linemarker_dir
;
416 if (CPP_PEDANTIC (pfile
) && ! CPP_OPTION (pfile
, preprocessed
)
417 && ! pfile
->state
.skipping
)
418 cpp_error (pfile
, CPP_DL_PEDWARN
,
419 "style of line directive is a GCC extension");
424 /* If we have a directive that is not an opening conditional,
425 invalidate any control macro. */
426 if (! (dir
->flags
& IF_COND
))
427 pfile
->mi_valid
= false;
429 /* Kluge alert. In order to be sure that code like this
434 does not cause '#define foo bar' to get executed when
435 compiled with -save-temps, we recognize directives in
436 -fpreprocessed mode only if the # is in column 1. macro.c
437 puts a space in front of any '#' at the start of a macro.
439 We exclude the -fdirectives-only case because macro expansion
440 has not been performed yet, and block comments can cause spaces
441 to preceed the directive. */
442 if (CPP_OPTION (pfile
, preprocessed
)
443 && !CPP_OPTION (pfile
, directives_only
)
444 && (indented
|| !(dir
->flags
& IN_I
)))
451 /* In failed conditional groups, all non-conditional
452 directives are ignored. Before doing that, whether
453 skipping or not, we should lex angle-bracketed headers
454 correctly, and maybe output some diagnostics. */
455 pfile
->state
.angled_headers
= dir
->flags
& INCL
;
456 pfile
->state
.directive_wants_padding
= dir
->flags
& INCL
;
457 if (! CPP_OPTION (pfile
, preprocessed
))
458 directive_diagnostics (pfile
, dir
, indented
);
459 if (pfile
->state
.skipping
&& !(dir
->flags
& COND
))
463 else if (dname
->type
== CPP_EOF
)
464 ; /* CPP_EOF is the "null directive". */
467 /* An unknown directive. Don't complain about it in assembly
468 source: we don't know where the comments are, and # may
469 introduce assembler pseudo-ops. Don't complain about invalid
470 directives in skipped conditional groups (6.10 p4). */
471 if (CPP_OPTION (pfile
, lang
) == CLK_ASM
)
473 else if (!pfile
->state
.skipping
)
474 cpp_error (pfile
, CPP_DL_ERROR
, "invalid preprocessing directive #%s",
475 cpp_token_as_text (pfile
, dname
));
478 pfile
->directive
= dir
;
479 if (CPP_OPTION (pfile
, traditional
))
480 prepare_directive_trad (pfile
);
483 pfile
->directive
->handler (pfile
);
485 _cpp_backup_tokens (pfile
, 1);
487 end_directive (pfile
, skip
);
488 if (was_parsing_args
&& !pfile
->state
.in_deferred_pragma
)
490 /* Restore state when within macro args. */
491 pfile
->state
.parsing_args
= 2;
492 pfile
->state
.prevent_expansion
= 1;
494 if (was_discarding_output
)
495 pfile
->state
.prevent_expansion
= 1;
499 /* Directive handler wrapper used by the command line option
500 processor. BUF is \n terminated. */
502 run_directive (cpp_reader
*pfile
, int dir_no
, const char *buf
, size_t count
)
504 cpp_push_buffer (pfile
, (const uchar
*) buf
, count
,
505 /* from_stage3 */ true);
506 start_directive (pfile
);
508 /* This is a short-term fix to prevent a leading '#' being
509 interpreted as a directive. */
510 _cpp_clean_line (pfile
);
512 pfile
->directive
= &dtable
[dir_no
];
513 if (CPP_OPTION (pfile
, traditional
))
514 prepare_directive_trad (pfile
);
515 pfile
->directive
->handler (pfile
);
516 end_directive (pfile
, 1);
517 _cpp_pop_buffer (pfile
);
520 /* Checks for validity the macro name in #define, #undef, #ifdef and
521 #ifndef directives. IS_DEF_OR_UNDEF is true if this call is
522 processing a #define or #undefine directive, and false
524 static cpp_hashnode
*
525 lex_macro_node (cpp_reader
*pfile
, bool is_def_or_undef
)
527 const cpp_token
*token
= _cpp_lex_token (pfile
);
529 /* The token immediately after #define must be an identifier. That
530 identifier may not be "defined", per C99 6.10.8p4.
531 In C++, it may not be any of the "named operators" either,
532 per C++98 [lex.digraph], [lex.key].
533 Finally, the identifier may not have been poisoned. (In that case
534 the lexer has issued the error message for us.) */
536 if (token
->type
== CPP_NAME
)
538 cpp_hashnode
*node
= token
->val
.node
;
540 if (is_def_or_undef
&& node
== pfile
->spec_nodes
.n_defined
)
541 cpp_error (pfile
, CPP_DL_ERROR
,
542 "\"defined\" cannot be used as a macro name");
543 else if (! (node
->flags
& NODE_POISONED
))
546 else if (token
->flags
& NAMED_OP
)
547 cpp_error (pfile
, CPP_DL_ERROR
,
548 "\"%s\" cannot be used as a macro name as it is an operator in C++",
549 NODE_NAME (token
->val
.node
));
550 else if (token
->type
== CPP_EOF
)
551 cpp_error (pfile
, CPP_DL_ERROR
, "no macro name given in #%s directive",
552 pfile
->directive
->name
);
554 cpp_error (pfile
, CPP_DL_ERROR
, "macro names must be identifiers");
559 /* Process a #define directive. Most work is done in macro.c. */
561 do_define (cpp_reader
*pfile
)
563 cpp_hashnode
*node
= lex_macro_node (pfile
, true);
567 /* If we have been requested to expand comments into macros,
568 then re-enable saving of comments. */
569 pfile
->state
.save_comments
=
570 ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
);
572 if (pfile
->cb
.before_define
)
573 pfile
->cb
.before_define (pfile
);
575 if (_cpp_create_definition (pfile
, node
))
576 if (pfile
->cb
.define
)
577 pfile
->cb
.define (pfile
, pfile
->directive_line
, node
);
579 node
->flags
&= ~NODE_USED
;
583 /* Handle #undef. Mark the identifier NT_VOID in the hash table. */
585 do_undef (cpp_reader
*pfile
)
587 cpp_hashnode
*node
= lex_macro_node (pfile
, true);
591 if (pfile
->cb
.before_define
)
592 pfile
->cb
.before_define (pfile
);
595 pfile
->cb
.undef (pfile
, pfile
->directive_line
, node
);
597 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified
598 identifier is not currently defined as a macro name. */
599 if (node
->type
== NT_MACRO
)
601 if (node
->flags
& NODE_WARN
)
602 cpp_error (pfile
, CPP_DL_WARNING
,
603 "undefining \"%s\"", NODE_NAME (node
));
605 if (CPP_OPTION (pfile
, warn_unused_macros
))
606 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
608 _cpp_free_definition (node
);
615 /* Undefine a single macro/assertion/whatever. */
618 undefine_macros (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*h
,
619 void *data_p ATTRIBUTE_UNUSED
)
621 /* Body of _cpp_free_definition inlined here for speed.
622 Macros and assertions no longer have anything to free. */
624 h
->flags
&= ~(NODE_POISONED
|NODE_BUILTIN
|NODE_DISABLED
|NODE_USED
);
628 /* Undefine all macros and assertions. */
631 cpp_undef_all (cpp_reader
*pfile
)
633 cpp_forall_identifiers (pfile
, undefine_macros
, NULL
);
637 /* Helper routine used by parse_include. Reinterpret the current line
638 as an h-char-sequence (< ... >); we are looking at the first token
639 after the <. Returns a malloced filename. */
641 glue_header_name (cpp_reader
*pfile
)
643 const cpp_token
*token
;
645 size_t len
, total_len
= 0, capacity
= 1024;
647 /* To avoid lexed tokens overwriting our glued name, we can only
648 allocate from the string pool once we've lexed everything. */
649 buffer
= XNEWVEC (char, capacity
);
652 token
= get_token_no_padding (pfile
);
654 if (token
->type
== CPP_GREATER
)
656 if (token
->type
== CPP_EOF
)
658 cpp_error (pfile
, CPP_DL_ERROR
, "missing terminating > character");
662 len
= cpp_token_len (token
) + 2; /* Leading space, terminating \0. */
663 if (total_len
+ len
> capacity
)
665 capacity
= (capacity
+ len
) * 2;
666 buffer
= XRESIZEVEC (char, buffer
, capacity
);
669 if (token
->flags
& PREV_WHITE
)
670 buffer
[total_len
++] = ' ';
672 total_len
= (cpp_spell_token (pfile
, token
, (uchar
*) &buffer
[total_len
],
677 buffer
[total_len
] = '\0';
681 /* Returns the file name of #include, #include_next, #import and
682 #pragma dependency. The string is malloced and the caller should
683 free it. Returns NULL on error. */
685 parse_include (cpp_reader
*pfile
, int *pangle_brackets
,
686 const cpp_token
***buf
)
689 const cpp_token
*header
;
691 /* Allow macro expansion. */
692 header
= get_token_no_padding (pfile
);
693 if (header
->type
== CPP_STRING
|| header
->type
== CPP_HEADER_NAME
)
695 fname
= XNEWVEC (char, header
->val
.str
.len
- 1);
696 memcpy (fname
, header
->val
.str
.text
+ 1, header
->val
.str
.len
- 2);
697 fname
[header
->val
.str
.len
- 2] = '\0';
698 *pangle_brackets
= header
->type
== CPP_HEADER_NAME
;
700 else if (header
->type
== CPP_LESS
)
702 fname
= glue_header_name (pfile
);
703 *pangle_brackets
= 1;
707 const unsigned char *dir
;
709 if (pfile
->directive
== &dtable
[T_PRAGMA
])
710 dir
= UC
"pragma dependency";
712 dir
= pfile
->directive
->name
;
713 cpp_error (pfile
, CPP_DL_ERROR
, "#%s expects \"FILENAME\" or <FILENAME>",
719 if (pfile
->directive
== &dtable
[T_PRAGMA
])
721 /* This pragma allows extra tokens after the file name. */
723 else if (buf
== NULL
|| CPP_OPTION (pfile
, discard_comments
))
727 /* If we are not discarding comments, then gather them while
728 doing the eol check. */
729 *buf
= check_eol_return_comments (pfile
);
735 /* Handle #include, #include_next and #import. */
737 do_include_common (cpp_reader
*pfile
, enum include_type type
)
741 const cpp_token
**buf
= NULL
;
743 /* Re-enable saving of comments if requested, so that the include
744 callback can dump comments which follow #include. */
745 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
747 fname
= parse_include (pfile
, &angle_brackets
, &buf
);
757 cpp_error (pfile
, CPP_DL_ERROR
, "empty filename in #%s",
758 pfile
->directive
->name
);
765 /* Prevent #include recursion. */
766 if (pfile
->line_table
->depth
>= CPP_STACK_MAX
)
767 cpp_error (pfile
, CPP_DL_ERROR
, "#include nested too deeply");
770 /* Get out of macro context, if we are. */
771 skip_rest_of_line (pfile
);
773 if (pfile
->cb
.include
)
774 pfile
->cb
.include (pfile
, pfile
->directive_line
,
775 pfile
->directive
->name
, fname
, angle_brackets
,
778 _cpp_stack_include (pfile
, fname
, angle_brackets
, type
);
787 do_include (cpp_reader
*pfile
)
789 do_include_common (pfile
, IT_INCLUDE
);
793 do_import (cpp_reader
*pfile
)
795 do_include_common (pfile
, IT_IMPORT
);
799 do_include_next (cpp_reader
*pfile
)
801 enum include_type type
= IT_INCLUDE_NEXT
;
803 /* If this is the primary source file, warn and use the normal
805 if (cpp_in_primary_file (pfile
))
807 cpp_error (pfile
, CPP_DL_WARNING
,
808 "#include_next in primary source file");
811 do_include_common (pfile
, type
);
814 /* Subroutine of do_linemarker. Read possible flags after file name.
815 LAST is the last flag seen; 0 if this is the first flag. Return the
816 flag if it is valid, 0 at the end of the directive. Otherwise
819 read_flag (cpp_reader
*pfile
, unsigned int last
)
821 const cpp_token
*token
= _cpp_lex_token (pfile
);
823 if (token
->type
== CPP_NUMBER
&& token
->val
.str
.len
== 1)
825 unsigned int flag
= token
->val
.str
.text
[0] - '0';
827 if (flag
> last
&& flag
<= 4
828 && (flag
!= 4 || last
== 3)
829 && (flag
!= 2 || last
== 0))
833 if (token
->type
!= CPP_EOF
)
834 cpp_error (pfile
, CPP_DL_ERROR
, "invalid flag \"%s\" in line directive",
835 cpp_token_as_text (pfile
, token
));
839 /* Subroutine of do_line and do_linemarker. Convert a number in STR,
840 of length LEN, to binary; store it in NUMP, and return false if the
841 number was well-formed, true if not. WRAPPED is set to true if the
842 number did not fit into 'unsigned long'. */
844 strtolinenum (const uchar
*str
, size_t len
, linenum_type
*nump
, bool *wrapped
)
846 linenum_type reg
= 0;
847 linenum_type reg_prev
= 0;
866 /* Interpret #line command.
867 Note that the filename string (if any) is a true string constant
868 (escapes are interpreted), unlike in #line. */
870 do_line (cpp_reader
*pfile
)
872 const struct line_maps
*line_table
= pfile
->line_table
;
873 const struct line_map
*map
= &line_table
->maps
[line_table
->used
- 1];
875 /* skip_rest_of_line() may cause line table to be realloc()ed so note down
878 unsigned char map_sysp
= map
->sysp
;
879 const cpp_token
*token
;
880 const char *new_file
= map
->to_file
;
881 linenum_type new_lineno
;
883 /* C99 raised the minimum limit on #line numbers. */
884 linenum_type cap
= CPP_OPTION (pfile
, c99
) ? 2147483647 : 32767;
887 /* #line commands expand macros. */
888 token
= cpp_get_token (pfile
);
889 if (token
->type
!= CPP_NUMBER
890 || strtolinenum (token
->val
.str
.text
, token
->val
.str
.len
,
891 &new_lineno
, &wrapped
))
893 if (token
->type
== CPP_EOF
)
894 cpp_error (pfile
, CPP_DL_ERROR
, "unexpected end of file after #line");
896 cpp_error (pfile
, CPP_DL_ERROR
,
897 "\"%s\" after #line is not a positive integer",
898 cpp_token_as_text (pfile
, token
));
902 if (CPP_PEDANTIC (pfile
) && (new_lineno
== 0 || new_lineno
> cap
|| wrapped
))
903 cpp_error (pfile
, CPP_DL_PEDWARN
, "line number out of range");
905 cpp_error (pfile
, CPP_DL_WARNING
, "line number out of range");
907 token
= cpp_get_token (pfile
);
908 if (token
->type
== CPP_STRING
)
910 cpp_string s
= { 0, 0 };
911 if (cpp_interpret_string_notranslate (pfile
, &token
->val
.str
, 1,
913 new_file
= (const char *)s
.text
;
916 else if (token
->type
!= CPP_EOF
)
918 cpp_error (pfile
, CPP_DL_ERROR
, "\"%s\" is not a valid filename",
919 cpp_token_as_text (pfile
, token
));
923 skip_rest_of_line (pfile
);
924 _cpp_do_file_change (pfile
, LC_RENAME
, new_file
, new_lineno
,
928 /* Interpret the # 44 "file" [flags] notation, which has slightly
929 different syntax and semantics from #line: Flags are allowed,
930 and we never complain about the line number being too big. */
932 do_linemarker (cpp_reader
*pfile
)
934 const struct line_maps
*line_table
= pfile
->line_table
;
935 const struct line_map
*map
= &line_table
->maps
[line_table
->used
- 1];
936 const cpp_token
*token
;
937 const char *new_file
= map
->to_file
;
938 linenum_type new_lineno
;
939 unsigned int new_sysp
= map
->sysp
;
940 enum lc_reason reason
= LC_RENAME
;
944 /* Back up so we can get the number again. Putting this in
945 _cpp_handle_directive risks two calls to _cpp_backup_tokens in
946 some circumstances, which can segfault. */
947 _cpp_backup_tokens (pfile
, 1);
949 /* #line commands expand macros. */
950 token
= cpp_get_token (pfile
);
951 if (token
->type
!= CPP_NUMBER
952 || strtolinenum (token
->val
.str
.text
, token
->val
.str
.len
,
953 &new_lineno
, &wrapped
))
955 /* Unlike #line, there does not seem to be a way to get an EOF
956 here. So, it should be safe to always spell the token. */
957 cpp_error (pfile
, CPP_DL_ERROR
,
958 "\"%s\" after # is not a positive integer",
959 cpp_token_as_text (pfile
, token
));
963 token
= cpp_get_token (pfile
);
964 if (token
->type
== CPP_STRING
)
966 cpp_string s
= { 0, 0 };
967 if (cpp_interpret_string_notranslate (pfile
, &token
->val
.str
,
969 new_file
= (const char *)s
.text
;
972 flag
= read_flag (pfile
, 0);
976 /* Fake an include for cpp_included (). */
977 _cpp_fake_include (pfile
, new_file
);
978 flag
= read_flag (pfile
, flag
);
983 flag
= read_flag (pfile
, flag
);
988 flag
= read_flag (pfile
, flag
);
992 pfile
->buffer
->sysp
= new_sysp
;
996 else if (token
->type
!= CPP_EOF
)
998 cpp_error (pfile
, CPP_DL_ERROR
, "\"%s\" is not a valid filename",
999 cpp_token_as_text (pfile
, token
));
1003 skip_rest_of_line (pfile
);
1004 _cpp_do_file_change (pfile
, reason
, new_file
, new_lineno
, new_sysp
);
1007 /* Arrange the file_change callback. pfile->line has changed to
1008 FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system
1009 header, 2 for a system header that needs to be extern "C" protected,
1010 and zero otherwise. */
1012 _cpp_do_file_change (cpp_reader
*pfile
, enum lc_reason reason
,
1013 const char *to_file
, linenum_type file_line
,
1016 const struct line_map
*map
= linemap_add (pfile
->line_table
, reason
, sysp
,
1017 to_file
, file_line
);
1019 linemap_line_start (pfile
->line_table
, map
->to_line
, 127);
1021 if (pfile
->cb
.file_change
)
1022 pfile
->cb
.file_change (pfile
, map
);
1025 /* Report a warning or error detected by the program we are
1026 processing. Use the directive's tokens in the error message. */
1028 do_diagnostic (cpp_reader
*pfile
, int code
, int print_dir
)
1030 const unsigned char *dir_name
;
1031 unsigned char *line
;
1032 source_location src_loc
= pfile
->cur_token
[-1].src_loc
;
1035 dir_name
= pfile
->directive
->name
;
1038 pfile
->state
.prevent_expansion
++;
1039 line
= cpp_output_line_to_string (pfile
, dir_name
);
1040 pfile
->state
.prevent_expansion
--;
1042 cpp_error_with_line (pfile
, code
, src_loc
, 0, "%s", line
);
1047 do_error (cpp_reader
*pfile
)
1049 do_diagnostic (pfile
, CPP_DL_ERROR
, 1);
1053 do_warning (cpp_reader
*pfile
)
1055 /* We want #warning diagnostics to be emitted in system headers too. */
1056 do_diagnostic (pfile
, CPP_DL_WARNING_SYSHDR
, 1);
1059 /* Report program identification. */
1061 do_ident (cpp_reader
*pfile
)
1063 const cpp_token
*str
= cpp_get_token (pfile
);
1065 if (str
->type
!= CPP_STRING
)
1066 cpp_error (pfile
, CPP_DL_ERROR
, "invalid #%s directive",
1067 pfile
->directive
->name
);
1068 else if (pfile
->cb
.ident
)
1069 pfile
->cb
.ident (pfile
, pfile
->directive_line
, &str
->val
.str
);
1074 /* Lookup a PRAGMA name in a singly-linked CHAIN. Returns the
1075 matching entry, or NULL if none is found. The returned entry could
1076 be the start of a namespace chain, or a pragma. */
1077 static struct pragma_entry
*
1078 lookup_pragma_entry (struct pragma_entry
*chain
, const cpp_hashnode
*pragma
)
1080 while (chain
&& chain
->pragma
!= pragma
)
1081 chain
= chain
->next
;
1086 /* Create and insert a blank pragma entry at the beginning of a
1087 singly-linked CHAIN. */
1088 static struct pragma_entry
*
1089 new_pragma_entry (cpp_reader
*pfile
, struct pragma_entry
**chain
)
1091 struct pragma_entry
*new_entry
;
1093 new_entry
= (struct pragma_entry
*)
1094 _cpp_aligned_alloc (pfile
, sizeof (struct pragma_entry
));
1096 memset (new_entry
, 0, sizeof (struct pragma_entry
));
1097 new_entry
->next
= *chain
;
1103 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
1104 goes in the global namespace. */
1105 static struct pragma_entry
*
1106 register_pragma_1 (cpp_reader
*pfile
, const char *space
, const char *name
,
1107 bool allow_name_expansion
)
1109 struct pragma_entry
**chain
= &pfile
->pragmas
;
1110 struct pragma_entry
*entry
;
1111 const cpp_hashnode
*node
;
1115 node
= cpp_lookup (pfile
, UC space
, strlen (space
));
1116 entry
= lookup_pragma_entry (*chain
, node
);
1119 entry
= new_pragma_entry (pfile
, chain
);
1120 entry
->pragma
= node
;
1121 entry
->is_nspace
= true;
1122 entry
->allow_expansion
= allow_name_expansion
;
1124 else if (!entry
->is_nspace
)
1126 else if (entry
->allow_expansion
!= allow_name_expansion
)
1128 cpp_error (pfile
, CPP_DL_ICE
,
1129 "registering pragmas in namespace \"%s\" with mismatched "
1130 "name expansion", space
);
1133 chain
= &entry
->u
.space
;
1135 else if (allow_name_expansion
)
1137 cpp_error (pfile
, CPP_DL_ICE
,
1138 "registering pragma \"%s\" with name expansion "
1139 "and no namespace", name
);
1143 /* Check for duplicates. */
1144 node
= cpp_lookup (pfile
, UC name
, strlen (name
));
1145 entry
= lookup_pragma_entry (*chain
, node
);
1148 entry
= new_pragma_entry (pfile
, chain
);
1149 entry
->pragma
= node
;
1153 if (entry
->is_nspace
)
1155 cpp_error (pfile
, CPP_DL_ICE
,
1156 "registering \"%s\" as both a pragma and a pragma namespace",
1159 cpp_error (pfile
, CPP_DL_ICE
, "#pragma %s %s is already registered",
1162 cpp_error (pfile
, CPP_DL_ICE
, "#pragma %s is already registered", name
);
1167 /* Register a cpplib internal pragma SPACE NAME with HANDLER. */
1169 register_pragma_internal (cpp_reader
*pfile
, const char *space
,
1170 const char *name
, pragma_cb handler
)
1172 struct pragma_entry
*entry
;
1174 entry
= register_pragma_1 (pfile
, space
, name
, false);
1175 entry
->is_internal
= true;
1176 entry
->u
.handler
= handler
;
1179 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
1180 goes in the global namespace. HANDLER is the handler it will call,
1181 which must be non-NULL. If ALLOW_EXPANSION is set, allow macro
1182 expansion while parsing pragma NAME. This function is exported
1185 cpp_register_pragma (cpp_reader
*pfile
, const char *space
, const char *name
,
1186 pragma_cb handler
, bool allow_expansion
)
1188 struct pragma_entry
*entry
;
1192 cpp_error (pfile
, CPP_DL_ICE
, "registering pragma with NULL handler");
1196 entry
= register_pragma_1 (pfile
, space
, name
, false);
1199 entry
->allow_expansion
= allow_expansion
;
1200 entry
->u
.handler
= handler
;
1204 /* Similarly, but create mark the pragma for deferred processing.
1205 When found, a CPP_PRAGMA token will be insertted into the stream
1206 with IDENT in the token->u.pragma slot. */
1208 cpp_register_deferred_pragma (cpp_reader
*pfile
, const char *space
,
1209 const char *name
, unsigned int ident
,
1210 bool allow_expansion
, bool allow_name_expansion
)
1212 struct pragma_entry
*entry
;
1214 entry
= register_pragma_1 (pfile
, space
, name
, allow_name_expansion
);
1217 entry
->is_deferred
= true;
1218 entry
->allow_expansion
= allow_expansion
;
1219 entry
->u
.ident
= ident
;
1223 /* Register the pragmas the preprocessor itself handles. */
1225 _cpp_init_internal_pragmas (cpp_reader
*pfile
)
1227 /* Pragmas in the global namespace. */
1228 register_pragma_internal (pfile
, 0, "once", do_pragma_once
);
1230 /* New GCC-specific pragmas should be put in the GCC namespace. */
1231 register_pragma_internal (pfile
, "GCC", "poison", do_pragma_poison
);
1232 register_pragma_internal (pfile
, "GCC", "system_header",
1233 do_pragma_system_header
);
1234 register_pragma_internal (pfile
, "GCC", "dependency", do_pragma_dependency
);
1237 /* Return the number of registered pragmas in PE. */
1240 count_registered_pragmas (struct pragma_entry
*pe
)
1243 for (; pe
!= NULL
; pe
= pe
->next
)
1246 ct
+= count_registered_pragmas (pe
->u
.space
);
1252 /* Save into SD the names of the registered pragmas referenced by PE,
1253 and return a pointer to the next free space in SD. */
1256 save_registered_pragmas (struct pragma_entry
*pe
, char **sd
)
1258 for (; pe
!= NULL
; pe
= pe
->next
)
1261 sd
= save_registered_pragmas (pe
->u
.space
, sd
);
1262 *sd
++ = (char *) xmemdup (HT_STR (&pe
->pragma
->ident
),
1263 HT_LEN (&pe
->pragma
->ident
),
1264 HT_LEN (&pe
->pragma
->ident
) + 1);
1269 /* Return a newly-allocated array which saves the names of the
1270 registered pragmas. */
1273 _cpp_save_pragma_names (cpp_reader
*pfile
)
1275 int ct
= count_registered_pragmas (pfile
->pragmas
);
1276 char **result
= XNEWVEC (char *, ct
);
1277 (void) save_registered_pragmas (pfile
->pragmas
, result
);
1281 /* Restore from SD the names of the registered pragmas referenced by PE,
1282 and return a pointer to the next unused name in SD. */
1285 restore_registered_pragmas (cpp_reader
*pfile
, struct pragma_entry
*pe
,
1288 for (; pe
!= NULL
; pe
= pe
->next
)
1291 sd
= restore_registered_pragmas (pfile
, pe
->u
.space
, sd
);
1292 pe
->pragma
= cpp_lookup (pfile
, UC
*sd
, strlen (*sd
));
1299 /* Restore the names of the registered pragmas from SAVED. */
1302 _cpp_restore_pragma_names (cpp_reader
*pfile
, char **saved
)
1304 (void) restore_registered_pragmas (pfile
, pfile
->pragmas
, saved
);
1308 /* Pragmata handling. We handle some, and pass the rest on to the
1309 front end. C99 defines three pragmas and says that no macro
1310 expansion is to be performed on them; whether or not macro
1311 expansion happens for other pragmas is implementation defined.
1312 This implementation allows for a mix of both, since GCC did not
1313 traditionally macro expand its (few) pragmas, whereas OpenMP
1314 specifies that macro expansion should happen. */
1316 do_pragma (cpp_reader
*pfile
)
1318 const struct pragma_entry
*p
= NULL
;
1319 const cpp_token
*token
, *pragma_token
= pfile
->cur_token
;
1321 unsigned int count
= 1;
1323 pfile
->state
.prevent_expansion
++;
1325 token
= cpp_get_token (pfile
);
1327 if (token
->type
== CPP_NAME
)
1329 p
= lookup_pragma_entry (pfile
->pragmas
, token
->val
.node
);
1330 if (p
&& p
->is_nspace
)
1332 bool allow_name_expansion
= p
->allow_expansion
;
1333 if (allow_name_expansion
)
1334 pfile
->state
.prevent_expansion
--;
1335 token
= cpp_get_token (pfile
);
1336 if (token
->type
== CPP_NAME
)
1337 p
= lookup_pragma_entry (p
->u
.space
, token
->val
.node
);
1340 if (allow_name_expansion
)
1341 pfile
->state
.prevent_expansion
++;
1350 pfile
->directive_result
.src_loc
= pragma_token
->src_loc
;
1351 pfile
->directive_result
.type
= CPP_PRAGMA
;
1352 pfile
->directive_result
.flags
= pragma_token
->flags
;
1353 pfile
->directive_result
.val
.pragma
= p
->u
.ident
;
1354 pfile
->state
.in_deferred_pragma
= true;
1355 pfile
->state
.pragma_allow_expansion
= p
->allow_expansion
;
1356 if (!p
->allow_expansion
)
1357 pfile
->state
.prevent_expansion
++;
1361 /* Since the handler below doesn't get the line number, that
1362 it might need for diagnostics, make sure it has the right
1363 numbers in place. */
1364 if (pfile
->cb
.line_change
)
1365 (*pfile
->cb
.line_change
) (pfile
, pragma_token
, false);
1366 if (p
->allow_expansion
)
1367 pfile
->state
.prevent_expansion
--;
1368 (*p
->u
.handler
) (pfile
);
1369 if (p
->allow_expansion
)
1370 pfile
->state
.prevent_expansion
++;
1373 else if (pfile
->cb
.def_pragma
)
1375 if (count
== 1 || pfile
->context
->prev
== NULL
)
1376 _cpp_backup_tokens (pfile
, count
);
1379 /* Invalid name comes from macro expansion, _cpp_backup_tokens
1380 won't allow backing 2 tokens. */
1381 /* ??? The token buffer is leaked. Perhaps if def_pragma hook
1382 reads both tokens, we could perhaps free it, but if it doesn't,
1383 we don't know the exact lifespan. */
1384 cpp_token
*toks
= XNEWVEC (cpp_token
, 2);
1386 toks
[0].flags
|= NO_EXPAND
;
1388 toks
[1].flags
|= NO_EXPAND
;
1389 _cpp_push_token_context (pfile
, NULL
, toks
, 2);
1391 pfile
->cb
.def_pragma (pfile
, pfile
->directive_line
);
1394 pfile
->state
.prevent_expansion
--;
1397 /* Handle #pragma once. */
1399 do_pragma_once (cpp_reader
*pfile
)
1401 if (cpp_in_primary_file (pfile
))
1402 cpp_error (pfile
, CPP_DL_WARNING
, "#pragma once in main file");
1405 _cpp_mark_file_once_only (pfile
, pfile
->buffer
->file
);
1408 /* Handle #pragma GCC poison, to poison one or more identifiers so
1409 that the lexer produces a hard error for each subsequent usage. */
1411 do_pragma_poison (cpp_reader
*pfile
)
1413 const cpp_token
*tok
;
1416 pfile
->state
.poisoned_ok
= 1;
1419 tok
= _cpp_lex_token (pfile
);
1420 if (tok
->type
== CPP_EOF
)
1422 if (tok
->type
!= CPP_NAME
)
1424 cpp_error (pfile
, CPP_DL_ERROR
,
1425 "invalid #pragma GCC poison directive");
1430 if (hp
->flags
& NODE_POISONED
)
1433 if (hp
->type
== NT_MACRO
)
1434 cpp_error (pfile
, CPP_DL_WARNING
, "poisoning existing macro \"%s\"",
1436 _cpp_free_definition (hp
);
1437 hp
->flags
|= NODE_POISONED
| NODE_DIAGNOSTIC
;
1439 pfile
->state
.poisoned_ok
= 0;
1442 /* Mark the current header as a system header. This will suppress
1443 some categories of warnings (notably those from -pedantic). It is
1444 intended for use in system libraries that cannot be implemented in
1445 conforming C, but cannot be certain that their headers appear in a
1446 system include directory. To prevent abuse, it is rejected in the
1447 primary source file. */
1449 do_pragma_system_header (cpp_reader
*pfile
)
1451 if (cpp_in_primary_file (pfile
))
1452 cpp_error (pfile
, CPP_DL_WARNING
,
1453 "#pragma system_header ignored outside include file");
1457 skip_rest_of_line (pfile
);
1458 cpp_make_system_header (pfile
, 1, 0);
1462 /* Check the modified date of the current include file against a specified
1463 file. Issue a diagnostic, if the specified file is newer. We use this to
1464 determine if a fixed header should be refixed. */
1466 do_pragma_dependency (cpp_reader
*pfile
)
1469 int angle_brackets
, ordering
;
1471 fname
= parse_include (pfile
, &angle_brackets
, NULL
);
1475 ordering
= _cpp_compare_file_date (pfile
, fname
, angle_brackets
);
1477 cpp_error (pfile
, CPP_DL_WARNING
, "cannot find source file %s", fname
);
1478 else if (ordering
> 0)
1480 cpp_error (pfile
, CPP_DL_WARNING
,
1481 "current file is older than %s", fname
);
1482 if (cpp_get_token (pfile
)->type
!= CPP_EOF
)
1484 _cpp_backup_tokens (pfile
, 1);
1485 do_diagnostic (pfile
, CPP_DL_WARNING
, 0);
1489 free ((void *) fname
);
1492 /* Get a token but skip padding. */
1493 static const cpp_token
*
1494 get_token_no_padding (cpp_reader
*pfile
)
1498 const cpp_token
*result
= cpp_get_token (pfile
);
1499 if (result
->type
!= CPP_PADDING
)
1504 /* Check syntax is "(string-literal)". Returns the string on success,
1505 or NULL on failure. */
1506 static const cpp_token
*
1507 get__Pragma_string (cpp_reader
*pfile
)
1509 const cpp_token
*string
;
1510 const cpp_token
*paren
;
1512 paren
= get_token_no_padding (pfile
);
1513 if (paren
->type
== CPP_EOF
)
1514 _cpp_backup_tokens (pfile
, 1);
1515 if (paren
->type
!= CPP_OPEN_PAREN
)
1518 string
= get_token_no_padding (pfile
);
1519 if (string
->type
== CPP_EOF
)
1520 _cpp_backup_tokens (pfile
, 1);
1521 if (string
->type
!= CPP_STRING
&& string
->type
!= CPP_WSTRING
1522 && string
->type
!= CPP_STRING32
&& string
->type
!= CPP_STRING16
)
1525 paren
= get_token_no_padding (pfile
);
1526 if (paren
->type
== CPP_EOF
)
1527 _cpp_backup_tokens (pfile
, 1);
1528 if (paren
->type
!= CPP_CLOSE_PAREN
)
1534 /* Destringize IN into a temporary buffer, by removing the first \ of
1535 \" and \\ sequences, and process the result as a #pragma directive. */
1537 destringize_and_run (cpp_reader
*pfile
, const cpp_string
*in
)
1539 const unsigned char *src
, *limit
;
1540 char *dest
, *result
;
1541 cpp_context
*saved_context
;
1542 cpp_token
*saved_cur_token
;
1543 tokenrun
*saved_cur_run
;
1546 const struct directive
*save_directive
;
1548 dest
= result
= (char *) alloca (in
->len
- 1);
1549 src
= in
->text
+ 1 + (in
->text
[0] == 'L');
1550 limit
= in
->text
+ in
->len
- 1;
1553 /* We know there is a character following the backslash. */
1554 if (*src
== '\\' && (src
[1] == '\\' || src
[1] == '"'))
1560 /* Ugh; an awful kludge. We are really not set up to be lexing
1561 tokens when in the middle of a macro expansion. Use a new
1562 context to force cpp_get_token to lex, and so skip_rest_of_line
1563 doesn't go beyond the end of the text. Also, remember the
1564 current lexing position so we can return to it later.
1566 Something like line-at-a-time lexing should remove the need for
1568 saved_context
= pfile
->context
;
1569 saved_cur_token
= pfile
->cur_token
;
1570 saved_cur_run
= pfile
->cur_run
;
1572 pfile
->context
= XNEW (cpp_context
);
1573 pfile
->context
->macro
= 0;
1574 pfile
->context
->prev
= 0;
1575 pfile
->context
->next
= 0;
1577 /* Inline run_directive, since we need to delay the _cpp_pop_buffer
1578 until we've read all of the tokens that we want. */
1579 cpp_push_buffer (pfile
, (const uchar
*) result
, dest
- result
,
1580 /* from_stage3 */ true);
1581 /* ??? Antique Disgusting Hack. What does this do? */
1582 if (pfile
->buffer
->prev
)
1583 pfile
->buffer
->file
= pfile
->buffer
->prev
->file
;
1585 start_directive (pfile
);
1586 _cpp_clean_line (pfile
);
1587 save_directive
= pfile
->directive
;
1588 pfile
->directive
= &dtable
[T_PRAGMA
];
1590 end_directive (pfile
, 1);
1591 pfile
->directive
= save_directive
;
1593 /* We always insert at least one token, the directive result. It'll
1594 either be a CPP_PADDING or a CPP_PRAGMA. In the later case, we
1595 need to insert *all* of the tokens, including the CPP_PRAGMA_EOL. */
1597 /* If we're not handling the pragma internally, read all of the tokens from
1598 the string buffer now, while the string buffer is still installed. */
1599 /* ??? Note that the token buffer allocated here is leaked. It's not clear
1600 to me what the true lifespan of the tokens are. It would appear that
1601 the lifespan is the entire parse of the main input stream, in which case
1602 this may not be wrong. */
1603 if (pfile
->directive_result
.type
== CPP_PRAGMA
)
1609 toks
= XNEWVEC (cpp_token
, maxcount
);
1610 toks
[0] = pfile
->directive_result
;
1614 if (count
== maxcount
)
1616 maxcount
= maxcount
* 3 / 2;
1617 toks
= XRESIZEVEC (cpp_token
, toks
, maxcount
);
1619 toks
[count
] = *cpp_get_token (pfile
);
1620 /* Macros have been already expanded by cpp_get_token
1621 if the pragma allowed expansion. */
1622 toks
[count
++].flags
|= NO_EXPAND
;
1624 while (toks
[count
-1].type
!= CPP_PRAGMA_EOL
);
1629 toks
= XNEW (cpp_token
);
1630 toks
[0] = pfile
->directive_result
;
1632 /* If we handled the entire pragma internally, make sure we get the
1633 line number correct for the next token. */
1634 if (pfile
->cb
.line_change
)
1635 pfile
->cb
.line_change (pfile
, pfile
->cur_token
, false);
1638 /* Finish inlining run_directive. */
1639 pfile
->buffer
->file
= NULL
;
1640 _cpp_pop_buffer (pfile
);
1642 /* Reset the old macro state before ... */
1643 XDELETE (pfile
->context
);
1644 pfile
->context
= saved_context
;
1645 pfile
->cur_token
= saved_cur_token
;
1646 pfile
->cur_run
= saved_cur_run
;
1648 /* ... inserting the new tokens we collected. */
1649 _cpp_push_token_context (pfile
, NULL
, toks
, count
);
1652 /* Handle the _Pragma operator. Return 0 on error, 1 if ok. */
1654 _cpp_do__Pragma (cpp_reader
*pfile
)
1656 const cpp_token
*string
= get__Pragma_string (pfile
);
1657 pfile
->directive_result
.type
= CPP_PADDING
;
1661 destringize_and_run (pfile
, &string
->val
.str
);
1664 cpp_error (pfile
, CPP_DL_ERROR
,
1665 "_Pragma takes a parenthesized string literal");
1669 /* Handle #ifdef. */
1671 do_ifdef (cpp_reader
*pfile
)
1675 if (! pfile
->state
.skipping
)
1677 cpp_hashnode
*node
= lex_macro_node (pfile
, false);
1681 skip
= node
->type
!= NT_MACRO
;
1682 _cpp_mark_macro_used (node
);
1683 if (!(node
->flags
& NODE_USED
))
1685 node
->flags
|= NODE_USED
;
1686 if (node
->type
== NT_MACRO
)
1688 if (pfile
->cb
.used_define
)
1689 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
1693 if (pfile
->cb
.used_undef
)
1694 pfile
->cb
.used_undef (pfile
, pfile
->directive_line
, node
);
1701 push_conditional (pfile
, skip
, T_IFDEF
, 0);
1704 /* Handle #ifndef. */
1706 do_ifndef (cpp_reader
*pfile
)
1709 cpp_hashnode
*node
= 0;
1711 if (! pfile
->state
.skipping
)
1713 node
= lex_macro_node (pfile
, false);
1717 skip
= node
->type
== NT_MACRO
;
1718 _cpp_mark_macro_used (node
);
1719 if (!(node
->flags
& NODE_USED
))
1721 node
->flags
|= NODE_USED
;
1722 if (node
->type
== NT_MACRO
)
1724 if (pfile
->cb
.used_define
)
1725 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
1729 if (pfile
->cb
.used_undef
)
1730 pfile
->cb
.used_undef (pfile
, pfile
->directive_line
, node
);
1737 push_conditional (pfile
, skip
, T_IFNDEF
, node
);
1740 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1741 pfile->mi_ind_cmacro so we can handle multiple-include
1742 optimizations. If macro expansion occurs in the expression, we
1743 cannot treat it as a controlling conditional, since the expansion
1744 could change in the future. That is handled by cpp_get_token. */
1746 do_if (cpp_reader
*pfile
)
1750 if (! pfile
->state
.skipping
)
1751 skip
= _cpp_parse_expr (pfile
, true) == false;
1753 push_conditional (pfile
, skip
, T_IF
, pfile
->mi_ind_cmacro
);
1756 /* Flip skipping state if appropriate and continue without changing
1757 if_stack; this is so that the error message for missing #endif's
1758 etc. will point to the original #if. */
1760 do_else (cpp_reader
*pfile
)
1762 cpp_buffer
*buffer
= pfile
->buffer
;
1763 struct if_stack
*ifs
= buffer
->if_stack
;
1766 cpp_error (pfile
, CPP_DL_ERROR
, "#else without #if");
1769 if (ifs
->type
== T_ELSE
)
1771 cpp_error (pfile
, CPP_DL_ERROR
, "#else after #else");
1772 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
1773 "the conditional began here");
1777 /* Skip any future (erroneous) #elses or #elifs. */
1778 pfile
->state
.skipping
= ifs
->skip_elses
;
1779 ifs
->skip_elses
= true;
1781 /* Invalidate any controlling macro. */
1784 /* Only check EOL if was not originally skipping. */
1785 if (!ifs
->was_skipping
&& CPP_OPTION (pfile
, warn_endif_labels
))
1790 /* Handle a #elif directive by not changing if_stack either. See the
1791 comment above do_else. */
1793 do_elif (cpp_reader
*pfile
)
1795 cpp_buffer
*buffer
= pfile
->buffer
;
1796 struct if_stack
*ifs
= buffer
->if_stack
;
1799 cpp_error (pfile
, CPP_DL_ERROR
, "#elif without #if");
1802 if (ifs
->type
== T_ELSE
)
1804 cpp_error (pfile
, CPP_DL_ERROR
, "#elif after #else");
1805 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
1806 "the conditional began here");
1810 if (! ifs
->was_skipping
)
1813 /* The standard mandates that the expression be parsed even
1814 if we are skipping elses at this point -- the lexical
1815 restrictions on #elif only apply to skipped groups, but
1816 this group is not being skipped. Temporarily set
1817 skipping to false to get lexer warnings. */
1818 pfile
->state
.skipping
= 0;
1819 value
= _cpp_parse_expr (pfile
, false);
1820 if (ifs
->skip_elses
)
1821 pfile
->state
.skipping
= 1;
1824 pfile
->state
.skipping
= ! value
;
1825 ifs
->skip_elses
= value
;
1829 /* Invalidate any controlling macro. */
1834 /* #endif pops the if stack and resets pfile->state.skipping. */
1836 do_endif (cpp_reader
*pfile
)
1838 cpp_buffer
*buffer
= pfile
->buffer
;
1839 struct if_stack
*ifs
= buffer
->if_stack
;
1842 cpp_error (pfile
, CPP_DL_ERROR
, "#endif without #if");
1845 /* Only check EOL if was not originally skipping. */
1846 if (!ifs
->was_skipping
&& CPP_OPTION (pfile
, warn_endif_labels
))
1849 /* If potential control macro, we go back outside again. */
1850 if (ifs
->next
== 0 && ifs
->mi_cmacro
)
1852 pfile
->mi_valid
= true;
1853 pfile
->mi_cmacro
= ifs
->mi_cmacro
;
1856 buffer
->if_stack
= ifs
->next
;
1857 pfile
->state
.skipping
= ifs
->was_skipping
;
1858 obstack_free (&pfile
->buffer_ob
, ifs
);
1862 /* Push an if_stack entry for a preprocessor conditional, and set
1863 pfile->state.skipping to SKIP. If TYPE indicates the conditional
1864 is #if or #ifndef, CMACRO is a potentially controlling macro, and
1865 we need to check here that we are at the top of the file. */
1867 push_conditional (cpp_reader
*pfile
, int skip
, int type
,
1868 const cpp_hashnode
*cmacro
)
1870 struct if_stack
*ifs
;
1871 cpp_buffer
*buffer
= pfile
->buffer
;
1873 ifs
= XOBNEW (&pfile
->buffer_ob
, struct if_stack
);
1874 ifs
->line
= pfile
->directive_line
;
1875 ifs
->next
= buffer
->if_stack
;
1876 ifs
->skip_elses
= pfile
->state
.skipping
|| !skip
;
1877 ifs
->was_skipping
= pfile
->state
.skipping
;
1879 /* This condition is effectively a test for top-of-file. */
1880 if (pfile
->mi_valid
&& pfile
->mi_cmacro
== 0)
1881 ifs
->mi_cmacro
= cmacro
;
1885 pfile
->state
.skipping
= skip
;
1886 buffer
->if_stack
= ifs
;
1889 /* Read the tokens of the answer into the macro pool, in a directive
1890 of type TYPE. Only commit the memory if we intend it as permanent
1891 storage, i.e. the #assert case. Returns 0 on success, and sets
1892 ANSWERP to point to the answer. */
1894 parse_answer (cpp_reader
*pfile
, struct answer
**answerp
, int type
)
1896 const cpp_token
*paren
;
1897 struct answer
*answer
;
1898 unsigned int acount
;
1900 /* In a conditional, it is legal to not have an open paren. We
1901 should save the following token in this case. */
1902 paren
= cpp_get_token (pfile
);
1904 /* If not a paren, see if we're OK. */
1905 if (paren
->type
!= CPP_OPEN_PAREN
)
1907 /* In a conditional no answer is a test for any answer. It
1908 could be followed by any token. */
1911 _cpp_backup_tokens (pfile
, 1);
1915 /* #unassert with no answer is valid - it removes all answers. */
1916 if (type
== T_UNASSERT
&& paren
->type
== CPP_EOF
)
1919 cpp_error (pfile
, CPP_DL_ERROR
, "missing '(' after predicate");
1923 for (acount
= 0;; acount
++)
1926 const cpp_token
*token
= cpp_get_token (pfile
);
1929 if (token
->type
== CPP_CLOSE_PAREN
)
1932 if (token
->type
== CPP_EOF
)
1934 cpp_error (pfile
, CPP_DL_ERROR
, "missing ')' to complete answer");
1938 /* struct answer includes the space for one token. */
1939 room_needed
= (sizeof (struct answer
) + acount
* sizeof (cpp_token
));
1941 if (BUFF_ROOM (pfile
->a_buff
) < room_needed
)
1942 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (struct answer
));
1944 dest
= &((struct answer
*) BUFF_FRONT (pfile
->a_buff
))->first
[acount
];
1947 /* Drop whitespace at start, for answer equivalence purposes. */
1949 dest
->flags
&= ~PREV_WHITE
;
1954 cpp_error (pfile
, CPP_DL_ERROR
, "predicate's answer is empty");
1958 answer
= (struct answer
*) BUFF_FRONT (pfile
->a_buff
);
1959 answer
->count
= acount
;
1960 answer
->next
= NULL
;
1966 /* Parses an assertion directive of type TYPE, returning a pointer to
1967 the hash node of the predicate, or 0 on error. If an answer was
1968 supplied, it is placed in ANSWERP, otherwise it is set to 0. */
1969 static cpp_hashnode
*
1970 parse_assertion (cpp_reader
*pfile
, struct answer
**answerp
, int type
)
1972 cpp_hashnode
*result
= 0;
1973 const cpp_token
*predicate
;
1975 /* We don't expand predicates or answers. */
1976 pfile
->state
.prevent_expansion
++;
1979 predicate
= cpp_get_token (pfile
);
1980 if (predicate
->type
== CPP_EOF
)
1981 cpp_error (pfile
, CPP_DL_ERROR
, "assertion without predicate");
1982 else if (predicate
->type
!= CPP_NAME
)
1983 cpp_error (pfile
, CPP_DL_ERROR
, "predicate must be an identifier");
1984 else if (parse_answer (pfile
, answerp
, type
) == 0)
1986 unsigned int len
= NODE_LEN (predicate
->val
.node
);
1987 unsigned char *sym
= (unsigned char *) alloca (len
+ 1);
1989 /* Prefix '#' to get it out of macro namespace. */
1991 memcpy (sym
+ 1, NODE_NAME (predicate
->val
.node
), len
);
1992 result
= cpp_lookup (pfile
, sym
, len
+ 1);
1995 pfile
->state
.prevent_expansion
--;
1999 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
2000 or a pointer to NULL if the answer is not in the chain. */
2001 static struct answer
**
2002 find_answer (cpp_hashnode
*node
, const struct answer
*candidate
)
2005 struct answer
**result
;
2007 for (result
= &node
->value
.answers
; *result
; result
= &(*result
)->next
)
2009 struct answer
*answer
= *result
;
2011 if (answer
->count
== candidate
->count
)
2013 for (i
= 0; i
< answer
->count
; i
++)
2014 if (! _cpp_equiv_tokens (&answer
->first
[i
], &candidate
->first
[i
]))
2017 if (i
== answer
->count
)
2025 /* Test an assertion within a preprocessor conditional. Returns
2026 nonzero on failure, zero on success. On success, the result of
2027 the test is written into VALUE, otherwise the value 0. */
2029 _cpp_test_assertion (cpp_reader
*pfile
, unsigned int *value
)
2031 struct answer
*answer
;
2034 node
= parse_assertion (pfile
, &answer
, T_IF
);
2036 /* For recovery, an erroneous assertion expression is handled as a
2037 failing assertion. */
2041 *value
= (node
->type
== NT_ASSERTION
&&
2042 (answer
== 0 || *find_answer (node
, answer
) != 0));
2043 else if (pfile
->cur_token
[-1].type
== CPP_EOF
)
2044 _cpp_backup_tokens (pfile
, 1);
2046 /* We don't commit the memory for the answer - it's temporary only. */
2050 /* Handle #assert. */
2052 do_assert (cpp_reader
*pfile
)
2054 struct answer
*new_answer
;
2057 node
= parse_assertion (pfile
, &new_answer
, T_ASSERT
);
2062 /* Place the new answer in the answer list. First check there
2063 is not a duplicate. */
2064 new_answer
->next
= 0;
2065 if (node
->type
== NT_ASSERTION
)
2067 if (*find_answer (node
, new_answer
))
2069 cpp_error (pfile
, CPP_DL_WARNING
, "\"%s\" re-asserted",
2070 NODE_NAME (node
) + 1);
2073 new_answer
->next
= node
->value
.answers
;
2076 answer_size
= sizeof (struct answer
) + ((new_answer
->count
- 1)
2077 * sizeof (cpp_token
));
2078 /* Commit or allocate storage for the object. */
2079 if (pfile
->hash_table
->alloc_subobject
)
2081 struct answer
*temp_answer
= new_answer
;
2082 new_answer
= (struct answer
*) pfile
->hash_table
->alloc_subobject
2084 memcpy (new_answer
, temp_answer
, answer_size
);
2087 BUFF_FRONT (pfile
->a_buff
) += answer_size
;
2089 node
->type
= NT_ASSERTION
;
2090 node
->value
.answers
= new_answer
;
2095 /* Handle #unassert. */
2097 do_unassert (cpp_reader
*pfile
)
2100 struct answer
*answer
;
2102 node
= parse_assertion (pfile
, &answer
, T_UNASSERT
);
2103 /* It isn't an error to #unassert something that isn't asserted. */
2104 if (node
&& node
->type
== NT_ASSERTION
)
2108 struct answer
**p
= find_answer (node
, answer
), *temp
;
2110 /* Remove the answer from the list. */
2115 /* Did we free the last answer? */
2116 if (node
->value
.answers
== 0)
2117 node
->type
= NT_VOID
;
2122 _cpp_free_definition (node
);
2125 /* We don't commit the memory for the answer - it's temporary only. */
2128 /* These are for -D, -U, -A. */
2130 /* Process the string STR as if it appeared as the body of a #define.
2131 If STR is just an identifier, define it with value 1.
2132 If STR has anything after the identifier, then it should
2133 be identifier=definition. */
2135 cpp_define (cpp_reader
*pfile
, const char *str
)
2140 /* Copy the entire option so we can modify it.
2141 Change the first "=" in the string to a space. If there is none,
2142 tack " 1" on the end. */
2144 count
= strlen (str
);
2145 buf
= (char *) alloca (count
+ 3);
2146 memcpy (buf
, str
, count
);
2148 p
= strchr (str
, '=');
2158 run_directive (pfile
, T_DEFINE
, buf
, count
);
2162 /* Use to build macros to be run through cpp_define() as
2164 Example: cpp_define_formatted (pfile, "MACRO=%d", value); */
2167 cpp_define_formatted (cpp_reader
*pfile
, const char *fmt
, ...)
2173 vasprintf (&ptr
, fmt
, ap
);
2176 cpp_define (pfile
, ptr
);
2181 /* Slight variant of the above for use by initialize_builtins. */
2183 _cpp_define_builtin (cpp_reader
*pfile
, const char *str
)
2185 size_t len
= strlen (str
);
2186 char *buf
= (char *) alloca (len
+ 1);
2187 memcpy (buf
, str
, len
);
2189 run_directive (pfile
, T_DEFINE
, buf
, len
);
2192 /* Process MACRO as if it appeared as the body of an #undef. */
2194 cpp_undef (cpp_reader
*pfile
, const char *macro
)
2196 size_t len
= strlen (macro
);
2197 char *buf
= (char *) alloca (len
+ 1);
2198 memcpy (buf
, macro
, len
);
2200 run_directive (pfile
, T_UNDEF
, buf
, len
);
2203 /* Like lex_macro_node, but read the input from STR. */
2204 static cpp_hashnode
*
2205 lex_macro_node_from_str (cpp_reader
*pfile
, const char *str
)
2207 size_t len
= strlen (str
);
2208 uchar
*buf
= (uchar
*) alloca (len
+ 1);
2211 memcpy (buf
, str
, len
);
2213 cpp_push_buffer (pfile
, buf
, len
, true);
2214 node
= lex_macro_node (pfile
, true);
2215 _cpp_pop_buffer (pfile
);
2220 /* If STR is a defined macro, return its definition node, else return NULL. */
2222 cpp_push_definition (cpp_reader
*pfile
, const char *str
)
2224 cpp_hashnode
*node
= lex_macro_node_from_str (pfile
, str
);
2225 if (node
&& node
->type
== NT_MACRO
)
2226 return node
->value
.macro
;
2231 /* Replace a previous definition DFN of the macro STR. If DFN is NULL,
2232 then the macro should be undefined. */
2234 cpp_pop_definition (cpp_reader
*pfile
, const char *str
, cpp_macro
*dfn
)
2236 cpp_hashnode
*node
= lex_macro_node_from_str (pfile
, str
);
2240 if (pfile
->cb
.before_define
)
2241 pfile
->cb
.before_define (pfile
);
2243 if (node
->type
== NT_MACRO
)
2245 if (pfile
->cb
.undef
)
2246 pfile
->cb
.undef (pfile
, pfile
->directive_line
, node
);
2247 if (CPP_OPTION (pfile
, warn_unused_macros
))
2248 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
2250 if (node
->type
!= NT_VOID
)
2251 _cpp_free_definition (node
);
2255 node
->type
= NT_MACRO
;
2256 node
->value
.macro
= dfn
;
2257 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_")))
2258 node
->flags
|= NODE_WARN
;
2260 if (pfile
->cb
.define
)
2261 pfile
->cb
.define (pfile
, pfile
->directive_line
, node
);
2265 /* Process the string STR as if it appeared as the body of a #assert. */
2267 cpp_assert (cpp_reader
*pfile
, const char *str
)
2269 handle_assertion (pfile
, str
, T_ASSERT
);
2272 /* Process STR as if it appeared as the body of an #unassert. */
2274 cpp_unassert (cpp_reader
*pfile
, const char *str
)
2276 handle_assertion (pfile
, str
, T_UNASSERT
);
2279 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
2281 handle_assertion (cpp_reader
*pfile
, const char *str
, int type
)
2283 size_t count
= strlen (str
);
2284 const char *p
= strchr (str
, '=');
2286 /* Copy the entire option so we can modify it. Change the first
2287 "=" in the string to a '(', and tack a ')' on the end. */
2288 char *buf
= (char *) alloca (count
+ 2);
2290 memcpy (buf
, str
, count
);
2299 run_directive (pfile
, type
, str
, count
);
2302 /* The number of errors for a given reader. */
2304 cpp_errors (cpp_reader
*pfile
)
2306 return pfile
->errors
;
2309 /* The options structure. */
2311 cpp_get_options (cpp_reader
*pfile
)
2313 return &pfile
->opts
;
2316 /* The callbacks structure. */
2318 cpp_get_callbacks (cpp_reader
*pfile
)
2323 /* Copy the given callbacks structure to our own. */
2325 cpp_set_callbacks (cpp_reader
*pfile
, cpp_callbacks
*cb
)
2330 /* The dependencies structure. (Creates one if it hasn't already been.) */
2332 cpp_get_deps (cpp_reader
*pfile
)
2335 pfile
->deps
= deps_init ();
2339 /* Push a new buffer on the buffer stack. Returns the new buffer; it
2340 doesn't fail. It does not generate a file change call back; that
2341 is the responsibility of the caller. */
2343 cpp_push_buffer (cpp_reader
*pfile
, const uchar
*buffer
, size_t len
,
2346 cpp_buffer
*new_buffer
= XOBNEW (&pfile
->buffer_ob
, cpp_buffer
);
2348 /* Clears, amongst other things, if_stack and mi_cmacro. */
2349 memset (new_buffer
, 0, sizeof (cpp_buffer
));
2351 new_buffer
->next_line
= new_buffer
->buf
= buffer
;
2352 new_buffer
->rlimit
= buffer
+ len
;
2353 new_buffer
->from_stage3
= from_stage3
;
2354 new_buffer
->prev
= pfile
->buffer
;
2355 new_buffer
->need_line
= true;
2357 pfile
->buffer
= new_buffer
;
2362 /* Pops a single buffer, with a file change call-back if appropriate.
2363 Then pushes the next -include file, if any remain. */
2365 _cpp_pop_buffer (cpp_reader
*pfile
)
2367 cpp_buffer
*buffer
= pfile
->buffer
;
2368 struct _cpp_file
*inc
= buffer
->file
;
2369 struct if_stack
*ifs
;
2371 /* Walk back up the conditional stack till we reach its level at
2372 entry to this file, issuing error messages. */
2373 for (ifs
= buffer
->if_stack
; ifs
; ifs
= ifs
->next
)
2374 cpp_error_with_line (pfile
, CPP_DL_ERROR
, ifs
->line
, 0,
2375 "unterminated #%s", dtable
[ifs
->type
].name
);
2377 /* In case of a missing #endif. */
2378 pfile
->state
.skipping
= 0;
2380 /* _cpp_do_file_change expects pfile->buffer to be the new one. */
2381 pfile
->buffer
= buffer
->prev
;
2383 free (buffer
->notes
);
2385 /* Free the buffer object now; we may want to push a new buffer
2386 in _cpp_push_next_include_file. */
2387 obstack_free (&pfile
->buffer_ob
, buffer
);
2391 _cpp_pop_file_buffer (pfile
, inc
);
2393 _cpp_do_file_change (pfile
, LC_LEAVE
, 0, 0, 0);
2397 /* Enter all recognized directives in the hash table. */
2399 _cpp_init_directives (cpp_reader
*pfile
)
2404 for (i
= 0; i
< (unsigned int) N_DIRECTIVES
; i
++)
2406 node
= cpp_lookup (pfile
, dtable
[i
].name
, dtable
[i
].length
);
2407 node
->is_directive
= 1;
2408 node
->directive_index
= i
;