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