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