1 /* Part of CPP library. (Macro and #define handling.) 2 Copyright (C) 1986-2018 Free Software Foundation, Inc. 3 Written by Per Bothner, 1994. 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 In other words, you are welcome to use, share and improve this program. 22 You are forbidden to forbid anyone else to use, share and improve 23 what you give them. Help stamp out software-hoarding! */ 24 25 #include "config.h" 26 #include "system.h" 27 #include "cpplib.h" 28 #include "internal.h" 29 30 typedef struct macro_arg macro_arg; 31 /* This structure represents the tokens of a macro argument. These 32 tokens can be macro themselves, in which case they can be either 33 expanded or unexpanded. When they are expanded, this data 34 structure keeps both the expanded and unexpanded forms. */ 35 struct macro_arg 36 { 37 const cpp_token **first; /* First token in unexpanded argument. */ 38 const cpp_token **expanded; /* Macro-expanded argument. */ 39 const cpp_token *stringified; /* Stringified argument. */ 40 unsigned int count; /* # of tokens in argument. */ 41 unsigned int expanded_count; /* # of tokens in expanded argument. */ 42 source_location *virt_locs; /* Where virtual locations for 43 unexpanded tokens are stored. */ 44 source_location *expanded_virt_locs; /* Where virtual locations for 45 expanded tokens are 46 stored. */ 47 }; 48 49 /* The kind of macro tokens which the instance of 50 macro_arg_token_iter is supposed to iterate over. */ 51 enum macro_arg_token_kind { 52 MACRO_ARG_TOKEN_NORMAL, 53 /* This is a macro argument token that got transformed into a string 54 literal, e.g. #foo. */ 55 MACRO_ARG_TOKEN_STRINGIFIED, 56 /* This is a token resulting from the expansion of a macro 57 argument that was itself a macro. */ 58 MACRO_ARG_TOKEN_EXPANDED 59 }; 60 61 /* An iterator over tokens coming from a function-like macro 62 argument. */ 63 typedef struct macro_arg_token_iter macro_arg_token_iter; 64 struct macro_arg_token_iter 65 { 66 /* Whether or not -ftrack-macro-expansion is used. */ 67 bool track_macro_exp_p; 68 /* The kind of token over which we are supposed to iterate. */ 69 enum macro_arg_token_kind kind; 70 /* A pointer to the current token pointed to by the iterator. */ 71 const cpp_token **token_ptr; 72 /* A pointer to the "full" location of the current token. If 73 -ftrack-macro-expansion is used this location tracks loci across 74 macro expansion. */ 75 const source_location *location_ptr; 76 #if CHECKING_P 77 /* The number of times the iterator went forward. This useful only 78 when checking is enabled. */ 79 size_t num_forwards; 80 #endif 81 }; 82 83 /* Saved data about an identifier being used as a macro argument 84 name. */ 85 struct macro_arg_saved_data { 86 /* The canonical (UTF-8) spelling of this identifier. */ 87 cpp_hashnode *canonical_node; 88 /* The previous value of this identifier. */ 89 union _cpp_hashnode_value value; 90 }; 91 92 static const char *vaopt_paste_error = 93 N_("'##' cannot appear at either end of __VA_OPT__"); 94 95 /* A class for tracking __VA_OPT__ state while iterating over a 96 sequence of tokens. This is used during both macro definition and 97 expansion. */ 98 class vaopt_state { 99 100 public: 101 102 /* Initialize the state tracker. ANY_ARGS is true if variable 103 arguments were provided to the macro invocation. */ 104 vaopt_state (cpp_reader *pfile, bool is_variadic, bool any_args) 105 : m_pfile (pfile), 106 m_allowed (any_args), 107 m_variadic (is_variadic), 108 m_last_was_paste (false), 109 m_state (0), 110 m_paste_location (0), 111 m_location (0) 112 { 113 } 114 115 enum update_type 116 { 117 ERROR, 118 DROP, 119 INCLUDE, 120 BEGIN, 121 END 122 }; 123 124 /* Given a token, update the state of this tracker and return a 125 boolean indicating whether the token should be be included in the 126 expansion. */ 127 update_type update (const cpp_token *token) 128 { 129 /* If the macro isn't variadic, just don't bother. */ 130 if (!m_variadic) 131 return INCLUDE; 132 133 if (token->type == CPP_NAME 134 && token->val.node.node == m_pfile->spec_nodes.n__VA_OPT__) 135 { 136 if (m_state > 0) 137 { 138 cpp_error_at (m_pfile, CPP_DL_ERROR, token->src_loc, 139 "__VA_OPT__ may not appear in a __VA_OPT__"); 140 return ERROR; 141 } 142 ++m_state; 143 m_location = token->src_loc; 144 return BEGIN; 145 } 146 else if (m_state == 1) 147 { 148 if (token->type != CPP_OPEN_PAREN) 149 { 150 cpp_error_at (m_pfile, CPP_DL_ERROR, m_location, 151 "__VA_OPT__ must be followed by an " 152 "open parenthesis"); 153 return ERROR; 154 } 155 ++m_state; 156 return DROP; 157 } 158 else if (m_state >= 2) 159 { 160 if (m_state == 2 && token->type == CPP_PASTE) 161 { 162 cpp_error_at (m_pfile, CPP_DL_ERROR, token->src_loc, 163 vaopt_paste_error); 164 return ERROR; 165 } 166 /* Advance states before further considering this token, in 167 case we see a close paren immediately after the open 168 paren. */ 169 if (m_state == 2) 170 ++m_state; 171 172 bool was_paste = m_last_was_paste; 173 m_last_was_paste = false; 174 if (token->type == CPP_PASTE) 175 { 176 m_last_was_paste = true; 177 m_paste_location = token->src_loc; 178 } 179 else if (token->type == CPP_OPEN_PAREN) 180 ++m_state; 181 else if (token->type == CPP_CLOSE_PAREN) 182 { 183 --m_state; 184 if (m_state == 2) 185 { 186 /* Saw the final paren. */ 187 m_state = 0; 188 189 if (was_paste) 190 { 191 cpp_error_at (m_pfile, CPP_DL_ERROR, token->src_loc, 192 vaopt_paste_error); 193 return ERROR; 194 } 195 196 return END; 197 } 198 } 199 return m_allowed ? INCLUDE : DROP; 200 } 201 202 /* Nothing to do with __VA_OPT__. */ 203 return INCLUDE; 204 } 205 206 /* Ensure that any __VA_OPT__ was completed. If ok, return true. 207 Otherwise, issue an error and return false. */ 208 bool completed () 209 { 210 if (m_variadic && m_state != 0) 211 cpp_error_at (m_pfile, CPP_DL_ERROR, m_location, 212 "unterminated __VA_OPT__"); 213 return m_state == 0; 214 } 215 216 private: 217 218 /* The cpp_reader. */ 219 cpp_reader *m_pfile; 220 221 /* True if there were varargs. */ 222 bool m_allowed; 223 /* True if the macro is variadic. */ 224 bool m_variadic; 225 /* If true, the previous token was ##. This is used to detect when 226 a paste occurs at the end of the sequence. */ 227 bool m_last_was_paste; 228 229 /* The state variable: 230 0 means not parsing 231 1 means __VA_OPT__ seen, looking for "(" 232 2 means "(" seen (so the next token can't be "##") 233 >= 3 means looking for ")", the number encodes the paren depth. */ 234 int m_state; 235 236 /* The location of the paste token. */ 237 source_location m_paste_location; 238 239 /* Location of the __VA_OPT__ token. */ 240 source_location m_location; 241 }; 242 243 /* Macro expansion. */ 244 245 static int enter_macro_context (cpp_reader *, cpp_hashnode *, 246 const cpp_token *, source_location); 247 static int builtin_macro (cpp_reader *, cpp_hashnode *, 248 source_location, source_location); 249 static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *, 250 const cpp_token **, unsigned int); 251 static void push_extended_tokens_context (cpp_reader *, cpp_hashnode *, 252 _cpp_buff *, source_location *, 253 const cpp_token **, unsigned int); 254 static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *, 255 _cpp_buff **, unsigned *); 256 static cpp_context *next_context (cpp_reader *); 257 static const cpp_token *padding_token (cpp_reader *, const cpp_token *); 258 static void expand_arg (cpp_reader *, macro_arg *); 259 static const cpp_token *new_string_token (cpp_reader *, uchar *, unsigned int); 260 static const cpp_token *stringify_arg (cpp_reader *, macro_arg *); 261 static void paste_all_tokens (cpp_reader *, const cpp_token *); 262 static bool paste_tokens (cpp_reader *, source_location, 263 const cpp_token **, const cpp_token *); 264 static void alloc_expanded_arg_mem (cpp_reader *, macro_arg *, size_t); 265 static void ensure_expanded_arg_room (cpp_reader *, macro_arg *, size_t, size_t *); 266 static void delete_macro_args (_cpp_buff*, unsigned num_args); 267 static void set_arg_token (macro_arg *, const cpp_token *, 268 source_location, size_t, 269 enum macro_arg_token_kind, 270 bool); 271 static const source_location *get_arg_token_location (const macro_arg *, 272 enum macro_arg_token_kind); 273 static const cpp_token **arg_token_ptr_at (const macro_arg *, 274 size_t, 275 enum macro_arg_token_kind, 276 source_location **virt_location); 277 278 static void macro_arg_token_iter_init (macro_arg_token_iter *, bool, 279 enum macro_arg_token_kind, 280 const macro_arg *, 281 const cpp_token **); 282 static const cpp_token *macro_arg_token_iter_get_token 283 (const macro_arg_token_iter *it); 284 static source_location macro_arg_token_iter_get_location 285 (const macro_arg_token_iter *); 286 static void macro_arg_token_iter_forward (macro_arg_token_iter *); 287 static _cpp_buff *tokens_buff_new (cpp_reader *, size_t, 288 source_location **); 289 static size_t tokens_buff_count (_cpp_buff *); 290 static const cpp_token **tokens_buff_last_token_ptr (_cpp_buff *); 291 static inline const cpp_token **tokens_buff_put_token_to (const cpp_token **, 292 source_location *, 293 const cpp_token *, 294 source_location, 295 source_location, 296 const line_map_macro *, 297 unsigned int); 298 299 static const cpp_token **tokens_buff_add_token (_cpp_buff *, 300 source_location *, 301 const cpp_token *, 302 source_location, 303 source_location, 304 const line_map_macro *, 305 unsigned int); 306 static inline void tokens_buff_remove_last_token (_cpp_buff *); 307 static void replace_args (cpp_reader *, cpp_hashnode *, cpp_macro *, 308 macro_arg *, source_location); 309 static _cpp_buff *funlike_invocation_p (cpp_reader *, cpp_hashnode *, 310 _cpp_buff **, unsigned *); 311 static bool create_iso_definition (cpp_reader *, cpp_macro *); 312 313 /* #define directive parsing and handling. */ 314 315 static cpp_token *alloc_expansion_token (cpp_reader *, cpp_macro *); 316 static cpp_token *lex_expansion_token (cpp_reader *, cpp_macro *); 317 static bool warn_of_redefinition (cpp_reader *, cpp_hashnode *, 318 const cpp_macro *); 319 static bool parse_params (cpp_reader *, cpp_macro *); 320 static void check_trad_stringification (cpp_reader *, const cpp_macro *, 321 const cpp_string *); 322 static bool reached_end_of_context (cpp_context *); 323 static void consume_next_token_from_context (cpp_reader *pfile, 324 const cpp_token **, 325 source_location *); 326 static const cpp_token* cpp_get_token_1 (cpp_reader *, source_location *); 327 328 static cpp_hashnode* macro_of_context (cpp_context *context); 329 330 static bool in_macro_expansion_p (cpp_reader *pfile); 331 332 /* Statistical counter tracking the number of macros that got 333 expanded. */ 334 unsigned num_expanded_macros_counter = 0; 335 /* Statistical counter tracking the total number tokens resulting 336 from macro expansion. */ 337 unsigned num_macro_tokens_counter = 0; 338 339 /* Emits a warning if NODE is a macro defined in the main file that 340 has not been used. */ 341 int 342 _cpp_warn_if_unused_macro (cpp_reader *pfile, cpp_hashnode *node, 343 void *v ATTRIBUTE_UNUSED) 344 { 345 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN)) 346 { 347 cpp_macro *macro = node->value.macro; 348 349 if (!macro->used 350 && MAIN_FILE_P (linemap_check_ordinary 351 (linemap_lookup (pfile->line_table, 352 macro->line)))) 353 cpp_warning_with_line (pfile, CPP_W_UNUSED_MACROS, macro->line, 0, 354 "macro \"%s\" is not used", NODE_NAME (node)); 355 } 356 357 return 1; 358 } 359 360 /* Allocates and returns a CPP_STRING token, containing TEXT of length 361 LEN, after null-terminating it. TEXT must be in permanent storage. */ 362 static const cpp_token * 363 new_string_token (cpp_reader *pfile, unsigned char *text, unsigned int len) 364 { 365 cpp_token *token = _cpp_temp_token (pfile); 366 367 text[len] = '\0'; 368 token->type = CPP_STRING; 369 token->val.str.len = len; 370 token->val.str.text = text; 371 token->flags = 0; 372 return token; 373 } 374 375 static const char * const monthnames[] = 376 { 377 "Jan", "Feb", "Mar", "Apr", "May", "Jun", 378 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" 379 }; 380 381 /* Helper function for builtin_macro. Returns the text generated by 382 a builtin macro. */ 383 const uchar * 384 _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node, 385 source_location loc) 386 { 387 const uchar *result = NULL; 388 linenum_type number = 1; 389 390 switch (node->value.builtin) 391 { 392 default: 393 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"", 394 NODE_NAME (node)); 395 break; 396 397 case BT_TIMESTAMP: 398 { 399 if (CPP_OPTION (pfile, warn_date_time)) 400 cpp_warning (pfile, CPP_W_DATE_TIME, "macro \"%s\" might prevent " 401 "reproducible builds", NODE_NAME (node)); 402 403 cpp_buffer *pbuffer = cpp_get_buffer (pfile); 404 if (pbuffer->timestamp == NULL) 405 { 406 /* Initialize timestamp value of the assotiated file. */ 407 struct _cpp_file *file = cpp_get_file (pbuffer); 408 if (file) 409 { 410 /* Generate __TIMESTAMP__ string, that represents 411 the date and time of the last modification 412 of the current source file. The string constant 413 looks like "Sun Sep 16 01:03:52 1973". */ 414 struct tm *tb = NULL; 415 struct stat *st = _cpp_get_file_stat (file); 416 if (st) 417 tb = localtime (&st->st_mtime); 418 if (tb) 419 { 420 char *str = asctime (tb); 421 size_t len = strlen (str); 422 unsigned char *buf = _cpp_unaligned_alloc (pfile, len + 2); 423 buf[0] = '"'; 424 strcpy ((char *) buf + 1, str); 425 buf[len] = '"'; 426 pbuffer->timestamp = buf; 427 } 428 else 429 { 430 cpp_errno (pfile, CPP_DL_WARNING, 431 "could not determine file timestamp"); 432 pbuffer->timestamp = UC"\"??? ??? ?? ??:??:?? ????\""; 433 } 434 } 435 } 436 result = pbuffer->timestamp; 437 } 438 break; 439 case BT_FILE: 440 case BT_BASE_FILE: 441 { 442 unsigned int len; 443 const char *name; 444 uchar *buf; 445 446 if (node->value.builtin == BT_FILE) 447 name = linemap_get_expansion_filename (pfile->line_table, 448 pfile->line_table->highest_line); 449 else 450 { 451 name = _cpp_get_file_name (pfile->main_file); 452 if (!name) 453 abort (); 454 } 455 if (pfile->cb.remap_filename) 456 name = pfile->cb.remap_filename (name); 457 len = strlen (name); 458 buf = _cpp_unaligned_alloc (pfile, len * 2 + 3); 459 result = buf; 460 *buf = '"'; 461 buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len); 462 *buf++ = '"'; 463 *buf = '\0'; 464 } 465 break; 466 467 case BT_INCLUDE_LEVEL: 468 /* The line map depth counts the primary source as level 1, but 469 historically __INCLUDE_DEPTH__ has called the primary source 470 level 0. */ 471 number = pfile->line_table->depth - 1; 472 break; 473 474 case BT_SPECLINE: 475 /* If __LINE__ is embedded in a macro, it must expand to the 476 line of the macro's invocation, not its definition. 477 Otherwise things like assert() will not work properly. 478 See WG14 N1911, WG21 N4220 sec 6.5, and PR 61861. */ 479 if (CPP_OPTION (pfile, traditional)) 480 loc = pfile->line_table->highest_line; 481 else 482 loc = linemap_resolve_location (pfile->line_table, loc, 483 LRK_MACRO_EXPANSION_POINT, NULL); 484 number = linemap_get_expansion_line (pfile->line_table, loc); 485 break; 486 487 /* __STDC__ has the value 1 under normal circumstances. 488 However, if (a) we are in a system header, (b) the option 489 stdc_0_in_system_headers is true (set by target config), and 490 (c) we are not in strictly conforming mode, then it has the 491 value 0. (b) and (c) are already checked in cpp_init_builtins. */ 492 case BT_STDC: 493 if (cpp_in_system_header (pfile)) 494 number = 0; 495 else 496 number = 1; 497 break; 498 499 case BT_DATE: 500 case BT_TIME: 501 if (CPP_OPTION (pfile, warn_date_time)) 502 cpp_warning (pfile, CPP_W_DATE_TIME, "macro \"%s\" might prevent " 503 "reproducible builds", NODE_NAME (node)); 504 if (pfile->date == NULL) 505 { 506 /* Allocate __DATE__ and __TIME__ strings from permanent 507 storage. We only do this once, and don't generate them 508 at init time, because time() and localtime() are very 509 slow on some systems. */ 510 time_t tt; 511 struct tm *tb = NULL; 512 513 /* Set a reproducible timestamp for __DATE__ and __TIME__ macro 514 if SOURCE_DATE_EPOCH is defined. */ 515 if (pfile->source_date_epoch == (time_t) -2 516 && pfile->cb.get_source_date_epoch != NULL) 517 pfile->source_date_epoch = pfile->cb.get_source_date_epoch (pfile); 518 519 if (pfile->source_date_epoch >= (time_t) 0) 520 tb = gmtime (&pfile->source_date_epoch); 521 else 522 { 523 /* (time_t) -1 is a legitimate value for "number of seconds 524 since the Epoch", so we have to do a little dance to 525 distinguish that from a genuine error. */ 526 errno = 0; 527 tt = time (NULL); 528 if (tt != (time_t)-1 || errno == 0) 529 tb = localtime (&tt); 530 } 531 532 if (tb) 533 { 534 pfile->date = _cpp_unaligned_alloc (pfile, 535 sizeof ("\"Oct 11 1347\"")); 536 sprintf ((char *) pfile->date, "\"%s %2d %4d\"", 537 monthnames[tb->tm_mon], tb->tm_mday, 538 tb->tm_year + 1900); 539 540 pfile->time = _cpp_unaligned_alloc (pfile, 541 sizeof ("\"12:34:56\"")); 542 sprintf ((char *) pfile->time, "\"%02d:%02d:%02d\"", 543 tb->tm_hour, tb->tm_min, tb->tm_sec); 544 } 545 else 546 { 547 cpp_errno (pfile, CPP_DL_WARNING, 548 "could not determine date and time"); 549 550 pfile->date = UC"\"??? ?? ????\""; 551 pfile->time = UC"\"??:??:??\""; 552 } 553 } 554 555 if (node->value.builtin == BT_DATE) 556 result = pfile->date; 557 else 558 result = pfile->time; 559 break; 560 561 case BT_COUNTER: 562 if (CPP_OPTION (pfile, directives_only) && pfile->state.in_directive) 563 cpp_error (pfile, CPP_DL_ERROR, 564 "__COUNTER__ expanded inside directive with -fdirectives-only"); 565 number = pfile->counter++; 566 break; 567 568 case BT_HAS_ATTRIBUTE: 569 number = pfile->cb.has_attribute (pfile); 570 break; 571 } 572 573 if (result == NULL) 574 { 575 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */ 576 result = _cpp_unaligned_alloc (pfile, 21); 577 sprintf ((char *) result, "%u", number); 578 } 579 580 return result; 581 } 582 583 /* Convert builtin macros like __FILE__ to a token and push it on the 584 context stack. Also handles _Pragma, for which a new token may not 585 be created. Returns 1 if it generates a new token context, 0 to 586 return the token to the caller. LOC is the location of the expansion 587 point of the macro. */ 588 static int 589 builtin_macro (cpp_reader *pfile, cpp_hashnode *node, 590 source_location loc, source_location expand_loc) 591 { 592 const uchar *buf; 593 size_t len; 594 char *nbuf; 595 596 if (node->value.builtin == BT_PRAGMA) 597 { 598 /* Don't interpret _Pragma within directives. The standard is 599 not clear on this, but to me this makes most sense. */ 600 if (pfile->state.in_directive) 601 return 0; 602 603 return _cpp_do__Pragma (pfile, loc); 604 } 605 606 buf = _cpp_builtin_macro_text (pfile, node, expand_loc); 607 len = ustrlen (buf); 608 nbuf = (char *) alloca (len + 1); 609 memcpy (nbuf, buf, len); 610 nbuf[len]='\n'; 611 612 cpp_push_buffer (pfile, (uchar *) nbuf, len, /* from_stage3 */ true); 613 _cpp_clean_line (pfile); 614 615 /* Set pfile->cur_token as required by _cpp_lex_direct. */ 616 pfile->cur_token = _cpp_temp_token (pfile); 617 cpp_token *token = _cpp_lex_direct (pfile); 618 /* We should point to the expansion point of the builtin macro. */ 619 token->src_loc = loc; 620 if (pfile->context->tokens_kind == TOKENS_KIND_EXTENDED) 621 { 622 /* We are tracking tokens resulting from macro expansion. 623 Create a macro line map and generate a virtual location for 624 the token resulting from the expansion of the built-in 625 macro. */ 626 source_location *virt_locs = NULL; 627 _cpp_buff *token_buf = tokens_buff_new (pfile, 1, &virt_locs); 628 const line_map_macro * map = 629 linemap_enter_macro (pfile->line_table, node, loc, 1); 630 tokens_buff_add_token (token_buf, virt_locs, token, 631 pfile->line_table->builtin_location, 632 pfile->line_table->builtin_location, 633 map, /*macro_token_index=*/0); 634 push_extended_tokens_context (pfile, node, token_buf, virt_locs, 635 (const cpp_token **)token_buf->base, 636 1); 637 } 638 else 639 _cpp_push_token_context (pfile, NULL, token, 1); 640 if (pfile->buffer->cur != pfile->buffer->rlimit) 641 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"", 642 NODE_NAME (node)); 643 _cpp_pop_buffer (pfile); 644 645 return 1; 646 } 647 648 /* Copies SRC, of length LEN, to DEST, adding backslashes before all 649 backslashes and double quotes. DEST must be of sufficient size. 650 Returns a pointer to the end of the string. */ 651 uchar * 652 cpp_quote_string (uchar *dest, const uchar *src, unsigned int len) 653 { 654 while (len--) 655 { 656 uchar c = *src++; 657 658 switch (c) 659 { 660 case '\n': 661 /* Naked LF can appear in raw string literals */ 662 c = 'n'; 663 /* FALLTHROUGH */ 664 665 case '\\': 666 case '"': 667 *dest++ = '\\'; 668 /* FALLTHROUGH */ 669 670 default: 671 *dest++ = c; 672 } 673 } 674 675 return dest; 676 } 677 678 /* Convert a token sequence ARG to a single string token according to 679 the rules of the ISO C #-operator. */ 680 static const cpp_token * 681 stringify_arg (cpp_reader *pfile, macro_arg *arg) 682 { 683 unsigned char *dest; 684 unsigned int i, escape_it, backslash_count = 0; 685 const cpp_token *source = NULL; 686 size_t len; 687 688 if (BUFF_ROOM (pfile->u_buff) < 3) 689 _cpp_extend_buff (pfile, &pfile->u_buff, 3); 690 dest = BUFF_FRONT (pfile->u_buff); 691 *dest++ = '"'; 692 693 /* Loop, reading in the argument's tokens. */ 694 for (i = 0; i < arg->count; i++) 695 { 696 const cpp_token *token = arg->first[i]; 697 698 if (token->type == CPP_PADDING) 699 { 700 if (source == NULL 701 || (!(source->flags & PREV_WHITE) 702 && token->val.source == NULL)) 703 source = token->val.source; 704 continue; 705 } 706 707 escape_it = (token->type == CPP_STRING || token->type == CPP_CHAR 708 || token->type == CPP_WSTRING || token->type == CPP_WCHAR 709 || token->type == CPP_STRING32 || token->type == CPP_CHAR32 710 || token->type == CPP_STRING16 || token->type == CPP_CHAR16 711 || token->type == CPP_UTF8STRING || token->type == CPP_UTF8CHAR 712 || cpp_userdef_string_p (token->type) 713 || cpp_userdef_char_p (token->type)); 714 715 /* Room for each char being written in octal, initial space and 716 final quote and NUL. */ 717 len = cpp_token_len (token); 718 if (escape_it) 719 len *= 4; 720 len += 3; 721 722 if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len) 723 { 724 size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff); 725 _cpp_extend_buff (pfile, &pfile->u_buff, len); 726 dest = BUFF_FRONT (pfile->u_buff) + len_so_far; 727 } 728 729 /* Leading white space? */ 730 if (dest - 1 != BUFF_FRONT (pfile->u_buff)) 731 { 732 if (source == NULL) 733 source = token; 734 if (source->flags & PREV_WHITE) 735 *dest++ = ' '; 736 } 737 source = NULL; 738 739 if (escape_it) 740 { 741 _cpp_buff *buff = _cpp_get_buff (pfile, len); 742 unsigned char *buf = BUFF_FRONT (buff); 743 len = cpp_spell_token (pfile, token, buf, true) - buf; 744 dest = cpp_quote_string (dest, buf, len); 745 _cpp_release_buff (pfile, buff); 746 } 747 else 748 dest = cpp_spell_token (pfile, token, dest, true); 749 750 if (token->type == CPP_OTHER && token->val.str.text[0] == '\\') 751 backslash_count++; 752 else 753 backslash_count = 0; 754 } 755 756 /* Ignore the final \ of invalid string literals. */ 757 if (backslash_count & 1) 758 { 759 cpp_error (pfile, CPP_DL_WARNING, 760 "invalid string literal, ignoring final '\\'"); 761 dest--; 762 } 763 764 /* Commit the memory, including NUL, and return the token. */ 765 *dest++ = '"'; 766 len = dest - BUFF_FRONT (pfile->u_buff); 767 BUFF_FRONT (pfile->u_buff) = dest + 1; 768 return new_string_token (pfile, dest - len, len); 769 } 770 771 /* Try to paste two tokens. On success, return nonzero. In any 772 case, PLHS is updated to point to the pasted token, which is 773 guaranteed to not have the PASTE_LEFT flag set. LOCATION is 774 the virtual location used for error reporting. */ 775 static bool 776 paste_tokens (cpp_reader *pfile, source_location location, 777 const cpp_token **plhs, const cpp_token *rhs) 778 { 779 unsigned char *buf, *end, *lhsend; 780 cpp_token *lhs; 781 unsigned int len; 782 783 len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 1; 784 buf = (unsigned char *) alloca (len); 785 end = lhsend = cpp_spell_token (pfile, *plhs, buf, true); 786 787 /* Avoid comment headers, since they are still processed in stage 3. 788 It is simpler to insert a space here, rather than modifying the 789 lexer to ignore comments in some circumstances. Simply returning 790 false doesn't work, since we want to clear the PASTE_LEFT flag. */ 791 if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ) 792 *end++ = ' '; 793 /* In one obscure case we might see padding here. */ 794 if (rhs->type != CPP_PADDING) 795 end = cpp_spell_token (pfile, rhs, end, true); 796 *end = '\n'; 797 798 cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true); 799 _cpp_clean_line (pfile); 800 801 /* Set pfile->cur_token as required by _cpp_lex_direct. */ 802 pfile->cur_token = _cpp_temp_token (pfile); 803 lhs = _cpp_lex_direct (pfile); 804 if (pfile->buffer->cur != pfile->buffer->rlimit) 805 { 806 source_location saved_loc = lhs->src_loc; 807 808 _cpp_pop_buffer (pfile); 809 _cpp_backup_tokens (pfile, 1); 810 *lhsend = '\0'; 811 812 /* We have to remove the PASTE_LEFT flag from the old lhs, but 813 we want to keep the new location. */ 814 *lhs = **plhs; 815 *plhs = lhs; 816 lhs->src_loc = saved_loc; 817 lhs->flags &= ~PASTE_LEFT; 818 819 /* Mandatory error for all apart from assembler. */ 820 if (CPP_OPTION (pfile, lang) != CLK_ASM) 821 cpp_error_with_line (pfile, CPP_DL_ERROR, location, 0, 822 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token", 823 buf, cpp_token_as_text (pfile, rhs)); 824 return false; 825 } 826 827 *plhs = lhs; 828 _cpp_pop_buffer (pfile); 829 return true; 830 } 831 832 /* Handles an arbitrarily long sequence of ## operators, with initial 833 operand LHS. This implementation is left-associative, 834 non-recursive, and finishes a paste before handling succeeding 835 ones. If a paste fails, we back up to the RHS of the failing ## 836 operator before pushing the context containing the result of prior 837 successful pastes, with the effect that the RHS appears in the 838 output stream after the pasted LHS normally. */ 839 static void 840 paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs) 841 { 842 const cpp_token *rhs = NULL; 843 cpp_context *context = pfile->context; 844 source_location virt_loc = 0; 845 846 /* We are expanding a macro and we must have been called on a token 847 that appears at the left hand side of a ## operator. */ 848 if (macro_of_context (pfile->context) == NULL 849 || (!(lhs->flags & PASTE_LEFT))) 850 abort (); 851 852 if (context->tokens_kind == TOKENS_KIND_EXTENDED) 853 /* The caller must have called consume_next_token_from_context 854 right before calling us. That has incremented the pointer to 855 the current virtual location. So it now points to the location 856 of the token that comes right after *LHS. We want the 857 resulting pasted token to have the location of the current 858 *LHS, though. */ 859 virt_loc = context->c.mc->cur_virt_loc[-1]; 860 else 861 /* We are not tracking macro expansion. So the best virtual 862 location we can get here is the expansion point of the macro we 863 are currently expanding. */ 864 virt_loc = pfile->invocation_location; 865 866 do 867 { 868 /* Take the token directly from the current context. We can do 869 this, because we are in the replacement list of either an 870 object-like macro, or a function-like macro with arguments 871 inserted. In either case, the constraints to #define 872 guarantee we have at least one more token. */ 873 if (context->tokens_kind == TOKENS_KIND_DIRECT) 874 rhs = FIRST (context).token++; 875 else if (context->tokens_kind == TOKENS_KIND_INDIRECT) 876 rhs = *FIRST (context).ptoken++; 877 else if (context->tokens_kind == TOKENS_KIND_EXTENDED) 878 { 879 /* So we are in presence of an extended token context, which 880 means that each token in this context has a virtual 881 location attached to it. So let's not forget to update 882 the pointer to the current virtual location of the 883 current token when we update the pointer to the current 884 token */ 885 886 rhs = *FIRST (context).ptoken++; 887 /* context->c.mc must be non-null, as if we were not in a 888 macro context, context->tokens_kind could not be equal to 889 TOKENS_KIND_EXTENDED. */ 890 context->c.mc->cur_virt_loc++; 891 } 892 893 if (rhs->type == CPP_PADDING) 894 { 895 if (rhs->flags & PASTE_LEFT) 896 abort (); 897 } 898 if (!paste_tokens (pfile, virt_loc, &lhs, rhs)) 899 break; 900 } 901 while (rhs->flags & PASTE_LEFT); 902 903 /* Put the resulting token in its own context. */ 904 if (context->tokens_kind == TOKENS_KIND_EXTENDED) 905 { 906 source_location *virt_locs = NULL; 907 _cpp_buff *token_buf = tokens_buff_new (pfile, 1, &virt_locs); 908 tokens_buff_add_token (token_buf, virt_locs, lhs, 909 virt_loc, 0, NULL, 0); 910 push_extended_tokens_context (pfile, context->c.mc->macro_node, 911 token_buf, virt_locs, 912 (const cpp_token **)token_buf->base, 1); 913 } 914 else 915 _cpp_push_token_context (pfile, NULL, lhs, 1); 916 } 917 918 /* Returns TRUE if the number of arguments ARGC supplied in an 919 invocation of the MACRO referenced by NODE is valid. An empty 920 invocation to a macro with no parameters should pass ARGC as zero. 921 922 Note that MACRO cannot necessarily be deduced from NODE, in case 923 NODE was redefined whilst collecting arguments. */ 924 bool 925 _cpp_arguments_ok (cpp_reader *pfile, cpp_macro *macro, const cpp_hashnode *node, unsigned int argc) 926 { 927 if (argc == macro->paramc) 928 return true; 929 930 if (argc < macro->paramc) 931 { 932 /* In C++2a (here the va_opt flag is used), and also as a GNU 933 extension, variadic arguments are allowed to not appear in 934 the invocation at all. 935 e.g. #define debug(format, args...) something 936 debug("string"); 937 938 This is exactly the same as if an empty variadic list had been 939 supplied - debug("string", ). */ 940 941 if (argc + 1 == macro->paramc && macro->variadic) 942 { 943 if (CPP_PEDANTIC (pfile) && ! macro->syshdr 944 && ! CPP_OPTION (pfile, va_opt)) 945 { 946 if (CPP_OPTION (pfile, cplusplus)) 947 cpp_error (pfile, CPP_DL_PEDWARN, 948 "ISO C++11 requires at least one argument " 949 "for the \"...\" in a variadic macro"); 950 else 951 cpp_error (pfile, CPP_DL_PEDWARN, 952 "ISO C99 requires at least one argument " 953 "for the \"...\" in a variadic macro"); 954 } 955 return true; 956 } 957 958 cpp_error (pfile, CPP_DL_ERROR, 959 "macro \"%s\" requires %u arguments, but only %u given", 960 NODE_NAME (node), macro->paramc, argc); 961 } 962 else 963 cpp_error (pfile, CPP_DL_ERROR, 964 "macro \"%s\" passed %u arguments, but takes just %u", 965 NODE_NAME (node), argc, macro->paramc); 966 967 return false; 968 } 969 970 /* Reads and returns the arguments to a function-like macro 971 invocation. Assumes the opening parenthesis has been processed. 972 If there is an error, emits an appropriate diagnostic and returns 973 NULL. Each argument is terminated by a CPP_EOF token, for the 974 future benefit of expand_arg(). If there are any deferred 975 #pragma directives among macro arguments, store pointers to the 976 CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer. 977 978 What is returned is the buffer that contains the memory allocated 979 to hold the macro arguments. NODE is the name of the macro this 980 function is dealing with. If NUM_ARGS is non-NULL, *NUM_ARGS is 981 set to the actual number of macro arguments allocated in the 982 returned buffer. */ 983 static _cpp_buff * 984 collect_args (cpp_reader *pfile, const cpp_hashnode *node, 985 _cpp_buff **pragma_buff, unsigned *num_args) 986 { 987 _cpp_buff *buff, *base_buff; 988 cpp_macro *macro; 989 macro_arg *args, *arg; 990 const cpp_token *token; 991 unsigned int argc; 992 source_location virt_loc; 993 bool track_macro_expansion_p = CPP_OPTION (pfile, track_macro_expansion); 994 unsigned num_args_alloced = 0; 995 996 macro = node->value.macro; 997 if (macro->paramc) 998 argc = macro->paramc; 999 else 1000 argc = 1; 1001 1002 #define DEFAULT_NUM_TOKENS_PER_MACRO_ARG 50 1003 #define ARG_TOKENS_EXTENT 1000 1004 1005 buff = _cpp_get_buff (pfile, argc * (DEFAULT_NUM_TOKENS_PER_MACRO_ARG 1006 * sizeof (cpp_token *) 1007 + sizeof (macro_arg))); 1008 base_buff = buff; 1009 args = (macro_arg *) buff->base; 1010 memset (args, 0, argc * sizeof (macro_arg)); 1011 buff->cur = (unsigned char *) &args[argc]; 1012 arg = args, argc = 0; 1013 1014 /* Collect the tokens making up each argument. We don't yet know 1015 how many arguments have been supplied, whether too many or too 1016 few. Hence the slightly bizarre usage of "argc" and "arg". */ 1017 do 1018 { 1019 unsigned int paren_depth = 0; 1020 unsigned int ntokens = 0; 1021 unsigned virt_locs_capacity = DEFAULT_NUM_TOKENS_PER_MACRO_ARG; 1022 num_args_alloced++; 1023 1024 argc++; 1025 arg->first = (const cpp_token **) buff->cur; 1026 if (track_macro_expansion_p) 1027 { 1028 virt_locs_capacity = DEFAULT_NUM_TOKENS_PER_MACRO_ARG; 1029 arg->virt_locs = XNEWVEC (source_location, 1030 virt_locs_capacity); 1031 } 1032 1033 for (;;) 1034 { 1035 /* Require space for 2 new tokens (including a CPP_EOF). */ 1036 if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit) 1037 { 1038 buff = _cpp_append_extend_buff (pfile, buff, 1039 ARG_TOKENS_EXTENT 1040 * sizeof (cpp_token *)); 1041 arg->first = (const cpp_token **) buff->cur; 1042 } 1043 if (track_macro_expansion_p 1044 && (ntokens + 2 > virt_locs_capacity)) 1045 { 1046 virt_locs_capacity += ARG_TOKENS_EXTENT; 1047 arg->virt_locs = XRESIZEVEC (source_location, 1048 arg->virt_locs, 1049 virt_locs_capacity); 1050 } 1051 1052 token = cpp_get_token_1 (pfile, &virt_loc); 1053 1054 if (token->type == CPP_PADDING) 1055 { 1056 /* Drop leading padding. */ 1057 if (ntokens == 0) 1058 continue; 1059 } 1060 else if (token->type == CPP_OPEN_PAREN) 1061 paren_depth++; 1062 else if (token->type == CPP_CLOSE_PAREN) 1063 { 1064 if (paren_depth-- == 0) 1065 break; 1066 } 1067 else if (token->type == CPP_COMMA) 1068 { 1069 /* A comma does not terminate an argument within 1070 parentheses or as part of a variable argument. */ 1071 if (paren_depth == 0 1072 && ! (macro->variadic && argc == macro->paramc)) 1073 break; 1074 } 1075 else if (token->type == CPP_EOF 1076 || (token->type == CPP_HASH && token->flags & BOL)) 1077 break; 1078 else if (token->type == CPP_PRAGMA) 1079 { 1080 cpp_token *newtok = _cpp_temp_token (pfile); 1081 1082 /* CPP_PRAGMA token lives in directive_result, which will 1083 be overwritten on the next directive. */ 1084 *newtok = *token; 1085 token = newtok; 1086 do 1087 { 1088 if (*pragma_buff == NULL 1089 || BUFF_ROOM (*pragma_buff) < sizeof (cpp_token *)) 1090 { 1091 _cpp_buff *next; 1092 if (*pragma_buff == NULL) 1093 *pragma_buff 1094 = _cpp_get_buff (pfile, 32 * sizeof (cpp_token *)); 1095 else 1096 { 1097 next = *pragma_buff; 1098 *pragma_buff 1099 = _cpp_get_buff (pfile, 1100 (BUFF_FRONT (*pragma_buff) 1101 - (*pragma_buff)->base) * 2); 1102 (*pragma_buff)->next = next; 1103 } 1104 } 1105 *(const cpp_token **) BUFF_FRONT (*pragma_buff) = token; 1106 BUFF_FRONT (*pragma_buff) += sizeof (cpp_token *); 1107 if (token->type == CPP_PRAGMA_EOL) 1108 break; 1109 token = cpp_get_token_1 (pfile, &virt_loc); 1110 } 1111 while (token->type != CPP_EOF); 1112 1113 /* In deferred pragmas parsing_args and prevent_expansion 1114 had been changed, reset it. */ 1115 pfile->state.parsing_args = 2; 1116 pfile->state.prevent_expansion = 1; 1117 1118 if (token->type == CPP_EOF) 1119 break; 1120 else 1121 continue; 1122 } 1123 set_arg_token (arg, token, virt_loc, 1124 ntokens, MACRO_ARG_TOKEN_NORMAL, 1125 CPP_OPTION (pfile, track_macro_expansion)); 1126 ntokens++; 1127 } 1128 1129 /* Drop trailing padding. */ 1130 while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING) 1131 ntokens--; 1132 1133 arg->count = ntokens; 1134 set_arg_token (arg, &pfile->eof, pfile->eof.src_loc, 1135 ntokens, MACRO_ARG_TOKEN_NORMAL, 1136 CPP_OPTION (pfile, track_macro_expansion)); 1137 1138 /* Terminate the argument. Excess arguments loop back and 1139 overwrite the final legitimate argument, before failing. */ 1140 if (argc <= macro->paramc) 1141 { 1142 buff->cur = (unsigned char *) &arg->first[ntokens + 1]; 1143 if (argc != macro->paramc) 1144 arg++; 1145 } 1146 } 1147 while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF); 1148 1149 if (token->type == CPP_EOF) 1150 { 1151 /* We still need the CPP_EOF to end directives, and to end 1152 pre-expansion of a macro argument. Step back is not 1153 unconditional, since we don't want to return a CPP_EOF to our 1154 callers at the end of an -include-d file. */ 1155 if (pfile->context->prev || pfile->state.in_directive) 1156 _cpp_backup_tokens (pfile, 1); 1157 cpp_error (pfile, CPP_DL_ERROR, 1158 "unterminated argument list invoking macro \"%s\"", 1159 NODE_NAME (node)); 1160 } 1161 else 1162 { 1163 /* A single empty argument is counted as no argument. */ 1164 if (argc == 1 && macro->paramc == 0 && args[0].count == 0) 1165 argc = 0; 1166 if (_cpp_arguments_ok (pfile, macro, node, argc)) 1167 { 1168 /* GCC has special semantics for , ## b where b is a varargs 1169 parameter: we remove the comma if b was omitted entirely. 1170 If b was merely an empty argument, the comma is retained. 1171 If the macro takes just one (varargs) parameter, then we 1172 retain the comma only if we are standards conforming. 1173 1174 If FIRST is NULL replace_args () swallows the comma. */ 1175 if (macro->variadic && (argc < macro->paramc 1176 || (argc == 1 && args[0].count == 0 1177 && !CPP_OPTION (pfile, std)))) 1178 args[macro->paramc - 1].first = NULL; 1179 if (num_args) 1180 *num_args = num_args_alloced; 1181 return base_buff; 1182 } 1183 } 1184 1185 /* An error occurred. */ 1186 _cpp_release_buff (pfile, base_buff); 1187 return NULL; 1188 } 1189 1190 /* Search for an opening parenthesis to the macro of NODE, in such a 1191 way that, if none is found, we don't lose the information in any 1192 intervening padding tokens. If we find the parenthesis, collect 1193 the arguments and return the buffer containing them. PRAGMA_BUFF 1194 argument is the same as in collect_args. If NUM_ARGS is non-NULL, 1195 *NUM_ARGS is set to the number of arguments contained in the 1196 returned buffer. */ 1197 static _cpp_buff * 1198 funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node, 1199 _cpp_buff **pragma_buff, unsigned *num_args) 1200 { 1201 const cpp_token *token, *padding = NULL; 1202 1203 for (;;) 1204 { 1205 token = cpp_get_token (pfile); 1206 if (token->type != CPP_PADDING) 1207 break; 1208 if (padding == NULL 1209 || (!(padding->flags & PREV_WHITE) && token->val.source == NULL)) 1210 padding = token; 1211 } 1212 1213 if (token->type == CPP_OPEN_PAREN) 1214 { 1215 pfile->state.parsing_args = 2; 1216 return collect_args (pfile, node, pragma_buff, num_args); 1217 } 1218 1219 /* CPP_EOF can be the end of macro arguments, or the end of the 1220 file. We mustn't back up over the latter. Ugh. */ 1221 if (token->type != CPP_EOF || token == &pfile->eof) 1222 { 1223 /* Back up. We may have skipped padding, in which case backing 1224 up more than one token when expanding macros is in general 1225 too difficult. We re-insert it in its own context. */ 1226 _cpp_backup_tokens (pfile, 1); 1227 if (padding) 1228 _cpp_push_token_context (pfile, NULL, padding, 1); 1229 } 1230 1231 return NULL; 1232 } 1233 1234 /* Return the real number of tokens in the expansion of MACRO. */ 1235 static inline unsigned int 1236 macro_real_token_count (const cpp_macro *macro) 1237 { 1238 unsigned int i; 1239 if (__builtin_expect (!macro->extra_tokens, true)) 1240 return macro->count; 1241 for (i = 0; i < macro->count; i++) 1242 if (macro->exp.tokens[i].type == CPP_PASTE) 1243 return i; 1244 abort (); 1245 } 1246 1247 /* Push the context of a macro with hash entry NODE onto the context 1248 stack. If we can successfully expand the macro, we push a context 1249 containing its yet-to-be-rescanned replacement list and return one. 1250 If there were additionally any unexpanded deferred #pragma 1251 directives among macro arguments, push another context containing 1252 the pragma tokens before the yet-to-be-rescanned replacement list 1253 and return two. Otherwise, we don't push a context and return 1254 zero. LOCATION is the location of the expansion point of the 1255 macro. */ 1256 static int 1257 enter_macro_context (cpp_reader *pfile, cpp_hashnode *node, 1258 const cpp_token *result, source_location location) 1259 { 1260 /* The presence of a macro invalidates a file's controlling macro. */ 1261 pfile->mi_valid = false; 1262 1263 pfile->state.angled_headers = false; 1264 1265 /* From here to when we push the context for the macro later down 1266 this function, we need to flag the fact that we are about to 1267 expand a macro. This is useful when -ftrack-macro-expansion is 1268 turned off. In that case, we need to record the location of the 1269 expansion point of the top-most macro we are about to to expand, 1270 into pfile->invocation_location. But we must not record any such 1271 location once the process of expanding the macro starts; that is, 1272 we must not do that recording between now and later down this 1273 function where set this flag to FALSE. */ 1274 pfile->about_to_expand_macro_p = true; 1275 1276 if ((node->flags & NODE_BUILTIN) && !(node->flags & NODE_USED)) 1277 { 1278 node->flags |= NODE_USED; 1279 if ((!pfile->cb.user_builtin_macro 1280 || !pfile->cb.user_builtin_macro (pfile, node)) 1281 && pfile->cb.used_define) 1282 pfile->cb.used_define (pfile, pfile->directive_line, node); 1283 } 1284 1285 /* Handle standard macros. */ 1286 if (! (node->flags & NODE_BUILTIN)) 1287 { 1288 cpp_macro *macro = node->value.macro; 1289 _cpp_buff *pragma_buff = NULL; 1290 1291 if (macro->fun_like) 1292 { 1293 _cpp_buff *buff; 1294 unsigned num_args = 0; 1295 1296 pfile->state.prevent_expansion++; 1297 pfile->keep_tokens++; 1298 pfile->state.parsing_args = 1; 1299 buff = funlike_invocation_p (pfile, node, &pragma_buff, 1300 &num_args); 1301 pfile->state.parsing_args = 0; 1302 pfile->keep_tokens--; 1303 pfile->state.prevent_expansion--; 1304 1305 if (buff == NULL) 1306 { 1307 if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr) 1308 cpp_warning (pfile, CPP_W_TRADITIONAL, 1309 "function-like macro \"%s\" must be used with arguments in traditional C", 1310 NODE_NAME (node)); 1311 1312 if (pragma_buff) 1313 _cpp_release_buff (pfile, pragma_buff); 1314 1315 pfile->about_to_expand_macro_p = false; 1316 return 0; 1317 } 1318 1319 if (macro->paramc > 0) 1320 replace_args (pfile, node, macro, 1321 (macro_arg *) buff->base, 1322 location); 1323 /* Free the memory used by the arguments of this 1324 function-like macro. This memory has been allocated by 1325 funlike_invocation_p and by replace_args. */ 1326 delete_macro_args (buff, num_args); 1327 } 1328 1329 /* Disable the macro within its expansion. */ 1330 node->flags |= NODE_DISABLED; 1331 1332 if (!(node->flags & NODE_USED)) 1333 { 1334 node->flags |= NODE_USED; 1335 if (pfile->cb.used_define) 1336 pfile->cb.used_define (pfile, pfile->directive_line, node); 1337 } 1338 1339 if (pfile->cb.used) 1340 pfile->cb.used (pfile, location, node); 1341 1342 macro->used = 1; 1343 1344 if (macro->paramc == 0) 1345 { 1346 unsigned tokens_count = macro_real_token_count (macro); 1347 if (CPP_OPTION (pfile, track_macro_expansion)) 1348 { 1349 unsigned int i; 1350 const cpp_token *src = macro->exp.tokens; 1351 const line_map_macro *map; 1352 source_location *virt_locs = NULL; 1353 _cpp_buff *macro_tokens 1354 = tokens_buff_new (pfile, tokens_count, &virt_locs); 1355 1356 /* Create a macro map to record the locations of the 1357 tokens that are involved in the expansion. LOCATION 1358 is the location of the macro expansion point. */ 1359 map = linemap_enter_macro (pfile->line_table, 1360 node, location, tokens_count); 1361 for (i = 0; i < tokens_count; ++i) 1362 { 1363 tokens_buff_add_token (macro_tokens, virt_locs, 1364 src, src->src_loc, 1365 src->src_loc, map, i); 1366 ++src; 1367 } 1368 push_extended_tokens_context (pfile, node, 1369 macro_tokens, 1370 virt_locs, 1371 (const cpp_token **) 1372 macro_tokens->base, 1373 tokens_count); 1374 } 1375 else 1376 _cpp_push_token_context (pfile, node, macro->exp.tokens, 1377 tokens_count); 1378 num_macro_tokens_counter += tokens_count; 1379 } 1380 1381 if (pragma_buff) 1382 { 1383 if (!pfile->state.in_directive) 1384 _cpp_push_token_context (pfile, NULL, 1385 padding_token (pfile, result), 1); 1386 do 1387 { 1388 unsigned tokens_count; 1389 _cpp_buff *tail = pragma_buff->next; 1390 pragma_buff->next = NULL; 1391 tokens_count = ((const cpp_token **) BUFF_FRONT (pragma_buff) 1392 - (const cpp_token **) pragma_buff->base); 1393 push_ptoken_context (pfile, NULL, pragma_buff, 1394 (const cpp_token **) pragma_buff->base, 1395 tokens_count); 1396 pragma_buff = tail; 1397 if (!CPP_OPTION (pfile, track_macro_expansion)) 1398 num_macro_tokens_counter += tokens_count; 1399 1400 } 1401 while (pragma_buff != NULL); 1402 pfile->about_to_expand_macro_p = false; 1403 return 2; 1404 } 1405 1406 pfile->about_to_expand_macro_p = false; 1407 return 1; 1408 } 1409 1410 pfile->about_to_expand_macro_p = false; 1411 /* Handle built-in macros and the _Pragma operator. */ 1412 { 1413 source_location loc, expand_loc; 1414 1415 if (/* The top-level macro invocation that triggered the expansion 1416 we are looking at is with a standard macro ...*/ 1417 !(pfile->top_most_macro_node->flags & NODE_BUILTIN) 1418 /* ... and it's a function-like macro invocation. */ 1419 && pfile->top_most_macro_node->value.macro->fun_like) 1420 { 1421 /* Then the location of the end of the macro invocation is the 1422 location of the closing parenthesis. */ 1423 loc = pfile->cur_token[-1].src_loc; 1424 expand_loc = loc; 1425 } 1426 else 1427 { 1428 /* Otherwise, the location of the end of the macro invocation is 1429 the location of the expansion point of that top-level macro 1430 invocation. */ 1431 loc = location; 1432 expand_loc = pfile->invocation_location; 1433 } 1434 1435 return builtin_macro (pfile, node, loc, expand_loc); 1436 } 1437 } 1438 1439 /* De-allocate the memory used by BUFF which is an array of instances 1440 of macro_arg. NUM_ARGS is the number of instances of macro_arg 1441 present in BUFF. */ 1442 static void 1443 delete_macro_args (_cpp_buff *buff, unsigned num_args) 1444 { 1445 macro_arg *macro_args; 1446 unsigned i; 1447 1448 if (buff == NULL) 1449 return; 1450 1451 macro_args = (macro_arg *) buff->base; 1452 1453 /* Walk instances of macro_arg to free their expanded tokens as well 1454 as their macro_arg::virt_locs members. */ 1455 for (i = 0; i < num_args; ++i) 1456 { 1457 if (macro_args[i].expanded) 1458 { 1459 free (macro_args[i].expanded); 1460 macro_args[i].expanded = NULL; 1461 } 1462 if (macro_args[i].virt_locs) 1463 { 1464 free (macro_args[i].virt_locs); 1465 macro_args[i].virt_locs = NULL; 1466 } 1467 if (macro_args[i].expanded_virt_locs) 1468 { 1469 free (macro_args[i].expanded_virt_locs); 1470 macro_args[i].expanded_virt_locs = NULL; 1471 } 1472 } 1473 _cpp_free_buff (buff); 1474 } 1475 1476 /* Set the INDEXth token of the macro argument ARG. TOKEN is the token 1477 to set, LOCATION is its virtual location. "Virtual" location means 1478 the location that encodes loci across macro expansion. Otherwise 1479 it has to be TOKEN->SRC_LOC. KIND is the kind of tokens the 1480 argument ARG is supposed to contain. Note that ARG must be 1481 tailored so that it has enough room to contain INDEX + 1 numbers of 1482 tokens, at least. */ 1483 static void 1484 set_arg_token (macro_arg *arg, const cpp_token *token, 1485 source_location location, size_t index, 1486 enum macro_arg_token_kind kind, 1487 bool track_macro_exp_p) 1488 { 1489 const cpp_token **token_ptr; 1490 source_location *loc = NULL; 1491 1492 token_ptr = 1493 arg_token_ptr_at (arg, index, kind, 1494 track_macro_exp_p ? &loc : NULL); 1495 *token_ptr = token; 1496 1497 if (loc != NULL) 1498 { 1499 /* We can't set the location of a stringified argument 1500 token and we can't set any location if we aren't tracking 1501 macro expansion locations. */ 1502 gcc_checking_assert (kind != MACRO_ARG_TOKEN_STRINGIFIED 1503 && track_macro_exp_p); 1504 *loc = location; 1505 } 1506 } 1507 1508 /* Get the pointer to the location of the argument token of the 1509 function-like macro argument ARG. This function must be called 1510 only when we -ftrack-macro-expansion is on. */ 1511 static const source_location * 1512 get_arg_token_location (const macro_arg *arg, 1513 enum macro_arg_token_kind kind) 1514 { 1515 const source_location *loc = NULL; 1516 const cpp_token **token_ptr = 1517 arg_token_ptr_at (arg, 0, kind, (source_location **) &loc); 1518 1519 if (token_ptr == NULL) 1520 return NULL; 1521 1522 return loc; 1523 } 1524 1525 /* Return the pointer to the INDEXth token of the macro argument ARG. 1526 KIND specifies the kind of token the macro argument ARG contains. 1527 If VIRT_LOCATION is non NULL, *VIRT_LOCATION is set to the address 1528 of the virtual location of the returned token if the 1529 -ftrack-macro-expansion flag is on; otherwise, it's set to the 1530 spelling location of the returned token. */ 1531 static const cpp_token ** 1532 arg_token_ptr_at (const macro_arg *arg, size_t index, 1533 enum macro_arg_token_kind kind, 1534 source_location **virt_location) 1535 { 1536 const cpp_token **tokens_ptr = NULL; 1537 1538 switch (kind) 1539 { 1540 case MACRO_ARG_TOKEN_NORMAL: 1541 tokens_ptr = arg->first; 1542 break; 1543 case MACRO_ARG_TOKEN_STRINGIFIED: 1544 tokens_ptr = (const cpp_token **) &arg->stringified; 1545 break; 1546 case MACRO_ARG_TOKEN_EXPANDED: 1547 tokens_ptr = arg->expanded; 1548 break; 1549 } 1550 1551 if (tokens_ptr == NULL) 1552 /* This can happen for e.g, an empty token argument to a 1553 funtion-like macro. */ 1554 return tokens_ptr; 1555 1556 if (virt_location) 1557 { 1558 if (kind == MACRO_ARG_TOKEN_NORMAL) 1559 *virt_location = &arg->virt_locs[index]; 1560 else if (kind == MACRO_ARG_TOKEN_EXPANDED) 1561 *virt_location = &arg->expanded_virt_locs[index]; 1562 else if (kind == MACRO_ARG_TOKEN_STRINGIFIED) 1563 *virt_location = 1564 (source_location *) &tokens_ptr[index]->src_loc; 1565 } 1566 return &tokens_ptr[index]; 1567 } 1568 1569 /* Initialize an iterator so that it iterates over the tokens of a 1570 function-like macro argument. KIND is the kind of tokens we want 1571 ITER to iterate over. TOKEN_PTR points the first token ITER will 1572 iterate over. */ 1573 static void 1574 macro_arg_token_iter_init (macro_arg_token_iter *iter, 1575 bool track_macro_exp_p, 1576 enum macro_arg_token_kind kind, 1577 const macro_arg *arg, 1578 const cpp_token **token_ptr) 1579 { 1580 iter->track_macro_exp_p = track_macro_exp_p; 1581 iter->kind = kind; 1582 iter->token_ptr = token_ptr; 1583 /* Unconditionally initialize this so that the compiler doesn't warn 1584 about iter->location_ptr being possibly uninitialized later after 1585 this code has been inlined somewhere. */ 1586 iter->location_ptr = NULL; 1587 if (track_macro_exp_p) 1588 iter->location_ptr = get_arg_token_location (arg, kind); 1589 #if CHECKING_P 1590 iter->num_forwards = 0; 1591 if (track_macro_exp_p 1592 && token_ptr != NULL 1593 && iter->location_ptr == NULL) 1594 abort (); 1595 #endif 1596 } 1597 1598 /* Move the iterator one token forward. Note that if IT was 1599 initialized on an argument that has a stringified token, moving it 1600 forward doesn't make sense as a stringified token is essentially one 1601 string. */ 1602 static void 1603 macro_arg_token_iter_forward (macro_arg_token_iter *it) 1604 { 1605 switch (it->kind) 1606 { 1607 case MACRO_ARG_TOKEN_NORMAL: 1608 case MACRO_ARG_TOKEN_EXPANDED: 1609 it->token_ptr++; 1610 if (it->track_macro_exp_p) 1611 it->location_ptr++; 1612 break; 1613 case MACRO_ARG_TOKEN_STRINGIFIED: 1614 #if CHECKING_P 1615 if (it->num_forwards > 0) 1616 abort (); 1617 #endif 1618 break; 1619 } 1620 1621 #if CHECKING_P 1622 it->num_forwards++; 1623 #endif 1624 } 1625 1626 /* Return the token pointed to by the iterator. */ 1627 static const cpp_token * 1628 macro_arg_token_iter_get_token (const macro_arg_token_iter *it) 1629 { 1630 #if CHECKING_P 1631 if (it->kind == MACRO_ARG_TOKEN_STRINGIFIED 1632 && it->num_forwards > 0) 1633 abort (); 1634 #endif 1635 if (it->token_ptr == NULL) 1636 return NULL; 1637 return *it->token_ptr; 1638 } 1639 1640 /* Return the location of the token pointed to by the iterator.*/ 1641 static source_location 1642 macro_arg_token_iter_get_location (const macro_arg_token_iter *it) 1643 { 1644 #if CHECKING_P 1645 if (it->kind == MACRO_ARG_TOKEN_STRINGIFIED 1646 && it->num_forwards > 0) 1647 abort (); 1648 #endif 1649 if (it->track_macro_exp_p) 1650 return *it->location_ptr; 1651 else 1652 return (*it->token_ptr)->src_loc; 1653 } 1654 1655 /* Return the index of a token [resulting from macro expansion] inside 1656 the total list of tokens resulting from a given macro 1657 expansion. The index can be different depending on whether if we 1658 want each tokens resulting from function-like macro arguments 1659 expansion to have a different location or not. 1660 1661 E.g, consider this function-like macro: 1662 1663 #define M(x) x - 3 1664 1665 Then consider us "calling" it (and thus expanding it) like: 1666 1667 M(1+4) 1668 1669 It will be expanded into: 1670 1671 1+4-3 1672 1673 Let's consider the case of the token '4'. 1674 1675 Its index can be 2 (it's the third token of the set of tokens 1676 resulting from the expansion) or it can be 0 if we consider that 1677 all tokens resulting from the expansion of the argument "1+2" have 1678 the same index, which is 0. In this later case, the index of token 1679 '-' would then be 1 and the index of token '3' would be 2. 1680 1681 The later case is useful to use less memory e.g, for the case of 1682 the user using the option -ftrack-macro-expansion=1. 1683 1684 ABSOLUTE_TOKEN_INDEX is the index of the macro argument token we 1685 are interested in. CUR_REPLACEMENT_TOKEN is the token of the macro 1686 parameter (inside the macro replacement list) that corresponds to 1687 the macro argument for which ABSOLUTE_TOKEN_INDEX is a token index 1688 of. 1689 1690 If we refer to the example above, for the '4' argument token, 1691 ABSOLUTE_TOKEN_INDEX would be set to 2, and CUR_REPLACEMENT_TOKEN 1692 would be set to the token 'x', in the replacement list "x - 3" of 1693 macro M. 1694 1695 This is a subroutine of replace_args. */ 1696 inline static unsigned 1697 expanded_token_index (cpp_reader *pfile, cpp_macro *macro, 1698 const cpp_token *cur_replacement_token, 1699 unsigned absolute_token_index) 1700 { 1701 if (CPP_OPTION (pfile, track_macro_expansion) > 1) 1702 return absolute_token_index; 1703 return cur_replacement_token - macro->exp.tokens; 1704 } 1705 1706 /* Copy whether PASTE_LEFT is set from SRC to *PASTE_FLAG. */ 1707 1708 static void 1709 copy_paste_flag (cpp_reader *pfile, const cpp_token **paste_flag, 1710 const cpp_token *src) 1711 { 1712 cpp_token *token = _cpp_temp_token (pfile); 1713 token->type = (*paste_flag)->type; 1714 token->val = (*paste_flag)->val; 1715 if (src->flags & PASTE_LEFT) 1716 token->flags = (*paste_flag)->flags | PASTE_LEFT; 1717 else 1718 token->flags = (*paste_flag)->flags & ~PASTE_LEFT; 1719 *paste_flag = token; 1720 } 1721 1722 /* True IFF the last token emitted into BUFF (if any) is PTR. */ 1723 1724 static bool 1725 last_token_is (_cpp_buff *buff, const cpp_token **ptr) 1726 { 1727 return (ptr && tokens_buff_last_token_ptr (buff) == ptr); 1728 } 1729 1730 /* Replace the parameters in a function-like macro of NODE with the 1731 actual ARGS, and place the result in a newly pushed token context. 1732 Expand each argument before replacing, unless it is operated upon 1733 by the # or ## operators. EXPANSION_POINT_LOC is the location of 1734 the expansion point of the macro. E.g, the location of the 1735 function-like macro invocation. */ 1736 static void 1737 replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, 1738 macro_arg *args, source_location expansion_point_loc) 1739 { 1740 unsigned int i, total; 1741 const cpp_token *src, *limit; 1742 const cpp_token **first = NULL; 1743 macro_arg *arg; 1744 _cpp_buff *buff = NULL; 1745 source_location *virt_locs = NULL; 1746 unsigned int exp_count; 1747 const line_map_macro *map = NULL; 1748 int track_macro_exp; 1749 1750 /* First, fully macro-expand arguments, calculating the number of 1751 tokens in the final expansion as we go. The ordering of the if 1752 statements below is subtle; we must handle stringification before 1753 pasting. */ 1754 1755 /* EXP_COUNT is the number of tokens in the macro replacement 1756 list. TOTAL is the number of tokens /after/ macro parameters 1757 have been replaced by their arguments. */ 1758 exp_count = macro_real_token_count (macro); 1759 total = exp_count; 1760 limit = macro->exp.tokens + exp_count; 1761 1762 for (src = macro->exp.tokens; src < limit; src++) 1763 if (src->type == CPP_MACRO_ARG) 1764 { 1765 /* Leading and trailing padding tokens. */ 1766 total += 2; 1767 /* Account for leading and padding tokens in exp_count too. 1768 This is going to be important later down this function, 1769 when we want to handle the case of (track_macro_exp < 1770 2). */ 1771 exp_count += 2; 1772 1773 /* We have an argument. If it is not being stringified or 1774 pasted it is macro-replaced before insertion. */ 1775 arg = &args[src->val.macro_arg.arg_no - 1]; 1776 1777 if (src->flags & STRINGIFY_ARG) 1778 { 1779 if (!arg->stringified) 1780 arg->stringified = stringify_arg (pfile, arg); 1781 } 1782 else if ((src->flags & PASTE_LEFT) 1783 || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT))) 1784 total += arg->count - 1; 1785 else 1786 { 1787 if (!arg->expanded) 1788 expand_arg (pfile, arg); 1789 total += arg->expanded_count - 1; 1790 } 1791 } 1792 1793 /* When the compiler is called with the -ftrack-macro-expansion 1794 flag, we need to keep track of the location of each token that 1795 results from macro expansion. 1796 1797 A token resulting from macro expansion is not a new token. It is 1798 simply the same token as the token coming from the macro 1799 definition. The new things that are allocated are the buffer 1800 that holds the tokens resulting from macro expansion and a new 1801 location that records many things like the locus of the expansion 1802 point as well as the original locus inside the definition of the 1803 macro. This location is called a virtual location. 1804 1805 So the buffer BUFF holds a set of cpp_token*, and the buffer 1806 VIRT_LOCS holds the virtual locations of the tokens held by BUFF. 1807 1808 Both of these two buffers are going to be hung off of the macro 1809 context, when the latter is pushed. The memory allocated to 1810 store the tokens and their locations is going to be freed once 1811 the context of macro expansion is popped. 1812 1813 As far as tokens are concerned, the memory overhead of 1814 -ftrack-macro-expansion is proportional to the number of 1815 macros that get expanded multiplied by sizeof (source_location). 1816 The good news is that extra memory gets freed when the macro 1817 context is freed, i.e shortly after the macro got expanded. */ 1818 1819 /* Is the -ftrack-macro-expansion flag in effect? */ 1820 track_macro_exp = CPP_OPTION (pfile, track_macro_expansion); 1821 1822 /* Now allocate memory space for tokens and locations resulting from 1823 the macro expansion, copy the tokens and replace the arguments. 1824 This memory must be freed when the context of the macro MACRO is 1825 popped. */ 1826 buff = tokens_buff_new (pfile, total, track_macro_exp ? &virt_locs : NULL); 1827 1828 first = (const cpp_token **) buff->base; 1829 1830 /* Create a macro map to record the locations of the tokens that are 1831 involved in the expansion. Note that the expansion point is set 1832 to the location of the closing parenthesis. Otherwise, the 1833 subsequent map created for the first token that comes after the 1834 macro map might have a wrong line number. That would lead to 1835 tokens with wrong line numbers after the macro expansion. This 1836 adds up to the memory overhead of the -ftrack-macro-expansion 1837 flag; for every macro that is expanded, a "macro map" is 1838 created. */ 1839 if (track_macro_exp) 1840 { 1841 int num_macro_tokens = total; 1842 if (track_macro_exp < 2) 1843 /* Then the number of macro tokens won't take in account the 1844 fact that function-like macro arguments can expand to 1845 multiple tokens. This is to save memory at the expense of 1846 accuracy. 1847 1848 Suppose we have #define SQUARE(A) A * A 1849 1850 And then we do SQUARE(2+3) 1851 1852 Then the tokens 2, +, 3, will have the same location, 1853 saying they come from the expansion of the argument A. */ 1854 num_macro_tokens = exp_count; 1855 map = linemap_enter_macro (pfile->line_table, node, 1856 expansion_point_loc, 1857 num_macro_tokens); 1858 } 1859 i = 0; 1860 vaopt_state vaopt_tracker (pfile, macro->variadic, 1861 args[macro->paramc - 1].count > 0); 1862 const cpp_token **vaopt_start = NULL; 1863 for (src = macro->exp.tokens; src < limit; src++) 1864 { 1865 unsigned int arg_tokens_count; 1866 macro_arg_token_iter from; 1867 const cpp_token **paste_flag = NULL; 1868 const cpp_token **tmp_token_ptr; 1869 1870 /* __VA_OPT__ handling. */ 1871 vaopt_state::update_type vostate = vaopt_tracker.update (src); 1872 if (vostate != vaopt_state::INCLUDE) 1873 { 1874 if (vostate == vaopt_state::BEGIN) 1875 { 1876 /* Padding on the left of __VA_OPT__ (unless RHS of ##). */ 1877 if (src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT)) 1878 { 1879 const cpp_token *t = padding_token (pfile, src); 1880 unsigned index = expanded_token_index (pfile, macro, src, i); 1881 /* Allocate a virtual location for the padding token and 1882 append the token and its location to BUFF and 1883 VIRT_LOCS. */ 1884 tokens_buff_add_token (buff, virt_locs, t, 1885 t->src_loc, t->src_loc, 1886 map, index); 1887 } 1888 vaopt_start = tokens_buff_last_token_ptr (buff); 1889 } 1890 else if (vostate == vaopt_state::END) 1891 { 1892 const cpp_token **start = vaopt_start; 1893 vaopt_start = NULL; 1894 1895 /* Remove any tail padding from inside the __VA_OPT__. */ 1896 paste_flag = tokens_buff_last_token_ptr (buff); 1897 while (paste_flag && paste_flag != start 1898 && (*paste_flag)->type == CPP_PADDING) 1899 { 1900 tokens_buff_remove_last_token (buff); 1901 paste_flag = tokens_buff_last_token_ptr (buff); 1902 } 1903 1904 if (src->flags & PASTE_LEFT) 1905 { 1906 /* With a non-empty __VA_OPT__ on the LHS of ##, the last 1907 token should be flagged PASTE_LEFT. */ 1908 if (paste_flag && (*paste_flag)->type != CPP_PADDING) 1909 copy_paste_flag (pfile, paste_flag, src); 1910 } 1911 else 1912 { 1913 /* Otherwise, avoid paste on RHS, __VA_OPT__(c)d or 1914 __VA_OPT__(c)__VA_OPT__(d). */ 1915 const cpp_token *t = &pfile->avoid_paste; 1916 tokens_buff_add_token (buff, virt_locs, 1917 t, t->src_loc, t->src_loc, 1918 NULL, 0); 1919 } 1920 } 1921 continue; 1922 } 1923 1924 if (src->type != CPP_MACRO_ARG) 1925 { 1926 /* Allocate a virtual location for token SRC, and add that 1927 token and its virtual location into the buffers BUFF and 1928 VIRT_LOCS. */ 1929 unsigned index = expanded_token_index (pfile, macro, src, i); 1930 tokens_buff_add_token (buff, virt_locs, src, 1931 src->src_loc, src->src_loc, 1932 map, index); 1933 i += 1; 1934 continue; 1935 } 1936 1937 paste_flag = 0; 1938 arg = &args[src->val.macro_arg.arg_no - 1]; 1939 /* SRC is a macro parameter that we need to replace with its 1940 corresponding argument. So at some point we'll need to 1941 iterate over the tokens of the macro argument and copy them 1942 into the "place" now holding the correspondig macro 1943 parameter. We are going to use the iterator type 1944 macro_argo_token_iter to handle that iterating. The 'if' 1945 below is to initialize the iterator depending on the type of 1946 tokens the macro argument has. It also does some adjustment 1947 related to padding tokens and some pasting corner cases. */ 1948 if (src->flags & STRINGIFY_ARG) 1949 { 1950 arg_tokens_count = 1; 1951 macro_arg_token_iter_init (&from, 1952 CPP_OPTION (pfile, 1953 track_macro_expansion), 1954 MACRO_ARG_TOKEN_STRINGIFIED, 1955 arg, &arg->stringified); 1956 } 1957 else if (src->flags & PASTE_LEFT) 1958 { 1959 arg_tokens_count = arg->count; 1960 macro_arg_token_iter_init (&from, 1961 CPP_OPTION (pfile, 1962 track_macro_expansion), 1963 MACRO_ARG_TOKEN_NORMAL, 1964 arg, arg->first); 1965 } 1966 else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT)) 1967 { 1968 int num_toks; 1969 arg_tokens_count = arg->count; 1970 macro_arg_token_iter_init (&from, 1971 CPP_OPTION (pfile, 1972 track_macro_expansion), 1973 MACRO_ARG_TOKEN_NORMAL, 1974 arg, arg->first); 1975 1976 num_toks = tokens_buff_count (buff); 1977 1978 if (num_toks != 0) 1979 { 1980 /* So the current parameter token is pasted to the previous 1981 token in the replacement list. Let's look at what 1982 we have as previous and current arguments. */ 1983 1984 /* This is the previous argument's token ... */ 1985 tmp_token_ptr = tokens_buff_last_token_ptr (buff); 1986 1987 if ((*tmp_token_ptr)->type == CPP_COMMA 1988 && macro->variadic 1989 && src->val.macro_arg.arg_no == macro->paramc) 1990 { 1991 /* ... which is a comma; and the current parameter 1992 is the last parameter of a variadic function-like 1993 macro. If the argument to the current last 1994 parameter is NULL, then swallow the comma, 1995 otherwise drop the paste flag. */ 1996 if (macro_arg_token_iter_get_token (&from) == NULL) 1997 tokens_buff_remove_last_token (buff); 1998 else 1999 paste_flag = tmp_token_ptr; 2000 } 2001 /* Remove the paste flag if the RHS is a placemarker, unless the 2002 previous emitted token is at the beginning of __VA_OPT__; 2003 placemarkers within __VA_OPT__ are ignored in that case. */ 2004 else if (arg_tokens_count == 0 2005 && tmp_token_ptr != vaopt_start) 2006 paste_flag = tmp_token_ptr; 2007 } 2008 } 2009 else 2010 { 2011 arg_tokens_count = arg->expanded_count; 2012 macro_arg_token_iter_init (&from, 2013 CPP_OPTION (pfile, 2014 track_macro_expansion), 2015 MACRO_ARG_TOKEN_EXPANDED, 2016 arg, arg->expanded); 2017 2018 if (last_token_is (buff, vaopt_start)) 2019 { 2020 /* We're expanding an arg at the beginning of __VA_OPT__. 2021 Skip padding. */ 2022 while (arg_tokens_count) 2023 { 2024 const cpp_token *t = macro_arg_token_iter_get_token (&from); 2025 if (t->type != CPP_PADDING) 2026 break; 2027 macro_arg_token_iter_forward (&from); 2028 --arg_tokens_count; 2029 } 2030 } 2031 } 2032 2033 /* Padding on the left of an argument (unless RHS of ##). */ 2034 if ((!pfile->state.in_directive || pfile->state.directive_wants_padding) 2035 && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT) 2036 && !last_token_is (buff, vaopt_start)) 2037 { 2038 const cpp_token *t = padding_token (pfile, src); 2039 unsigned index = expanded_token_index (pfile, macro, src, i); 2040 /* Allocate a virtual location for the padding token and 2041 append the token and its location to BUFF and 2042 VIRT_LOCS. */ 2043 tokens_buff_add_token (buff, virt_locs, t, 2044 t->src_loc, t->src_loc, 2045 map, index); 2046 } 2047 2048 if (arg_tokens_count) 2049 { 2050 /* So now we've got the number of tokens that make up the 2051 argument that is going to replace the current parameter 2052 in the macro's replacement list. */ 2053 unsigned int j; 2054 for (j = 0; j < arg_tokens_count; ++j) 2055 { 2056 /* So if track_macro_exp is < 2, the user wants to 2057 save extra memory while tracking macro expansion 2058 locations. So in that case here is what we do: 2059 2060 Suppose we have #define SQUARE(A) A * A 2061 2062 And then we do SQUARE(2+3) 2063 2064 Then the tokens 2, +, 3, will have the same location, 2065 saying they come from the expansion of the argument 2066 A. 2067 2068 So that means we are going to ignore the COUNT tokens 2069 resulting from the expansion of the current macro 2070 argument. In other words all the ARG_TOKENS_COUNT tokens 2071 resulting from the expansion of the macro argument will 2072 have the index I. Normally, each of those tokens should 2073 have index I+J. */ 2074 unsigned token_index = i; 2075 unsigned index; 2076 if (track_macro_exp > 1) 2077 token_index += j; 2078 2079 index = expanded_token_index (pfile, macro, src, token_index); 2080 tokens_buff_add_token (buff, virt_locs, 2081 macro_arg_token_iter_get_token (&from), 2082 macro_arg_token_iter_get_location (&from), 2083 src->src_loc, map, index); 2084 macro_arg_token_iter_forward (&from); 2085 } 2086 2087 /* With a non-empty argument on the LHS of ##, the last 2088 token should be flagged PASTE_LEFT. */ 2089 if (src->flags & PASTE_LEFT) 2090 paste_flag 2091 = (const cpp_token **) tokens_buff_last_token_ptr (buff); 2092 } 2093 else if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, c99) 2094 && ! macro->syshdr && ! cpp_in_system_header (pfile)) 2095 { 2096 if (CPP_OPTION (pfile, cplusplus)) 2097 cpp_pedwarning (pfile, CPP_W_PEDANTIC, 2098 "invoking macro %s argument %d: " 2099 "empty macro arguments are undefined" 2100 " in ISO C++98", 2101 NODE_NAME (node), src->val.macro_arg.arg_no); 2102 else if (CPP_OPTION (pfile, cpp_warn_c90_c99_compat)) 2103 cpp_pedwarning (pfile, 2104 CPP_OPTION (pfile, cpp_warn_c90_c99_compat) > 0 2105 ? CPP_W_C90_C99_COMPAT : CPP_W_PEDANTIC, 2106 "invoking macro %s argument %d: " 2107 "empty macro arguments are undefined" 2108 " in ISO C90", 2109 NODE_NAME (node), src->val.macro_arg.arg_no); 2110 } 2111 else if (CPP_OPTION (pfile, cpp_warn_c90_c99_compat) > 0 2112 && ! CPP_OPTION (pfile, cplusplus) 2113 && ! macro->syshdr && ! cpp_in_system_header (pfile)) 2114 cpp_warning (pfile, CPP_W_C90_C99_COMPAT, 2115 "invoking macro %s argument %d: " 2116 "empty macro arguments are undefined" 2117 " in ISO C90", 2118 NODE_NAME (node), src->val.macro_arg.arg_no); 2119 2120 /* Avoid paste on RHS (even case count == 0). */ 2121 if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT) 2122 && !last_token_is (buff, vaopt_start)) 2123 { 2124 const cpp_token *t = &pfile->avoid_paste; 2125 tokens_buff_add_token (buff, virt_locs, 2126 t, t->src_loc, t->src_loc, 2127 NULL, 0); 2128 } 2129 2130 /* Add a new paste flag, or remove an unwanted one. */ 2131 if (paste_flag) 2132 copy_paste_flag (pfile, paste_flag, src); 2133 2134 i += arg_tokens_count; 2135 } 2136 2137 if (track_macro_exp) 2138 push_extended_tokens_context (pfile, node, buff, virt_locs, first, 2139 tokens_buff_count (buff)); 2140 else 2141 push_ptoken_context (pfile, node, buff, first, 2142 tokens_buff_count (buff)); 2143 2144 num_macro_tokens_counter += tokens_buff_count (buff); 2145 } 2146 2147 /* Return a special padding token, with padding inherited from SOURCE. */ 2148 static const cpp_token * 2149 padding_token (cpp_reader *pfile, const cpp_token *source) 2150 { 2151 cpp_token *result = _cpp_temp_token (pfile); 2152 2153 result->type = CPP_PADDING; 2154 2155 /* Data in GCed data structures cannot be made const so far, so we 2156 need a cast here. */ 2157 result->val.source = (cpp_token *) source; 2158 result->flags = 0; 2159 return result; 2160 } 2161 2162 /* Get a new uninitialized context. Create a new one if we cannot 2163 re-use an old one. */ 2164 static cpp_context * 2165 next_context (cpp_reader *pfile) 2166 { 2167 cpp_context *result = pfile->context->next; 2168 2169 if (result == 0) 2170 { 2171 result = XNEW (cpp_context); 2172 memset (result, 0, sizeof (cpp_context)); 2173 result->prev = pfile->context; 2174 result->next = 0; 2175 pfile->context->next = result; 2176 } 2177 2178 pfile->context = result; 2179 return result; 2180 } 2181 2182 /* Push a list of pointers to tokens. */ 2183 static void 2184 push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff, 2185 const cpp_token **first, unsigned int count) 2186 { 2187 cpp_context *context = next_context (pfile); 2188 2189 context->tokens_kind = TOKENS_KIND_INDIRECT; 2190 context->c.macro = macro; 2191 context->buff = buff; 2192 FIRST (context).ptoken = first; 2193 LAST (context).ptoken = first + count; 2194 } 2195 2196 /* Push a list of tokens. 2197 2198 A NULL macro means that we should continue the current macro 2199 expansion, in essence. That means that if we are currently in a 2200 macro expansion context, we'll make the new pfile->context refer to 2201 the current macro. */ 2202 void 2203 _cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro, 2204 const cpp_token *first, unsigned int count) 2205 { 2206 cpp_context *context; 2207 2208 if (macro == NULL) 2209 macro = macro_of_context (pfile->context); 2210 2211 context = next_context (pfile); 2212 context->tokens_kind = TOKENS_KIND_DIRECT; 2213 context->c.macro = macro; 2214 context->buff = NULL; 2215 FIRST (context).token = first; 2216 LAST (context).token = first + count; 2217 } 2218 2219 /* Build a context containing a list of tokens as well as their 2220 virtual locations and push it. TOKENS_BUFF is the buffer that 2221 contains the tokens pointed to by FIRST. If TOKENS_BUFF is 2222 non-NULL, it means that the context owns it, meaning that 2223 _cpp_pop_context will free it as well as VIRT_LOCS_BUFF that 2224 contains the virtual locations. 2225 2226 A NULL macro means that we should continue the current macro 2227 expansion, in essence. That means that if we are currently in a 2228 macro expansion context, we'll make the new pfile->context refer to 2229 the current macro. */ 2230 static void 2231 push_extended_tokens_context (cpp_reader *pfile, 2232 cpp_hashnode *macro, 2233 _cpp_buff *token_buff, 2234 source_location *virt_locs, 2235 const cpp_token **first, 2236 unsigned int count) 2237 { 2238 cpp_context *context; 2239 macro_context *m; 2240 2241 if (macro == NULL) 2242 macro = macro_of_context (pfile->context); 2243 2244 context = next_context (pfile); 2245 context->tokens_kind = TOKENS_KIND_EXTENDED; 2246 context->buff = token_buff; 2247 2248 m = XNEW (macro_context); 2249 m->macro_node = macro; 2250 m->virt_locs = virt_locs; 2251 m->cur_virt_loc = virt_locs; 2252 context->c.mc = m; 2253 FIRST (context).ptoken = first; 2254 LAST (context).ptoken = first + count; 2255 } 2256 2257 /* Push a traditional macro's replacement text. */ 2258 void 2259 _cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro, 2260 const uchar *start, size_t len) 2261 { 2262 cpp_context *context = next_context (pfile); 2263 2264 context->tokens_kind = TOKENS_KIND_DIRECT; 2265 context->c.macro = macro; 2266 context->buff = NULL; 2267 CUR (context) = start; 2268 RLIMIT (context) = start + len; 2269 macro->flags |= NODE_DISABLED; 2270 } 2271 2272 /* Creates a buffer that holds tokens a.k.a "token buffer", usually 2273 for the purpose of storing them on a cpp_context. If VIRT_LOCS is 2274 non-null (which means that -ftrack-macro-expansion is on), 2275 *VIRT_LOCS is set to a newly allocated buffer that is supposed to 2276 hold the virtual locations of the tokens resulting from macro 2277 expansion. */ 2278 static _cpp_buff* 2279 tokens_buff_new (cpp_reader *pfile, size_t len, 2280 source_location **virt_locs) 2281 { 2282 size_t tokens_size = len * sizeof (cpp_token *); 2283 size_t locs_size = len * sizeof (source_location); 2284 2285 if (virt_locs != NULL) 2286 *virt_locs = XNEWVEC (source_location, locs_size); 2287 return _cpp_get_buff (pfile, tokens_size); 2288 } 2289 2290 /* Returns the number of tokens contained in a token buffer. The 2291 buffer holds a set of cpp_token*. */ 2292 static size_t 2293 tokens_buff_count (_cpp_buff *buff) 2294 { 2295 return (BUFF_FRONT (buff) - buff->base) / sizeof (cpp_token *); 2296 } 2297 2298 /* Return a pointer to the last token contained in the token buffer 2299 BUFF. */ 2300 static const cpp_token ** 2301 tokens_buff_last_token_ptr (_cpp_buff *buff) 2302 { 2303 if (BUFF_FRONT (buff) == buff->base) 2304 return NULL; 2305 return &((const cpp_token **) BUFF_FRONT (buff))[-1]; 2306 } 2307 2308 /* Remove the last token contained in the token buffer TOKENS_BUFF. 2309 If VIRT_LOCS_BUFF is non-NULL, it should point at the buffer 2310 containing the virtual locations of the tokens in TOKENS_BUFF; in 2311 which case the function updates that buffer as well. */ 2312 static inline void 2313 tokens_buff_remove_last_token (_cpp_buff *tokens_buff) 2314 2315 { 2316 if (BUFF_FRONT (tokens_buff) > tokens_buff->base) 2317 BUFF_FRONT (tokens_buff) = 2318 (unsigned char *) &((cpp_token **) BUFF_FRONT (tokens_buff))[-1]; 2319 } 2320 2321 /* Insert a token into the token buffer at the position pointed to by 2322 DEST. Note that the buffer is not enlarged so the previous token 2323 that was at *DEST is overwritten. VIRT_LOC_DEST, if non-null, 2324 means -ftrack-macro-expansion is effect; it then points to where to 2325 insert the virtual location of TOKEN. TOKEN is the token to 2326 insert. VIRT_LOC is the virtual location of the token, i.e, the 2327 location possibly encoding its locus across macro expansion. If 2328 TOKEN is an argument of a function-like macro (inside a macro 2329 replacement list), PARM_DEF_LOC is the spelling location of the 2330 macro parameter that TOKEN is replacing, in the replacement list of 2331 the macro. If TOKEN is not an argument of a function-like macro or 2332 if it doesn't come from a macro expansion, then VIRT_LOC can just 2333 be set to the same value as PARM_DEF_LOC. If MAP is non null, it 2334 means TOKEN comes from a macro expansion and MAP is the macro map 2335 associated to the macro. MACRO_TOKEN_INDEX points to the index of 2336 the token in the macro map; it is not considered if MAP is NULL. 2337 2338 Upon successful completion this function returns the a pointer to 2339 the position of the token coming right after the insertion 2340 point. */ 2341 static inline const cpp_token ** 2342 tokens_buff_put_token_to (const cpp_token **dest, 2343 source_location *virt_loc_dest, 2344 const cpp_token *token, 2345 source_location virt_loc, 2346 source_location parm_def_loc, 2347 const line_map_macro *map, 2348 unsigned int macro_token_index) 2349 { 2350 source_location macro_loc = virt_loc; 2351 const cpp_token **result; 2352 2353 if (virt_loc_dest) 2354 { 2355 /* -ftrack-macro-expansion is on. */ 2356 if (map) 2357 macro_loc = linemap_add_macro_token (map, macro_token_index, 2358 virt_loc, parm_def_loc); 2359 *virt_loc_dest = macro_loc; 2360 } 2361 *dest = token; 2362 result = &dest[1]; 2363 2364 return result; 2365 } 2366 2367 /* Adds a token at the end of the tokens contained in BUFFER. Note 2368 that this function doesn't enlarge BUFFER when the number of tokens 2369 reaches BUFFER's size; it aborts in that situation. 2370 2371 TOKEN is the token to append. VIRT_LOC is the virtual location of 2372 the token, i.e, the location possibly encoding its locus across 2373 macro expansion. If TOKEN is an argument of a function-like macro 2374 (inside a macro replacement list), PARM_DEF_LOC is the location of 2375 the macro parameter that TOKEN is replacing. If TOKEN doesn't come 2376 from a macro expansion, then VIRT_LOC can just be set to the same 2377 value as PARM_DEF_LOC. If MAP is non null, it means TOKEN comes 2378 from a macro expansion and MAP is the macro map associated to the 2379 macro. MACRO_TOKEN_INDEX points to the index of the token in the 2380 macro map; It is not considered if MAP is NULL. If VIRT_LOCS is 2381 non-null, it means -ftrack-macro-expansion is on; in which case 2382 this function adds the virtual location DEF_LOC to the VIRT_LOCS 2383 array, at the same index as the one of TOKEN in BUFFER. Upon 2384 successful completion this function returns the a pointer to the 2385 position of the token coming right after the insertion point. */ 2386 static const cpp_token ** 2387 tokens_buff_add_token (_cpp_buff *buffer, 2388 source_location *virt_locs, 2389 const cpp_token *token, 2390 source_location virt_loc, 2391 source_location parm_def_loc, 2392 const line_map_macro *map, 2393 unsigned int macro_token_index) 2394 { 2395 const cpp_token **result; 2396 source_location *virt_loc_dest = NULL; 2397 unsigned token_index = 2398 (BUFF_FRONT (buffer) - buffer->base) / sizeof (cpp_token *); 2399 2400 /* Abort if we pass the end the buffer. */ 2401 if (BUFF_FRONT (buffer) > BUFF_LIMIT (buffer)) 2402 abort (); 2403 2404 if (virt_locs != NULL) 2405 virt_loc_dest = &virt_locs[token_index]; 2406 2407 result = 2408 tokens_buff_put_token_to ((const cpp_token **) BUFF_FRONT (buffer), 2409 virt_loc_dest, token, virt_loc, parm_def_loc, 2410 map, macro_token_index); 2411 2412 BUFF_FRONT (buffer) = (unsigned char *) result; 2413 return result; 2414 } 2415 2416 /* Allocate space for the function-like macro argument ARG to store 2417 the tokens resulting from the macro-expansion of the tokens that 2418 make up ARG itself. That space is allocated in ARG->expanded and 2419 needs to be freed using free. */ 2420 static void 2421 alloc_expanded_arg_mem (cpp_reader *pfile, macro_arg *arg, size_t capacity) 2422 { 2423 gcc_checking_assert (arg->expanded == NULL 2424 && arg->expanded_virt_locs == NULL); 2425 2426 arg->expanded = XNEWVEC (const cpp_token *, capacity); 2427 if (CPP_OPTION (pfile, track_macro_expansion)) 2428 arg->expanded_virt_locs = XNEWVEC (source_location, capacity); 2429 2430 } 2431 2432 /* If necessary, enlarge ARG->expanded to so that it can contain SIZE 2433 tokens. */ 2434 static void 2435 ensure_expanded_arg_room (cpp_reader *pfile, macro_arg *arg, 2436 size_t size, size_t *expanded_capacity) 2437 { 2438 if (size <= *expanded_capacity) 2439 return; 2440 2441 size *= 2; 2442 2443 arg->expanded = 2444 XRESIZEVEC (const cpp_token *, arg->expanded, size); 2445 *expanded_capacity = size; 2446 2447 if (CPP_OPTION (pfile, track_macro_expansion)) 2448 { 2449 if (arg->expanded_virt_locs == NULL) 2450 arg->expanded_virt_locs = XNEWVEC (source_location, size); 2451 else 2452 arg->expanded_virt_locs = XRESIZEVEC (source_location, 2453 arg->expanded_virt_locs, 2454 size); 2455 } 2456 } 2457 2458 /* Expand an argument ARG before replacing parameters in a 2459 function-like macro. This works by pushing a context with the 2460 argument's tokens, and then expanding that into a temporary buffer 2461 as if it were a normal part of the token stream. collect_args() 2462 has terminated the argument's tokens with a CPP_EOF so that we know 2463 when we have fully expanded the argument. */ 2464 static void 2465 expand_arg (cpp_reader *pfile, macro_arg *arg) 2466 { 2467 size_t capacity; 2468 bool saved_warn_trad; 2469 bool track_macro_exp_p = CPP_OPTION (pfile, track_macro_expansion); 2470 2471 if (arg->count == 0 2472 || arg->expanded != NULL) 2473 return; 2474 2475 /* Don't warn about funlike macros when pre-expanding. */ 2476 saved_warn_trad = CPP_WTRADITIONAL (pfile); 2477 CPP_WTRADITIONAL (pfile) = 0; 2478 2479 /* Loop, reading in the tokens of the argument. */ 2480 capacity = 256; 2481 alloc_expanded_arg_mem (pfile, arg, capacity); 2482 2483 if (track_macro_exp_p) 2484 push_extended_tokens_context (pfile, NULL, NULL, 2485 arg->virt_locs, 2486 arg->first, 2487 arg->count + 1); 2488 else 2489 push_ptoken_context (pfile, NULL, NULL, 2490 arg->first, arg->count + 1); 2491 2492 for (;;) 2493 { 2494 const cpp_token *token; 2495 source_location location; 2496 2497 ensure_expanded_arg_room (pfile, arg, arg->expanded_count + 1, 2498 &capacity); 2499 2500 token = cpp_get_token_1 (pfile, &location); 2501 2502 if (token->type == CPP_EOF) 2503 break; 2504 2505 set_arg_token (arg, token, location, 2506 arg->expanded_count, MACRO_ARG_TOKEN_EXPANDED, 2507 CPP_OPTION (pfile, track_macro_expansion)); 2508 arg->expanded_count++; 2509 } 2510 2511 _cpp_pop_context (pfile); 2512 2513 CPP_WTRADITIONAL (pfile) = saved_warn_trad; 2514 } 2515 2516 /* Returns the macro associated to the current context if we are in 2517 the context a macro expansion, NULL otherwise. */ 2518 static cpp_hashnode* 2519 macro_of_context (cpp_context *context) 2520 { 2521 if (context == NULL) 2522 return NULL; 2523 2524 return (context->tokens_kind == TOKENS_KIND_EXTENDED) 2525 ? context->c.mc->macro_node 2526 : context->c.macro; 2527 } 2528 2529 /* Return TRUE iff we are expanding a macro or are about to start 2530 expanding one. If we are effectively expanding a macro, the 2531 function macro_of_context returns a pointer to the macro being 2532 expanded. */ 2533 static bool 2534 in_macro_expansion_p (cpp_reader *pfile) 2535 { 2536 if (pfile == NULL) 2537 return false; 2538 2539 return (pfile->about_to_expand_macro_p 2540 || macro_of_context (pfile->context)); 2541 } 2542 2543 /* Pop the current context off the stack, re-enabling the macro if the 2544 context represented a macro's replacement list. Initially the 2545 context structure was not freed so that we can re-use it later, but 2546 now we do free it to reduce peak memory consumption. */ 2547 void 2548 _cpp_pop_context (cpp_reader *pfile) 2549 { 2550 cpp_context *context = pfile->context; 2551 2552 /* We should not be popping the base context. */ 2553 if (context == &pfile->base_context) 2554 abort (); 2555 2556 if (context->c.macro) 2557 { 2558 cpp_hashnode *macro; 2559 if (context->tokens_kind == TOKENS_KIND_EXTENDED) 2560 { 2561 macro_context *mc = context->c.mc; 2562 macro = mc->macro_node; 2563 /* If context->buff is set, it means the life time of tokens 2564 is bound to the life time of this context; so we must 2565 free the tokens; that means we must free the virtual 2566 locations of these tokens too. */ 2567 if (context->buff && mc->virt_locs) 2568 { 2569 free (mc->virt_locs); 2570 mc->virt_locs = NULL; 2571 } 2572 free (mc); 2573 context->c.mc = NULL; 2574 } 2575 else 2576 macro = context->c.macro; 2577 2578 /* Beware that MACRO can be NULL in cases like when we are 2579 called from expand_arg. In those cases, a dummy context with 2580 tokens is pushed just for the purpose of walking them using 2581 cpp_get_token_1. In that case, no 'macro' field is set into 2582 the dummy context. */ 2583 if (macro != NULL 2584 /* Several contiguous macro expansion contexts can be 2585 associated to the same macro; that means it's the same 2586 macro expansion that spans across all these (sub) 2587 contexts. So we should re-enable an expansion-disabled 2588 macro only when we are sure we are really out of that 2589 macro expansion. */ 2590 && macro_of_context (context->prev) != macro) 2591 macro->flags &= ~NODE_DISABLED; 2592 2593 if (macro == pfile->top_most_macro_node && context->prev == NULL) 2594 /* We are popping the context of the top-most macro node. */ 2595 pfile->top_most_macro_node = NULL; 2596 } 2597 2598 if (context->buff) 2599 { 2600 /* Decrease memory peak consumption by freeing the memory used 2601 by the context. */ 2602 _cpp_free_buff (context->buff); 2603 } 2604 2605 pfile->context = context->prev; 2606 /* decrease peak memory consumption by feeing the context. */ 2607 pfile->context->next = NULL; 2608 free (context); 2609 } 2610 2611 /* Return TRUE if we reached the end of the set of tokens stored in 2612 CONTEXT, FALSE otherwise. */ 2613 static inline bool 2614 reached_end_of_context (cpp_context *context) 2615 { 2616 if (context->tokens_kind == TOKENS_KIND_DIRECT) 2617 return FIRST (context).token == LAST (context).token; 2618 else if (context->tokens_kind == TOKENS_KIND_INDIRECT 2619 || context->tokens_kind == TOKENS_KIND_EXTENDED) 2620 return FIRST (context).ptoken == LAST (context).ptoken; 2621 else 2622 abort (); 2623 } 2624 2625 /* Consume the next token contained in the current context of PFILE, 2626 and return it in *TOKEN. It's "full location" is returned in 2627 *LOCATION. If -ftrack-macro-location is in effeect, fFull location" 2628 means the location encoding the locus of the token across macro 2629 expansion; otherwise it's just is the "normal" location of the 2630 token which (*TOKEN)->src_loc. */ 2631 static inline void 2632 consume_next_token_from_context (cpp_reader *pfile, 2633 const cpp_token ** token, 2634 source_location *location) 2635 { 2636 cpp_context *c = pfile->context; 2637 2638 if ((c)->tokens_kind == TOKENS_KIND_DIRECT) 2639 { 2640 *token = FIRST (c).token; 2641 *location = (*token)->src_loc; 2642 FIRST (c).token++; 2643 } 2644 else if ((c)->tokens_kind == TOKENS_KIND_INDIRECT) 2645 { 2646 *token = *FIRST (c).ptoken; 2647 *location = (*token)->src_loc; 2648 FIRST (c).ptoken++; 2649 } 2650 else if ((c)->tokens_kind == TOKENS_KIND_EXTENDED) 2651 { 2652 macro_context *m = c->c.mc; 2653 *token = *FIRST (c).ptoken; 2654 if (m->virt_locs) 2655 { 2656 *location = *m->cur_virt_loc; 2657 m->cur_virt_loc++; 2658 } 2659 else 2660 *location = (*token)->src_loc; 2661 FIRST (c).ptoken++; 2662 } 2663 else 2664 abort (); 2665 } 2666 2667 /* In the traditional mode of the preprocessor, if we are currently in 2668 a directive, the location of a token must be the location of the 2669 start of the directive line. This function returns the proper 2670 location if we are in the traditional mode, and just returns 2671 LOCATION otherwise. */ 2672 2673 static inline source_location 2674 maybe_adjust_loc_for_trad_cpp (cpp_reader *pfile, source_location location) 2675 { 2676 if (CPP_OPTION (pfile, traditional)) 2677 { 2678 if (pfile->state.in_directive) 2679 return pfile->directive_line; 2680 } 2681 return location; 2682 } 2683 2684 /* Routine to get a token as well as its location. 2685 2686 Macro expansions and directives are transparently handled, 2687 including entering included files. Thus tokens are post-macro 2688 expansion, and after any intervening directives. External callers 2689 see CPP_EOF only at EOF. Internal callers also see it when meeting 2690 a directive inside a macro call, when at the end of a directive and 2691 state.in_directive is still 1, and at the end of argument 2692 pre-expansion. 2693 2694 LOC is an out parameter; *LOC is set to the location "as expected 2695 by the user". Please read the comment of 2696 cpp_get_token_with_location to learn more about the meaning of this 2697 location. */ 2698 static const cpp_token* 2699 cpp_get_token_1 (cpp_reader *pfile, source_location *location) 2700 { 2701 const cpp_token *result; 2702 /* This token is a virtual token that either encodes a location 2703 related to macro expansion or a spelling location. */ 2704 source_location virt_loc = 0; 2705 /* pfile->about_to_expand_macro_p can be overriden by indirect calls 2706 to functions that push macro contexts. So let's save it so that 2707 we can restore it when we are about to leave this routine. */ 2708 bool saved_about_to_expand_macro = pfile->about_to_expand_macro_p; 2709 2710 for (;;) 2711 { 2712 cpp_hashnode *node; 2713 cpp_context *context = pfile->context; 2714 2715 /* Context->prev == 0 <=> base context. */ 2716 if (!context->prev) 2717 { 2718 result = _cpp_lex_token (pfile); 2719 virt_loc = result->src_loc; 2720 } 2721 else if (!reached_end_of_context (context)) 2722 { 2723 consume_next_token_from_context (pfile, &result, 2724 &virt_loc); 2725 if (result->flags & PASTE_LEFT) 2726 { 2727 paste_all_tokens (pfile, result); 2728 if (pfile->state.in_directive) 2729 continue; 2730 result = padding_token (pfile, result); 2731 goto out; 2732 } 2733 } 2734 else 2735 { 2736 if (pfile->context->c.macro) 2737 ++num_expanded_macros_counter; 2738 _cpp_pop_context (pfile); 2739 if (pfile->state.in_directive) 2740 continue; 2741 result = &pfile->avoid_paste; 2742 goto out; 2743 } 2744 2745 if (pfile->state.in_directive && result->type == CPP_COMMENT) 2746 continue; 2747 2748 if (result->type != CPP_NAME) 2749 break; 2750 2751 node = result->val.node.node; 2752 2753 if (node->type != NT_MACRO || (result->flags & NO_EXPAND)) 2754 break; 2755 2756 if (!(node->flags & NODE_DISABLED)) 2757 { 2758 int ret = 0; 2759 /* If not in a macro context, and we're going to start an 2760 expansion, record the location and the top level macro 2761 about to be expanded. */ 2762 if (!in_macro_expansion_p (pfile)) 2763 { 2764 pfile->invocation_location = result->src_loc; 2765 pfile->top_most_macro_node = node; 2766 } 2767 if (pfile->state.prevent_expansion) 2768 break; 2769 2770 /* Conditional macros require that a predicate be evaluated 2771 first. */ 2772 if ((node->flags & NODE_CONDITIONAL) != 0) 2773 { 2774 if (pfile->cb.macro_to_expand) 2775 { 2776 bool whitespace_after; 2777 const cpp_token *peek_tok = cpp_peek_token (pfile, 0); 2778 2779 whitespace_after = (peek_tok->type == CPP_PADDING 2780 || (peek_tok->flags & PREV_WHITE)); 2781 node = pfile->cb.macro_to_expand (pfile, result); 2782 if (node) 2783 ret = enter_macro_context (pfile, node, result, 2784 virt_loc); 2785 else if (whitespace_after) 2786 { 2787 /* If macro_to_expand hook returned NULL and it 2788 ate some tokens, see if we don't need to add 2789 a padding token in between this and the 2790 next token. */ 2791 peek_tok = cpp_peek_token (pfile, 0); 2792 if (peek_tok->type != CPP_PADDING 2793 && (peek_tok->flags & PREV_WHITE) == 0) 2794 _cpp_push_token_context (pfile, NULL, 2795 padding_token (pfile, 2796 peek_tok), 1); 2797 } 2798 } 2799 } 2800 else 2801 ret = enter_macro_context (pfile, node, result, 2802 virt_loc); 2803 if (ret) 2804 { 2805 if (pfile->state.in_directive || ret == 2) 2806 continue; 2807 result = padding_token (pfile, result); 2808 goto out; 2809 } 2810 } 2811 else 2812 { 2813 /* Flag this token as always unexpandable. FIXME: move this 2814 to collect_args()?. */ 2815 cpp_token *t = _cpp_temp_token (pfile); 2816 t->type = result->type; 2817 t->flags = result->flags | NO_EXPAND; 2818 t->val = result->val; 2819 result = t; 2820 } 2821 2822 break; 2823 } 2824 2825 out: 2826 if (location != NULL) 2827 { 2828 if (virt_loc == 0) 2829 virt_loc = result->src_loc; 2830 *location = virt_loc; 2831 2832 if (!CPP_OPTION (pfile, track_macro_expansion) 2833 && macro_of_context (pfile->context) != NULL) 2834 /* We are in a macro expansion context, are not tracking 2835 virtual location, but were asked to report the location 2836 of the expansion point of the macro being expanded. */ 2837 *location = pfile->invocation_location; 2838 2839 *location = maybe_adjust_loc_for_trad_cpp (pfile, *location); 2840 } 2841 2842 pfile->about_to_expand_macro_p = saved_about_to_expand_macro; 2843 return result; 2844 } 2845 2846 /* External routine to get a token. Also used nearly everywhere 2847 internally, except for places where we know we can safely call 2848 _cpp_lex_token directly, such as lexing a directive name. 2849 2850 Macro expansions and directives are transparently handled, 2851 including entering included files. Thus tokens are post-macro 2852 expansion, and after any intervening directives. External callers 2853 see CPP_EOF only at EOF. Internal callers also see it when meeting 2854 a directive inside a macro call, when at the end of a directive and 2855 state.in_directive is still 1, and at the end of argument 2856 pre-expansion. */ 2857 const cpp_token * 2858 cpp_get_token (cpp_reader *pfile) 2859 { 2860 return cpp_get_token_1 (pfile, NULL); 2861 } 2862 2863 /* Like cpp_get_token, but also returns a virtual token location 2864 separate from the spelling location carried by the returned token. 2865 2866 LOC is an out parameter; *LOC is set to the location "as expected 2867 by the user". This matters when a token results from macro 2868 expansion; in that case the token's spelling location indicates the 2869 locus of the token in the definition of the macro but *LOC 2870 virtually encodes all the other meaningful locuses associated to 2871 the token. 2872 2873 What? virtual location? Yes, virtual location. 2874 2875 If the token results from macro expansion and if macro expansion 2876 location tracking is enabled its virtual location encodes (at the 2877 same time): 2878 2879 - the spelling location of the token 2880 2881 - the locus of the macro expansion point 2882 2883 - the locus of the point where the token got instantiated as part 2884 of the macro expansion process. 2885 2886 You have to use the linemap API to get the locus you are interested 2887 in from a given virtual location. 2888 2889 Note however that virtual locations are not necessarily ordered for 2890 relations '<' and '>'. One must use the function 2891 linemap_location_before_p instead of using the relational operator 2892 '<'. 2893 2894 If macro expansion tracking is off and if the token results from 2895 macro expansion the virtual location is the expansion point of the 2896 macro that got expanded. 2897 2898 When the token doesn't result from macro expansion, the virtual 2899 location is just the same thing as its spelling location. */ 2900 2901 const cpp_token * 2902 cpp_get_token_with_location (cpp_reader *pfile, source_location *loc) 2903 { 2904 return cpp_get_token_1 (pfile, loc); 2905 } 2906 2907 /* Returns true if we're expanding an object-like macro that was 2908 defined in a system header. Just checks the macro at the top of 2909 the stack. Used for diagnostic suppression. */ 2910 int 2911 cpp_sys_macro_p (cpp_reader *pfile) 2912 { 2913 cpp_hashnode *node = NULL; 2914 2915 if (pfile->context->tokens_kind == TOKENS_KIND_EXTENDED) 2916 node = pfile->context->c.mc->macro_node; 2917 else 2918 node = pfile->context->c.macro; 2919 2920 return node && node->value.macro && node->value.macro->syshdr; 2921 } 2922 2923 /* Read each token in, until end of the current file. Directives are 2924 transparently processed. */ 2925 void 2926 cpp_scan_nooutput (cpp_reader *pfile) 2927 { 2928 /* Request a CPP_EOF token at the end of this file, rather than 2929 transparently continuing with the including file. */ 2930 pfile->buffer->return_at_eof = true; 2931 2932 pfile->state.discarding_output++; 2933 pfile->state.prevent_expansion++; 2934 2935 if (CPP_OPTION (pfile, traditional)) 2936 while (_cpp_read_logical_line_trad (pfile)) 2937 ; 2938 else 2939 while (cpp_get_token (pfile)->type != CPP_EOF) 2940 ; 2941 2942 pfile->state.discarding_output--; 2943 pfile->state.prevent_expansion--; 2944 } 2945 2946 /* Step back one or more tokens obtained from the lexer. */ 2947 void 2948 _cpp_backup_tokens_direct (cpp_reader *pfile, unsigned int count) 2949 { 2950 pfile->lookaheads += count; 2951 while (count--) 2952 { 2953 pfile->cur_token--; 2954 if (pfile->cur_token == pfile->cur_run->base 2955 /* Possible with -fpreprocessed and no leading #line. */ 2956 && pfile->cur_run->prev != NULL) 2957 { 2958 pfile->cur_run = pfile->cur_run->prev; 2959 pfile->cur_token = pfile->cur_run->limit; 2960 } 2961 } 2962 } 2963 2964 /* Step back one (or more) tokens. Can only step back more than 1 if 2965 they are from the lexer, and not from macro expansion. */ 2966 void 2967 _cpp_backup_tokens (cpp_reader *pfile, unsigned int count) 2968 { 2969 if (pfile->context->prev == NULL) 2970 _cpp_backup_tokens_direct (pfile, count); 2971 else 2972 { 2973 if (count != 1) 2974 abort (); 2975 if (pfile->context->tokens_kind == TOKENS_KIND_DIRECT) 2976 FIRST (pfile->context).token--; 2977 else if (pfile->context->tokens_kind == TOKENS_KIND_INDIRECT) 2978 FIRST (pfile->context).ptoken--; 2979 else if (pfile->context->tokens_kind == TOKENS_KIND_EXTENDED) 2980 { 2981 FIRST (pfile->context).ptoken--; 2982 if (pfile->context->c.macro) 2983 { 2984 macro_context *m = pfile->context->c.mc; 2985 m->cur_virt_loc--; 2986 gcc_checking_assert (m->cur_virt_loc >= m->virt_locs); 2987 } 2988 else 2989 abort (); 2990 } 2991 else 2992 abort (); 2993 } 2994 } 2995 2996 /* #define directive parsing and handling. */ 2997 2998 /* Returns nonzero if a macro redefinition warning is required. */ 2999 static bool 3000 warn_of_redefinition (cpp_reader *pfile, cpp_hashnode *node, 3001 const cpp_macro *macro2) 3002 { 3003 const cpp_macro *macro1; 3004 unsigned int i; 3005 3006 /* Some redefinitions need to be warned about regardless. */ 3007 if (node->flags & NODE_WARN) 3008 return true; 3009 3010 /* Suppress warnings for builtins that lack the NODE_WARN flag, 3011 unless Wbuiltin-macro-redefined. */ 3012 if (node->flags & NODE_BUILTIN 3013 && (!pfile->cb.user_builtin_macro 3014 || !pfile->cb.user_builtin_macro (pfile, node))) 3015 return CPP_OPTION (pfile, warn_builtin_macro_redefined); 3016 3017 /* Redefinitions of conditional (context-sensitive) macros, on 3018 the other hand, must be allowed silently. */ 3019 if (node->flags & NODE_CONDITIONAL) 3020 return false; 3021 3022 /* Redefinition of a macro is allowed if and only if the old and new 3023 definitions are the same. (6.10.3 paragraph 2). */ 3024 macro1 = node->value.macro; 3025 3026 /* Don't check count here as it can be different in valid 3027 traditional redefinitions with just whitespace differences. */ 3028 if (macro1->paramc != macro2->paramc 3029 || macro1->fun_like != macro2->fun_like 3030 || macro1->variadic != macro2->variadic) 3031 return true; 3032 3033 /* Check parameter spellings. */ 3034 for (i = 0; i < macro1->paramc; i++) 3035 if (macro1->params[i] != macro2->params[i]) 3036 return true; 3037 3038 /* Check the replacement text or tokens. */ 3039 if (CPP_OPTION (pfile, traditional)) 3040 return _cpp_expansions_different_trad (macro1, macro2); 3041 3042 if (macro1->count != macro2->count) 3043 return true; 3044 3045 for (i = 0; i < macro1->count; i++) 3046 if (!_cpp_equiv_tokens (¯o1->exp.tokens[i], ¯o2->exp.tokens[i])) 3047 return true; 3048 3049 return false; 3050 } 3051 3052 /* Free the definition of hashnode H. */ 3053 void 3054 _cpp_free_definition (cpp_hashnode *h) 3055 { 3056 /* Macros and assertions no longer have anything to free. */ 3057 h->type = NT_VOID; 3058 /* Clear builtin flag in case of redefinition. */ 3059 h->flags &= ~(NODE_BUILTIN | NODE_DISABLED | NODE_USED); 3060 } 3061 3062 /* Save parameter NODE (spelling SPELLING) to the parameter list of 3063 macro MACRO. Returns zero on success, nonzero if the parameter is 3064 a duplicate. */ 3065 bool 3066 _cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node, 3067 cpp_hashnode *spelling) 3068 { 3069 unsigned int len; 3070 /* Constraint 6.10.3.6 - duplicate parameter names. */ 3071 if (node->flags & NODE_MACRO_ARG) 3072 { 3073 cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"", 3074 NODE_NAME (node)); 3075 return true; 3076 } 3077 3078 if (BUFF_ROOM (pfile->a_buff) 3079 < (macro->paramc + 1) * sizeof (cpp_hashnode *)) 3080 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *)); 3081 3082 ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = spelling; 3083 node->flags |= NODE_MACRO_ARG; 3084 len = macro->paramc * sizeof (struct macro_arg_saved_data); 3085 if (len > pfile->macro_buffer_len) 3086 { 3087 pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer, 3088 len); 3089 pfile->macro_buffer_len = len; 3090 } 3091 struct macro_arg_saved_data save; 3092 save.value = node->value; 3093 save.canonical_node = node; 3094 ((struct macro_arg_saved_data *) pfile->macro_buffer)[macro->paramc - 1] 3095 = save; 3096 3097 node->value.arg_index = macro->paramc; 3098 return false; 3099 } 3100 3101 /* Check the syntax of the parameters in a MACRO definition. Returns 3102 false if an error occurs. */ 3103 static bool 3104 parse_params (cpp_reader *pfile, cpp_macro *macro) 3105 { 3106 unsigned int prev_ident = 0; 3107 3108 for (;;) 3109 { 3110 const cpp_token *token = _cpp_lex_token (pfile); 3111 3112 switch (token->type) 3113 { 3114 default: 3115 /* Allow/ignore comments in parameter lists if we are 3116 preserving comments in macro expansions. */ 3117 if (token->type == CPP_COMMENT 3118 && ! CPP_OPTION (pfile, discard_comments_in_macro_exp)) 3119 continue; 3120 3121 cpp_error (pfile, CPP_DL_ERROR, 3122 "\"%s\" may not appear in macro parameter list", 3123 cpp_token_as_text (pfile, token)); 3124 return false; 3125 3126 case CPP_NAME: 3127 if (prev_ident) 3128 { 3129 cpp_error (pfile, CPP_DL_ERROR, 3130 "macro parameters must be comma-separated"); 3131 return false; 3132 } 3133 prev_ident = 1; 3134 3135 if (_cpp_save_parameter (pfile, macro, token->val.node.node, 3136 token->val.node.spelling)) 3137 return false; 3138 continue; 3139 3140 case CPP_CLOSE_PAREN: 3141 if (prev_ident || macro->paramc == 0) 3142 return true; 3143 3144 /* Fall through to pick up the error. */ 3145 /* FALLTHRU */ 3146 case CPP_COMMA: 3147 if (!prev_ident) 3148 { 3149 cpp_error (pfile, CPP_DL_ERROR, "parameter name missing"); 3150 return false; 3151 } 3152 prev_ident = 0; 3153 continue; 3154 3155 case CPP_ELLIPSIS: 3156 macro->variadic = 1; 3157 if (!prev_ident) 3158 { 3159 _cpp_save_parameter (pfile, macro, 3160 pfile->spec_nodes.n__VA_ARGS__, 3161 pfile->spec_nodes.n__VA_ARGS__); 3162 pfile->state.va_args_ok = 1; 3163 if (! CPP_OPTION (pfile, c99) 3164 && CPP_OPTION (pfile, cpp_pedantic) 3165 && CPP_OPTION (pfile, warn_variadic_macros)) 3166 { 3167 if (CPP_OPTION (pfile, cplusplus)) 3168 cpp_pedwarning 3169 (pfile, CPP_W_VARIADIC_MACROS, 3170 "anonymous variadic macros were introduced in C++11"); 3171 else 3172 cpp_pedwarning 3173 (pfile, CPP_W_VARIADIC_MACROS, 3174 "anonymous variadic macros were introduced in C99"); 3175 } 3176 else if (CPP_OPTION (pfile, cpp_warn_c90_c99_compat) > 0 3177 && ! CPP_OPTION (pfile, cplusplus)) 3178 cpp_error (pfile, CPP_DL_WARNING, 3179 "anonymous variadic macros were introduced in C99"); 3180 } 3181 else if (CPP_OPTION (pfile, cpp_pedantic) 3182 && CPP_OPTION (pfile, warn_variadic_macros)) 3183 { 3184 if (CPP_OPTION (pfile, cplusplus)) 3185 cpp_pedwarning (pfile, CPP_W_VARIADIC_MACROS, 3186 "ISO C++ does not permit named variadic macros"); 3187 else 3188 cpp_pedwarning (pfile, CPP_W_VARIADIC_MACROS, 3189 "ISO C does not permit named variadic macros"); 3190 } 3191 3192 /* We're at the end, and just expect a closing parenthesis. */ 3193 token = _cpp_lex_token (pfile); 3194 if (token->type == CPP_CLOSE_PAREN) 3195 return true; 3196 /* Fall through. */ 3197 3198 case CPP_EOF: 3199 cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list"); 3200 return false; 3201 } 3202 } 3203 } 3204 3205 /* Allocate room for a token from a macro's replacement list. */ 3206 static cpp_token * 3207 alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro) 3208 { 3209 if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token)) 3210 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token)); 3211 3212 return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++]; 3213 } 3214 3215 /* Lex a token from the expansion of MACRO, but mark parameters as we 3216 find them and warn of traditional stringification. */ 3217 static cpp_token * 3218 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro) 3219 { 3220 cpp_token *token, *saved_cur_token; 3221 3222 saved_cur_token = pfile->cur_token; 3223 pfile->cur_token = alloc_expansion_token (pfile, macro); 3224 token = _cpp_lex_direct (pfile); 3225 pfile->cur_token = saved_cur_token; 3226 3227 /* Is this a parameter? */ 3228 if (token->type == CPP_NAME 3229 && (token->val.node.node->flags & NODE_MACRO_ARG) != 0) 3230 { 3231 cpp_hashnode *spelling = token->val.node.spelling; 3232 token->type = CPP_MACRO_ARG; 3233 token->val.macro_arg.arg_no = token->val.node.node->value.arg_index; 3234 token->val.macro_arg.spelling = spelling; 3235 } 3236 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0 3237 && (token->type == CPP_STRING || token->type == CPP_CHAR)) 3238 check_trad_stringification (pfile, macro, &token->val.str); 3239 3240 return token; 3241 } 3242 3243 static bool 3244 create_iso_definition (cpp_reader *pfile, cpp_macro *macro) 3245 { 3246 cpp_token *token; 3247 const cpp_token *ctoken; 3248 bool following_paste_op = false; 3249 const char *paste_op_error_msg = 3250 N_("'##' cannot appear at either end of a macro expansion"); 3251 unsigned int num_extra_tokens = 0; 3252 3253 /* Get the first token of the expansion (or the '(' of a 3254 function-like macro). */ 3255 ctoken = _cpp_lex_token (pfile); 3256 3257 if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE)) 3258 { 3259 bool ok = parse_params (pfile, macro); 3260 macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff); 3261 if (!ok) 3262 return false; 3263 3264 /* Success. Commit or allocate the parameter array. */ 3265 if (pfile->hash_table->alloc_subobject) 3266 { 3267 cpp_hashnode **params = 3268 (cpp_hashnode **) pfile->hash_table->alloc_subobject 3269 (sizeof (cpp_hashnode *) * macro->paramc); 3270 memcpy (params, macro->params, 3271 sizeof (cpp_hashnode *) * macro->paramc); 3272 macro->params = params; 3273 } 3274 else 3275 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->params[macro->paramc]; 3276 macro->fun_like = 1; 3277 } 3278 else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE)) 3279 { 3280 /* While ISO C99 requires whitespace before replacement text 3281 in a macro definition, ISO C90 with TC1 allows characters 3282 from the basic source character set there. */ 3283 if (CPP_OPTION (pfile, c99)) 3284 { 3285 if (CPP_OPTION (pfile, cplusplus)) 3286 cpp_error (pfile, CPP_DL_PEDWARN, 3287 "ISO C++11 requires whitespace after the macro name"); 3288 else 3289 cpp_error (pfile, CPP_DL_PEDWARN, 3290 "ISO C99 requires whitespace after the macro name"); 3291 } 3292 else 3293 { 3294 int warntype = CPP_DL_WARNING; 3295 switch (ctoken->type) 3296 { 3297 case CPP_ATSIGN: 3298 case CPP_AT_NAME: 3299 case CPP_OBJC_STRING: 3300 /* '@' is not in basic character set. */ 3301 warntype = CPP_DL_PEDWARN; 3302 break; 3303 case CPP_OTHER: 3304 /* Basic character set sans letters, digits and _. */ 3305 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~", 3306 ctoken->val.str.text[0]) == NULL) 3307 warntype = CPP_DL_PEDWARN; 3308 break; 3309 default: 3310 /* All other tokens start with a character from basic 3311 character set. */ 3312 break; 3313 } 3314 cpp_error (pfile, warntype, 3315 "missing whitespace after the macro name"); 3316 } 3317 } 3318 3319 if (macro->fun_like) 3320 token = lex_expansion_token (pfile, macro); 3321 else 3322 { 3323 token = alloc_expansion_token (pfile, macro); 3324 *token = *ctoken; 3325 } 3326 3327 /* The argument doesn't matter here. */ 3328 vaopt_state vaopt_tracker (pfile, macro->variadic, true); 3329 3330 for (;;) 3331 { 3332 /* Check the stringifying # constraint 6.10.3.2.1 of 3333 function-like macros when lexing the subsequent token. */ 3334 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like) 3335 { 3336 if (token->type == CPP_MACRO_ARG) 3337 { 3338 if (token->flags & PREV_WHITE) 3339 token->flags |= SP_PREV_WHITE; 3340 if (token[-1].flags & DIGRAPH) 3341 token->flags |= SP_DIGRAPH; 3342 token->flags &= ~PREV_WHITE; 3343 token->flags |= STRINGIFY_ARG; 3344 token->flags |= token[-1].flags & PREV_WHITE; 3345 token[-1] = token[0]; 3346 macro->count--; 3347 } 3348 /* Let assembler get away with murder. */ 3349 else if (CPP_OPTION (pfile, lang) != CLK_ASM) 3350 { 3351 cpp_error (pfile, CPP_DL_ERROR, 3352 "'#' is not followed by a macro parameter"); 3353 return false; 3354 } 3355 } 3356 3357 if (token->type == CPP_EOF) 3358 { 3359 /* Paste operator constraint 6.10.3.3.1: 3360 Token-paste ##, can appear in both object-like and 3361 function-like macros, but not at the end. */ 3362 if (following_paste_op) 3363 { 3364 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg); 3365 return false; 3366 } 3367 break; 3368 } 3369 3370 /* Paste operator constraint 6.10.3.3.1. */ 3371 if (token->type == CPP_PASTE) 3372 { 3373 /* Token-paste ##, can appear in both object-like and 3374 function-like macros, but not at the beginning. */ 3375 if (macro->count == 1) 3376 { 3377 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg); 3378 return false; 3379 } 3380 3381 if (token[-1].flags & PASTE_LEFT) 3382 { 3383 macro->extra_tokens = 1; 3384 num_extra_tokens++; 3385 token->val.token_no = macro->count - 1; 3386 } 3387 else 3388 { 3389 --macro->count; 3390 token[-1].flags |= PASTE_LEFT; 3391 if (token->flags & DIGRAPH) 3392 token[-1].flags |= SP_DIGRAPH; 3393 if (token->flags & PREV_WHITE) 3394 token[-1].flags |= SP_PREV_WHITE; 3395 } 3396 } 3397 3398 if (vaopt_tracker.update (token) == vaopt_state::ERROR) 3399 return false; 3400 3401 following_paste_op = (token->type == CPP_PASTE); 3402 token = lex_expansion_token (pfile, macro); 3403 } 3404 3405 if (!vaopt_tracker.completed ()) 3406 return false; 3407 3408 macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff); 3409 macro->traditional = 0; 3410 3411 /* Don't count the CPP_EOF. */ 3412 macro->count--; 3413 3414 /* Clear whitespace on first token for warn_of_redefinition(). */ 3415 if (macro->count) 3416 macro->exp.tokens[0].flags &= ~PREV_WHITE; 3417 3418 /* Commit or allocate the memory. */ 3419 if (pfile->hash_table->alloc_subobject) 3420 { 3421 cpp_token *tokns = 3422 (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token) 3423 * macro->count); 3424 if (num_extra_tokens) 3425 { 3426 /* Place second and subsequent ## or %:%: tokens in 3427 sequences of consecutive such tokens at the end of the 3428 list to preserve information about where they appear, how 3429 they are spelt and whether they are preceded by 3430 whitespace without otherwise interfering with macro 3431 expansion. */ 3432 cpp_token *normal_dest = tokns; 3433 cpp_token *extra_dest = tokns + macro->count - num_extra_tokens; 3434 unsigned int i; 3435 for (i = 0; i < macro->count; i++) 3436 { 3437 if (macro->exp.tokens[i].type == CPP_PASTE) 3438 *extra_dest++ = macro->exp.tokens[i]; 3439 else 3440 *normal_dest++ = macro->exp.tokens[i]; 3441 } 3442 } 3443 else 3444 memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count); 3445 macro->exp.tokens = tokns; 3446 } 3447 else 3448 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->exp.tokens[macro->count]; 3449 3450 return true; 3451 } 3452 3453 /* Parse a macro and save its expansion. Returns nonzero on success. */ 3454 bool 3455 _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node) 3456 { 3457 cpp_macro *macro; 3458 unsigned int i; 3459 bool ok; 3460 3461 if (pfile->hash_table->alloc_subobject) 3462 macro = (cpp_macro *) pfile->hash_table->alloc_subobject 3463 (sizeof (cpp_macro)); 3464 else 3465 macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro)); 3466 macro->line = pfile->directive_line; 3467 macro->params = 0; 3468 macro->paramc = 0; 3469 macro->variadic = 0; 3470 macro->used = !CPP_OPTION (pfile, warn_unused_macros); 3471 macro->count = 0; 3472 macro->fun_like = 0; 3473 macro->extra_tokens = 0; 3474 /* To suppress some diagnostics. */ 3475 macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0; 3476 3477 if (CPP_OPTION (pfile, traditional)) 3478 ok = _cpp_create_trad_definition (pfile, macro); 3479 else 3480 { 3481 ok = create_iso_definition (pfile, macro); 3482 3483 /* We set the type for SEEN_EOL() in directives.c. 3484 3485 Longer term we should lex the whole line before coming here, 3486 and just copy the expansion. */ 3487 3488 /* Stop the lexer accepting __VA_ARGS__. */ 3489 pfile->state.va_args_ok = 0; 3490 } 3491 3492 /* Clear the fast argument lookup indices. */ 3493 for (i = macro->paramc; i-- > 0; ) 3494 { 3495 struct macro_arg_saved_data *save = 3496 &((struct macro_arg_saved_data *) pfile->macro_buffer)[i]; 3497 struct cpp_hashnode *node = save->canonical_node; 3498 node->flags &= ~ NODE_MACRO_ARG; 3499 node->value = save->value; 3500 } 3501 3502 if (!ok) 3503 return ok; 3504 3505 if (node->type == NT_MACRO) 3506 { 3507 if (CPP_OPTION (pfile, warn_unused_macros)) 3508 _cpp_warn_if_unused_macro (pfile, node, NULL); 3509 3510 if (warn_of_redefinition (pfile, node, macro)) 3511 { 3512 const int reason = ((node->flags & NODE_BUILTIN) 3513 && !(node->flags & NODE_WARN)) 3514 ? CPP_W_BUILTIN_MACRO_REDEFINED : CPP_W_NONE; 3515 3516 bool warned = 3517 cpp_pedwarning_with_line (pfile, reason, 3518 pfile->directive_line, 0, 3519 "\"%s\" redefined", NODE_NAME (node)); 3520 3521 if (warned && node->type == NT_MACRO && !(node->flags & NODE_BUILTIN)) 3522 cpp_error_with_line (pfile, CPP_DL_NOTE, 3523 node->value.macro->line, 0, 3524 "this is the location of the previous definition"); 3525 } 3526 } 3527 3528 if (node->type != NT_VOID) 3529 _cpp_free_definition (node); 3530 3531 /* Enter definition in hash table. */ 3532 node->type = NT_MACRO; 3533 node->value.macro = macro; 3534 if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_")) 3535 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_FORMAT_MACROS") 3536 /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned 3537 in the C standard, as something that one must use in C++. 3538 However DR#593 and C++11 indicate that they play no role in C++. 3539 We special-case them anyway. */ 3540 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_LIMIT_MACROS") 3541 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_CONSTANT_MACROS")) 3542 node->flags |= NODE_WARN; 3543 3544 /* If user defines one of the conditional macros, remove the 3545 conditional flag */ 3546 node->flags &= ~NODE_CONDITIONAL; 3547 3548 return ok; 3549 } 3550 3551 /* Warn if a token in STRING matches one of a function-like MACRO's 3552 parameters. */ 3553 static void 3554 check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro, 3555 const cpp_string *string) 3556 { 3557 unsigned int i, len; 3558 const uchar *p, *q, *limit; 3559 3560 /* Loop over the string. */ 3561 limit = string->text + string->len - 1; 3562 for (p = string->text + 1; p < limit; p = q) 3563 { 3564 /* Find the start of an identifier. */ 3565 while (p < limit && !is_idstart (*p)) 3566 p++; 3567 3568 /* Find the end of the identifier. */ 3569 q = p; 3570 while (q < limit && is_idchar (*q)) 3571 q++; 3572 3573 len = q - p; 3574 3575 /* Loop over the function macro arguments to see if the 3576 identifier inside the string matches one of them. */ 3577 for (i = 0; i < macro->paramc; i++) 3578 { 3579 const cpp_hashnode *node = macro->params[i]; 3580 3581 if (NODE_LEN (node) == len 3582 && !memcmp (p, NODE_NAME (node), len)) 3583 { 3584 cpp_warning (pfile, CPP_W_TRADITIONAL, 3585 "macro argument \"%s\" would be stringified in traditional C", 3586 NODE_NAME (node)); 3587 break; 3588 } 3589 } 3590 } 3591 } 3592 3593 /* Returns true of NODE is a function-like macro. */ 3594 bool 3595 cpp_fun_like_macro_p (cpp_hashnode *node) 3596 { 3597 return (node->type == NT_MACRO 3598 && (node->flags & (NODE_BUILTIN | NODE_MACRO_ARG)) == 0 3599 && node->value.macro->fun_like); 3600 } 3601 3602 /* Returns the name, arguments and expansion of a macro, in a format 3603 suitable to be read back in again, and therefore also for DWARF 2 3604 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION". 3605 Caller is expected to generate the "#define" bit if needed. The 3606 returned text is temporary, and automatically freed later. */ 3607 const unsigned char * 3608 cpp_macro_definition (cpp_reader *pfile, cpp_hashnode *node) 3609 { 3610 unsigned int i, len; 3611 const cpp_macro *macro; 3612 unsigned char *buffer; 3613 3614 if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN)) 3615 { 3616 if (node->type != NT_MACRO 3617 || !pfile->cb.user_builtin_macro 3618 || !pfile->cb.user_builtin_macro (pfile, node)) 3619 { 3620 cpp_error (pfile, CPP_DL_ICE, 3621 "invalid hash type %d in cpp_macro_definition", 3622 node->type); 3623 return 0; 3624 } 3625 } 3626 3627 macro = node->value.macro; 3628 /* Calculate length. */ 3629 len = NODE_LEN (node) * 10 + 2; /* ' ' and NUL. */ 3630 if (macro->fun_like) 3631 { 3632 len += 4; /* "()" plus possible final ".." of named 3633 varargs (we have + 1 below). */ 3634 for (i = 0; i < macro->paramc; i++) 3635 len += NODE_LEN (macro->params[i]) + 1; /* "," */ 3636 } 3637 3638 /* This should match below where we fill in the buffer. */ 3639 if (CPP_OPTION (pfile, traditional)) 3640 len += _cpp_replacement_text_len (macro); 3641 else 3642 { 3643 unsigned int count = macro_real_token_count (macro); 3644 for (i = 0; i < count; i++) 3645 { 3646 cpp_token *token = ¯o->exp.tokens[i]; 3647 3648 if (token->type == CPP_MACRO_ARG) 3649 len += NODE_LEN (token->val.macro_arg.spelling); 3650 else 3651 len += cpp_token_len (token); 3652 3653 if (token->flags & STRINGIFY_ARG) 3654 len++; /* "#" */ 3655 if (token->flags & PASTE_LEFT) 3656 len += 3; /* " ##" */ 3657 if (token->flags & PREV_WHITE) 3658 len++; /* " " */ 3659 } 3660 } 3661 3662 if (len > pfile->macro_buffer_len) 3663 { 3664 pfile->macro_buffer = XRESIZEVEC (unsigned char, 3665 pfile->macro_buffer, len); 3666 pfile->macro_buffer_len = len; 3667 } 3668 3669 /* Fill in the buffer. Start with the macro name. */ 3670 buffer = pfile->macro_buffer; 3671 buffer = _cpp_spell_ident_ucns (buffer, node); 3672 3673 /* Parameter names. */ 3674 if (macro->fun_like) 3675 { 3676 *buffer++ = '('; 3677 for (i = 0; i < macro->paramc; i++) 3678 { 3679 cpp_hashnode *param = macro->params[i]; 3680 3681 if (param != pfile->spec_nodes.n__VA_ARGS__) 3682 { 3683 memcpy (buffer, NODE_NAME (param), NODE_LEN (param)); 3684 buffer += NODE_LEN (param); 3685 } 3686 3687 if (i + 1 < macro->paramc) 3688 /* Don't emit a space after the comma here; we're trying 3689 to emit a Dwarf-friendly definition, and the Dwarf spec 3690 forbids spaces in the argument list. */ 3691 *buffer++ = ','; 3692 else if (macro->variadic) 3693 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.'; 3694 } 3695 *buffer++ = ')'; 3696 } 3697 3698 /* The Dwarf spec requires a space after the macro name, even if the 3699 definition is the empty string. */ 3700 *buffer++ = ' '; 3701 3702 if (CPP_OPTION (pfile, traditional)) 3703 buffer = _cpp_copy_replacement_text (macro, buffer); 3704 else if (macro->count) 3705 /* Expansion tokens. */ 3706 { 3707 unsigned int count = macro_real_token_count (macro); 3708 for (i = 0; i < count; i++) 3709 { 3710 cpp_token *token = ¯o->exp.tokens[i]; 3711 3712 if (token->flags & PREV_WHITE) 3713 *buffer++ = ' '; 3714 if (token->flags & STRINGIFY_ARG) 3715 *buffer++ = '#'; 3716 3717 if (token->type == CPP_MACRO_ARG) 3718 { 3719 memcpy (buffer, 3720 NODE_NAME (token->val.macro_arg.spelling), 3721 NODE_LEN (token->val.macro_arg.spelling)); 3722 buffer += NODE_LEN (token->val.macro_arg.spelling); 3723 } 3724 else 3725 buffer = cpp_spell_token (pfile, token, buffer, true); 3726 3727 if (token->flags & PASTE_LEFT) 3728 { 3729 *buffer++ = ' '; 3730 *buffer++ = '#'; 3731 *buffer++ = '#'; 3732 /* Next has PREV_WHITE; see _cpp_create_definition. */ 3733 } 3734 } 3735 } 3736 3737 *buffer = '\0'; 3738 return pfile->macro_buffer; 3739 } 3740 3741 /* Get the line at which the macro was defined. */ 3742 3743 source_location 3744 cpp_macro_definition_location (cpp_hashnode *node) 3745 { 3746 return node->value.macro->line; 3747 } 3748