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