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 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 9This program is free software; you can redistribute it and/or modify it 10under the terms of the GNU General Public License as published by the 11Free Software Foundation; either version 2, or (at your option) any 12later version. 13 14This program is distributed in the hope that it will be useful, 15but WITHOUT ANY WARRANTY; without even the implied warranty of 16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17GNU General Public License for more details. 18 19You should have received a copy of the GNU General Public License 20along with this program; if not, write to the Free Software 21Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 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 32typedef struct macro_arg macro_arg; 33struct macro_arg 34{ 35 const cpp_token **first; /* First token in unexpanded argument. */ 36 const cpp_token **expanded; /* Macro-expanded argument. */ 37 const cpp_token *stringified; /* Stringified argument. */ 38 unsigned int count; /* # of tokens in argument. */ 39 unsigned int expanded_count; /* # of tokens in expanded argument. */ 40}; 41 42/* Macro expansion. */ 43 44static int enter_macro_context (cpp_reader *, cpp_hashnode *); 45static int builtin_macro (cpp_reader *, cpp_hashnode *); 46static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *, 47 const cpp_token **, unsigned int); 48static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *); 49static cpp_context *next_context (cpp_reader *); 50static const cpp_token *padding_token (cpp_reader *, const cpp_token *); 51static void expand_arg (cpp_reader *, macro_arg *); 52static const cpp_token *new_string_token (cpp_reader *, uchar *, unsigned int); 53static const cpp_token *stringify_arg (cpp_reader *, macro_arg *); 54static void paste_all_tokens (cpp_reader *, const cpp_token *); 55static bool paste_tokens (cpp_reader *, const cpp_token **, const cpp_token *); 56static void replace_args (cpp_reader *, cpp_hashnode *, cpp_macro *, 57 macro_arg *); 58static _cpp_buff *funlike_invocation_p (cpp_reader *, cpp_hashnode *); 59static bool create_iso_definition (cpp_reader *, cpp_macro *); 60 61/* #define directive parsing and handling. */ 62 63static cpp_token *alloc_expansion_token (cpp_reader *, cpp_macro *); 64static cpp_token *lex_expansion_token (cpp_reader *, cpp_macro *); 65static bool warn_of_redefinition (cpp_reader *, const cpp_hashnode *, 66 const cpp_macro *); 67static bool parse_params (cpp_reader *, cpp_macro *); 68static void check_trad_stringification (cpp_reader *, const cpp_macro *, 69 const cpp_string *); 70 71/* Emits a warning if NODE is a macro defined in the main file that 72 has not been used. */ 73int 74_cpp_warn_if_unused_macro (cpp_reader *pfile, cpp_hashnode *node, 75 void *v ATTRIBUTE_UNUSED) 76{ 77 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN)) 78 { 79 cpp_macro *macro = node->value.macro; 80 81 if (!macro->used 82 && MAIN_FILE_P (linemap_lookup (pfile->line_table, macro->line))) 83 cpp_error_with_line (pfile, CPP_DL_WARNING, macro->line, 0, 84 "macro \"%s\" is not used", NODE_NAME (node)); 85 } 86 87 return 1; 88} 89 90/* Allocates and returns a CPP_STRING token, containing TEXT of length 91 LEN, after null-terminating it. TEXT must be in permanent storage. */ 92static const cpp_token * 93new_string_token (cpp_reader *pfile, unsigned char *text, unsigned int len) 94{ 95 cpp_token *token = _cpp_temp_token (pfile); 96 97 text[len] = '\0'; 98 token->type = CPP_STRING; 99 token->val.str.len = len; 100 token->val.str.text = text; 101 token->flags = 0; 102 return token; 103} 104 105static const char * const monthnames[] = 106{ 107 "Jan", "Feb", "Mar", "Apr", "May", "Jun", 108 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" 109}; 110 111/* Helper function for builtin_macro. Returns the text generated by 112 a builtin macro. */ 113const uchar * 114_cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node) 115{ 116 const struct line_map *map; 117 const uchar *result = NULL; 118 unsigned int number = 1; 119 120 switch (node->value.builtin) 121 { 122 default: 123 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"", 124 NODE_NAME (node)); 125 break; 126 127 case BT_TIMESTAMP: 128 { 129 cpp_buffer *pbuffer = cpp_get_buffer (pfile); 130 if (pbuffer->timestamp == NULL) 131 { 132 /* Initialize timestamp value of the assotiated file. */ 133 struct _cpp_file *file = cpp_get_file (pbuffer); 134 if (file) 135 { 136 /* Generate __TIMESTAMP__ string, that represents 137 the date and time of the last modification 138 of the current source file. The string constant 139 looks like "Sun Sep 16 01:03:52 1973". */ 140 struct tm *tb = NULL; 141 struct stat *st = _cpp_get_file_stat (file); 142 if (st) 143 tb = localtime (&st->st_mtime); 144 if (tb) 145 { 146 char *str = asctime (tb); 147 size_t len = strlen (str); 148 unsigned char *buf = _cpp_unaligned_alloc (pfile, len + 2); 149 buf[0] = '"'; 150 strcpy ((char *) buf + 1, str); 151 buf[len] = '"'; 152 pbuffer->timestamp = buf; 153 } 154 else 155 { 156 cpp_errno (pfile, CPP_DL_WARNING, 157 "could not determine file timestamp"); 158 pbuffer->timestamp = U"\"??? ??? ?? ??:??:?? ????\""; 159 } 160 } 161 } 162 result = pbuffer->timestamp; 163 } 164 break; 165 case BT_FILE: 166 case BT_BASE_FILE: 167 { 168 unsigned int len; 169 const char *name; 170 uchar *buf; 171 map = linemap_lookup (pfile->line_table, pfile->line_table->highest_line); 172 173 if (node->value.builtin == BT_BASE_FILE) 174 while (! MAIN_FILE_P (map)) 175 map = INCLUDED_FROM (pfile->line_table, map); 176 177 name = map->to_file; 178 len = strlen (name); 179 buf = _cpp_unaligned_alloc (pfile, len * 2 + 3); 180 result = buf; 181 *buf = '"'; 182 buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len); 183 *buf++ = '"'; 184 *buf = '\0'; 185 } 186 break; 187 188 case BT_INCLUDE_LEVEL: 189 /* The line map depth counts the primary source as level 1, but 190 historically __INCLUDE_DEPTH__ has called the primary source 191 level 0. */ 192 number = pfile->line_table->depth - 1; 193 break; 194 195 case BT_SPECLINE: 196 map = &pfile->line_table->maps[pfile->line_table->used-1]; 197 /* If __LINE__ is embedded in a macro, it must expand to the 198 line of the macro's invocation, not its definition. 199 Otherwise things like assert() will not work properly. */ 200 if (CPP_OPTION (pfile, traditional)) 201 number = pfile->line_table->highest_line; 202 else 203 number = pfile->cur_token[-1].src_loc; 204 number = SOURCE_LINE (map, number); 205 break; 206 207 /* __STDC__ has the value 1 under normal circumstances. 208 However, if (a) we are in a system header, (b) the option 209 stdc_0_in_system_headers is true (set by target config), and 210 (c) we are not in strictly conforming mode, then it has the 211 value 0. (b) and (c) are already checked in cpp_init_builtins. */ 212 case BT_STDC: 213 if (cpp_in_system_header (pfile)) 214 number = 0; 215 else 216 number = 1; 217 break; 218 219 case BT_DATE: 220 case BT_TIME: 221 if (pfile->date == NULL) 222 { 223 /* Allocate __DATE__ and __TIME__ strings from permanent 224 storage. We only do this once, and don't generate them 225 at init time, because time() and localtime() are very 226 slow on some systems. */ 227 time_t tt; 228 struct tm *tb = NULL; 229 230 /* (time_t) -1 is a legitimate value for "number of seconds 231 since the Epoch", so we have to do a little dance to 232 distinguish that from a genuine error. */ 233 errno = 0; 234 tt = time(NULL); 235 if (tt != (time_t)-1 || errno == 0) 236 tb = localtime (&tt); 237 238 if (tb) 239 { 240 pfile->date = _cpp_unaligned_alloc (pfile, 241 sizeof ("\"Oct 11 1347\"")); 242 sprintf ((char *) pfile->date, "\"%s %2d %4d\"", 243 monthnames[tb->tm_mon], tb->tm_mday, 244 tb->tm_year + 1900); 245 246 pfile->time = _cpp_unaligned_alloc (pfile, 247 sizeof ("\"12:34:56\"")); 248 sprintf ((char *) pfile->time, "\"%02d:%02d:%02d\"", 249 tb->tm_hour, tb->tm_min, tb->tm_sec); 250 } 251 else 252 { 253 cpp_errno (pfile, CPP_DL_WARNING, 254 "could not determine date and time"); 255 256 pfile->date = U"\"??? ?? ????\""; 257 pfile->time = U"\"??:??:??\""; 258 } 259 } 260 261 if (node->value.builtin == BT_DATE) 262 result = pfile->date; 263 else 264 result = pfile->time; 265 break; 266 267 case BT_COUNTER: 268 if (CPP_OPTION (pfile, directives_only) && pfile->state.in_directive) 269 cpp_error (pfile, CPP_DL_ERROR, 270 "__COUNTER__ expanded inside directive with -fdirectives-only"); 271 number = pfile->nextcounter++; 272 break; 273 } 274 275 if (result == NULL) 276 { 277 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */ 278 result = _cpp_unaligned_alloc (pfile, 21); 279 sprintf ((char *) result, "%u", number); 280 } 281 282 return result; 283} 284 285/* Convert builtin macros like __FILE__ to a token and push it on the 286 context stack. Also handles _Pragma, for which a new token may not 287 be created. Returns 1 if it generates a new token context, 0 to 288 return the token to the caller. */ 289static int 290builtin_macro (cpp_reader *pfile, cpp_hashnode *node) 291{ 292 const uchar *buf; 293 size_t len; 294 char *nbuf; 295 296 if (node->value.builtin == BT_PRAGMA) 297 { 298 /* Don't interpret _Pragma within directives. The standard is 299 not clear on this, but to me this makes most sense. */ 300 if (pfile->state.in_directive) 301 return 0; 302 303 _cpp_do__Pragma (pfile); 304 return 1; 305 } 306 307 buf = _cpp_builtin_macro_text (pfile, node); 308 len = ustrlen (buf); 309 nbuf = (char *) alloca (len + 1); 310 memcpy (nbuf, buf, len); 311 nbuf[len]='\n'; 312 313 cpp_push_buffer (pfile, (uchar *) nbuf, len, /* from_stage3 */ true); 314 _cpp_clean_line (pfile); 315 316 /* Set pfile->cur_token as required by _cpp_lex_direct. */ 317 pfile->cur_token = _cpp_temp_token (pfile); 318 _cpp_push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1); 319 if (pfile->buffer->cur != pfile->buffer->rlimit) 320 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"", 321 NODE_NAME (node)); 322 _cpp_pop_buffer (pfile); 323 324 return 1; 325} 326 327/* Copies SRC, of length LEN, to DEST, adding backslashes before all 328 backslashes and double quotes. DEST must be of sufficient size. 329 Returns a pointer to the end of the string. */ 330uchar * 331cpp_quote_string (uchar *dest, const uchar *src, unsigned int len) 332{ 333 while (len--) 334 { 335 uchar c = *src++; 336 337 if (c == '\\' || c == '"') 338 { 339 *dest++ = '\\'; 340 *dest++ = c; 341 } 342 else 343 *dest++ = c; 344 } 345 346 return dest; 347} 348 349/* Convert a token sequence ARG to a single string token according to 350 the rules of the ISO C #-operator. */ 351static const cpp_token * 352stringify_arg (cpp_reader *pfile, macro_arg *arg) 353{ 354 unsigned char *dest; 355 unsigned int i, escape_it, backslash_count = 0; 356 const cpp_token *source = NULL; 357 size_t len; 358 359 if (BUFF_ROOM (pfile->u_buff) < 3) 360 _cpp_extend_buff (pfile, &pfile->u_buff, 3); 361 dest = BUFF_FRONT (pfile->u_buff); 362 *dest++ = '"'; 363 364 /* Loop, reading in the argument's tokens. */ 365 for (i = 0; i < arg->count; i++) 366 { 367 const cpp_token *token = arg->first[i]; 368 369 if (token->type == CPP_PADDING) 370 { 371 if (source == NULL) 372 source = token->val.source; 373 continue; 374 } 375 376 escape_it = (token->type == CPP_STRING || token->type == CPP_WSTRING 377 || token->type == CPP_CHAR || token->type == CPP_WCHAR); 378 379 /* Room for each char being written in octal, initial space and 380 final quote and NUL. */ 381 len = cpp_token_len (token); 382 if (escape_it) 383 len *= 4; 384 len += 3; 385 386 if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len) 387 { 388 size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff); 389 _cpp_extend_buff (pfile, &pfile->u_buff, len); 390 dest = BUFF_FRONT (pfile->u_buff) + len_so_far; 391 } 392 393 /* Leading white space? */ 394 if (dest - 1 != BUFF_FRONT (pfile->u_buff)) 395 { 396 if (source == NULL) 397 source = token; 398 if (source->flags & PREV_WHITE) 399 *dest++ = ' '; 400 } 401 source = NULL; 402 403 if (escape_it) 404 { 405 _cpp_buff *buff = _cpp_get_buff (pfile, len); 406 unsigned char *buf = BUFF_FRONT (buff); 407 len = cpp_spell_token (pfile, token, buf, true) - buf; 408 dest = cpp_quote_string (dest, buf, len); 409 _cpp_release_buff (pfile, buff); 410 } 411 else 412 dest = cpp_spell_token (pfile, token, dest, true); 413 414 if (token->type == CPP_OTHER && token->val.str.text[0] == '\\') 415 backslash_count++; 416 else 417 backslash_count = 0; 418 } 419 420 /* Ignore the final \ of invalid string literals. */ 421 if (backslash_count & 1) 422 { 423 cpp_error (pfile, CPP_DL_WARNING, 424 "invalid string literal, ignoring final '\\'"); 425 dest--; 426 } 427 428 /* Commit the memory, including NUL, and return the token. */ 429 *dest++ = '"'; 430 len = dest - BUFF_FRONT (pfile->u_buff); 431 BUFF_FRONT (pfile->u_buff) = dest + 1; 432 return new_string_token (pfile, dest - len, len); 433} 434 435/* Try to paste two tokens. On success, return nonzero. In any 436 case, PLHS is updated to point to the pasted token, which is 437 guaranteed to not have the PASTE_LEFT flag set. */ 438static bool 439paste_tokens (cpp_reader *pfile, const cpp_token **plhs, const cpp_token *rhs) 440{ 441 unsigned char *buf, *end, *lhsend; 442 cpp_token *lhs; 443 unsigned int len; 444 445 len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 1; 446 buf = (unsigned char *) alloca (len); 447 end = lhsend = cpp_spell_token (pfile, *plhs, buf, false); 448 449 /* Avoid comment headers, since they are still processed in stage 3. 450 It is simpler to insert a space here, rather than modifying the 451 lexer to ignore comments in some circumstances. Simply returning 452 false doesn't work, since we want to clear the PASTE_LEFT flag. */ 453 if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ) 454 *end++ = ' '; 455 end = cpp_spell_token (pfile, rhs, end, false); 456 *end = '\n'; 457 458 cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true); 459 _cpp_clean_line (pfile); 460 461 /* Set pfile->cur_token as required by _cpp_lex_direct. */ 462 pfile->cur_token = _cpp_temp_token (pfile); 463 lhs = _cpp_lex_direct (pfile); 464 if (pfile->buffer->cur != pfile->buffer->rlimit) 465 { 466 source_location saved_loc = lhs->src_loc; 467 468 _cpp_pop_buffer (pfile); 469 _cpp_backup_tokens (pfile, 1); 470 *lhsend = '\0'; 471 472 /* We have to remove the PASTE_LEFT flag from the old lhs, but 473 we want to keep the new location. */ 474 *lhs = **plhs; 475 *plhs = lhs; 476 lhs->src_loc = saved_loc; 477 lhs->flags &= ~PASTE_LEFT; 478 479 /* Mandatory error for all apart from assembler. */ 480 if (CPP_OPTION (pfile, lang) != CLK_ASM) 481 cpp_error (pfile, CPP_DL_ERROR, 482 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token", 483 buf, cpp_token_as_text (pfile, rhs)); 484 return false; 485 } 486 487 *plhs = lhs; 488 _cpp_pop_buffer (pfile); 489 return true; 490} 491 492/* Handles an arbitrarily long sequence of ## operators, with initial 493 operand LHS. This implementation is left-associative, 494 non-recursive, and finishes a paste before handling succeeding 495 ones. If a paste fails, we back up to the RHS of the failing ## 496 operator before pushing the context containing the result of prior 497 successful pastes, with the effect that the RHS appears in the 498 output stream after the pasted LHS normally. */ 499static void 500paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs) 501{ 502 const cpp_token *rhs; 503 cpp_context *context = pfile->context; 504 505 do 506 { 507 /* Take the token directly from the current context. We can do 508 this, because we are in the replacement list of either an 509 object-like macro, or a function-like macro with arguments 510 inserted. In either case, the constraints to #define 511 guarantee we have at least one more token. */ 512 if (context->direct_p) 513 rhs = FIRST (context).token++; 514 else 515 rhs = *FIRST (context).ptoken++; 516 517 if (rhs->type == CPP_PADDING) 518 abort (); 519 520 if (!paste_tokens (pfile, &lhs, rhs)) 521 break; 522 } 523 while (rhs->flags & PASTE_LEFT); 524 525 /* Put the resulting token in its own context. */ 526 _cpp_push_token_context (pfile, NULL, lhs, 1); 527} 528 529/* Returns TRUE if the number of arguments ARGC supplied in an 530 invocation of the MACRO referenced by NODE is valid. An empty 531 invocation to a macro with no parameters should pass ARGC as zero. 532 533 Note that MACRO cannot necessarily be deduced from NODE, in case 534 NODE was redefined whilst collecting arguments. */ 535bool 536_cpp_arguments_ok (cpp_reader *pfile, cpp_macro *macro, const cpp_hashnode *node, unsigned int argc) 537{ 538 if (argc == macro->paramc) 539 return true; 540 541 if (argc < macro->paramc) 542 { 543 /* As an extension, a rest argument is allowed to not appear in 544 the invocation at all. 545 e.g. #define debug(format, args...) something 546 debug("string"); 547 548 This is exactly the same as if there had been an empty rest 549 argument - debug("string", ). */ 550 551 if (argc + 1 == macro->paramc && macro->variadic) 552 { 553 if (CPP_PEDANTIC (pfile) && ! macro->syshdr) 554 cpp_error (pfile, CPP_DL_PEDWARN, 555 "ISO C99 requires rest arguments to be used"); 556 return true; 557 } 558 559 cpp_error (pfile, CPP_DL_ERROR, 560 "macro \"%s\" requires %u arguments, but only %u given", 561 NODE_NAME (node), macro->paramc, argc); 562 } 563 else 564 cpp_error (pfile, CPP_DL_ERROR, 565 "macro \"%s\" passed %u arguments, but takes just %u", 566 NODE_NAME (node), argc, macro->paramc); 567 568 return false; 569} 570 571/* Reads and returns the arguments to a function-like macro 572 invocation. Assumes the opening parenthesis has been processed. 573 If there is an error, emits an appropriate diagnostic and returns 574 NULL. Each argument is terminated by a CPP_EOF token, for the 575 future benefit of expand_arg(). */ 576static _cpp_buff * 577collect_args (cpp_reader *pfile, const cpp_hashnode *node) 578{ 579 _cpp_buff *buff, *base_buff; 580 cpp_macro *macro; 581 macro_arg *args, *arg; 582 const cpp_token *token; 583 unsigned int argc; 584 585 macro = node->value.macro; 586 if (macro->paramc) 587 argc = macro->paramc; 588 else 589 argc = 1; 590 buff = _cpp_get_buff (pfile, argc * (50 * sizeof (cpp_token *) 591 + sizeof (macro_arg))); 592 base_buff = buff; 593 args = (macro_arg *) buff->base; 594 memset (args, 0, argc * sizeof (macro_arg)); 595 buff->cur = (unsigned char *) &args[argc]; 596 arg = args, argc = 0; 597 598 /* Collect the tokens making up each argument. We don't yet know 599 how many arguments have been supplied, whether too many or too 600 few. Hence the slightly bizarre usage of "argc" and "arg". */ 601 do 602 { 603 unsigned int paren_depth = 0; 604 unsigned int ntokens = 0; 605 606 argc++; 607 arg->first = (const cpp_token **) buff->cur; 608 609 for (;;) 610 { 611 /* Require space for 2 new tokens (including a CPP_EOF). */ 612 if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit) 613 { 614 buff = _cpp_append_extend_buff (pfile, buff, 615 1000 * sizeof (cpp_token *)); 616 arg->first = (const cpp_token **) buff->cur; 617 } 618 619 token = cpp_get_token (pfile); 620 621 if (token->type == CPP_PADDING) 622 { 623 /* Drop leading padding. */ 624 if (ntokens == 0) 625 continue; 626 } 627 else if (token->type == CPP_OPEN_PAREN) 628 paren_depth++; 629 else if (token->type == CPP_CLOSE_PAREN) 630 { 631 if (paren_depth-- == 0) 632 break; 633 } 634 else if (token->type == CPP_COMMA) 635 { 636 /* A comma does not terminate an argument within 637 parentheses or as part of a variable argument. */ 638 if (paren_depth == 0 639 && ! (macro->variadic && argc == macro->paramc)) 640 break; 641 } 642 else if (token->type == CPP_EOF 643 || (token->type == CPP_HASH && token->flags & BOL)) 644 break; 645 646 arg->first[ntokens++] = token; 647 } 648 649 /* Drop trailing padding. */ 650 while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING) 651 ntokens--; 652 653 arg->count = ntokens; 654 arg->first[ntokens] = &pfile->eof; 655 656 /* Terminate the argument. Excess arguments loop back and 657 overwrite the final legitimate argument, before failing. */ 658 if (argc <= macro->paramc) 659 { 660 buff->cur = (unsigned char *) &arg->first[ntokens + 1]; 661 if (argc != macro->paramc) 662 arg++; 663 } 664 } 665 while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF); 666 667 if (token->type == CPP_EOF) 668 { 669 /* We still need the CPP_EOF to end directives, and to end 670 pre-expansion of a macro argument. Step back is not 671 unconditional, since we don't want to return a CPP_EOF to our 672 callers at the end of an -include-d file. */ 673 if (pfile->context->prev || pfile->state.in_directive) 674 _cpp_backup_tokens (pfile, 1); 675 cpp_error (pfile, CPP_DL_ERROR, 676 "unterminated argument list invoking macro \"%s\"", 677 NODE_NAME (node)); 678 } 679 else 680 { 681 /* A single empty argument is counted as no argument. */ 682 if (argc == 1 && macro->paramc == 0 && args[0].count == 0) 683 argc = 0; 684 if (_cpp_arguments_ok (pfile, macro, node, argc)) 685 { 686 /* GCC has special semantics for , ## b where b is a varargs 687 parameter: we remove the comma if b was omitted entirely. 688 If b was merely an empty argument, the comma is retained. 689 If the macro takes just one (varargs) parameter, then we 690 retain the comma only if we are standards conforming. 691 692 If FIRST is NULL replace_args () swallows the comma. */ 693 if (macro->variadic && (argc < macro->paramc 694 || (argc == 1 && args[0].count == 0 695 && !CPP_OPTION (pfile, std)))) 696 args[macro->paramc - 1].first = NULL; 697 return base_buff; 698 } 699 } 700 701 /* An error occurred. */ 702 _cpp_release_buff (pfile, base_buff); 703 return NULL; 704} 705 706/* Search for an opening parenthesis to the macro of NODE, in such a 707 way that, if none is found, we don't lose the information in any 708 intervening padding tokens. If we find the parenthesis, collect 709 the arguments and return the buffer containing them. */ 710static _cpp_buff * 711funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node) 712{ 713 const cpp_token *token, *padding = NULL; 714 715 for (;;) 716 { 717 token = cpp_get_token (pfile); 718 if (token->type != CPP_PADDING) 719 break; 720 if (padding == NULL 721 || (!(padding->flags & PREV_WHITE) && token->val.source == NULL)) 722 padding = token; 723 } 724 725 if (token->type == CPP_OPEN_PAREN) 726 { 727 pfile->state.parsing_args = 2; 728 return collect_args (pfile, node); 729 } 730 731 /* CPP_EOF can be the end of macro arguments, or the end of the 732 file. We mustn't back up over the latter. Ugh. */ 733 if (token->type != CPP_EOF || token == &pfile->eof) 734 { 735 /* Back up. We may have skipped padding, in which case backing 736 up more than one token when expanding macros is in general 737 too difficult. We re-insert it in its own context. */ 738 _cpp_backup_tokens (pfile, 1); 739 if (padding) 740 _cpp_push_token_context (pfile, NULL, padding, 1); 741 } 742 743 return NULL; 744} 745 746/* Push the context of a macro with hash entry NODE onto the context 747 stack. If we can successfully expand the macro, we push a context 748 containing its yet-to-be-rescanned replacement list and return one. 749 Otherwise, we don't push a context and return zero. */ 750static int 751enter_macro_context (cpp_reader *pfile, cpp_hashnode *node) 752{ 753 /* The presence of a macro invalidates a file's controlling macro. */ 754 pfile->mi_valid = false; 755 756 pfile->state.angled_headers = false; 757 758 /* Handle standard macros. */ 759 if (! (node->flags & NODE_BUILTIN)) 760 { 761 cpp_macro *macro = node->value.macro; 762 763 if (macro->fun_like) 764 { 765 _cpp_buff *buff; 766 767 pfile->state.prevent_expansion++; 768 pfile->keep_tokens++; 769 pfile->state.parsing_args = 1; 770 buff = funlike_invocation_p (pfile, node); 771 pfile->state.parsing_args = 0; 772 pfile->keep_tokens--; 773 pfile->state.prevent_expansion--; 774 775 if (buff == NULL) 776 { 777 if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr) 778 cpp_error (pfile, CPP_DL_WARNING, 779 "function-like macro \"%s\" must be used with arguments in traditional C", 780 NODE_NAME (node)); 781 782 return 0; 783 } 784 785 if (macro->paramc > 0) 786 replace_args (pfile, node, macro, (macro_arg *) buff->base); 787 _cpp_release_buff (pfile, buff); 788 } 789 790 /* Disable the macro within its expansion. */ 791 node->flags |= NODE_DISABLED; 792 793 macro->used = 1; 794 795 if (macro->paramc == 0) 796 _cpp_push_token_context (pfile, node, macro->exp.tokens, macro->count); 797 798 return 1; 799 } 800 801 /* Handle built-in macros and the _Pragma operator. */ 802 return builtin_macro (pfile, node); 803} 804 805/* Replace the parameters in a function-like macro of NODE with the 806 actual ARGS, and place the result in a newly pushed token context. 807 Expand each argument before replacing, unless it is operated upon 808 by the # or ## operators. */ 809static void 810replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg *args) 811{ 812 unsigned int i, total; 813 const cpp_token *src, *limit; 814 const cpp_token **dest, **first; 815 macro_arg *arg; 816 _cpp_buff *buff; 817 818 /* First, fully macro-expand arguments, calculating the number of 819 tokens in the final expansion as we go. The ordering of the if 820 statements below is subtle; we must handle stringification before 821 pasting. */ 822 total = macro->count; 823 limit = macro->exp.tokens + macro->count; 824 825 for (src = macro->exp.tokens; src < limit; src++) 826 if (src->type == CPP_MACRO_ARG) 827 { 828 /* Leading and trailing padding tokens. */ 829 total += 2; 830 831 /* We have an argument. If it is not being stringified or 832 pasted it is macro-replaced before insertion. */ 833 arg = &args[src->val.arg_no - 1]; 834 835 if (src->flags & STRINGIFY_ARG) 836 { 837 if (!arg->stringified) 838 arg->stringified = stringify_arg (pfile, arg); 839 } 840 else if ((src->flags & PASTE_LEFT) 841 || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT))) 842 total += arg->count - 1; 843 else 844 { 845 if (!arg->expanded) 846 expand_arg (pfile, arg); 847 total += arg->expanded_count - 1; 848 } 849 } 850 851 /* Now allocate space for the expansion, copy the tokens and replace 852 the arguments. */ 853 buff = _cpp_get_buff (pfile, total * sizeof (cpp_token *)); 854 first = (const cpp_token **) buff->base; 855 dest = first; 856 857 for (src = macro->exp.tokens; src < limit; src++) 858 { 859 unsigned int count; 860 const cpp_token **from, **paste_flag; 861 862 if (src->type != CPP_MACRO_ARG) 863 { 864 *dest++ = src; 865 continue; 866 } 867 868 paste_flag = 0; 869 arg = &args[src->val.arg_no - 1]; 870 if (src->flags & STRINGIFY_ARG) 871 count = 1, from = &arg->stringified; 872 else if (src->flags & PASTE_LEFT) 873 count = arg->count, from = arg->first; 874 else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT)) 875 { 876 count = arg->count, from = arg->first; 877 if (dest != first) 878 { 879 if (dest[-1]->type == CPP_COMMA 880 && macro->variadic 881 && src->val.arg_no == macro->paramc) 882 { 883 /* Swallow a pasted comma if from == NULL, otherwise 884 drop the paste flag. */ 885 if (from == NULL) 886 dest--; 887 else 888 paste_flag = dest - 1; 889 } 890 /* Remove the paste flag if the RHS is a placemarker. */ 891 else if (count == 0) 892 paste_flag = dest - 1; 893 } 894 } 895 else 896 count = arg->expanded_count, from = arg->expanded; 897 898 /* Padding on the left of an argument (unless RHS of ##). */ 899 if ((!pfile->state.in_directive || pfile->state.directive_wants_padding) 900 && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT)) 901 *dest++ = padding_token (pfile, src); 902 903 if (count) 904 { 905 memcpy (dest, from, count * sizeof (cpp_token *)); 906 dest += count; 907 908 /* With a non-empty argument on the LHS of ##, the last 909 token should be flagged PASTE_LEFT. */ 910 if (src->flags & PASTE_LEFT) 911 paste_flag = dest - 1; 912 } 913 914 /* Avoid paste on RHS (even case count == 0). */ 915 if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT)) 916 *dest++ = &pfile->avoid_paste; 917 918 /* Add a new paste flag, or remove an unwanted one. */ 919 if (paste_flag) 920 { 921 cpp_token *token = _cpp_temp_token (pfile); 922 token->type = (*paste_flag)->type; 923 token->val = (*paste_flag)->val; 924 if (src->flags & PASTE_LEFT) 925 token->flags = (*paste_flag)->flags | PASTE_LEFT; 926 else 927 token->flags = (*paste_flag)->flags & ~PASTE_LEFT; 928 *paste_flag = token; 929 } 930 } 931 932 /* Free the expanded arguments. */ 933 for (i = 0; i < macro->paramc; i++) 934 if (args[i].expanded) 935 free (args[i].expanded); 936 937 push_ptoken_context (pfile, node, buff, first, dest - first); 938} 939 940/* Return a special padding token, with padding inherited from SOURCE. */ 941static const cpp_token * 942padding_token (cpp_reader *pfile, const cpp_token *source) 943{ 944 cpp_token *result = _cpp_temp_token (pfile); 945 946 result->type = CPP_PADDING; 947 948 /* Data in GCed data structures cannot be made const so far, so we 949 need a cast here. */ 950 result->val.source = (cpp_token *) source; 951 result->flags = 0; 952 return result; 953} 954 955/* Get a new uninitialized context. Create a new one if we cannot 956 re-use an old one. */ 957static cpp_context * 958next_context (cpp_reader *pfile) 959{ 960 cpp_context *result = pfile->context->next; 961 962 if (result == 0) 963 { 964 result = XNEW (cpp_context); 965 result->prev = pfile->context; 966 result->next = 0; 967 pfile->context->next = result; 968 } 969 970 pfile->context = result; 971 return result; 972} 973 974/* Push a list of pointers to tokens. */ 975static void 976push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff, 977 const cpp_token **first, unsigned int count) 978{ 979 cpp_context *context = next_context (pfile); 980 981 context->direct_p = false; 982 context->macro = macro; 983 context->buff = buff; 984 FIRST (context).ptoken = first; 985 LAST (context).ptoken = first + count; 986} 987 988/* Push a list of tokens. */ 989void 990_cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro, 991 const cpp_token *first, unsigned int count) 992{ 993 cpp_context *context = next_context (pfile); 994 995 context->direct_p = true; 996 context->macro = macro; 997 context->buff = NULL; 998 FIRST (context).token = first; 999 LAST (context).token = first + count; 1000} 1001 1002/* Push a traditional macro's replacement text. */ 1003void 1004_cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro, 1005 const uchar *start, size_t len) 1006{ 1007 cpp_context *context = next_context (pfile); 1008 1009 context->direct_p = true; 1010 context->macro = macro; 1011 context->buff = NULL; 1012 CUR (context) = start; 1013 RLIMIT (context) = start + len; 1014 macro->flags |= NODE_DISABLED; 1015} 1016 1017/* Expand an argument ARG before replacing parameters in a 1018 function-like macro. This works by pushing a context with the 1019 argument's tokens, and then expanding that into a temporary buffer 1020 as if it were a normal part of the token stream. collect_args() 1021 has terminated the argument's tokens with a CPP_EOF so that we know 1022 when we have fully expanded the argument. */ 1023static void 1024expand_arg (cpp_reader *pfile, macro_arg *arg) 1025{ 1026 unsigned int capacity; 1027 bool saved_warn_trad; 1028 1029 if (arg->count == 0) 1030 return; 1031 1032 /* Don't warn about funlike macros when pre-expanding. */ 1033 saved_warn_trad = CPP_WTRADITIONAL (pfile); 1034 CPP_WTRADITIONAL (pfile) = 0; 1035 1036 /* Loop, reading in the arguments. */ 1037 capacity = 256; 1038 arg->expanded = XNEWVEC (const cpp_token *, capacity); 1039 1040 push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1); 1041 for (;;) 1042 { 1043 const cpp_token *token; 1044 1045 if (arg->expanded_count + 1 >= capacity) 1046 { 1047 capacity *= 2; 1048 arg->expanded = XRESIZEVEC (const cpp_token *, arg->expanded, 1049 capacity); 1050 } 1051 1052 token = cpp_get_token (pfile); 1053 1054 if (token->type == CPP_EOF) 1055 break; 1056 1057 arg->expanded[arg->expanded_count++] = token; 1058 } 1059 1060 _cpp_pop_context (pfile); 1061 1062 CPP_WTRADITIONAL (pfile) = saved_warn_trad; 1063} 1064 1065/* Pop the current context off the stack, re-enabling the macro if the 1066 context represented a macro's replacement list. The context 1067 structure is not freed so that we can re-use it later. */ 1068void 1069_cpp_pop_context (cpp_reader *pfile) 1070{ 1071 cpp_context *context = pfile->context; 1072 1073 if (context->macro) 1074 context->macro->flags &= ~NODE_DISABLED; 1075 1076 if (context->buff) 1077 _cpp_release_buff (pfile, context->buff); 1078 1079 pfile->context = context->prev; 1080} 1081 1082/* External routine to get a token. Also used nearly everywhere 1083 internally, except for places where we know we can safely call 1084 _cpp_lex_token directly, such as lexing a directive name. 1085 1086 Macro expansions and directives are transparently handled, 1087 including entering included files. Thus tokens are post-macro 1088 expansion, and after any intervening directives. External callers 1089 see CPP_EOF only at EOF. Internal callers also see it when meeting 1090 a directive inside a macro call, when at the end of a directive and 1091 state.in_directive is still 1, and at the end of argument 1092 pre-expansion. */ 1093const cpp_token * 1094cpp_get_token (cpp_reader *pfile) 1095{ 1096 const cpp_token *result; 1097 1098 for (;;) 1099 { 1100 cpp_hashnode *node; 1101 cpp_context *context = pfile->context; 1102 1103 /* Context->prev == 0 <=> base context. */ 1104 if (!context->prev) 1105 result = _cpp_lex_token (pfile); 1106 else if (FIRST (context).token != LAST (context).token) 1107 { 1108 if (context->direct_p) 1109 result = FIRST (context).token++; 1110 else 1111 result = *FIRST (context).ptoken++; 1112 1113 if (result->flags & PASTE_LEFT) 1114 { 1115 paste_all_tokens (pfile, result); 1116 if (pfile->state.in_directive) 1117 continue; 1118 return padding_token (pfile, result); 1119 } 1120 } 1121 else 1122 { 1123 _cpp_pop_context (pfile); 1124 if (pfile->state.in_directive) 1125 continue; 1126 return &pfile->avoid_paste; 1127 } 1128 1129 if (pfile->state.in_directive && result->type == CPP_COMMENT) 1130 continue; 1131 1132 if (result->type != CPP_NAME) 1133 break; 1134 1135 node = result->val.node; 1136 1137 if (node->type != NT_MACRO || (result->flags & NO_EXPAND)) 1138 break; 1139 1140 if (!(node->flags & NODE_DISABLED)) 1141 { 1142 if (!pfile->state.prevent_expansion 1143 && enter_macro_context (pfile, node)) 1144 { 1145 if (pfile->state.in_directive) 1146 continue; 1147 return padding_token (pfile, result); 1148 } 1149 } 1150 else 1151 { 1152 /* Flag this token as always unexpandable. FIXME: move this 1153 to collect_args()?. */ 1154 cpp_token *t = _cpp_temp_token (pfile); 1155 t->type = result->type; 1156 t->flags = result->flags | NO_EXPAND; 1157 t->val = result->val; 1158 result = t; 1159 } 1160 1161 break; 1162 } 1163 1164 return result; 1165} 1166 1167/* Returns true if we're expanding an object-like macro that was 1168 defined in a system header. Just checks the macro at the top of 1169 the stack. Used for diagnostic suppression. */ 1170int 1171cpp_sys_macro_p (cpp_reader *pfile) 1172{ 1173 cpp_hashnode *node = pfile->context->macro; 1174 1175 return node && node->value.macro && node->value.macro->syshdr; 1176} 1177 1178/* Read each token in, until end of the current file. Directives are 1179 transparently processed. */ 1180void 1181cpp_scan_nooutput (cpp_reader *pfile) 1182{ 1183 /* Request a CPP_EOF token at the end of this file, rather than 1184 transparently continuing with the including file. */ 1185 pfile->buffer->return_at_eof = true; 1186 1187 pfile->state.discarding_output++; 1188 pfile->state.prevent_expansion++; 1189 1190 if (CPP_OPTION (pfile, traditional)) 1191 while (_cpp_read_logical_line_trad (pfile)) 1192 ; 1193 else 1194 while (cpp_get_token (pfile)->type != CPP_EOF) 1195 ; 1196 1197 pfile->state.discarding_output--; 1198 pfile->state.prevent_expansion--; 1199} 1200 1201/* Step back one (or more) tokens. Can only step back more than 1 if 1202 they are from the lexer, and not from macro expansion. */ 1203void 1204_cpp_backup_tokens (cpp_reader *pfile, unsigned int count) 1205{ 1206 if (pfile->context->prev == NULL) 1207 { 1208 pfile->lookaheads += count; 1209 while (count--) 1210 { 1211 pfile->cur_token--; 1212 if (pfile->cur_token == pfile->cur_run->base 1213 /* Possible with -fpreprocessed and no leading #line. */ 1214 && pfile->cur_run->prev != NULL) 1215 { 1216 pfile->cur_run = pfile->cur_run->prev; 1217 pfile->cur_token = pfile->cur_run->limit; 1218 } 1219 } 1220 } 1221 else 1222 { 1223 if (count != 1) 1224 abort (); 1225 if (pfile->context->direct_p) 1226 FIRST (pfile->context).token--; 1227 else 1228 FIRST (pfile->context).ptoken--; 1229 } 1230} 1231 1232/* #define directive parsing and handling. */ 1233 1234/* Returns nonzero if a macro redefinition warning is required. */ 1235static bool 1236warn_of_redefinition (cpp_reader *pfile, const cpp_hashnode *node, 1237 const cpp_macro *macro2) 1238{ 1239 const cpp_macro *macro1; 1240 unsigned int i; 1241 1242 /* Some redefinitions need to be warned about regardless. */ 1243 if (node->flags & NODE_WARN) 1244 return true; 1245 1246 /* Redefinition of a macro is allowed if and only if the old and new 1247 definitions are the same. (6.10.3 paragraph 2). */ 1248 macro1 = node->value.macro; 1249 1250 /* Don't check count here as it can be different in valid 1251 traditional redefinitions with just whitespace differences. */ 1252 if (macro1->paramc != macro2->paramc 1253 || macro1->fun_like != macro2->fun_like 1254 || macro1->variadic != macro2->variadic) 1255 return true; 1256 1257 /* Check parameter spellings. */ 1258 for (i = 0; i < macro1->paramc; i++) 1259 if (macro1->params[i] != macro2->params[i]) 1260 return true; 1261 1262 /* Check the replacement text or tokens. */ 1263 if (CPP_OPTION (pfile, traditional)) 1264 return _cpp_expansions_different_trad (macro1, macro2); 1265 1266 if (macro1->count != macro2->count) 1267 return true; 1268 1269 for (i = 0; i < macro1->count; i++) 1270 if (!_cpp_equiv_tokens (¯o1->exp.tokens[i], ¯o2->exp.tokens[i])) 1271 return true; 1272 1273 return false; 1274} 1275 1276/* Free the definition of hashnode H. */ 1277void 1278_cpp_free_definition (cpp_hashnode *h) 1279{ 1280 /* Macros and assertions no longer have anything to free. */ 1281 h->type = NT_VOID; 1282 /* Clear builtin flag in case of redefinition. */ 1283 h->flags &= ~(NODE_BUILTIN | NODE_DISABLED); 1284} 1285 1286/* Save parameter NODE to the parameter list of macro MACRO. Returns 1287 zero on success, nonzero if the parameter is a duplicate. */ 1288bool 1289_cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node) 1290{ 1291 unsigned int len; 1292 /* Constraint 6.10.3.6 - duplicate parameter names. */ 1293 if (node->flags & NODE_MACRO_ARG) 1294 { 1295 cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"", 1296 NODE_NAME (node)); 1297 return true; 1298 } 1299 1300 if (BUFF_ROOM (pfile->a_buff) 1301 < (macro->paramc + 1) * sizeof (cpp_hashnode *)) 1302 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *)); 1303 1304 ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node; 1305 node->flags |= NODE_MACRO_ARG; 1306 len = macro->paramc * sizeof (union _cpp_hashnode_value); 1307 if (len > pfile->macro_buffer_len) 1308 { 1309 pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer, 1310 len); 1311 pfile->macro_buffer_len = len; 1312 } 1313 ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1] 1314 = node->value; 1315 1316 node->value.arg_index = macro->paramc; 1317 return false; 1318} 1319 1320/* Check the syntax of the parameters in a MACRO definition. Returns 1321 false if an error occurs. */ 1322static bool 1323parse_params (cpp_reader *pfile, cpp_macro *macro) 1324{ 1325 unsigned int prev_ident = 0; 1326 1327 for (;;) 1328 { 1329 const cpp_token *token = _cpp_lex_token (pfile); 1330 1331 switch (token->type) 1332 { 1333 default: 1334 /* Allow/ignore comments in parameter lists if we are 1335 preserving comments in macro expansions. */ 1336 if (token->type == CPP_COMMENT 1337 && ! CPP_OPTION (pfile, discard_comments_in_macro_exp)) 1338 continue; 1339 1340 cpp_error (pfile, CPP_DL_ERROR, 1341 "\"%s\" may not appear in macro parameter list", 1342 cpp_token_as_text (pfile, token)); 1343 return false; 1344 1345 case CPP_NAME: 1346 if (prev_ident) 1347 { 1348 cpp_error (pfile, CPP_DL_ERROR, 1349 "macro parameters must be comma-separated"); 1350 return false; 1351 } 1352 prev_ident = 1; 1353 1354 if (_cpp_save_parameter (pfile, macro, token->val.node)) 1355 return false; 1356 continue; 1357 1358 case CPP_CLOSE_PAREN: 1359 if (prev_ident || macro->paramc == 0) 1360 return true; 1361 1362 /* Fall through to pick up the error. */ 1363 case CPP_COMMA: 1364 if (!prev_ident) 1365 { 1366 cpp_error (pfile, CPP_DL_ERROR, "parameter name missing"); 1367 return false; 1368 } 1369 prev_ident = 0; 1370 continue; 1371 1372 case CPP_ELLIPSIS: 1373 macro->variadic = 1; 1374 if (!prev_ident) 1375 { 1376 _cpp_save_parameter (pfile, macro, 1377 pfile->spec_nodes.n__VA_ARGS__); 1378 pfile->state.va_args_ok = 1; 1379 if (! CPP_OPTION (pfile, c99) 1380 && CPP_OPTION (pfile, pedantic) 1381 && CPP_OPTION (pfile, warn_variadic_macros)) 1382 cpp_error (pfile, CPP_DL_PEDWARN, 1383 "anonymous variadic macros were introduced in C99"); 1384 } 1385 else if (CPP_OPTION (pfile, pedantic) 1386 && CPP_OPTION (pfile, warn_variadic_macros)) 1387 cpp_error (pfile, CPP_DL_PEDWARN, 1388 "ISO C does not permit named variadic macros"); 1389 1390 /* We're at the end, and just expect a closing parenthesis. */ 1391 token = _cpp_lex_token (pfile); 1392 if (token->type == CPP_CLOSE_PAREN) 1393 return true; 1394 /* Fall through. */ 1395 1396 case CPP_EOF: 1397 cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list"); 1398 return false; 1399 } 1400 } 1401} 1402 1403/* Allocate room for a token from a macro's replacement list. */ 1404static cpp_token * 1405alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro) 1406{ 1407 if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token)) 1408 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token)); 1409 1410 return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++]; 1411} 1412 1413/* Lex a token from the expansion of MACRO, but mark parameters as we 1414 find them and warn of traditional stringification. */ 1415static cpp_token * 1416lex_expansion_token (cpp_reader *pfile, cpp_macro *macro) 1417{ 1418 cpp_token *token, *saved_cur_token; 1419 1420 saved_cur_token = pfile->cur_token; 1421 pfile->cur_token = alloc_expansion_token (pfile, macro); 1422 token = _cpp_lex_direct (pfile); 1423 pfile->cur_token = saved_cur_token; 1424 1425 /* Is this a parameter? */ 1426 if (token->type == CPP_NAME 1427 && (token->val.node->flags & NODE_MACRO_ARG) != 0) 1428 { 1429 token->type = CPP_MACRO_ARG; 1430 token->val.arg_no = token->val.node->value.arg_index; 1431 } 1432 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0 1433 && (token->type == CPP_STRING || token->type == CPP_CHAR)) 1434 check_trad_stringification (pfile, macro, &token->val.str); 1435 1436 return token; 1437} 1438 1439static bool 1440create_iso_definition (cpp_reader *pfile, cpp_macro *macro) 1441{ 1442 cpp_token *token; 1443 const cpp_token *ctoken; 1444 1445 /* Get the first token of the expansion (or the '(' of a 1446 function-like macro). */ 1447 ctoken = _cpp_lex_token (pfile); 1448 1449 if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE)) 1450 { 1451 bool ok = parse_params (pfile, macro); 1452 macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff); 1453 if (!ok) 1454 return false; 1455 1456 /* Success. Commit or allocate the parameter array. */ 1457 if (pfile->hash_table->alloc_subobject) 1458 { 1459 cpp_hashnode **params = 1460 (cpp_hashnode **) pfile->hash_table->alloc_subobject 1461 (sizeof (cpp_hashnode *) * macro->paramc); 1462 memcpy (params, macro->params, 1463 sizeof (cpp_hashnode *) * macro->paramc); 1464 macro->params = params; 1465 } 1466 else 1467 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->params[macro->paramc]; 1468 macro->fun_like = 1; 1469 } 1470 else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE)) 1471 { 1472 /* While ISO C99 requires whitespace before replacement text 1473 in a macro definition, ISO C90 with TC1 allows there characters 1474 from the basic source character set. */ 1475 if (CPP_OPTION (pfile, c99)) 1476 cpp_error (pfile, CPP_DL_PEDWARN, 1477 "ISO C99 requires whitespace after the macro name"); 1478 else 1479 { 1480 int warntype = CPP_DL_WARNING; 1481 switch (ctoken->type) 1482 { 1483 case CPP_ATSIGN: 1484 case CPP_AT_NAME: 1485 case CPP_OBJC_STRING: 1486 /* '@' is not in basic character set. */ 1487 warntype = CPP_DL_PEDWARN; 1488 break; 1489 case CPP_OTHER: 1490 /* Basic character set sans letters, digits and _. */ 1491 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~", 1492 ctoken->val.str.text[0]) == NULL) 1493 warntype = CPP_DL_PEDWARN; 1494 break; 1495 default: 1496 /* All other tokens start with a character from basic 1497 character set. */ 1498 break; 1499 } 1500 cpp_error (pfile, warntype, 1501 "missing whitespace after the macro name"); 1502 } 1503 } 1504 1505 if (macro->fun_like) 1506 token = lex_expansion_token (pfile, macro); 1507 else 1508 { 1509 token = alloc_expansion_token (pfile, macro); 1510 *token = *ctoken; 1511 } 1512 1513 for (;;) 1514 { 1515 /* Check the stringifying # constraint 6.10.3.2.1 of 1516 function-like macros when lexing the subsequent token. */ 1517 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like) 1518 { 1519 if (token->type == CPP_MACRO_ARG) 1520 { 1521 token->flags &= ~PREV_WHITE; 1522 token->flags |= STRINGIFY_ARG; 1523 token->flags |= token[-1].flags & PREV_WHITE; 1524 token[-1] = token[0]; 1525 macro->count--; 1526 } 1527 /* Let assembler get away with murder. */ 1528 else if (CPP_OPTION (pfile, lang) != CLK_ASM) 1529 { 1530 cpp_error (pfile, CPP_DL_ERROR, 1531 "'#' is not followed by a macro parameter"); 1532 return false; 1533 } 1534 } 1535 1536 if (token->type == CPP_EOF) 1537 break; 1538 1539 /* Paste operator constraint 6.10.3.3.1. */ 1540 if (token->type == CPP_PASTE) 1541 { 1542 /* Token-paste ##, can appear in both object-like and 1543 function-like macros, but not at the ends. */ 1544 if (--macro->count > 0) 1545 token = lex_expansion_token (pfile, macro); 1546 1547 if (macro->count == 0 || token->type == CPP_EOF) 1548 { 1549 cpp_error (pfile, CPP_DL_ERROR, 1550 "'##' cannot appear at either end of a macro expansion"); 1551 return false; 1552 } 1553 1554 token[-1].flags |= PASTE_LEFT; 1555 } 1556 1557 token = lex_expansion_token (pfile, macro); 1558 } 1559 1560 macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff); 1561 macro->traditional = 0; 1562 1563 /* Don't count the CPP_EOF. */ 1564 macro->count--; 1565 1566 /* Clear whitespace on first token for warn_of_redefinition(). */ 1567 if (macro->count) 1568 macro->exp.tokens[0].flags &= ~PREV_WHITE; 1569 1570 /* Commit or allocate the memory. */ 1571 if (pfile->hash_table->alloc_subobject) 1572 { 1573 cpp_token *tokns = 1574 (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token) 1575 * macro->count); 1576 memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count); 1577 macro->exp.tokens = tokns; 1578 } 1579 else 1580 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->exp.tokens[macro->count]; 1581 1582 return true; 1583} 1584 1585/* Parse a macro and save its expansion. Returns nonzero on success. */ 1586bool 1587_cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node) 1588{ 1589 cpp_macro *macro; 1590 unsigned int i; 1591 bool ok; 1592 1593 if (pfile->hash_table->alloc_subobject) 1594 macro = (cpp_macro *) pfile->hash_table->alloc_subobject 1595 (sizeof (cpp_macro)); 1596 else 1597 macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro)); 1598 macro->line = pfile->directive_line; 1599 macro->params = 0; 1600 macro->paramc = 0; 1601 macro->variadic = 0; 1602 macro->used = !CPP_OPTION (pfile, warn_unused_macros); 1603 macro->count = 0; 1604 macro->fun_like = 0; 1605 /* To suppress some diagnostics. */ 1606 macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0; 1607 1608 if (CPP_OPTION (pfile, traditional)) 1609 ok = _cpp_create_trad_definition (pfile, macro); 1610 else 1611 { 1612 ok = create_iso_definition (pfile, macro); 1613 1614 /* We set the type for SEEN_EOL() in directives.c. 1615 1616 Longer term we should lex the whole line before coming here, 1617 and just copy the expansion. */ 1618 1619 /* Stop the lexer accepting __VA_ARGS__. */ 1620 pfile->state.va_args_ok = 0; 1621 } 1622 1623 /* Clear the fast argument lookup indices. */ 1624 for (i = macro->paramc; i-- > 0; ) 1625 { 1626 struct cpp_hashnode *node = macro->params[i]; 1627 node->flags &= ~ NODE_MACRO_ARG; 1628 node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i]; 1629 } 1630 1631 if (!ok) 1632 return ok; 1633 1634 if (node->type == NT_MACRO) 1635 { 1636 if (CPP_OPTION (pfile, warn_unused_macros)) 1637 _cpp_warn_if_unused_macro (pfile, node, NULL); 1638 1639 if (warn_of_redefinition (pfile, node, macro)) 1640 { 1641 cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->directive_line, 0, 1642 "\"%s\" redefined", NODE_NAME (node)); 1643 1644 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN)) 1645 cpp_error_with_line (pfile, CPP_DL_PEDWARN, 1646 node->value.macro->line, 0, 1647 "this is the location of the previous definition"); 1648 } 1649 } 1650 1651 if (node->type != NT_VOID) 1652 _cpp_free_definition (node); 1653 1654 /* Enter definition in hash table. */ 1655 node->type = NT_MACRO; 1656 node->value.macro = macro; 1657 if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_"))) 1658 node->flags |= NODE_WARN; 1659 1660 return ok; 1661} 1662 1663/* Warn if a token in STRING matches one of a function-like MACRO's 1664 parameters. */ 1665static void 1666check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro, 1667 const cpp_string *string) 1668{ 1669 unsigned int i, len; 1670 const uchar *p, *q, *limit; 1671 1672 /* Loop over the string. */ 1673 limit = string->text + string->len - 1; 1674 for (p = string->text + 1; p < limit; p = q) 1675 { 1676 /* Find the start of an identifier. */ 1677 while (p < limit && !is_idstart (*p)) 1678 p++; 1679 1680 /* Find the end of the identifier. */ 1681 q = p; 1682 while (q < limit && is_idchar (*q)) 1683 q++; 1684 1685 len = q - p; 1686 1687 /* Loop over the function macro arguments to see if the 1688 identifier inside the string matches one of them. */ 1689 for (i = 0; i < macro->paramc; i++) 1690 { 1691 const cpp_hashnode *node = macro->params[i]; 1692 1693 if (NODE_LEN (node) == len 1694 && !memcmp (p, NODE_NAME (node), len)) 1695 { 1696 cpp_error (pfile, CPP_DL_WARNING, 1697 "macro argument \"%s\" would be stringified in traditional C", 1698 NODE_NAME (node)); 1699 break; 1700 } 1701 } 1702 } 1703} 1704 1705/* Returns the name, arguments and expansion of a macro, in a format 1706 suitable to be read back in again, and therefore also for DWARF 2 1707 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION". 1708 Caller is expected to generate the "#define" bit if needed. The 1709 returned text is temporary, and automatically freed later. */ 1710const unsigned char * 1711cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node) 1712{ 1713 unsigned int i, len; 1714 const cpp_macro *macro = node->value.macro; 1715 unsigned char *buffer; 1716 1717 if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN)) 1718 { 1719 cpp_error (pfile, CPP_DL_ICE, 1720 "invalid hash type %d in cpp_macro_definition", node->type); 1721 return 0; 1722 } 1723 1724 /* Calculate length. */ 1725 len = NODE_LEN (node) + 2; /* ' ' and NUL. */ 1726 if (macro->fun_like) 1727 { 1728 len += 4; /* "()" plus possible final ".." of named 1729 varargs (we have + 1 below). */ 1730 for (i = 0; i < macro->paramc; i++) 1731 len += NODE_LEN (macro->params[i]) + 1; /* "," */ 1732 } 1733 1734 /* This should match below where we fill in the buffer. */ 1735 if (CPP_OPTION (pfile, traditional)) 1736 len += _cpp_replacement_text_len (macro); 1737 else 1738 { 1739 for (i = 0; i < macro->count; i++) 1740 { 1741 cpp_token *token = ¯o->exp.tokens[i]; 1742 1743 if (token->type == CPP_MACRO_ARG) 1744 len += NODE_LEN (macro->params[token->val.arg_no - 1]); 1745 else 1746 len += cpp_token_len (token); 1747 1748 if (token->flags & STRINGIFY_ARG) 1749 len++; /* "#" */ 1750 if (token->flags & PASTE_LEFT) 1751 len += 3; /* " ##" */ 1752 if (token->flags & PREV_WHITE) 1753 len++; /* " " */ 1754 } 1755 } 1756 1757 if (len > pfile->macro_buffer_len) 1758 { 1759 pfile->macro_buffer = XRESIZEVEC (unsigned char, 1760 pfile->macro_buffer, len); 1761 pfile->macro_buffer_len = len; 1762 } 1763 1764 /* Fill in the buffer. Start with the macro name. */ 1765 buffer = pfile->macro_buffer; 1766 memcpy (buffer, NODE_NAME (node), NODE_LEN (node)); 1767 buffer += NODE_LEN (node); 1768 1769 /* Parameter names. */ 1770 if (macro->fun_like) 1771 { 1772 *buffer++ = '('; 1773 for (i = 0; i < macro->paramc; i++) 1774 { 1775 cpp_hashnode *param = macro->params[i]; 1776 1777 if (param != pfile->spec_nodes.n__VA_ARGS__) 1778 { 1779 memcpy (buffer, NODE_NAME (param), NODE_LEN (param)); 1780 buffer += NODE_LEN (param); 1781 } 1782 1783 if (i + 1 < macro->paramc) 1784 /* Don't emit a space after the comma here; we're trying 1785 to emit a Dwarf-friendly definition, and the Dwarf spec 1786 forbids spaces in the argument list. */ 1787 *buffer++ = ','; 1788 else if (macro->variadic) 1789 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.'; 1790 } 1791 *buffer++ = ')'; 1792 } 1793 1794 /* The Dwarf spec requires a space after the macro name, even if the 1795 definition is the empty string. */ 1796 *buffer++ = ' '; 1797 1798 if (CPP_OPTION (pfile, traditional)) 1799 buffer = _cpp_copy_replacement_text (macro, buffer); 1800 else if (macro->count) 1801 /* Expansion tokens. */ 1802 { 1803 for (i = 0; i < macro->count; i++) 1804 { 1805 cpp_token *token = ¯o->exp.tokens[i]; 1806 1807 if (token->flags & PREV_WHITE) 1808 *buffer++ = ' '; 1809 if (token->flags & STRINGIFY_ARG) 1810 *buffer++ = '#'; 1811 1812 if (token->type == CPP_MACRO_ARG) 1813 { 1814 memcpy (buffer, 1815 NODE_NAME (macro->params[token->val.arg_no - 1]), 1816 NODE_LEN (macro->params[token->val.arg_no - 1])); 1817 buffer += NODE_LEN (macro->params[token->val.arg_no - 1]); 1818 } 1819 else 1820 buffer = cpp_spell_token (pfile, token, buffer, false); 1821 1822 if (token->flags & PASTE_LEFT) 1823 { 1824 *buffer++ = ' '; 1825 *buffer++ = '#'; 1826 *buffer++ = '#'; 1827 /* Next has PREV_WHITE; see _cpp_create_definition. */ 1828 } 1829 } 1830 } 1831 1832 *buffer = '\0'; 1833 return pfile->macro_buffer; 1834} 1835