1 /* CPP Library. (Directive handling.)
2 Copyright (C) 1986-2016 Free Software Foundation, Inc.
3 Contributed by Per Bothner, 1994-95.
4 Based on CCCP program by Paul Rubin, June 1986
5 Adapted to ANSI C, Richard Stallman, Jan 1987
6
7 This program is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 3, or (at your option) any
10 later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
20
21 #include "config.h"
22 #include "system.h"
23 #include "cpplib.h"
24 #include "internal.h"
25 #include "mkdeps.h"
26 #include "obstack.h"
27
28 /* Stack of conditionals currently in progress
29 (including both successful and failing conditionals). */
30 struct if_stack
31 {
32 struct if_stack *next;
33 source_location line; /* Line where condition started. */
34 const cpp_hashnode *mi_cmacro;/* macro name for #ifndef around entire file */
35 bool skip_elses; /* Can future #else / #elif be skipped? */
36 bool was_skipping; /* If were skipping on entry. */
37 int type; /* Most recent conditional for diagnostics. */
38 };
39
40 /* Contains a registered pragma or pragma namespace. */
41 typedef void (*pragma_cb) (cpp_reader *);
42 struct pragma_entry
43 {
44 struct pragma_entry *next;
45 const cpp_hashnode *pragma; /* Name and length. */
46 bool is_nspace;
47 bool is_internal;
48 bool is_deferred;
49 bool allow_expansion;
50 union {
51 pragma_cb handler;
52 struct pragma_entry *space;
53 unsigned int ident;
54 } u;
55 };
56
57 /* Values for the origin field of struct directive. KANDR directives
58 come from traditional (K&R) C. STDC89 directives come from the
59 1989 C standard. EXTENSION directives are extensions. */
60 #define KANDR 0
61 #define STDC89 1
62 #define EXTENSION 2
63
64 /* Values for the flags field of struct directive. COND indicates a
65 conditional; IF_COND an opening conditional. INCL means to treat
66 "..." and <...> as q-char and h-char sequences respectively. IN_I
67 means this directive should be handled even if -fpreprocessed is in
68 effect (these are the directives with callback hooks).
69
70 EXPAND is set on directives that are always macro-expanded. */
71 #define COND (1 << 0)
72 #define IF_COND (1 << 1)
73 #define INCL (1 << 2)
74 #define IN_I (1 << 3)
75 #define EXPAND (1 << 4)
76 #define DEPRECATED (1 << 5)
77
78 /* Defines one #-directive, including how to handle it. */
79 typedef void (*directive_handler) (cpp_reader *);
80 typedef struct directive directive;
81 struct directive
82 {
83 directive_handler handler; /* Function to handle directive. */
84 const uchar *name; /* Name of directive. */
85 unsigned short length; /* Length of name. */
86 unsigned char origin; /* Origin of directive. */
87 unsigned char flags; /* Flags describing this directive. */
88 };
89
90 /* Forward declarations. */
91
92 static void skip_rest_of_line (cpp_reader *);
93 static void check_eol (cpp_reader *, bool);
94 static void start_directive (cpp_reader *);
95 static void prepare_directive_trad (cpp_reader *);
96 static void end_directive (cpp_reader *, int);
97 static void directive_diagnostics (cpp_reader *, const directive *, int);
98 static void run_directive (cpp_reader *, int, const char *, size_t);
99 static char *glue_header_name (cpp_reader *);
100 static const char *parse_include (cpp_reader *, int *, const cpp_token ***,
101 source_location *);
102 static void push_conditional (cpp_reader *, int, int, const cpp_hashnode *);
103 static unsigned int read_flag (cpp_reader *, unsigned int);
104 static bool strtolinenum (const uchar *, size_t, linenum_type *, bool *);
105 static void do_diagnostic (cpp_reader *, int, 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 *,
114 char **);
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_pragma_warning_or_error (cpp_reader *, bool error);
120 static void do_pragma_warning (cpp_reader *);
121 static void do_pragma_error (cpp_reader *);
122 static void do_linemarker (cpp_reader *);
123 static const cpp_token *get_token_no_padding (cpp_reader *);
124 static const cpp_token *get__Pragma_string (cpp_reader *);
125 static void destringize_and_run (cpp_reader *, const cpp_string *,
126 source_location);
127 static int parse_answer (cpp_reader *, struct answer **, int, source_location);
128 static cpp_hashnode *parse_assertion (cpp_reader *, struct answer **, int);
129 static struct answer ** find_answer (cpp_hashnode *, const struct answer *);
130 static void handle_assertion (cpp_reader *, const char *, int);
131 static void do_pragma_push_macro (cpp_reader *);
132 static void do_pragma_pop_macro (cpp_reader *);
133 static void cpp_pop_definition (cpp_reader *, struct def_pragma_macro *);
134
135 /* This is the table of directive handlers. It is ordered by
136 frequency of occurrence; the numbers at the end are directive
137 counts from all the source code I have lying around (egcs and libc
138 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
139 pcmcia-cs-3.0.9). This is no longer important as directive lookup
140 is now O(1). All extensions other than #warning, #include_next,
141 and #import are deprecated. The name is where the extension
142 appears to have come from. */
143
144 #define DIRECTIVE_TABLE \
145 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
146 D(include, T_INCLUDE, KANDR, INCL | EXPAND) /* 52262 */ \
147 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
148 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
149 D(if, T_IF, KANDR, COND | IF_COND | EXPAND) /* 18162 */ \
150 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
151 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
152 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
153 D(line, T_LINE, KANDR, EXPAND) /* 2465 */ \
154 D(elif, T_ELIF, STDC89, COND | EXPAND) /* 610 */ \
155 D(error, T_ERROR, STDC89, 0) /* 475 */ \
156 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
157 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
158 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL | EXPAND) /* 19 */ \
159 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
160 D(import, T_IMPORT, EXTENSION, INCL | EXPAND) /* 0 ObjC */ \
161 D(assert, T_ASSERT, EXTENSION, DEPRECATED) /* 0 SVR4 */ \
162 D(unassert, T_UNASSERT, EXTENSION, DEPRECATED) /* 0 SVR4 */ \
163 D(sccs, T_SCCS, EXTENSION, IN_I) /* 0 SVR4? */
164
165 /* #sccs is synonymous with #ident. */
166 #define do_sccs do_ident
167
168 /* Use the table to generate a series of prototypes, an enum for the
169 directive names, and an array of directive handlers. */
170
171 #define D(name, t, o, f) static void do_##name (cpp_reader *);
172 DIRECTIVE_TABLE
173 #undef D
174
175 #define D(n, tag, o, f) tag,
176 enum
177 {
178 DIRECTIVE_TABLE
179 N_DIRECTIVES
180 };
181 #undef D
182
183 #define D(name, t, origin, flags) \
184 { do_##name, (const uchar *) #name, \
185 sizeof #name - 1, origin, flags },
186 static const directive dtable[] =
187 {
188 DIRECTIVE_TABLE
189 };
190 #undef D
191 #undef DIRECTIVE_TABLE
192
193 /* Wrapper struct directive for linemarkers.
194 The origin is more or less true - the original K+R cpp
195 did use this notation in its preprocessed output. */
196 static const directive linemarker_dir =
197 {
198 do_linemarker, UC"#", 1, KANDR, IN_I
199 };
200
201 #define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
202
203 /* Skip any remaining tokens in a directive. */
204 static void
skip_rest_of_line(cpp_reader * pfile)205 skip_rest_of_line (cpp_reader *pfile)
206 {
207 /* Discard all stacked contexts. */
208 while (pfile->context->prev)
209 _cpp_pop_context (pfile);
210
211 /* Sweep up all tokens remaining on the line. */
212 if (! SEEN_EOL ())
213 while (_cpp_lex_token (pfile)->type != CPP_EOF)
214 ;
215 }
216
217 /* Helper function for check_oel. */
218
219 static void
check_eol_1(cpp_reader * pfile,bool expand,int reason)220 check_eol_1 (cpp_reader *pfile, bool expand, int reason)
221 {
222 if (! SEEN_EOL () && (expand
223 ? cpp_get_token (pfile)
224 : _cpp_lex_token (pfile))->type != CPP_EOF)
225 cpp_pedwarning (pfile, reason, "extra tokens at end of #%s directive",
226 pfile->directive->name);
227 }
228
229 /* Variant of check_eol used for Wendif-labels warnings. */
230
231 static void
check_eol_endif_labels(cpp_reader * pfile)232 check_eol_endif_labels (cpp_reader *pfile)
233 {
234 check_eol_1 (pfile, false, CPP_W_ENDIF_LABELS);
235 }
236
237 /* Ensure there are no stray tokens at the end of a directive. If
238 EXPAND is true, tokens macro-expanding to nothing are allowed. */
239
240 static void
check_eol(cpp_reader * pfile,bool expand)241 check_eol (cpp_reader *pfile, bool expand)
242 {
243 check_eol_1 (pfile, expand, CPP_W_NONE);
244 }
245
246 /* Ensure there are no stray tokens other than comments at the end of
247 a directive, and gather the comments. */
248 static const cpp_token **
check_eol_return_comments(cpp_reader * pfile)249 check_eol_return_comments (cpp_reader *pfile)
250 {
251 size_t c;
252 size_t capacity = 8;
253 const cpp_token **buf;
254
255 buf = XNEWVEC (const cpp_token *, capacity);
256 c = 0;
257 if (! SEEN_EOL ())
258 {
259 while (1)
260 {
261 const cpp_token *tok;
262
263 tok = _cpp_lex_token (pfile);
264 if (tok->type == CPP_EOF)
265 break;
266 if (tok->type != CPP_COMMENT)
267 cpp_error (pfile, CPP_DL_PEDWARN,
268 "extra tokens at end of #%s directive",
269 pfile->directive->name);
270 else
271 {
272 if (c + 1 >= capacity)
273 {
274 capacity *= 2;
275 buf = XRESIZEVEC (const cpp_token *, buf, capacity);
276 }
277 buf[c] = tok;
278 ++c;
279 }
280 }
281 }
282 buf[c] = NULL;
283 return buf;
284 }
285
286 /* Called when entering a directive, _Pragma or command-line directive. */
287 static void
start_directive(cpp_reader * pfile)288 start_directive (cpp_reader *pfile)
289 {
290 /* Setup in-directive state. */
291 pfile->state.in_directive = 1;
292 pfile->state.save_comments = 0;
293 pfile->directive_result.type = CPP_PADDING;
294
295 /* Some handlers need the position of the # for diagnostics. */
296 pfile->directive_line = pfile->line_table->highest_line;
297 }
298
299 /* Called when leaving a directive, _Pragma or command-line directive. */
300 static void
end_directive(cpp_reader * pfile,int skip_line)301 end_directive (cpp_reader *pfile, int skip_line)
302 {
303 if (CPP_OPTION (pfile, traditional))
304 {
305 /* Revert change of prepare_directive_trad. */
306 if (!pfile->state.in_deferred_pragma)
307 pfile->state.prevent_expansion--;
308
309 if (pfile->directive != &dtable[T_DEFINE])
310 _cpp_remove_overlay (pfile);
311 }
312 else if (pfile->state.in_deferred_pragma)
313 ;
314 /* We don't skip for an assembler #. */
315 else if (skip_line)
316 {
317 skip_rest_of_line (pfile);
318 if (!pfile->keep_tokens)
319 {
320 pfile->cur_run = &pfile->base_run;
321 pfile->cur_token = pfile->base_run.base;
322 }
323 }
324
325 /* Restore state. */
326 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
327 pfile->state.in_directive = 0;
328 pfile->state.in_expression = 0;
329 pfile->state.angled_headers = 0;
330 pfile->directive = 0;
331 }
332
333 /* Prepare to handle the directive in pfile->directive. */
334 static void
prepare_directive_trad(cpp_reader * pfile)335 prepare_directive_trad (cpp_reader *pfile)
336 {
337 if (pfile->directive != &dtable[T_DEFINE])
338 {
339 bool no_expand = (pfile->directive
340 && ! (pfile->directive->flags & EXPAND));
341 bool was_skipping = pfile->state.skipping;
342
343 pfile->state.in_expression = (pfile->directive == &dtable[T_IF]
344 || pfile->directive == &dtable[T_ELIF]);
345 if (pfile->state.in_expression)
346 pfile->state.skipping = false;
347
348 if (no_expand)
349 pfile->state.prevent_expansion++;
350 _cpp_scan_out_logical_line (pfile, NULL, false);
351 if (no_expand)
352 pfile->state.prevent_expansion--;
353
354 pfile->state.skipping = was_skipping;
355 _cpp_overlay_buffer (pfile, pfile->out.base,
356 pfile->out.cur - pfile->out.base);
357 }
358
359 /* Stop ISO C from expanding anything. */
360 pfile->state.prevent_expansion++;
361 }
362
363 /* Output diagnostics for a directive DIR. INDENTED is nonzero if
364 the '#' was indented. */
365 static void
directive_diagnostics(cpp_reader * pfile,const directive * dir,int indented)366 directive_diagnostics (cpp_reader *pfile, const directive *dir, int indented)
367 {
368 /* Issue -pedantic or deprecated warnings for extensions. We let
369 -pedantic take precedence if both are applicable. */
370 if (! pfile->state.skipping)
371 {
372 if (dir->origin == EXTENSION
373 && !(dir == &dtable[T_IMPORT] && CPP_OPTION (pfile, objc))
374 && CPP_PEDANTIC (pfile))
375 cpp_error (pfile, CPP_DL_PEDWARN, "#%s is a GCC extension", dir->name);
376 else if (((dir->flags & DEPRECATED) != 0
377 || (dir == &dtable[T_IMPORT] && !CPP_OPTION (pfile, objc)))
378 && CPP_OPTION (pfile, cpp_warn_deprecated))
379 cpp_warning (pfile, CPP_W_DEPRECATED,
380 "#%s is a deprecated GCC extension", dir->name);
381 }
382
383 /* Traditionally, a directive is ignored unless its # is in
384 column 1. Therefore in code intended to work with K+R
385 compilers, directives added by C89 must have their #
386 indented, and directives present in traditional C must not.
387 This is true even of directives in skipped conditional
388 blocks. #elif cannot be used at all. */
389 if (CPP_WTRADITIONAL (pfile))
390 {
391 if (dir == &dtable[T_ELIF])
392 cpp_warning (pfile, CPP_W_TRADITIONAL,
393 "suggest not using #elif in traditional C");
394 else if (indented && dir->origin == KANDR)
395 cpp_warning (pfile, CPP_W_TRADITIONAL,
396 "traditional C ignores #%s with the # indented",
397 dir->name);
398 else if (!indented && dir->origin != KANDR)
399 cpp_warning (pfile, CPP_W_TRADITIONAL,
400 "suggest hiding #%s from traditional C with an indented #",
401 dir->name);
402 }
403 }
404
405 /* Check if we have a known directive. INDENTED is nonzero if the
406 '#' of the directive was indented. This function is in this file
407 to save unnecessarily exporting dtable etc. to lex.c. Returns
408 nonzero if the line of tokens has been handled, zero if we should
409 continue processing the line. */
410 int
_cpp_handle_directive(cpp_reader * pfile,int indented)411 _cpp_handle_directive (cpp_reader *pfile, int indented)
412 {
413 const directive *dir = 0;
414 const cpp_token *dname;
415 bool was_parsing_args = pfile->state.parsing_args;
416 bool was_discarding_output = pfile->state.discarding_output;
417 int skip = 1;
418
419 if (was_discarding_output)
420 pfile->state.prevent_expansion = 0;
421
422 if (was_parsing_args)
423 {
424 if (CPP_OPTION (pfile, cpp_pedantic))
425 cpp_error (pfile, CPP_DL_PEDWARN,
426 "embedding a directive within macro arguments is not portable");
427 pfile->state.parsing_args = 0;
428 pfile->state.prevent_expansion = 0;
429 }
430 start_directive (pfile);
431 dname = _cpp_lex_token (pfile);
432
433 if (dname->type == CPP_NAME)
434 {
435 if (dname->val.node.node->is_directive)
436 dir = &dtable[dname->val.node.node->directive_index];
437 }
438 /* We do not recognize the # followed by a number extension in
439 assembler code. */
440 else if (dname->type == CPP_NUMBER && CPP_OPTION (pfile, lang) != CLK_ASM)
441 {
442 dir = &linemarker_dir;
443 if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed)
444 && ! pfile->state.skipping)
445 cpp_error (pfile, CPP_DL_PEDWARN,
446 "style of line directive is a GCC extension");
447 }
448
449 if (dir)
450 {
451 /* If we have a directive that is not an opening conditional,
452 invalidate any control macro. */
453 if (! (dir->flags & IF_COND))
454 pfile->mi_valid = false;
455
456 /* Kluge alert. In order to be sure that code like this
457
458 #define HASH #
459 HASH define foo bar
460
461 does not cause '#define foo bar' to get executed when
462 compiled with -save-temps, we recognize directives in
463 -fpreprocessed mode only if the # is in column 1. macro.c
464 puts a space in front of any '#' at the start of a macro.
465
466 We exclude the -fdirectives-only case because macro expansion
467 has not been performed yet, and block comments can cause spaces
468 to precede the directive. */
469 if (CPP_OPTION (pfile, preprocessed)
470 && !CPP_OPTION (pfile, directives_only)
471 && (indented || !(dir->flags & IN_I)))
472 {
473 skip = 0;
474 dir = 0;
475 }
476 else
477 {
478 /* In failed conditional groups, all non-conditional
479 directives are ignored. Before doing that, whether
480 skipping or not, we should lex angle-bracketed headers
481 correctly, and maybe output some diagnostics. */
482 pfile->state.angled_headers = dir->flags & INCL;
483 pfile->state.directive_wants_padding = dir->flags & INCL;
484 if (! CPP_OPTION (pfile, preprocessed))
485 directive_diagnostics (pfile, dir, indented);
486 if (pfile->state.skipping && !(dir->flags & COND))
487 dir = 0;
488 }
489 }
490 else if (dname->type == CPP_EOF)
491 ; /* CPP_EOF is the "null directive". */
492 else
493 {
494 /* An unknown directive. Don't complain about it in assembly
495 source: we don't know where the comments are, and # may
496 introduce assembler pseudo-ops. Don't complain about invalid
497 directives in skipped conditional groups (6.10 p4). */
498 if (CPP_OPTION (pfile, lang) == CLK_ASM)
499 skip = 0;
500 else if (!pfile->state.skipping)
501 cpp_error (pfile, CPP_DL_ERROR, "invalid preprocessing directive #%s",
502 cpp_token_as_text (pfile, dname));
503 }
504
505 pfile->directive = dir;
506 if (CPP_OPTION (pfile, traditional))
507 prepare_directive_trad (pfile);
508
509 if (dir)
510 pfile->directive->handler (pfile);
511 else if (skip == 0)
512 _cpp_backup_tokens (pfile, 1);
513
514 end_directive (pfile, skip);
515 if (was_parsing_args && !pfile->state.in_deferred_pragma)
516 {
517 /* Restore state when within macro args. */
518 pfile->state.parsing_args = 2;
519 pfile->state.prevent_expansion = 1;
520 }
521 if (was_discarding_output)
522 pfile->state.prevent_expansion = 1;
523 return skip;
524 }
525
526 /* Directive handler wrapper used by the command line option
527 processor. BUF is \n terminated. */
528 static void
run_directive(cpp_reader * pfile,int dir_no,const char * buf,size_t count)529 run_directive (cpp_reader *pfile, int dir_no, const char *buf, size_t count)
530 {
531 cpp_push_buffer (pfile, (const uchar *) buf, count,
532 /* from_stage3 */ true);
533 start_directive (pfile);
534
535 /* This is a short-term fix to prevent a leading '#' being
536 interpreted as a directive. */
537 _cpp_clean_line (pfile);
538
539 pfile->directive = &dtable[dir_no];
540 if (CPP_OPTION (pfile, traditional))
541 prepare_directive_trad (pfile);
542 pfile->directive->handler (pfile);
543 end_directive (pfile, 1);
544 _cpp_pop_buffer (pfile);
545 }
546
547 /* Checks for validity the macro name in #define, #undef, #ifdef and
548 #ifndef directives. IS_DEF_OR_UNDEF is true if this call is
549 processing a #define or #undefine directive, and false
550 otherwise. */
551 static cpp_hashnode *
lex_macro_node(cpp_reader * pfile,bool is_def_or_undef)552 lex_macro_node (cpp_reader *pfile, bool is_def_or_undef)
553 {
554 const cpp_token *token = _cpp_lex_token (pfile);
555
556 /* The token immediately after #define must be an identifier. That
557 identifier may not be "defined", per C99 6.10.8p4.
558 In C++, it may not be any of the "named operators" either,
559 per C++98 [lex.digraph], [lex.key].
560 Finally, the identifier may not have been poisoned. (In that case
561 the lexer has issued the error message for us.) */
562
563 if (token->type == CPP_NAME)
564 {
565 cpp_hashnode *node = token->val.node.node;
566
567 if (is_def_or_undef && node == pfile->spec_nodes.n_defined)
568 cpp_error (pfile, CPP_DL_ERROR,
569 "\"defined\" cannot be used as a macro name");
570 else if (is_def_or_undef
571 && (node == pfile->spec_nodes.n__has_include__
572 || node == pfile->spec_nodes.n__has_include_next__))
573 cpp_error (pfile, CPP_DL_ERROR,
574 "\"__has_include__\" cannot be used as a macro name");
575 else if (! (node->flags & NODE_POISONED))
576 return node;
577 }
578 else if (token->flags & NAMED_OP)
579 cpp_error (pfile, CPP_DL_ERROR,
580 "\"%s\" cannot be used as a macro name as it is an operator in C++",
581 NODE_NAME (token->val.node.node));
582 else if (token->type == CPP_EOF)
583 cpp_error (pfile, CPP_DL_ERROR, "no macro name given in #%s directive",
584 pfile->directive->name);
585 else
586 cpp_error (pfile, CPP_DL_ERROR, "macro names must be identifiers");
587
588 return NULL;
589 }
590
591 /* Process a #define directive. Most work is done in macro.c. */
592 static void
do_define(cpp_reader * pfile)593 do_define (cpp_reader *pfile)
594 {
595 cpp_hashnode *node = lex_macro_node (pfile, true);
596
597 if (node)
598 {
599 /* If we have been requested to expand comments into macros,
600 then re-enable saving of comments. */
601 pfile->state.save_comments =
602 ! CPP_OPTION (pfile, discard_comments_in_macro_exp);
603
604 if (pfile->cb.before_define)
605 pfile->cb.before_define (pfile);
606
607 if (_cpp_create_definition (pfile, node))
608 if (pfile->cb.define)
609 pfile->cb.define (pfile, pfile->directive_line, node);
610
611 node->flags &= ~NODE_USED;
612 }
613 }
614
615 /* Handle #undef. Mark the identifier NT_VOID in the hash table. */
616 static void
do_undef(cpp_reader * pfile)617 do_undef (cpp_reader *pfile)
618 {
619 cpp_hashnode *node = lex_macro_node (pfile, true);
620
621 if (node)
622 {
623 if (pfile->cb.before_define)
624 pfile->cb.before_define (pfile);
625
626 if (pfile->cb.undef)
627 pfile->cb.undef (pfile, pfile->directive_line, node);
628
629 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified
630 identifier is not currently defined as a macro name. */
631 if (node->type == NT_MACRO)
632 {
633 if (node->flags & NODE_WARN)
634 cpp_error (pfile, CPP_DL_WARNING,
635 "undefining \"%s\"", NODE_NAME (node));
636 else if ((node->flags & NODE_BUILTIN)
637 && CPP_OPTION (pfile, warn_builtin_macro_redefined))
638 cpp_warning_with_line (pfile, CPP_W_BUILTIN_MACRO_REDEFINED,
639 pfile->directive_line, 0,
640 "undefining \"%s\"", NODE_NAME (node));
641
642 if (CPP_OPTION (pfile, warn_unused_macros))
643 _cpp_warn_if_unused_macro (pfile, node, NULL);
644
645 _cpp_free_definition (node);
646 }
647 }
648
649 check_eol (pfile, false);
650 }
651
652 /* Undefine a single macro/assertion/whatever. */
653
654 static int
undefine_macros(cpp_reader * pfile ATTRIBUTE_UNUSED,cpp_hashnode * h,void * data_p ATTRIBUTE_UNUSED)655 undefine_macros (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *h,
656 void *data_p ATTRIBUTE_UNUSED)
657 {
658 /* Body of _cpp_free_definition inlined here for speed.
659 Macros and assertions no longer have anything to free. */
660 h->type = NT_VOID;
661 h->flags &= ~(NODE_POISONED|NODE_BUILTIN|NODE_DISABLED|NODE_USED);
662 return 1;
663 }
664
665 /* Undefine all macros and assertions. */
666
667 void
cpp_undef_all(cpp_reader * pfile)668 cpp_undef_all (cpp_reader *pfile)
669 {
670 cpp_forall_identifiers (pfile, undefine_macros, NULL);
671 }
672
673
674 /* Helper routine used by parse_include. Reinterpret the current line
675 as an h-char-sequence (< ... >); we are looking at the first token
676 after the <. Returns a malloced filename. */
677 static char *
glue_header_name(cpp_reader * pfile)678 glue_header_name (cpp_reader *pfile)
679 {
680 const cpp_token *token;
681 char *buffer;
682 size_t len, total_len = 0, capacity = 1024;
683
684 /* To avoid lexed tokens overwriting our glued name, we can only
685 allocate from the string pool once we've lexed everything. */
686 buffer = XNEWVEC (char, capacity);
687 for (;;)
688 {
689 token = get_token_no_padding (pfile);
690
691 if (token->type == CPP_GREATER)
692 break;
693 if (token->type == CPP_EOF)
694 {
695 cpp_error (pfile, CPP_DL_ERROR, "missing terminating > character");
696 break;
697 }
698
699 len = cpp_token_len (token) + 2; /* Leading space, terminating \0. */
700 if (total_len + len > capacity)
701 {
702 capacity = (capacity + len) * 2;
703 buffer = XRESIZEVEC (char, buffer, capacity);
704 }
705
706 if (token->flags & PREV_WHITE)
707 buffer[total_len++] = ' ';
708
709 total_len = (cpp_spell_token (pfile, token, (uchar *) &buffer[total_len],
710 true)
711 - (uchar *) buffer);
712 }
713
714 buffer[total_len] = '\0';
715 return buffer;
716 }
717
718 /* Returns the file name of #include, #include_next, #import and
719 #pragma dependency. The string is malloced and the caller should
720 free it. Returns NULL on error. LOCATION is the source location
721 of the file name. */
722
723 static const char *
parse_include(cpp_reader * pfile,int * pangle_brackets,const cpp_token *** buf,source_location * location)724 parse_include (cpp_reader *pfile, int *pangle_brackets,
725 const cpp_token ***buf, source_location *location)
726 {
727 char *fname;
728 const cpp_token *header;
729
730 /* Allow macro expansion. */
731 header = get_token_no_padding (pfile);
732 *location = header->src_loc;
733 if ((header->type == CPP_STRING && header->val.str.text[0] != 'R')
734 || header->type == CPP_HEADER_NAME)
735 {
736 fname = XNEWVEC (char, header->val.str.len - 1);
737 memcpy (fname, header->val.str.text + 1, header->val.str.len - 2);
738 fname[header->val.str.len - 2] = '\0';
739 *pangle_brackets = header->type == CPP_HEADER_NAME;
740 }
741 else if (header->type == CPP_LESS)
742 {
743 fname = glue_header_name (pfile);
744 *pangle_brackets = 1;
745 }
746 else
747 {
748 const unsigned char *dir;
749
750 if (pfile->directive == &dtable[T_PRAGMA])
751 dir = UC"pragma dependency";
752 else
753 dir = pfile->directive->name;
754 cpp_error (pfile, CPP_DL_ERROR, "#%s expects \"FILENAME\" or <FILENAME>",
755 dir);
756
757 return NULL;
758 }
759
760 if (pfile->directive == &dtable[T_PRAGMA])
761 {
762 /* This pragma allows extra tokens after the file name. */
763 }
764 else if (buf == NULL || CPP_OPTION (pfile, discard_comments))
765 check_eol (pfile, true);
766 else
767 {
768 /* If we are not discarding comments, then gather them while
769 doing the eol check. */
770 *buf = check_eol_return_comments (pfile);
771 }
772
773 return fname;
774 }
775
776 /* Handle #include, #include_next and #import. */
777 static void
do_include_common(cpp_reader * pfile,enum include_type type)778 do_include_common (cpp_reader *pfile, enum include_type type)
779 {
780 const char *fname;
781 int angle_brackets;
782 const cpp_token **buf = NULL;
783 source_location location;
784
785 /* Re-enable saving of comments if requested, so that the include
786 callback can dump comments which follow #include. */
787 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
788
789 fname = parse_include (pfile, &angle_brackets, &buf, &location);
790 if (!fname)
791 {
792 if (buf)
793 XDELETEVEC (buf);
794 return;
795 }
796
797 if (!*fname)
798 {
799 cpp_error_with_line (pfile, CPP_DL_ERROR, location, 0,
800 "empty filename in #%s",
801 pfile->directive->name);
802 XDELETEVEC (fname);
803 if (buf)
804 XDELETEVEC (buf);
805 return;
806 }
807
808 /* Prevent #include recursion. */
809 if (pfile->line_table->depth >= CPP_STACK_MAX)
810 cpp_error (pfile, CPP_DL_ERROR, "#include nested too deeply");
811 else
812 {
813 /* Get out of macro context, if we are. */
814 skip_rest_of_line (pfile);
815
816 if (pfile->cb.include)
817 pfile->cb.include (pfile, pfile->directive_line,
818 pfile->directive->name, fname, angle_brackets,
819 buf);
820
821 _cpp_stack_include (pfile, fname, angle_brackets, type);
822 }
823
824 XDELETEVEC (fname);
825 if (buf)
826 XDELETEVEC (buf);
827 }
828
829 static void
do_include(cpp_reader * pfile)830 do_include (cpp_reader *pfile)
831 {
832 do_include_common (pfile, IT_INCLUDE);
833 }
834
835 static void
do_import(cpp_reader * pfile)836 do_import (cpp_reader *pfile)
837 {
838 do_include_common (pfile, IT_IMPORT);
839 }
840
841 static void
do_include_next(cpp_reader * pfile)842 do_include_next (cpp_reader *pfile)
843 {
844 enum include_type type = IT_INCLUDE_NEXT;
845
846 /* If this is the primary source file, warn and use the normal
847 search logic. */
848 if (cpp_in_primary_file (pfile))
849 {
850 cpp_error (pfile, CPP_DL_WARNING,
851 "#include_next in primary source file");
852 type = IT_INCLUDE;
853 }
854 do_include_common (pfile, type);
855 }
856
857 /* Subroutine of do_linemarker. Read possible flags after file name.
858 LAST is the last flag seen; 0 if this is the first flag. Return the
859 flag if it is valid, 0 at the end of the directive. Otherwise
860 complain. */
861 static unsigned int
read_flag(cpp_reader * pfile,unsigned int last)862 read_flag (cpp_reader *pfile, unsigned int last)
863 {
864 const cpp_token *token = _cpp_lex_token (pfile);
865
866 if (token->type == CPP_NUMBER && token->val.str.len == 1)
867 {
868 unsigned int flag = token->val.str.text[0] - '0';
869
870 if (flag > last && flag <= 4
871 && (flag != 4 || last == 3)
872 && (flag != 2 || last == 0))
873 return flag;
874 }
875
876 if (token->type != CPP_EOF)
877 cpp_error (pfile, CPP_DL_ERROR, "invalid flag \"%s\" in line directive",
878 cpp_token_as_text (pfile, token));
879 return 0;
880 }
881
882 /* Subroutine of do_line and do_linemarker. Convert a number in STR,
883 of length LEN, to binary; store it in NUMP, and return false if the
884 number was well-formed, true if not. WRAPPED is set to true if the
885 number did not fit into 'unsigned long'. */
886 static bool
strtolinenum(const uchar * str,size_t len,linenum_type * nump,bool * wrapped)887 strtolinenum (const uchar *str, size_t len, linenum_type *nump, bool *wrapped)
888 {
889 linenum_type reg = 0;
890 linenum_type reg_prev = 0;
891
892 uchar c;
893 *wrapped = false;
894 while (len--)
895 {
896 c = *str++;
897 if (!ISDIGIT (c))
898 return true;
899 reg *= 10;
900 reg += c - '0';
901 if (reg < reg_prev)
902 *wrapped = true;
903 reg_prev = reg;
904 }
905 *nump = reg;
906 return false;
907 }
908
909 /* Interpret #line command.
910 Note that the filename string (if any) is a true string constant
911 (escapes are interpreted), unlike in #line. */
912 static void
do_line(cpp_reader * pfile)913 do_line (cpp_reader *pfile)
914 {
915 struct line_maps *line_table = pfile->line_table;
916 const line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
917
918 /* skip_rest_of_line() may cause line table to be realloc()ed so note down
919 sysp right now. */
920
921 unsigned char map_sysp = ORDINARY_MAP_IN_SYSTEM_HEADER_P (map);
922 const cpp_token *token;
923 const char *new_file = ORDINARY_MAP_FILE_NAME (map);
924 linenum_type new_lineno;
925
926 /* C99 raised the minimum limit on #line numbers. */
927 linenum_type cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
928 bool wrapped;
929
930 /* #line commands expand macros. */
931 token = cpp_get_token (pfile);
932 if (token->type != CPP_NUMBER
933 || strtolinenum (token->val.str.text, token->val.str.len,
934 &new_lineno, &wrapped))
935 {
936 if (token->type == CPP_EOF)
937 cpp_error (pfile, CPP_DL_ERROR, "unexpected end of file after #line");
938 else
939 cpp_error (pfile, CPP_DL_ERROR,
940 "\"%s\" after #line is not a positive integer",
941 cpp_token_as_text (pfile, token));
942 return;
943 }
944
945 if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap || wrapped))
946 cpp_error (pfile, CPP_DL_PEDWARN, "line number out of range");
947 else if (wrapped)
948 cpp_error (pfile, CPP_DL_WARNING, "line number out of range");
949
950 token = cpp_get_token (pfile);
951 if (token->type == CPP_STRING)
952 {
953 cpp_string s = { 0, 0 };
954 if (cpp_interpret_string_notranslate (pfile, &token->val.str, 1,
955 &s, CPP_STRING))
956 new_file = (const char *)s.text;
957 check_eol (pfile, true);
958 }
959 else if (token->type != CPP_EOF)
960 {
961 cpp_error (pfile, CPP_DL_ERROR, "\"%s\" is not a valid filename",
962 cpp_token_as_text (pfile, token));
963 return;
964 }
965
966 skip_rest_of_line (pfile);
967 _cpp_do_file_change (pfile, LC_RENAME_VERBATIM, new_file, new_lineno,
968 map_sysp);
969 line_table->seen_line_directive = true;
970 }
971
972 /* Interpret the # 44 "file" [flags] notation, which has slightly
973 different syntax and semantics from #line: Flags are allowed,
974 and we never complain about the line number being too big. */
975 static void
do_linemarker(cpp_reader * pfile)976 do_linemarker (cpp_reader *pfile)
977 {
978 struct line_maps *line_table = pfile->line_table;
979 const line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
980 const cpp_token *token;
981 const char *new_file = ORDINARY_MAP_FILE_NAME (map);
982 linenum_type new_lineno;
983 unsigned int new_sysp = ORDINARY_MAP_IN_SYSTEM_HEADER_P (map);
984 enum lc_reason reason = LC_RENAME_VERBATIM;
985 int flag;
986 bool wrapped;
987
988 /* Back up so we can get the number again. Putting this in
989 _cpp_handle_directive risks two calls to _cpp_backup_tokens in
990 some circumstances, which can segfault. */
991 _cpp_backup_tokens (pfile, 1);
992
993 /* #line commands expand macros. */
994 token = cpp_get_token (pfile);
995 if (token->type != CPP_NUMBER
996 || strtolinenum (token->val.str.text, token->val.str.len,
997 &new_lineno, &wrapped))
998 {
999 /* Unlike #line, there does not seem to be a way to get an EOF
1000 here. So, it should be safe to always spell the token. */
1001 cpp_error (pfile, CPP_DL_ERROR,
1002 "\"%s\" after # is not a positive integer",
1003 cpp_token_as_text (pfile, token));
1004 return;
1005 }
1006
1007 token = cpp_get_token (pfile);
1008 if (token->type == CPP_STRING)
1009 {
1010 cpp_string s = { 0, 0 };
1011 if (cpp_interpret_string_notranslate (pfile, &token->val.str,
1012 1, &s, CPP_STRING))
1013 new_file = (const char *)s.text;
1014
1015 new_sysp = 0;
1016 flag = read_flag (pfile, 0);
1017 if (flag == 1)
1018 {
1019 reason = LC_ENTER;
1020 /* Fake an include for cpp_included (). */
1021 _cpp_fake_include (pfile, new_file);
1022 flag = read_flag (pfile, flag);
1023 }
1024 else if (flag == 2)
1025 {
1026 reason = LC_LEAVE;
1027 flag = read_flag (pfile, flag);
1028 }
1029 if (flag == 3)
1030 {
1031 new_sysp = 1;
1032 flag = read_flag (pfile, flag);
1033 if (flag == 4)
1034 new_sysp = 2;
1035 }
1036 pfile->buffer->sysp = new_sysp;
1037
1038 check_eol (pfile, false);
1039 }
1040 else if (token->type != CPP_EOF)
1041 {
1042 cpp_error (pfile, CPP_DL_ERROR, "\"%s\" is not a valid filename",
1043 cpp_token_as_text (pfile, token));
1044 return;
1045 }
1046
1047 skip_rest_of_line (pfile);
1048
1049 if (reason == LC_LEAVE)
1050 {
1051 /* Reread map since cpp_get_token can invalidate it with a
1052 reallocation. */
1053 map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
1054 const line_map_ordinary *from;
1055 if (MAIN_FILE_P (map)
1056 || (new_file
1057 && (from = INCLUDED_FROM (pfile->line_table, map)) != NULL
1058 && filename_cmp (ORDINARY_MAP_FILE_NAME (from), new_file) != 0))
1059 {
1060 cpp_warning (pfile, CPP_W_NONE,
1061 "file \"%s\" linemarker ignored due to "
1062 "incorrect nesting", new_file);
1063 return;
1064 }
1065 }
1066 /* Compensate for the increment in linemap_add that occurs in
1067 _cpp_do_file_change. We're currently at the start of the line
1068 *following* the #line directive. A separate source_location for this
1069 location makes no sense (until we do the LC_LEAVE), and
1070 complicates LAST_SOURCE_LINE_LOCATION. */
1071 pfile->line_table->highest_location--;
1072
1073 _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp);
1074 line_table->seen_line_directive = true;
1075 }
1076
1077 /* Arrange the file_change callback. pfile->line has changed to
1078 FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system
1079 header, 2 for a system header that needs to be extern "C" protected,
1080 and zero otherwise. */
1081 void
_cpp_do_file_change(cpp_reader * pfile,enum lc_reason reason,const char * to_file,linenum_type file_line,unsigned int sysp)1082 _cpp_do_file_change (cpp_reader *pfile, enum lc_reason reason,
1083 const char *to_file, linenum_type file_line,
1084 unsigned int sysp)
1085 {
1086 linemap_assert (reason != LC_ENTER_MACRO);
1087 const struct line_map *map = linemap_add (pfile->line_table, reason, sysp,
1088 to_file, file_line);
1089 const line_map_ordinary *ord_map = NULL;
1090 if (map != NULL)
1091 {
1092 ord_map = linemap_check_ordinary (map);
1093 linemap_line_start (pfile->line_table,
1094 ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map),
1095 127);
1096 }
1097
1098 if (pfile->cb.file_change)
1099 pfile->cb.file_change (pfile, ord_map);
1100 }
1101
1102 /* Report a warning or error detected by the program we are
1103 processing. Use the directive's tokens in the error message. */
1104 static void
do_diagnostic(cpp_reader * pfile,int code,int reason,int print_dir)1105 do_diagnostic (cpp_reader *pfile, int code, int reason, int print_dir)
1106 {
1107 const unsigned char *dir_name;
1108 unsigned char *line;
1109 source_location src_loc = pfile->cur_token[-1].src_loc;
1110
1111 if (print_dir)
1112 dir_name = pfile->directive->name;
1113 else
1114 dir_name = NULL;
1115 pfile->state.prevent_expansion++;
1116 line = cpp_output_line_to_string (pfile, dir_name);
1117 pfile->state.prevent_expansion--;
1118
1119 if (code == CPP_DL_WARNING_SYSHDR && reason)
1120 cpp_warning_with_line_syshdr (pfile, reason, src_loc, 0, "%s", line);
1121 else if (code == CPP_DL_WARNING && reason)
1122 cpp_warning_with_line (pfile, reason, src_loc, 0, "%s", line);
1123 else
1124 cpp_error_with_line (pfile, code, src_loc, 0, "%s", line);
1125 free (line);
1126 }
1127
1128 static void
do_error(cpp_reader * pfile)1129 do_error (cpp_reader *pfile)
1130 {
1131 do_diagnostic (pfile, CPP_DL_ERROR, 0, 1);
1132 }
1133
1134 static void
do_warning(cpp_reader * pfile)1135 do_warning (cpp_reader *pfile)
1136 {
1137 /* We want #warning diagnostics to be emitted in system headers too. */
1138 do_diagnostic (pfile, CPP_DL_WARNING_SYSHDR, CPP_W_WARNING_DIRECTIVE, 1);
1139 }
1140
1141 /* Report program identification. */
1142 static void
do_ident(cpp_reader * pfile)1143 do_ident (cpp_reader *pfile)
1144 {
1145 const cpp_token *str = cpp_get_token (pfile);
1146
1147 if (str->type != CPP_STRING)
1148 cpp_error (pfile, CPP_DL_ERROR, "invalid #%s directive",
1149 pfile->directive->name);
1150 else if (pfile->cb.ident)
1151 pfile->cb.ident (pfile, pfile->directive_line, &str->val.str);
1152
1153 check_eol (pfile, false);
1154 }
1155
1156 /* Lookup a PRAGMA name in a singly-linked CHAIN. Returns the
1157 matching entry, or NULL if none is found. The returned entry could
1158 be the start of a namespace chain, or a pragma. */
1159 static struct pragma_entry *
lookup_pragma_entry(struct pragma_entry * chain,const cpp_hashnode * pragma)1160 lookup_pragma_entry (struct pragma_entry *chain, const cpp_hashnode *pragma)
1161 {
1162 while (chain && chain->pragma != pragma)
1163 chain = chain->next;
1164
1165 return chain;
1166 }
1167
1168 /* Create and insert a blank pragma entry at the beginning of a
1169 singly-linked CHAIN. */
1170 static struct pragma_entry *
new_pragma_entry(cpp_reader * pfile,struct pragma_entry ** chain)1171 new_pragma_entry (cpp_reader *pfile, struct pragma_entry **chain)
1172 {
1173 struct pragma_entry *new_entry;
1174
1175 new_entry = (struct pragma_entry *)
1176 _cpp_aligned_alloc (pfile, sizeof (struct pragma_entry));
1177
1178 memset (new_entry, 0, sizeof (struct pragma_entry));
1179 new_entry->next = *chain;
1180
1181 *chain = new_entry;
1182 return new_entry;
1183 }
1184
1185 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
1186 goes in the global namespace. */
1187 static struct pragma_entry *
register_pragma_1(cpp_reader * pfile,const char * space,const char * name,bool allow_name_expansion)1188 register_pragma_1 (cpp_reader *pfile, const char *space, const char *name,
1189 bool allow_name_expansion)
1190 {
1191 struct pragma_entry **chain = &pfile->pragmas;
1192 struct pragma_entry *entry;
1193 const cpp_hashnode *node;
1194
1195 if (space)
1196 {
1197 node = cpp_lookup (pfile, UC space, strlen (space));
1198 entry = lookup_pragma_entry (*chain, node);
1199 if (!entry)
1200 {
1201 entry = new_pragma_entry (pfile, chain);
1202 entry->pragma = node;
1203 entry->is_nspace = true;
1204 entry->allow_expansion = allow_name_expansion;
1205 }
1206 else if (!entry->is_nspace)
1207 goto clash;
1208 else if (entry->allow_expansion != allow_name_expansion)
1209 {
1210 cpp_error (pfile, CPP_DL_ICE,
1211 "registering pragmas in namespace \"%s\" with mismatched "
1212 "name expansion", space);
1213 return NULL;
1214 }
1215 chain = &entry->u.space;
1216 }
1217 else if (allow_name_expansion)
1218 {
1219 cpp_error (pfile, CPP_DL_ICE,
1220 "registering pragma \"%s\" with name expansion "
1221 "and no namespace", name);
1222 return NULL;
1223 }
1224
1225 /* Check for duplicates. */
1226 node = cpp_lookup (pfile, UC name, strlen (name));
1227 entry = lookup_pragma_entry (*chain, node);
1228 if (entry == NULL)
1229 {
1230 entry = new_pragma_entry (pfile, chain);
1231 entry->pragma = node;
1232 return entry;
1233 }
1234
1235 if (entry->is_nspace)
1236 clash:
1237 cpp_error (pfile, CPP_DL_ICE,
1238 "registering \"%s\" as both a pragma and a pragma namespace",
1239 NODE_NAME (node));
1240 else if (space)
1241 cpp_error (pfile, CPP_DL_ICE, "#pragma %s %s is already registered",
1242 space, name);
1243 else
1244 cpp_error (pfile, CPP_DL_ICE, "#pragma %s is already registered", name);
1245
1246 return NULL;
1247 }
1248
1249 /* Register a cpplib internal pragma SPACE NAME with HANDLER. */
1250 static void
register_pragma_internal(cpp_reader * pfile,const char * space,const char * name,pragma_cb handler)1251 register_pragma_internal (cpp_reader *pfile, const char *space,
1252 const char *name, pragma_cb handler)
1253 {
1254 struct pragma_entry *entry;
1255
1256 entry = register_pragma_1 (pfile, space, name, false);
1257 entry->is_internal = true;
1258 entry->u.handler = handler;
1259 }
1260
1261 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
1262 goes in the global namespace. HANDLER is the handler it will call,
1263 which must be non-NULL. If ALLOW_EXPANSION is set, allow macro
1264 expansion while parsing pragma NAME. This function is exported
1265 from libcpp. */
1266 void
cpp_register_pragma(cpp_reader * pfile,const char * space,const char * name,pragma_cb handler,bool allow_expansion)1267 cpp_register_pragma (cpp_reader *pfile, const char *space, const char *name,
1268 pragma_cb handler, bool allow_expansion)
1269 {
1270 struct pragma_entry *entry;
1271
1272 if (!handler)
1273 {
1274 cpp_error (pfile, CPP_DL_ICE, "registering pragma with NULL handler");
1275 return;
1276 }
1277
1278 entry = register_pragma_1 (pfile, space, name, false);
1279 if (entry)
1280 {
1281 entry->allow_expansion = allow_expansion;
1282 entry->u.handler = handler;
1283 }
1284 }
1285
1286 /* Similarly, but create mark the pragma for deferred processing.
1287 When found, a CPP_PRAGMA token will be insertted into the stream
1288 with IDENT in the token->u.pragma slot. */
1289 void
cpp_register_deferred_pragma(cpp_reader * pfile,const char * space,const char * name,unsigned int ident,bool allow_expansion,bool allow_name_expansion)1290 cpp_register_deferred_pragma (cpp_reader *pfile, const char *space,
1291 const char *name, unsigned int ident,
1292 bool allow_expansion, bool allow_name_expansion)
1293 {
1294 struct pragma_entry *entry;
1295
1296 entry = register_pragma_1 (pfile, space, name, allow_name_expansion);
1297 if (entry)
1298 {
1299 entry->is_deferred = true;
1300 entry->allow_expansion = allow_expansion;
1301 entry->u.ident = ident;
1302 }
1303 }
1304
1305 /* Register the pragmas the preprocessor itself handles. */
1306 void
_cpp_init_internal_pragmas(cpp_reader * pfile)1307 _cpp_init_internal_pragmas (cpp_reader *pfile)
1308 {
1309 /* Pragmas in the global namespace. */
1310 register_pragma_internal (pfile, 0, "once", do_pragma_once);
1311 register_pragma_internal (pfile, 0, "push_macro", do_pragma_push_macro);
1312 register_pragma_internal (pfile, 0, "pop_macro", do_pragma_pop_macro);
1313
1314 /* New GCC-specific pragmas should be put in the GCC namespace. */
1315 register_pragma_internal (pfile, "GCC", "poison", do_pragma_poison);
1316 register_pragma_internal (pfile, "GCC", "system_header",
1317 do_pragma_system_header);
1318 register_pragma_internal (pfile, "GCC", "dependency", do_pragma_dependency);
1319 register_pragma_internal (pfile, "GCC", "warning", do_pragma_warning);
1320 register_pragma_internal (pfile, "GCC", "error", do_pragma_error);
1321 }
1322
1323 /* Return the number of registered pragmas in PE. */
1324
1325 static int
count_registered_pragmas(struct pragma_entry * pe)1326 count_registered_pragmas (struct pragma_entry *pe)
1327 {
1328 int ct = 0;
1329 for (; pe != NULL; pe = pe->next)
1330 {
1331 if (pe->is_nspace)
1332 ct += count_registered_pragmas (pe->u.space);
1333 ct++;
1334 }
1335 return ct;
1336 }
1337
1338 /* Save into SD the names of the registered pragmas referenced by PE,
1339 and return a pointer to the next free space in SD. */
1340
1341 static char **
save_registered_pragmas(struct pragma_entry * pe,char ** sd)1342 save_registered_pragmas (struct pragma_entry *pe, char **sd)
1343 {
1344 for (; pe != NULL; pe = pe->next)
1345 {
1346 if (pe->is_nspace)
1347 sd = save_registered_pragmas (pe->u.space, sd);
1348 *sd++ = (char *) xmemdup (HT_STR (&pe->pragma->ident),
1349 HT_LEN (&pe->pragma->ident),
1350 HT_LEN (&pe->pragma->ident) + 1);
1351 }
1352 return sd;
1353 }
1354
1355 /* Return a newly-allocated array which saves the names of the
1356 registered pragmas. */
1357
1358 char **
_cpp_save_pragma_names(cpp_reader * pfile)1359 _cpp_save_pragma_names (cpp_reader *pfile)
1360 {
1361 int ct = count_registered_pragmas (pfile->pragmas);
1362 char **result = XNEWVEC (char *, ct);
1363 (void) save_registered_pragmas (pfile->pragmas, result);
1364 return result;
1365 }
1366
1367 /* Restore from SD the names of the registered pragmas referenced by PE,
1368 and return a pointer to the next unused name in SD. */
1369
1370 static char **
restore_registered_pragmas(cpp_reader * pfile,struct pragma_entry * pe,char ** sd)1371 restore_registered_pragmas (cpp_reader *pfile, struct pragma_entry *pe,
1372 char **sd)
1373 {
1374 for (; pe != NULL; pe = pe->next)
1375 {
1376 if (pe->is_nspace)
1377 sd = restore_registered_pragmas (pfile, pe->u.space, sd);
1378 pe->pragma = cpp_lookup (pfile, UC *sd, strlen (*sd));
1379 free (*sd);
1380 sd++;
1381 }
1382 return sd;
1383 }
1384
1385 /* Restore the names of the registered pragmas from SAVED. */
1386
1387 void
_cpp_restore_pragma_names(cpp_reader * pfile,char ** saved)1388 _cpp_restore_pragma_names (cpp_reader *pfile, char **saved)
1389 {
1390 (void) restore_registered_pragmas (pfile, pfile->pragmas, saved);
1391 free (saved);
1392 }
1393
1394 /* Pragmata handling. We handle some, and pass the rest on to the
1395 front end. C99 defines three pragmas and says that no macro
1396 expansion is to be performed on them; whether or not macro
1397 expansion happens for other pragmas is implementation defined.
1398 This implementation allows for a mix of both, since GCC did not
1399 traditionally macro expand its (few) pragmas, whereas OpenMP
1400 specifies that macro expansion should happen. */
1401 static void
do_pragma(cpp_reader * pfile)1402 do_pragma (cpp_reader *pfile)
1403 {
1404 const struct pragma_entry *p = NULL;
1405 const cpp_token *token, *pragma_token;
1406 source_location pragma_token_virt_loc = 0;
1407 cpp_token ns_token;
1408 unsigned int count = 1;
1409
1410 pfile->state.prevent_expansion++;
1411
1412 pragma_token = token = cpp_get_token_with_location (pfile,
1413 &pragma_token_virt_loc);
1414 ns_token = *token;
1415 if (token->type == CPP_NAME)
1416 {
1417 p = lookup_pragma_entry (pfile->pragmas, token->val.node.node);
1418 if (p && p->is_nspace)
1419 {
1420 bool allow_name_expansion = p->allow_expansion;
1421 if (allow_name_expansion)
1422 pfile->state.prevent_expansion--;
1423
1424 token = cpp_get_token (pfile);
1425 if (token->type == CPP_NAME)
1426 p = lookup_pragma_entry (p->u.space, token->val.node.node);
1427 else
1428 p = NULL;
1429 if (allow_name_expansion)
1430 pfile->state.prevent_expansion++;
1431 count = 2;
1432 }
1433 }
1434
1435 if (p)
1436 {
1437 if (p->is_deferred)
1438 {
1439 pfile->directive_result.src_loc = pragma_token_virt_loc;
1440 pfile->directive_result.type = CPP_PRAGMA;
1441 pfile->directive_result.flags = pragma_token->flags;
1442 pfile->directive_result.val.pragma = p->u.ident;
1443 pfile->state.in_deferred_pragma = true;
1444 pfile->state.pragma_allow_expansion = p->allow_expansion;
1445 if (!p->allow_expansion)
1446 pfile->state.prevent_expansion++;
1447 }
1448 else
1449 {
1450 /* Since the handler below doesn't get the line number, that
1451 it might need for diagnostics, make sure it has the right
1452 numbers in place. */
1453 if (pfile->cb.line_change)
1454 (*pfile->cb.line_change) (pfile, pragma_token, false);
1455 if (p->allow_expansion)
1456 pfile->state.prevent_expansion--;
1457 (*p->u.handler) (pfile);
1458 if (p->allow_expansion)
1459 pfile->state.prevent_expansion++;
1460 }
1461 }
1462 else if (pfile->cb.def_pragma)
1463 {
1464 if (count == 1 || pfile->context->prev == NULL)
1465 _cpp_backup_tokens (pfile, count);
1466 else
1467 {
1468 /* Invalid name comes from macro expansion, _cpp_backup_tokens
1469 won't allow backing 2 tokens. */
1470 /* ??? The token buffer is leaked. Perhaps if def_pragma hook
1471 reads both tokens, we could perhaps free it, but if it doesn't,
1472 we don't know the exact lifespan. */
1473 cpp_token *toks = XNEWVEC (cpp_token, 2);
1474 toks[0] = ns_token;
1475 toks[0].flags |= NO_EXPAND;
1476 toks[1] = *token;
1477 toks[1].flags |= NO_EXPAND;
1478 _cpp_push_token_context (pfile, NULL, toks, 2);
1479 }
1480 pfile->cb.def_pragma (pfile, pfile->directive_line);
1481 }
1482
1483 pfile->state.prevent_expansion--;
1484 }
1485
1486 /* Handle #pragma once. */
1487 static void
do_pragma_once(cpp_reader * pfile)1488 do_pragma_once (cpp_reader *pfile)
1489 {
1490 if (cpp_in_primary_file (pfile))
1491 cpp_error (pfile, CPP_DL_WARNING, "#pragma once in main file");
1492
1493 check_eol (pfile, false);
1494 _cpp_mark_file_once_only (pfile, pfile->buffer->file);
1495 }
1496
1497 /* Handle #pragma push_macro(STRING). */
1498 static void
do_pragma_push_macro(cpp_reader * pfile)1499 do_pragma_push_macro (cpp_reader *pfile)
1500 {
1501 cpp_hashnode *node;
1502 size_t defnlen;
1503 const uchar *defn = NULL;
1504 char *macroname, *dest;
1505 const char *limit, *src;
1506 const cpp_token *txt;
1507 struct def_pragma_macro *c;
1508
1509 txt = get__Pragma_string (pfile);
1510 if (!txt)
1511 {
1512 source_location src_loc = pfile->cur_token[-1].src_loc;
1513 cpp_error_with_line (pfile, CPP_DL_ERROR, src_loc, 0,
1514 "invalid #pragma push_macro directive");
1515 check_eol (pfile, false);
1516 skip_rest_of_line (pfile);
1517 return;
1518 }
1519 dest = macroname = (char *) alloca (txt->val.str.len + 2);
1520 src = (const char *) (txt->val.str.text + 1 + (txt->val.str.text[0] == 'L'));
1521 limit = (const char *) (txt->val.str.text + txt->val.str.len - 1);
1522 while (src < limit)
1523 {
1524 /* We know there is a character following the backslash. */
1525 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1526 src++;
1527 *dest++ = *src++;
1528 }
1529 *dest = 0;
1530 check_eol (pfile, false);
1531 skip_rest_of_line (pfile);
1532 c = XNEW (struct def_pragma_macro);
1533 memset (c, 0, sizeof (struct def_pragma_macro));
1534 c->name = XNEWVAR (char, strlen (macroname) + 1);
1535 strcpy (c->name, macroname);
1536 c->next = pfile->pushed_macros;
1537 node = _cpp_lex_identifier (pfile, c->name);
1538 if (node->type == NT_VOID)
1539 c->is_undef = 1;
1540 else
1541 {
1542 defn = cpp_macro_definition (pfile, node);
1543 defnlen = ustrlen (defn);
1544 c->definition = XNEWVEC (uchar, defnlen + 2);
1545 c->definition[defnlen] = '\n';
1546 c->definition[defnlen + 1] = 0;
1547 c->line = node->value.macro->line;
1548 c->syshdr = node->value.macro->syshdr;
1549 c->used = node->value.macro->used;
1550 memcpy (c->definition, defn, defnlen);
1551 }
1552
1553 pfile->pushed_macros = c;
1554 }
1555
1556 /* Handle #pragma pop_macro(STRING). */
1557 static void
do_pragma_pop_macro(cpp_reader * pfile)1558 do_pragma_pop_macro (cpp_reader *pfile)
1559 {
1560 char *macroname, *dest;
1561 const char *limit, *src;
1562 const cpp_token *txt;
1563 struct def_pragma_macro *l = NULL, *c = pfile->pushed_macros;
1564 txt = get__Pragma_string (pfile);
1565 if (!txt)
1566 {
1567 source_location src_loc = pfile->cur_token[-1].src_loc;
1568 cpp_error_with_line (pfile, CPP_DL_ERROR, src_loc, 0,
1569 "invalid #pragma pop_macro directive");
1570 check_eol (pfile, false);
1571 skip_rest_of_line (pfile);
1572 return;
1573 }
1574 dest = macroname = (char *) alloca (txt->val.str.len + 2);
1575 src = (const char *) (txt->val.str.text + 1 + (txt->val.str.text[0] == 'L'));
1576 limit = (const char *) (txt->val.str.text + txt->val.str.len - 1);
1577 while (src < limit)
1578 {
1579 /* We know there is a character following the backslash. */
1580 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1581 src++;
1582 *dest++ = *src++;
1583 }
1584 *dest = 0;
1585 check_eol (pfile, false);
1586 skip_rest_of_line (pfile);
1587
1588 while (c != NULL)
1589 {
1590 if (!strcmp (c->name, macroname))
1591 {
1592 if (!l)
1593 pfile->pushed_macros = c->next;
1594 else
1595 l->next = c->next;
1596 cpp_pop_definition (pfile, c);
1597 free (c->definition);
1598 free (c->name);
1599 free (c);
1600 break;
1601 }
1602 l = c;
1603 c = c->next;
1604 }
1605 }
1606
1607 /* Handle #pragma GCC poison, to poison one or more identifiers so
1608 that the lexer produces a hard error for each subsequent usage. */
1609 static void
do_pragma_poison(cpp_reader * pfile)1610 do_pragma_poison (cpp_reader *pfile)
1611 {
1612 const cpp_token *tok;
1613 cpp_hashnode *hp;
1614
1615 pfile->state.poisoned_ok = 1;
1616 for (;;)
1617 {
1618 tok = _cpp_lex_token (pfile);
1619 if (tok->type == CPP_EOF)
1620 break;
1621 if (tok->type != CPP_NAME)
1622 {
1623 cpp_error (pfile, CPP_DL_ERROR,
1624 "invalid #pragma GCC poison directive");
1625 break;
1626 }
1627
1628 hp = tok->val.node.node;
1629 if (hp->flags & NODE_POISONED)
1630 continue;
1631
1632 if (hp->type == NT_MACRO)
1633 cpp_error (pfile, CPP_DL_WARNING, "poisoning existing macro \"%s\"",
1634 NODE_NAME (hp));
1635 _cpp_free_definition (hp);
1636 hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1637 }
1638 pfile->state.poisoned_ok = 0;
1639 }
1640
1641 /* Mark the current header as a system header. This will suppress
1642 some categories of warnings (notably those from -pedantic). It is
1643 intended for use in system libraries that cannot be implemented in
1644 conforming C, but cannot be certain that their headers appear in a
1645 system include directory. To prevent abuse, it is rejected in the
1646 primary source file. */
1647 static void
do_pragma_system_header(cpp_reader * pfile)1648 do_pragma_system_header (cpp_reader *pfile)
1649 {
1650 if (cpp_in_primary_file (pfile))
1651 cpp_error (pfile, CPP_DL_WARNING,
1652 "#pragma system_header ignored outside include file");
1653 else
1654 {
1655 check_eol (pfile, false);
1656 skip_rest_of_line (pfile);
1657 cpp_make_system_header (pfile, 1, 0);
1658 }
1659 }
1660
1661 /* Check the modified date of the current include file against a specified
1662 file. Issue a diagnostic, if the specified file is newer. We use this to
1663 determine if a fixed header should be refixed. */
1664 static void
do_pragma_dependency(cpp_reader * pfile)1665 do_pragma_dependency (cpp_reader *pfile)
1666 {
1667 const char *fname;
1668 int angle_brackets, ordering;
1669 source_location location;
1670
1671 fname = parse_include (pfile, &angle_brackets, NULL, &location);
1672 if (!fname)
1673 return;
1674
1675 ordering = _cpp_compare_file_date (pfile, fname, angle_brackets);
1676 if (ordering < 0)
1677 cpp_error (pfile, CPP_DL_WARNING, "cannot find source file %s", fname);
1678 else if (ordering > 0)
1679 {
1680 cpp_error (pfile, CPP_DL_WARNING,
1681 "current file is older than %s", fname);
1682 if (cpp_get_token (pfile)->type != CPP_EOF)
1683 {
1684 _cpp_backup_tokens (pfile, 1);
1685 do_diagnostic (pfile, CPP_DL_WARNING, 0, 0);
1686 }
1687 }
1688
1689 free ((void *) fname);
1690 }
1691
1692 /* Issue a diagnostic with the message taken from the pragma. If
1693 ERROR is true, the diagnostic is a warning, otherwise, it is an
1694 error. */
1695 static void
do_pragma_warning_or_error(cpp_reader * pfile,bool error)1696 do_pragma_warning_or_error (cpp_reader *pfile, bool error)
1697 {
1698 const cpp_token *tok = _cpp_lex_token (pfile);
1699 cpp_string str;
1700 if (tok->type != CPP_STRING
1701 || !cpp_interpret_string_notranslate (pfile, &tok->val.str, 1, &str,
1702 CPP_STRING)
1703 || str.len == 0)
1704 {
1705 cpp_error (pfile, CPP_DL_ERROR, "invalid \"#pragma GCC %s\" directive",
1706 error ? "error" : "warning");
1707 return;
1708 }
1709 cpp_error (pfile, error ? CPP_DL_ERROR : CPP_DL_WARNING,
1710 "%s", str.text);
1711 free ((void *)str.text);
1712 }
1713
1714 /* Issue a warning diagnostic. */
1715 static void
do_pragma_warning(cpp_reader * pfile)1716 do_pragma_warning (cpp_reader *pfile)
1717 {
1718 do_pragma_warning_or_error (pfile, false);
1719 }
1720
1721 /* Issue an error diagnostic. */
1722 static void
do_pragma_error(cpp_reader * pfile)1723 do_pragma_error (cpp_reader *pfile)
1724 {
1725 do_pragma_warning_or_error (pfile, true);
1726 }
1727
1728 /* Get a token but skip padding. */
1729 static const cpp_token *
get_token_no_padding(cpp_reader * pfile)1730 get_token_no_padding (cpp_reader *pfile)
1731 {
1732 for (;;)
1733 {
1734 const cpp_token *result = cpp_get_token (pfile);
1735 if (result->type != CPP_PADDING)
1736 return result;
1737 }
1738 }
1739
1740 /* Check syntax is "(string-literal)". Returns the string on success,
1741 or NULL on failure. */
1742 static const cpp_token *
get__Pragma_string(cpp_reader * pfile)1743 get__Pragma_string (cpp_reader *pfile)
1744 {
1745 const cpp_token *string;
1746 const cpp_token *paren;
1747
1748 paren = get_token_no_padding (pfile);
1749 if (paren->type == CPP_EOF)
1750 _cpp_backup_tokens (pfile, 1);
1751 if (paren->type != CPP_OPEN_PAREN)
1752 return NULL;
1753
1754 string = get_token_no_padding (pfile);
1755 if (string->type == CPP_EOF)
1756 _cpp_backup_tokens (pfile, 1);
1757 if (string->type != CPP_STRING && string->type != CPP_WSTRING
1758 && string->type != CPP_STRING32 && string->type != CPP_STRING16
1759 && string->type != CPP_UTF8STRING)
1760 return NULL;
1761
1762 paren = get_token_no_padding (pfile);
1763 if (paren->type == CPP_EOF)
1764 _cpp_backup_tokens (pfile, 1);
1765 if (paren->type != CPP_CLOSE_PAREN)
1766 return NULL;
1767
1768 return string;
1769 }
1770
1771 /* Destringize IN into a temporary buffer, by removing the first \ of
1772 \" and \\ sequences, and process the result as a #pragma directive. */
1773 static void
destringize_and_run(cpp_reader * pfile,const cpp_string * in,source_location expansion_loc)1774 destringize_and_run (cpp_reader *pfile, const cpp_string *in,
1775 source_location expansion_loc)
1776 {
1777 const unsigned char *src, *limit;
1778 char *dest, *result;
1779 cpp_context *saved_context;
1780 cpp_token *saved_cur_token;
1781 tokenrun *saved_cur_run;
1782 cpp_token *toks;
1783 int count;
1784 const struct directive *save_directive;
1785
1786 dest = result = (char *) alloca (in->len - 1);
1787 src = in->text + 1 + (in->text[0] == 'L');
1788 limit = in->text + in->len - 1;
1789 while (src < limit)
1790 {
1791 /* We know there is a character following the backslash. */
1792 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1793 src++;
1794 *dest++ = *src++;
1795 }
1796 *dest = '\n';
1797
1798 /* Ugh; an awful kludge. We are really not set up to be lexing
1799 tokens when in the middle of a macro expansion. Use a new
1800 context to force cpp_get_token to lex, and so skip_rest_of_line
1801 doesn't go beyond the end of the text. Also, remember the
1802 current lexing position so we can return to it later.
1803
1804 Something like line-at-a-time lexing should remove the need for
1805 this. */
1806 saved_context = pfile->context;
1807 saved_cur_token = pfile->cur_token;
1808 saved_cur_run = pfile->cur_run;
1809
1810 pfile->context = XCNEW (cpp_context);
1811
1812 /* Inline run_directive, since we need to delay the _cpp_pop_buffer
1813 until we've read all of the tokens that we want. */
1814 cpp_push_buffer (pfile, (const uchar *) result, dest - result,
1815 /* from_stage3 */ true);
1816 /* ??? Antique Disgusting Hack. What does this do? */
1817 if (pfile->buffer->prev)
1818 pfile->buffer->file = pfile->buffer->prev->file;
1819
1820 start_directive (pfile);
1821 _cpp_clean_line (pfile);
1822 save_directive = pfile->directive;
1823 pfile->directive = &dtable[T_PRAGMA];
1824 do_pragma (pfile);
1825 end_directive (pfile, 1);
1826 pfile->directive = save_directive;
1827
1828 /* We always insert at least one token, the directive result. It'll
1829 either be a CPP_PADDING or a CPP_PRAGMA. In the later case, we
1830 need to insert *all* of the tokens, including the CPP_PRAGMA_EOL. */
1831
1832 /* If we're not handling the pragma internally, read all of the tokens from
1833 the string buffer now, while the string buffer is still installed. */
1834 /* ??? Note that the token buffer allocated here is leaked. It's not clear
1835 to me what the true lifespan of the tokens are. It would appear that
1836 the lifespan is the entire parse of the main input stream, in which case
1837 this may not be wrong. */
1838 if (pfile->directive_result.type == CPP_PRAGMA)
1839 {
1840 int maxcount;
1841
1842 count = 1;
1843 maxcount = 50;
1844 toks = XNEWVEC (cpp_token, maxcount);
1845 toks[0] = pfile->directive_result;
1846
1847 do
1848 {
1849 if (count == maxcount)
1850 {
1851 maxcount = maxcount * 3 / 2;
1852 toks = XRESIZEVEC (cpp_token, toks, maxcount);
1853 }
1854 toks[count] = *cpp_get_token (pfile);
1855 /* _Pragma is a builtin, so we're not within a macro-map, and so
1856 the token locations are set to bogus ordinary locations
1857 near to, but after that of the "_Pragma".
1858 Paper over this by setting them equal to the location of the
1859 _Pragma itself (PR preprocessor/69126). */
1860 toks[count].src_loc = expansion_loc;
1861 /* Macros have been already expanded by cpp_get_token
1862 if the pragma allowed expansion. */
1863 toks[count++].flags |= NO_EXPAND;
1864 }
1865 while (toks[count-1].type != CPP_PRAGMA_EOL);
1866 }
1867 else
1868 {
1869 count = 1;
1870 toks = XNEW (cpp_token);
1871 toks[0] = pfile->directive_result;
1872
1873 /* If we handled the entire pragma internally, make sure we get the
1874 line number correct for the next token. */
1875 if (pfile->cb.line_change)
1876 pfile->cb.line_change (pfile, pfile->cur_token, false);
1877 }
1878
1879 /* Finish inlining run_directive. */
1880 pfile->buffer->file = NULL;
1881 _cpp_pop_buffer (pfile);
1882
1883 /* Reset the old macro state before ... */
1884 XDELETE (pfile->context);
1885 pfile->context = saved_context;
1886 pfile->cur_token = saved_cur_token;
1887 pfile->cur_run = saved_cur_run;
1888
1889 /* ... inserting the new tokens we collected. */
1890 _cpp_push_token_context (pfile, NULL, toks, count);
1891 }
1892
1893 /* Handle the _Pragma operator. Return 0 on error, 1 if ok. */
1894 int
_cpp_do__Pragma(cpp_reader * pfile,source_location expansion_loc)1895 _cpp_do__Pragma (cpp_reader *pfile, source_location expansion_loc)
1896 {
1897 const cpp_token *string = get__Pragma_string (pfile);
1898 pfile->directive_result.type = CPP_PADDING;
1899
1900 if (string)
1901 {
1902 destringize_and_run (pfile, &string->val.str, expansion_loc);
1903 return 1;
1904 }
1905 cpp_error (pfile, CPP_DL_ERROR,
1906 "_Pragma takes a parenthesized string literal");
1907 return 0;
1908 }
1909
1910 /* Handle #ifdef. */
1911 static void
do_ifdef(cpp_reader * pfile)1912 do_ifdef (cpp_reader *pfile)
1913 {
1914 int skip = 1;
1915
1916 if (! pfile->state.skipping)
1917 {
1918 cpp_hashnode *node = lex_macro_node (pfile, false);
1919
1920 if (node)
1921 {
1922 /* Do not treat conditional macros as being defined. This is due to
1923 the powerpc and spu ports using conditional macros for 'vector',
1924 'bool', and 'pixel' to act as conditional keywords. This messes
1925 up tests like #ifndef bool. */
1926 skip = (node->type != NT_MACRO
1927 || ((node->flags & NODE_CONDITIONAL) != 0));
1928 _cpp_mark_macro_used (node);
1929 if (!(node->flags & NODE_USED))
1930 {
1931 node->flags |= NODE_USED;
1932 if (node->type == NT_MACRO)
1933 {
1934 if ((node->flags & NODE_BUILTIN)
1935 && pfile->cb.user_builtin_macro)
1936 pfile->cb.user_builtin_macro (pfile, node);
1937 if (pfile->cb.used_define)
1938 pfile->cb.used_define (pfile, pfile->directive_line, node);
1939 }
1940 else
1941 {
1942 if (pfile->cb.used_undef)
1943 pfile->cb.used_undef (pfile, pfile->directive_line, node);
1944 }
1945 }
1946 if (pfile->cb.used)
1947 pfile->cb.used (pfile, pfile->directive_line, node);
1948 check_eol (pfile, false);
1949 }
1950 }
1951
1952 push_conditional (pfile, skip, T_IFDEF, 0);
1953 }
1954
1955 /* Handle #ifndef. */
1956 static void
do_ifndef(cpp_reader * pfile)1957 do_ifndef (cpp_reader *pfile)
1958 {
1959 int skip = 1;
1960 cpp_hashnode *node = 0;
1961
1962 if (! pfile->state.skipping)
1963 {
1964 node = lex_macro_node (pfile, false);
1965
1966 if (node)
1967 {
1968 /* Do not treat conditional macros as being defined. This is due to
1969 the powerpc and spu ports using conditional macros for 'vector',
1970 'bool', and 'pixel' to act as conditional keywords. This messes
1971 up tests like #ifndef bool. */
1972 skip = (node->type == NT_MACRO
1973 && ((node->flags & NODE_CONDITIONAL) == 0));
1974 _cpp_mark_macro_used (node);
1975 if (!(node->flags & NODE_USED))
1976 {
1977 node->flags |= NODE_USED;
1978 if (node->type == NT_MACRO)
1979 {
1980 if ((node->flags & NODE_BUILTIN)
1981 && pfile->cb.user_builtin_macro)
1982 pfile->cb.user_builtin_macro (pfile, node);
1983 if (pfile->cb.used_define)
1984 pfile->cb.used_define (pfile, pfile->directive_line, node);
1985 }
1986 else
1987 {
1988 if (pfile->cb.used_undef)
1989 pfile->cb.used_undef (pfile, pfile->directive_line, node);
1990 }
1991 }
1992 if (pfile->cb.used)
1993 pfile->cb.used (pfile, pfile->directive_line, node);
1994 check_eol (pfile, false);
1995 }
1996 }
1997
1998 push_conditional (pfile, skip, T_IFNDEF, node);
1999 }
2000
2001 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
2002 pfile->mi_ind_cmacro so we can handle multiple-include
2003 optimizations. If macro expansion occurs in the expression, we
2004 cannot treat it as a controlling conditional, since the expansion
2005 could change in the future. That is handled by cpp_get_token. */
2006 static void
do_if(cpp_reader * pfile)2007 do_if (cpp_reader *pfile)
2008 {
2009 int skip = 1;
2010
2011 if (! pfile->state.skipping)
2012 skip = _cpp_parse_expr (pfile, true) == false;
2013
2014 push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
2015 }
2016
2017 /* Flip skipping state if appropriate and continue without changing
2018 if_stack; this is so that the error message for missing #endif's
2019 etc. will point to the original #if. */
2020 static void
do_else(cpp_reader * pfile)2021 do_else (cpp_reader *pfile)
2022 {
2023 cpp_buffer *buffer = pfile->buffer;
2024 struct if_stack *ifs = buffer->if_stack;
2025
2026 if (ifs == NULL)
2027 cpp_error (pfile, CPP_DL_ERROR, "#else without #if");
2028 else
2029 {
2030 if (ifs->type == T_ELSE)
2031 {
2032 cpp_error (pfile, CPP_DL_ERROR, "#else after #else");
2033 cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
2034 "the conditional began here");
2035 }
2036 ifs->type = T_ELSE;
2037
2038 /* Skip any future (erroneous) #elses or #elifs. */
2039 pfile->state.skipping = ifs->skip_elses;
2040 ifs->skip_elses = true;
2041
2042 /* Invalidate any controlling macro. */
2043 ifs->mi_cmacro = 0;
2044
2045 /* Only check EOL if was not originally skipping. */
2046 if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
2047 check_eol_endif_labels (pfile);
2048 }
2049 }
2050
2051 /* Handle a #elif directive by not changing if_stack either. See the
2052 comment above do_else. */
2053 static void
do_elif(cpp_reader * pfile)2054 do_elif (cpp_reader *pfile)
2055 {
2056 cpp_buffer *buffer = pfile->buffer;
2057 struct if_stack *ifs = buffer->if_stack;
2058
2059 if (ifs == NULL)
2060 cpp_error (pfile, CPP_DL_ERROR, "#elif without #if");
2061 else
2062 {
2063 if (ifs->type == T_ELSE)
2064 {
2065 cpp_error (pfile, CPP_DL_ERROR, "#elif after #else");
2066 cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
2067 "the conditional began here");
2068 }
2069 ifs->type = T_ELIF;
2070
2071 /* See DR#412: "Only the first group whose control condition
2072 evaluates to true (nonzero) is processed; any following groups
2073 are skipped and their controlling directives are processed as
2074 if they were in a group that is skipped." */
2075 if (ifs->skip_elses)
2076 pfile->state.skipping = 1;
2077 else
2078 {
2079 pfile->state.skipping = ! _cpp_parse_expr (pfile, false);
2080 ifs->skip_elses = ! pfile->state.skipping;
2081 }
2082
2083 /* Invalidate any controlling macro. */
2084 ifs->mi_cmacro = 0;
2085 }
2086 }
2087
2088 /* #endif pops the if stack and resets pfile->state.skipping. */
2089 static void
do_endif(cpp_reader * pfile)2090 do_endif (cpp_reader *pfile)
2091 {
2092 cpp_buffer *buffer = pfile->buffer;
2093 struct if_stack *ifs = buffer->if_stack;
2094
2095 if (ifs == NULL)
2096 cpp_error (pfile, CPP_DL_ERROR, "#endif without #if");
2097 else
2098 {
2099 /* Only check EOL if was not originally skipping. */
2100 if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
2101 check_eol_endif_labels (pfile);
2102
2103 /* If potential control macro, we go back outside again. */
2104 if (ifs->next == 0 && ifs->mi_cmacro)
2105 {
2106 pfile->mi_valid = true;
2107 pfile->mi_cmacro = ifs->mi_cmacro;
2108 }
2109
2110 buffer->if_stack = ifs->next;
2111 pfile->state.skipping = ifs->was_skipping;
2112 obstack_free (&pfile->buffer_ob, ifs);
2113 }
2114 }
2115
2116 /* Push an if_stack entry for a preprocessor conditional, and set
2117 pfile->state.skipping to SKIP. If TYPE indicates the conditional
2118 is #if or #ifndef, CMACRO is a potentially controlling macro, and
2119 we need to check here that we are at the top of the file. */
2120 static void
push_conditional(cpp_reader * pfile,int skip,int type,const cpp_hashnode * cmacro)2121 push_conditional (cpp_reader *pfile, int skip, int type,
2122 const cpp_hashnode *cmacro)
2123 {
2124 struct if_stack *ifs;
2125 cpp_buffer *buffer = pfile->buffer;
2126
2127 ifs = XOBNEW (&pfile->buffer_ob, struct if_stack);
2128 ifs->line = pfile->directive_line;
2129 ifs->next = buffer->if_stack;
2130 ifs->skip_elses = pfile->state.skipping || !skip;
2131 ifs->was_skipping = pfile->state.skipping;
2132 ifs->type = type;
2133 /* This condition is effectively a test for top-of-file. */
2134 if (pfile->mi_valid && pfile->mi_cmacro == 0)
2135 ifs->mi_cmacro = cmacro;
2136 else
2137 ifs->mi_cmacro = 0;
2138
2139 pfile->state.skipping = skip;
2140 buffer->if_stack = ifs;
2141 }
2142
2143 /* Read the tokens of the answer into the macro pool, in a directive
2144 of type TYPE. Only commit the memory if we intend it as permanent
2145 storage, i.e. the #assert case. Returns 0 on success, and sets
2146 ANSWERP to point to the answer. PRED_LOC is the location of the
2147 predicate. */
2148 static int
parse_answer(cpp_reader * pfile,struct answer ** answerp,int type,source_location pred_loc)2149 parse_answer (cpp_reader *pfile, struct answer **answerp, int type,
2150 source_location pred_loc)
2151 {
2152 const cpp_token *paren;
2153 struct answer *answer;
2154 unsigned int acount;
2155
2156 /* In a conditional, it is legal to not have an open paren. We
2157 should save the following token in this case. */
2158 paren = cpp_get_token (pfile);
2159
2160 /* If not a paren, see if we're OK. */
2161 if (paren->type != CPP_OPEN_PAREN)
2162 {
2163 /* In a conditional no answer is a test for any answer. It
2164 could be followed by any token. */
2165 if (type == T_IF)
2166 {
2167 _cpp_backup_tokens (pfile, 1);
2168 return 0;
2169 }
2170
2171 /* #unassert with no answer is valid - it removes all answers. */
2172 if (type == T_UNASSERT && paren->type == CPP_EOF)
2173 return 0;
2174
2175 cpp_error_with_line (pfile, CPP_DL_ERROR, pred_loc, 0,
2176 "missing '(' after predicate");
2177 return 1;
2178 }
2179
2180 for (acount = 0;; acount++)
2181 {
2182 size_t room_needed;
2183 const cpp_token *token = cpp_get_token (pfile);
2184 cpp_token *dest;
2185
2186 if (token->type == CPP_CLOSE_PAREN)
2187 break;
2188
2189 if (token->type == CPP_EOF)
2190 {
2191 cpp_error (pfile, CPP_DL_ERROR, "missing ')' to complete answer");
2192 return 1;
2193 }
2194
2195 /* struct answer includes the space for one token. */
2196 room_needed = (sizeof (struct answer) + acount * sizeof (cpp_token));
2197
2198 if (BUFF_ROOM (pfile->a_buff) < room_needed)
2199 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer));
2200
2201 dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount];
2202 *dest = *token;
2203
2204 /* Drop whitespace at start, for answer equivalence purposes. */
2205 if (acount == 0)
2206 dest->flags &= ~PREV_WHITE;
2207 }
2208
2209 if (acount == 0)
2210 {
2211 cpp_error (pfile, CPP_DL_ERROR, "predicate's answer is empty");
2212 return 1;
2213 }
2214
2215 answer = (struct answer *) BUFF_FRONT (pfile->a_buff);
2216 answer->count = acount;
2217 answer->next = NULL;
2218 *answerp = answer;
2219
2220 return 0;
2221 }
2222
2223 /* Parses an assertion directive of type TYPE, returning a pointer to
2224 the hash node of the predicate, or 0 on error. If an answer was
2225 supplied, it is placed in ANSWERP, otherwise it is set to 0. */
2226 static cpp_hashnode *
parse_assertion(cpp_reader * pfile,struct answer ** answerp,int type)2227 parse_assertion (cpp_reader *pfile, struct answer **answerp, int type)
2228 {
2229 cpp_hashnode *result = 0;
2230 const cpp_token *predicate;
2231
2232 /* We don't expand predicates or answers. */
2233 pfile->state.prevent_expansion++;
2234
2235 *answerp = 0;
2236 predicate = cpp_get_token (pfile);
2237 if (predicate->type == CPP_EOF)
2238 cpp_error (pfile, CPP_DL_ERROR, "assertion without predicate");
2239 else if (predicate->type != CPP_NAME)
2240 cpp_error_with_line (pfile, CPP_DL_ERROR, predicate->src_loc, 0,
2241 "predicate must be an identifier");
2242 else if (parse_answer (pfile, answerp, type, predicate->src_loc) == 0)
2243 {
2244 unsigned int len = NODE_LEN (predicate->val.node.node);
2245 unsigned char *sym = (unsigned char *) alloca (len + 1);
2246
2247 /* Prefix '#' to get it out of macro namespace. */
2248 sym[0] = '#';
2249 memcpy (sym + 1, NODE_NAME (predicate->val.node.node), len);
2250 result = cpp_lookup (pfile, sym, len + 1);
2251 }
2252
2253 pfile->state.prevent_expansion--;
2254 return result;
2255 }
2256
2257 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
2258 or a pointer to NULL if the answer is not in the chain. */
2259 static struct answer **
find_answer(cpp_hashnode * node,const struct answer * candidate)2260 find_answer (cpp_hashnode *node, const struct answer *candidate)
2261 {
2262 unsigned int i;
2263 struct answer **result;
2264
2265 for (result = &node->value.answers; *result; result = &(*result)->next)
2266 {
2267 struct answer *answer = *result;
2268
2269 if (answer->count == candidate->count)
2270 {
2271 for (i = 0; i < answer->count; i++)
2272 if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
2273 break;
2274
2275 if (i == answer->count)
2276 break;
2277 }
2278 }
2279
2280 return result;
2281 }
2282
2283 /* Test an assertion within a preprocessor conditional. Returns
2284 nonzero on failure, zero on success. On success, the result of
2285 the test is written into VALUE, otherwise the value 0. */
2286 int
_cpp_test_assertion(cpp_reader * pfile,unsigned int * value)2287 _cpp_test_assertion (cpp_reader *pfile, unsigned int *value)
2288 {
2289 struct answer *answer;
2290 cpp_hashnode *node;
2291
2292 node = parse_assertion (pfile, &answer, T_IF);
2293
2294 /* For recovery, an erroneous assertion expression is handled as a
2295 failing assertion. */
2296 *value = 0;
2297
2298 if (node)
2299 *value = (node->type == NT_ASSERTION &&
2300 (answer == 0 || *find_answer (node, answer) != 0));
2301 else if (pfile->cur_token[-1].type == CPP_EOF)
2302 _cpp_backup_tokens (pfile, 1);
2303
2304 /* We don't commit the memory for the answer - it's temporary only. */
2305 return node == 0;
2306 }
2307
2308 /* Handle #assert. */
2309 static void
do_assert(cpp_reader * pfile)2310 do_assert (cpp_reader *pfile)
2311 {
2312 struct answer *new_answer;
2313 cpp_hashnode *node;
2314
2315 node = parse_assertion (pfile, &new_answer, T_ASSERT);
2316 if (node)
2317 {
2318 size_t answer_size;
2319
2320 /* Place the new answer in the answer list. First check there
2321 is not a duplicate. */
2322 new_answer->next = 0;
2323 if (node->type == NT_ASSERTION)
2324 {
2325 if (*find_answer (node, new_answer))
2326 {
2327 cpp_error (pfile, CPP_DL_WARNING, "\"%s\" re-asserted",
2328 NODE_NAME (node) + 1);
2329 return;
2330 }
2331 new_answer->next = node->value.answers;
2332 }
2333
2334 answer_size = sizeof (struct answer) + ((new_answer->count - 1)
2335 * sizeof (cpp_token));
2336 /* Commit or allocate storage for the object. */
2337 if (pfile->hash_table->alloc_subobject)
2338 {
2339 struct answer *temp_answer = new_answer;
2340 new_answer = (struct answer *) pfile->hash_table->alloc_subobject
2341 (answer_size);
2342 memcpy (new_answer, temp_answer, answer_size);
2343 }
2344 else
2345 BUFF_FRONT (pfile->a_buff) += answer_size;
2346
2347 node->type = NT_ASSERTION;
2348 node->value.answers = new_answer;
2349 check_eol (pfile, false);
2350 }
2351 }
2352
2353 /* Handle #unassert. */
2354 static void
do_unassert(cpp_reader * pfile)2355 do_unassert (cpp_reader *pfile)
2356 {
2357 cpp_hashnode *node;
2358 struct answer *answer;
2359
2360 node = parse_assertion (pfile, &answer, T_UNASSERT);
2361 /* It isn't an error to #unassert something that isn't asserted. */
2362 if (node && node->type == NT_ASSERTION)
2363 {
2364 if (answer)
2365 {
2366 struct answer **p = find_answer (node, answer), *temp;
2367
2368 /* Remove the answer from the list. */
2369 temp = *p;
2370 if (temp)
2371 *p = temp->next;
2372
2373 /* Did we free the last answer? */
2374 if (node->value.answers == 0)
2375 node->type = NT_VOID;
2376
2377 check_eol (pfile, false);
2378 }
2379 else
2380 _cpp_free_definition (node);
2381 }
2382
2383 /* We don't commit the memory for the answer - it's temporary only. */
2384 }
2385
2386 /* These are for -D, -U, -A. */
2387
2388 /* Process the string STR as if it appeared as the body of a #define.
2389 If STR is just an identifier, define it with value 1.
2390 If STR has anything after the identifier, then it should
2391 be identifier=definition. */
2392 void
cpp_define(cpp_reader * pfile,const char * str)2393 cpp_define (cpp_reader *pfile, const char *str)
2394 {
2395 char *buf;
2396 const char *p;
2397 size_t count;
2398
2399 /* Copy the entire option so we can modify it.
2400 Change the first "=" in the string to a space. If there is none,
2401 tack " 1" on the end. */
2402
2403 count = strlen (str);
2404 buf = (char *) alloca (count + 3);
2405 memcpy (buf, str, count);
2406
2407 p = strchr (str, '=');
2408 if (p)
2409 buf[p - str] = ' ';
2410 else
2411 {
2412 buf[count++] = ' ';
2413 buf[count++] = '1';
2414 }
2415 buf[count] = '\n';
2416
2417 run_directive (pfile, T_DEFINE, buf, count);
2418 }
2419
2420
2421 /* Use to build macros to be run through cpp_define() as
2422 described above.
2423 Example: cpp_define_formatted (pfile, "MACRO=%d", value); */
2424
2425 void
cpp_define_formatted(cpp_reader * pfile,const char * fmt,...)2426 cpp_define_formatted (cpp_reader *pfile, const char *fmt, ...)
2427 {
2428 char *ptr;
2429
2430 va_list ap;
2431 va_start (ap, fmt);
2432 ptr = xvasprintf (fmt, ap);
2433 va_end (ap);
2434
2435 cpp_define (pfile, ptr);
2436 free (ptr);
2437 }
2438
2439
2440 /* Slight variant of the above for use by initialize_builtins. */
2441 void
_cpp_define_builtin(cpp_reader * pfile,const char * str)2442 _cpp_define_builtin (cpp_reader *pfile, const char *str)
2443 {
2444 size_t len = strlen (str);
2445 char *buf = (char *) alloca (len + 1);
2446 memcpy (buf, str, len);
2447 buf[len] = '\n';
2448 run_directive (pfile, T_DEFINE, buf, len);
2449 }
2450
2451 /* Process MACRO as if it appeared as the body of an #undef. */
2452 void
cpp_undef(cpp_reader * pfile,const char * macro)2453 cpp_undef (cpp_reader *pfile, const char *macro)
2454 {
2455 size_t len = strlen (macro);
2456 char *buf = (char *) alloca (len + 1);
2457 memcpy (buf, macro, len);
2458 buf[len] = '\n';
2459 run_directive (pfile, T_UNDEF, buf, len);
2460 }
2461
2462 /* Replace a previous definition DEF of the macro STR. If DEF is NULL,
2463 or first element is zero, then the macro should be undefined. */
2464 static void
cpp_pop_definition(cpp_reader * pfile,struct def_pragma_macro * c)2465 cpp_pop_definition (cpp_reader *pfile, struct def_pragma_macro *c)
2466 {
2467 cpp_hashnode *node = _cpp_lex_identifier (pfile, c->name);
2468 if (node == NULL)
2469 return;
2470
2471 if (pfile->cb.before_define)
2472 pfile->cb.before_define (pfile);
2473
2474 if (node->type == NT_MACRO)
2475 {
2476 if (pfile->cb.undef)
2477 pfile->cb.undef (pfile, pfile->directive_line, node);
2478 if (CPP_OPTION (pfile, warn_unused_macros))
2479 _cpp_warn_if_unused_macro (pfile, node, NULL);
2480 }
2481 if (node->type != NT_VOID)
2482 _cpp_free_definition (node);
2483
2484 if (c->is_undef)
2485 return;
2486 {
2487 size_t namelen;
2488 const uchar *dn;
2489 cpp_hashnode *h = NULL;
2490 cpp_buffer *nbuf;
2491
2492 namelen = ustrcspn (c->definition, "( \n");
2493 h = cpp_lookup (pfile, c->definition, namelen);
2494 dn = c->definition + namelen;
2495
2496 h->type = NT_VOID;
2497 h->flags &= ~(NODE_POISONED|NODE_BUILTIN|NODE_DISABLED|NODE_USED);
2498 nbuf = cpp_push_buffer (pfile, dn, ustrchr (dn, '\n') - dn, true);
2499 if (nbuf != NULL)
2500 {
2501 _cpp_clean_line (pfile);
2502 nbuf->sysp = 1;
2503 if (!_cpp_create_definition (pfile, h))
2504 abort ();
2505 _cpp_pop_buffer (pfile);
2506 }
2507 else
2508 abort ();
2509 h->value.macro->line = c->line;
2510 h->value.macro->syshdr = c->syshdr;
2511 h->value.macro->used = c->used;
2512 }
2513 }
2514
2515 /* Process the string STR as if it appeared as the body of a #assert. */
2516 void
cpp_assert(cpp_reader * pfile,const char * str)2517 cpp_assert (cpp_reader *pfile, const char *str)
2518 {
2519 handle_assertion (pfile, str, T_ASSERT);
2520 }
2521
2522 /* Process STR as if it appeared as the body of an #unassert. */
2523 void
cpp_unassert(cpp_reader * pfile,const char * str)2524 cpp_unassert (cpp_reader *pfile, const char *str)
2525 {
2526 handle_assertion (pfile, str, T_UNASSERT);
2527 }
2528
2529 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
2530 static void
handle_assertion(cpp_reader * pfile,const char * str,int type)2531 handle_assertion (cpp_reader *pfile, const char *str, int type)
2532 {
2533 size_t count = strlen (str);
2534 const char *p = strchr (str, '=');
2535
2536 /* Copy the entire option so we can modify it. Change the first
2537 "=" in the string to a '(', and tack a ')' on the end. */
2538 char *buf = (char *) alloca (count + 2);
2539
2540 memcpy (buf, str, count);
2541 if (p)
2542 {
2543 buf[p - str] = '(';
2544 buf[count++] = ')';
2545 }
2546 buf[count] = '\n';
2547 str = buf;
2548
2549 run_directive (pfile, type, str, count);
2550 }
2551
2552 /* The options structure. */
2553 cpp_options *
cpp_get_options(cpp_reader * pfile)2554 cpp_get_options (cpp_reader *pfile)
2555 {
2556 return &pfile->opts;
2557 }
2558
2559 /* The callbacks structure. */
2560 cpp_callbacks *
cpp_get_callbacks(cpp_reader * pfile)2561 cpp_get_callbacks (cpp_reader *pfile)
2562 {
2563 return &pfile->cb;
2564 }
2565
2566 /* Copy the given callbacks structure to our own. */
2567 void
cpp_set_callbacks(cpp_reader * pfile,cpp_callbacks * cb)2568 cpp_set_callbacks (cpp_reader *pfile, cpp_callbacks *cb)
2569 {
2570 pfile->cb = *cb;
2571 }
2572
2573 /* The dependencies structure. (Creates one if it hasn't already been.) */
2574 struct deps *
cpp_get_deps(cpp_reader * pfile)2575 cpp_get_deps (cpp_reader *pfile)
2576 {
2577 if (!pfile->deps)
2578 pfile->deps = deps_init ();
2579 return pfile->deps;
2580 }
2581
2582 /* Push a new buffer on the buffer stack. Returns the new buffer; it
2583 doesn't fail. It does not generate a file change call back; that
2584 is the responsibility of the caller. */
2585 cpp_buffer *
cpp_push_buffer(cpp_reader * pfile,const uchar * buffer,size_t len,int from_stage3)2586 cpp_push_buffer (cpp_reader *pfile, const uchar *buffer, size_t len,
2587 int from_stage3)
2588 {
2589 cpp_buffer *new_buffer = XOBNEW (&pfile->buffer_ob, cpp_buffer);
2590
2591 /* Clears, amongst other things, if_stack and mi_cmacro. */
2592 memset (new_buffer, 0, sizeof (cpp_buffer));
2593
2594 new_buffer->next_line = new_buffer->buf = buffer;
2595 new_buffer->rlimit = buffer + len;
2596 new_buffer->from_stage3 = from_stage3;
2597 new_buffer->prev = pfile->buffer;
2598 new_buffer->need_line = true;
2599
2600 pfile->buffer = new_buffer;
2601
2602 return new_buffer;
2603 }
2604
2605 /* Pops a single buffer, with a file change call-back if appropriate.
2606 Then pushes the next -include file, if any remain. */
2607 void
_cpp_pop_buffer(cpp_reader * pfile)2608 _cpp_pop_buffer (cpp_reader *pfile)
2609 {
2610 cpp_buffer *buffer = pfile->buffer;
2611 struct _cpp_file *inc = buffer->file;
2612 struct if_stack *ifs;
2613 const unsigned char *to_free;
2614
2615 /* Walk back up the conditional stack till we reach its level at
2616 entry to this file, issuing error messages. */
2617 for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
2618 cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
2619 "unterminated #%s", dtable[ifs->type].name);
2620
2621 /* In case of a missing #endif. */
2622 pfile->state.skipping = 0;
2623
2624 /* _cpp_do_file_change expects pfile->buffer to be the new one. */
2625 pfile->buffer = buffer->prev;
2626
2627 to_free = buffer->to_free;
2628 free (buffer->notes);
2629
2630 /* Free the buffer object now; we may want to push a new buffer
2631 in _cpp_push_next_include_file. */
2632 obstack_free (&pfile->buffer_ob, buffer);
2633
2634 if (inc)
2635 {
2636 _cpp_pop_file_buffer (pfile, inc, to_free);
2637
2638 _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
2639 }
2640 }
2641
2642 /* Enter all recognized directives in the hash table. */
2643 void
_cpp_init_directives(cpp_reader * pfile)2644 _cpp_init_directives (cpp_reader *pfile)
2645 {
2646 unsigned int i;
2647 cpp_hashnode *node;
2648
2649 for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
2650 {
2651 node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
2652 node->is_directive = 1;
2653 node->directive_index = i;
2654 }
2655 }
2656
2657 /* Extract header file from a bracket include. Parsing starts after '<'.
2658 The string is malloced and must be freed by the caller. */
2659 char *
_cpp_bracket_include(cpp_reader * pfile)2660 _cpp_bracket_include(cpp_reader *pfile)
2661 {
2662 return glue_header_name (pfile);
2663 }
2664
2665