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 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 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 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 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 && 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 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 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 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 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 * 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 * 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 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 856 do_include (cpp_reader *pfile) 857 { 858 do_include_common (pfile, IT_INCLUDE); 859 } 860 861 static void 862 do_import (cpp_reader *pfile) 863 { 864 do_include_common (pfile, IT_IMPORT); 865 } 866 867 static void 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 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 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 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 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 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 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 1156 do_error (cpp_reader *pfile) 1157 { 1158 do_diagnostic (pfile, CPP_DL_ERROR, CPP_W_NONE, 1); 1159 } 1160 1161 static void 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 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 * 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 * 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 * 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 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 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 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 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 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 ** 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 ** 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 ** 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 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 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 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 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 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 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 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 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 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 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 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 * 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 * 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 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 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 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 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 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 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 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 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 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 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 * 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 ** 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 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 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 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 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 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 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 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 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 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 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 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 * 2529 cpp_get_options (cpp_reader *pfile) 2530 { 2531 return &pfile->opts; 2532 } 2533 2534 /* The callbacks structure. */ 2535 cpp_callbacks * 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 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 * 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 * 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 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 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 * 2637 _cpp_bracket_include(cpp_reader *pfile) 2638 { 2639 return glue_header_name (pfile); 2640 } 2641 2642