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