1 /* C preprocessor macro expansion for GDB. 2 Copyright (C) 2002, 2007, 2008, 2009, 2010, 2011 3 Free Software Foundation, Inc. 4 Contributed by Red Hat, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 #include "defs.h" 22 #include "gdb_obstack.h" 23 #include "bcache.h" 24 #include "macrotab.h" 25 #include "macroexp.h" 26 #include "gdb_assert.h" 27 #include "c-lang.h" 28 29 30 31 /* A resizeable, substringable string type. */ 32 33 34 /* A string type that we can resize, quickly append to, and use to 35 refer to substrings of other strings. */ 36 struct macro_buffer 37 { 38 /* An array of characters. The first LEN bytes are the real text, 39 but there are SIZE bytes allocated to the array. If SIZE is 40 zero, then this doesn't point to a malloc'ed block. If SHARED is 41 non-zero, then this buffer is actually a pointer into some larger 42 string, and we shouldn't append characters to it, etc. Because 43 of sharing, we can't assume in general that the text is 44 null-terminated. */ 45 char *text; 46 47 /* The number of characters in the string. */ 48 int len; 49 50 /* The number of characters allocated to the string. If SHARED is 51 non-zero, this is meaningless; in this case, we set it to zero so 52 that any "do we have room to append something?" tests will fail, 53 so we don't always have to check SHARED before using this field. */ 54 int size; 55 56 /* Zero if TEXT can be safely realloc'ed (i.e., it's its own malloc 57 block). Non-zero if TEXT is actually pointing into the middle of 58 some other block, and we shouldn't reallocate it. */ 59 int shared; 60 61 /* For detecting token splicing. 62 63 This is the index in TEXT of the first character of the token 64 that abuts the end of TEXT. If TEXT contains no tokens, then we 65 set this equal to LEN. If TEXT ends in whitespace, then there is 66 no token abutting the end of TEXT (it's just whitespace), and 67 again, we set this equal to LEN. We set this to -1 if we don't 68 know the nature of TEXT. */ 69 int last_token; 70 71 /* If this buffer is holding the result from get_token, then this 72 is non-zero if it is an identifier token, zero otherwise. */ 73 int is_identifier; 74 }; 75 76 77 /* Set the macro buffer *B to the empty string, guessing that its 78 final contents will fit in N bytes. (It'll get resized if it 79 doesn't, so the guess doesn't have to be right.) Allocate the 80 initial storage with xmalloc. */ 81 static void 82 init_buffer (struct macro_buffer *b, int n) 83 { 84 b->size = n; 85 if (n > 0) 86 b->text = (char *) xmalloc (n); 87 else 88 b->text = NULL; 89 b->len = 0; 90 b->shared = 0; 91 b->last_token = -1; 92 } 93 94 95 /* Set the macro buffer *BUF to refer to the LEN bytes at ADDR, as a 96 shared substring. */ 97 static void 98 init_shared_buffer (struct macro_buffer *buf, char *addr, int len) 99 { 100 buf->text = addr; 101 buf->len = len; 102 buf->shared = 1; 103 buf->size = 0; 104 buf->last_token = -1; 105 } 106 107 108 /* Free the text of the buffer B. Raise an error if B is shared. */ 109 static void 110 free_buffer (struct macro_buffer *b) 111 { 112 gdb_assert (! b->shared); 113 if (b->size) 114 xfree (b->text); 115 } 116 117 118 /* A cleanup function for macro buffers. */ 119 static void 120 cleanup_macro_buffer (void *untyped_buf) 121 { 122 free_buffer ((struct macro_buffer *) untyped_buf); 123 } 124 125 126 /* Resize the buffer B to be at least N bytes long. Raise an error if 127 B shouldn't be resized. */ 128 static void 129 resize_buffer (struct macro_buffer *b, int n) 130 { 131 /* We shouldn't be trying to resize shared strings. */ 132 gdb_assert (! b->shared); 133 134 if (b->size == 0) 135 b->size = n; 136 else 137 while (b->size <= n) 138 b->size *= 2; 139 140 b->text = xrealloc (b->text, b->size); 141 } 142 143 144 /* Append the character C to the buffer B. */ 145 static void 146 appendc (struct macro_buffer *b, int c) 147 { 148 int new_len = b->len + 1; 149 150 if (new_len > b->size) 151 resize_buffer (b, new_len); 152 153 b->text[b->len] = c; 154 b->len = new_len; 155 } 156 157 158 /* Append the LEN bytes at ADDR to the buffer B. */ 159 static void 160 appendmem (struct macro_buffer *b, char *addr, int len) 161 { 162 int new_len = b->len + len; 163 164 if (new_len > b->size) 165 resize_buffer (b, new_len); 166 167 memcpy (b->text + b->len, addr, len); 168 b->len = new_len; 169 } 170 171 172 173 /* Recognizing preprocessor tokens. */ 174 175 176 int 177 macro_is_whitespace (int c) 178 { 179 return (c == ' ' 180 || c == '\t' 181 || c == '\n' 182 || c == '\v' 183 || c == '\f'); 184 } 185 186 187 int 188 macro_is_digit (int c) 189 { 190 return ('0' <= c && c <= '9'); 191 } 192 193 194 int 195 macro_is_identifier_nondigit (int c) 196 { 197 return (c == '_' 198 || ('a' <= c && c <= 'z') 199 || ('A' <= c && c <= 'Z')); 200 } 201 202 203 static void 204 set_token (struct macro_buffer *tok, char *start, char *end) 205 { 206 init_shared_buffer (tok, start, end - start); 207 tok->last_token = 0; 208 209 /* Presumed; get_identifier may overwrite this. */ 210 tok->is_identifier = 0; 211 } 212 213 214 static int 215 get_comment (struct macro_buffer *tok, char *p, char *end) 216 { 217 if (p + 2 > end) 218 return 0; 219 else if (p[0] == '/' 220 && p[1] == '*') 221 { 222 char *tok_start = p; 223 224 p += 2; 225 226 for (; p < end; p++) 227 if (p + 2 <= end 228 && p[0] == '*' 229 && p[1] == '/') 230 { 231 p += 2; 232 set_token (tok, tok_start, p); 233 return 1; 234 } 235 236 error (_("Unterminated comment in macro expansion.")); 237 } 238 else if (p[0] == '/' 239 && p[1] == '/') 240 { 241 char *tok_start = p; 242 243 p += 2; 244 for (; p < end; p++) 245 if (*p == '\n') 246 break; 247 248 set_token (tok, tok_start, p); 249 return 1; 250 } 251 else 252 return 0; 253 } 254 255 256 static int 257 get_identifier (struct macro_buffer *tok, char *p, char *end) 258 { 259 if (p < end 260 && macro_is_identifier_nondigit (*p)) 261 { 262 char *tok_start = p; 263 264 while (p < end 265 && (macro_is_identifier_nondigit (*p) 266 || macro_is_digit (*p))) 267 p++; 268 269 set_token (tok, tok_start, p); 270 tok->is_identifier = 1; 271 return 1; 272 } 273 else 274 return 0; 275 } 276 277 278 static int 279 get_pp_number (struct macro_buffer *tok, char *p, char *end) 280 { 281 if (p < end 282 && (macro_is_digit (*p) 283 || (*p == '.' 284 && p + 2 <= end 285 && macro_is_digit (p[1])))) 286 { 287 char *tok_start = p; 288 289 while (p < end) 290 { 291 if (p + 2 <= end 292 && strchr ("eEpP", *p) 293 && (p[1] == '+' || p[1] == '-')) 294 p += 2; 295 else if (macro_is_digit (*p) 296 || macro_is_identifier_nondigit (*p) 297 || *p == '.') 298 p++; 299 else 300 break; 301 } 302 303 set_token (tok, tok_start, p); 304 return 1; 305 } 306 else 307 return 0; 308 } 309 310 311 312 /* If the text starting at P going up to (but not including) END 313 starts with a character constant, set *TOK to point to that 314 character constant, and return 1. Otherwise, return zero. 315 Signal an error if it contains a malformed or incomplete character 316 constant. */ 317 static int 318 get_character_constant (struct macro_buffer *tok, char *p, char *end) 319 { 320 /* ISO/IEC 9899:1999 (E) Section 6.4.4.4 paragraph 1 321 But of course, what really matters is that we handle it the same 322 way GDB's C/C++ lexer does. So we call parse_escape in utils.c 323 to handle escape sequences. */ 324 if ((p + 1 <= end && *p == '\'') 325 || (p + 2 <= end 326 && (p[0] == 'L' || p[0] == 'u' || p[0] == 'U') 327 && p[1] == '\'')) 328 { 329 char *tok_start = p; 330 char *body_start; 331 int char_count = 0; 332 333 if (*p == '\'') 334 p++; 335 else if (*p == 'L' || *p == 'u' || *p == 'U') 336 p += 2; 337 else 338 gdb_assert_not_reached ("unexpected character constant"); 339 340 body_start = p; 341 for (;;) 342 { 343 if (p >= end) 344 error (_("Unmatched single quote.")); 345 else if (*p == '\'') 346 { 347 if (!char_count) 348 error (_("A character constant must contain at least one " 349 "character.")); 350 p++; 351 break; 352 } 353 else if (*p == '\\') 354 { 355 p++; 356 char_count += c_parse_escape (&p, NULL); 357 } 358 else 359 { 360 p++; 361 char_count++; 362 } 363 } 364 365 set_token (tok, tok_start, p); 366 return 1; 367 } 368 else 369 return 0; 370 } 371 372 373 /* If the text starting at P going up to (but not including) END 374 starts with a string literal, set *TOK to point to that string 375 literal, and return 1. Otherwise, return zero. Signal an error if 376 it contains a malformed or incomplete string literal. */ 377 static int 378 get_string_literal (struct macro_buffer *tok, char *p, char *end) 379 { 380 if ((p + 1 <= end 381 && *p == '"') 382 || (p + 2 <= end 383 && (p[0] == 'L' || p[0] == 'u' || p[0] == 'U') 384 && p[1] == '"')) 385 { 386 char *tok_start = p; 387 388 if (*p == '"') 389 p++; 390 else if (*p == 'L' || *p == 'u' || *p == 'U') 391 p += 2; 392 else 393 gdb_assert_not_reached ("unexpected string literal"); 394 395 for (;;) 396 { 397 if (p >= end) 398 error (_("Unterminated string in expression.")); 399 else if (*p == '"') 400 { 401 p++; 402 break; 403 } 404 else if (*p == '\n') 405 error (_("Newline characters may not appear in string " 406 "constants.")); 407 else if (*p == '\\') 408 { 409 p++; 410 c_parse_escape (&p, NULL); 411 } 412 else 413 p++; 414 } 415 416 set_token (tok, tok_start, p); 417 return 1; 418 } 419 else 420 return 0; 421 } 422 423 424 static int 425 get_punctuator (struct macro_buffer *tok, char *p, char *end) 426 { 427 /* Here, speed is much less important than correctness and clarity. */ 428 429 /* ISO/IEC 9899:1999 (E) Section 6.4.6 Paragraph 1. 430 Note that this table is ordered in a special way. A punctuator 431 which is a prefix of another punctuator must appear after its 432 "extension". Otherwise, the wrong token will be returned. */ 433 static const char * const punctuators[] = { 434 "[", "]", "(", ")", "{", "}", "?", ";", ",", "~", 435 "...", ".", 436 "->", "--", "-=", "-", 437 "++", "+=", "+", 438 "*=", "*", 439 "!=", "!", 440 "&&", "&=", "&", 441 "/=", "/", 442 "%>", "%:%:", "%:", "%=", "%", 443 "^=", "^", 444 "##", "#", 445 ":>", ":", 446 "||", "|=", "|", 447 "<<=", "<<", "<=", "<:", "<%", "<", 448 ">>=", ">>", ">=", ">", 449 "==", "=", 450 0 451 }; 452 453 int i; 454 455 if (p + 1 <= end) 456 { 457 for (i = 0; punctuators[i]; i++) 458 { 459 const char *punctuator = punctuators[i]; 460 461 if (p[0] == punctuator[0]) 462 { 463 int len = strlen (punctuator); 464 465 if (p + len <= end 466 && ! memcmp (p, punctuator, len)) 467 { 468 set_token (tok, p, p + len); 469 return 1; 470 } 471 } 472 } 473 } 474 475 return 0; 476 } 477 478 479 /* Peel the next preprocessor token off of SRC, and put it in TOK. 480 Mutate TOK to refer to the first token in SRC, and mutate SRC to 481 refer to the text after that token. SRC must be a shared buffer; 482 the resulting TOK will be shared, pointing into the same string SRC 483 does. Initialize TOK's last_token field. Return non-zero if we 484 succeed, or 0 if we didn't find any more tokens in SRC. */ 485 static int 486 get_token (struct macro_buffer *tok, 487 struct macro_buffer *src) 488 { 489 char *p = src->text; 490 char *end = p + src->len; 491 492 gdb_assert (src->shared); 493 494 /* From the ISO C standard, ISO/IEC 9899:1999 (E), section 6.4: 495 496 preprocessing-token: 497 header-name 498 identifier 499 pp-number 500 character-constant 501 string-literal 502 punctuator 503 each non-white-space character that cannot be one of the above 504 505 We don't have to deal with header-name tokens, since those can 506 only occur after a #include, which we will never see. */ 507 508 while (p < end) 509 if (macro_is_whitespace (*p)) 510 p++; 511 else if (get_comment (tok, p, end)) 512 p += tok->len; 513 else if (get_pp_number (tok, p, end) 514 || get_character_constant (tok, p, end) 515 || get_string_literal (tok, p, end) 516 /* Note: the grammar in the standard seems to be 517 ambiguous: L'x' can be either a wide character 518 constant, or an identifier followed by a normal 519 character constant. By trying `get_identifier' after 520 we try get_character_constant and get_string_literal, 521 we give the wide character syntax precedence. Now, 522 since GDB doesn't handle wide character constants 523 anyway, is this the right thing to do? */ 524 || get_identifier (tok, p, end) 525 || get_punctuator (tok, p, end)) 526 { 527 /* How many characters did we consume, including whitespace? */ 528 int consumed = p - src->text + tok->len; 529 530 src->text += consumed; 531 src->len -= consumed; 532 return 1; 533 } 534 else 535 { 536 /* We have found a "non-whitespace character that cannot be 537 one of the above." Make a token out of it. */ 538 int consumed; 539 540 set_token (tok, p, p + 1); 541 consumed = p - src->text + tok->len; 542 src->text += consumed; 543 src->len -= consumed; 544 return 1; 545 } 546 547 return 0; 548 } 549 550 551 552 /* Appending token strings, with and without splicing */ 553 554 555 /* Append the macro buffer SRC to the end of DEST, and ensure that 556 doing so doesn't splice the token at the end of SRC with the token 557 at the beginning of DEST. SRC and DEST must have their last_token 558 fields set. Upon return, DEST's last_token field is set correctly. 559 560 For example: 561 562 If DEST is "(" and SRC is "y", then we can return with 563 DEST set to "(y" --- we've simply appended the two buffers. 564 565 However, if DEST is "x" and SRC is "y", then we must not return 566 with DEST set to "xy" --- that would splice the two tokens "x" and 567 "y" together to make a single token "xy". However, it would be 568 fine to return with DEST set to "x y". Similarly, "<" and "<" must 569 yield "< <", not "<<", etc. */ 570 static void 571 append_tokens_without_splicing (struct macro_buffer *dest, 572 struct macro_buffer *src) 573 { 574 int original_dest_len = dest->len; 575 struct macro_buffer dest_tail, new_token; 576 577 gdb_assert (src->last_token != -1); 578 gdb_assert (dest->last_token != -1); 579 580 /* First, just try appending the two, and call get_token to see if 581 we got a splice. */ 582 appendmem (dest, src->text, src->len); 583 584 /* If DEST originally had no token abutting its end, then we can't 585 have spliced anything, so we're done. */ 586 if (dest->last_token == original_dest_len) 587 { 588 dest->last_token = original_dest_len + src->last_token; 589 return; 590 } 591 592 /* Set DEST_TAIL to point to the last token in DEST, followed by 593 all the stuff we just appended. */ 594 init_shared_buffer (&dest_tail, 595 dest->text + dest->last_token, 596 dest->len - dest->last_token); 597 598 /* Re-parse DEST's last token. We know that DEST used to contain 599 at least one token, so if it doesn't contain any after the 600 append, then we must have spliced "/" and "*" or "/" and "/" to 601 make a comment start. (Just for the record, I got this right 602 the first time. This is not a bug fix.) */ 603 if (get_token (&new_token, &dest_tail) 604 && (new_token.text + new_token.len 605 == dest->text + original_dest_len)) 606 { 607 /* No splice, so we're done. */ 608 dest->last_token = original_dest_len + src->last_token; 609 return; 610 } 611 612 /* Okay, a simple append caused a splice. Let's chop dest back to 613 its original length and try again, but separate the texts with a 614 space. */ 615 dest->len = original_dest_len; 616 appendc (dest, ' '); 617 appendmem (dest, src->text, src->len); 618 619 init_shared_buffer (&dest_tail, 620 dest->text + dest->last_token, 621 dest->len - dest->last_token); 622 623 /* Try to re-parse DEST's last token, as above. */ 624 if (get_token (&new_token, &dest_tail) 625 && (new_token.text + new_token.len 626 == dest->text + original_dest_len)) 627 { 628 /* No splice, so we're done. */ 629 dest->last_token = original_dest_len + 1 + src->last_token; 630 return; 631 } 632 633 /* As far as I know, there's no case where inserting a space isn't 634 enough to prevent a splice. */ 635 internal_error (__FILE__, __LINE__, 636 _("unable to avoid splicing tokens during macro expansion")); 637 } 638 639 /* Stringify an argument, and insert it into DEST. ARG is the text to 640 stringify; it is LEN bytes long. */ 641 642 static void 643 stringify (struct macro_buffer *dest, char *arg, int len) 644 { 645 /* Trim initial whitespace from ARG. */ 646 while (len > 0 && macro_is_whitespace (*arg)) 647 { 648 ++arg; 649 --len; 650 } 651 652 /* Trim trailing whitespace from ARG. */ 653 while (len > 0 && macro_is_whitespace (arg[len - 1])) 654 --len; 655 656 /* Insert the string. */ 657 appendc (dest, '"'); 658 while (len > 0) 659 { 660 /* We could try to handle strange cases here, like control 661 characters, but there doesn't seem to be much point. */ 662 if (macro_is_whitespace (*arg)) 663 { 664 /* Replace a sequence of whitespace with a single space. */ 665 appendc (dest, ' '); 666 while (len > 1 && macro_is_whitespace (arg[1])) 667 { 668 ++arg; 669 --len; 670 } 671 } 672 else if (*arg == '\\' || *arg == '"') 673 { 674 appendc (dest, '\\'); 675 appendc (dest, *arg); 676 } 677 else 678 appendc (dest, *arg); 679 ++arg; 680 --len; 681 } 682 appendc (dest, '"'); 683 dest->last_token = dest->len; 684 } 685 686 687 /* Expanding macros! */ 688 689 690 /* A singly-linked list of the names of the macros we are currently 691 expanding --- for detecting expansion loops. */ 692 struct macro_name_list { 693 const char *name; 694 struct macro_name_list *next; 695 }; 696 697 698 /* Return non-zero if we are currently expanding the macro named NAME, 699 according to LIST; otherwise, return zero. 700 701 You know, it would be possible to get rid of all the NO_LOOP 702 arguments to these functions by simply generating a new lookup 703 function and baton which refuses to find the definition for a 704 particular macro, and otherwise delegates the decision to another 705 function/baton pair. But that makes the linked list of excluded 706 macros chained through untyped baton pointers, which will make it 707 harder to debug. :( */ 708 static int 709 currently_rescanning (struct macro_name_list *list, const char *name) 710 { 711 for (; list; list = list->next) 712 if (strcmp (name, list->name) == 0) 713 return 1; 714 715 return 0; 716 } 717 718 719 /* Gather the arguments to a macro expansion. 720 721 NAME is the name of the macro being invoked. (It's only used for 722 printing error messages.) 723 724 Assume that SRC is the text of the macro invocation immediately 725 following the macro name. For example, if we're processing the 726 text foo(bar, baz), then NAME would be foo and SRC will be (bar, 727 baz). 728 729 If SRC doesn't start with an open paren ( token at all, return 730 zero, leave SRC unchanged, and don't set *ARGC_P to anything. 731 732 If SRC doesn't contain a properly terminated argument list, then 733 raise an error. 734 735 For a variadic macro, NARGS holds the number of formal arguments to 736 the macro. For a GNU-style variadic macro, this should be the 737 number of named arguments. For a non-variadic macro, NARGS should 738 be -1. 739 740 Otherwise, return a pointer to the first element of an array of 741 macro buffers referring to the argument texts, and set *ARGC_P to 742 the number of arguments we found --- the number of elements in the 743 array. The macro buffers share their text with SRC, and their 744 last_token fields are initialized. The array is allocated with 745 xmalloc, and the caller is responsible for freeing it. 746 747 NOTE WELL: if SRC starts with a open paren ( token followed 748 immediately by a close paren ) token (e.g., the invocation looks 749 like "foo()"), we treat that as one argument, which happens to be 750 the empty list of tokens. The caller should keep in mind that such 751 a sequence of tokens is a valid way to invoke one-parameter 752 function-like macros, but also a valid way to invoke zero-parameter 753 function-like macros. Eeew. 754 755 Consume the tokens from SRC; after this call, SRC contains the text 756 following the invocation. */ 757 758 static struct macro_buffer * 759 gather_arguments (const char *name, struct macro_buffer *src, 760 int nargs, int *argc_p) 761 { 762 struct macro_buffer tok; 763 int args_len, args_size; 764 struct macro_buffer *args = NULL; 765 struct cleanup *back_to = make_cleanup (free_current_contents, &args); 766 767 /* Does SRC start with an opening paren token? Read from a copy of 768 SRC, so SRC itself is unaffected if we don't find an opening 769 paren. */ 770 { 771 struct macro_buffer temp; 772 773 init_shared_buffer (&temp, src->text, src->len); 774 775 if (! get_token (&tok, &temp) 776 || tok.len != 1 777 || tok.text[0] != '(') 778 { 779 discard_cleanups (back_to); 780 return 0; 781 } 782 } 783 784 /* Consume SRC's opening paren. */ 785 get_token (&tok, src); 786 787 args_len = 0; 788 args_size = 6; 789 args = (struct macro_buffer *) xmalloc (sizeof (*args) * args_size); 790 791 for (;;) 792 { 793 struct macro_buffer *arg; 794 int depth; 795 796 /* Make sure we have room for the next argument. */ 797 if (args_len >= args_size) 798 { 799 args_size *= 2; 800 args = xrealloc (args, sizeof (*args) * args_size); 801 } 802 803 /* Initialize the next argument. */ 804 arg = &args[args_len++]; 805 set_token (arg, src->text, src->text); 806 807 /* Gather the argument's tokens. */ 808 depth = 0; 809 for (;;) 810 { 811 if (! get_token (&tok, src)) 812 error (_("Malformed argument list for macro `%s'."), name); 813 814 /* Is tok an opening paren? */ 815 if (tok.len == 1 && tok.text[0] == '(') 816 depth++; 817 818 /* Is tok is a closing paren? */ 819 else if (tok.len == 1 && tok.text[0] == ')') 820 { 821 /* If it's a closing paren at the top level, then that's 822 the end of the argument list. */ 823 if (depth == 0) 824 { 825 /* In the varargs case, the last argument may be 826 missing. Add an empty argument in this case. */ 827 if (nargs != -1 && args_len == nargs - 1) 828 { 829 /* Make sure we have room for the argument. */ 830 if (args_len >= args_size) 831 { 832 args_size++; 833 args = xrealloc (args, sizeof (*args) * args_size); 834 } 835 arg = &args[args_len++]; 836 set_token (arg, src->text, src->text); 837 } 838 839 discard_cleanups (back_to); 840 *argc_p = args_len; 841 return args; 842 } 843 844 depth--; 845 } 846 847 /* If tok is a comma at top level, then that's the end of 848 the current argument. However, if we are handling a 849 variadic macro and we are computing the last argument, we 850 want to include the comma and remaining tokens. */ 851 else if (tok.len == 1 && tok.text[0] == ',' && depth == 0 852 && (nargs == -1 || args_len < nargs)) 853 break; 854 855 /* Extend the current argument to enclose this token. If 856 this is the current argument's first token, leave out any 857 leading whitespace, just for aesthetics. */ 858 if (arg->len == 0) 859 { 860 arg->text = tok.text; 861 arg->len = tok.len; 862 arg->last_token = 0; 863 } 864 else 865 { 866 arg->len = (tok.text + tok.len) - arg->text; 867 arg->last_token = tok.text - arg->text; 868 } 869 } 870 } 871 } 872 873 874 /* The `expand' and `substitute_args' functions both invoke `scan' 875 recursively, so we need a forward declaration somewhere. */ 876 static void scan (struct macro_buffer *dest, 877 struct macro_buffer *src, 878 struct macro_name_list *no_loop, 879 macro_lookup_ftype *lookup_func, 880 void *lookup_baton); 881 882 883 /* A helper function for substitute_args. 884 885 ARGV is a vector of all the arguments; ARGC is the number of 886 arguments. IS_VARARGS is true if the macro being substituted is a 887 varargs macro; in this case VA_ARG_NAME is the name of the 888 "variable" argument. VA_ARG_NAME is ignored if IS_VARARGS is 889 false. 890 891 If the token TOK is the name of a parameter, return the parameter's 892 index. If TOK is not an argument, return -1. */ 893 894 static int 895 find_parameter (const struct macro_buffer *tok, 896 int is_varargs, const struct macro_buffer *va_arg_name, 897 int argc, const char * const *argv) 898 { 899 int i; 900 901 if (! tok->is_identifier) 902 return -1; 903 904 for (i = 0; i < argc; ++i) 905 if (tok->len == strlen (argv[i]) 906 && !memcmp (tok->text, argv[i], tok->len)) 907 return i; 908 909 if (is_varargs && tok->len == va_arg_name->len 910 && ! memcmp (tok->text, va_arg_name->text, tok->len)) 911 return argc - 1; 912 913 return -1; 914 } 915 916 /* Given the macro definition DEF, being invoked with the actual 917 arguments given by ARGC and ARGV, substitute the arguments into the 918 replacement list, and store the result in DEST. 919 920 IS_VARARGS should be true if DEF is a varargs macro. In this case, 921 VA_ARG_NAME should be the name of the "variable" argument -- either 922 __VA_ARGS__ for c99-style varargs, or the final argument name, for 923 GNU-style varargs. If IS_VARARGS is false, this parameter is 924 ignored. 925 926 If it is necessary to expand macro invocations in one of the 927 arguments, use LOOKUP_FUNC and LOOKUP_BATON to find the macro 928 definitions, and don't expand invocations of the macros listed in 929 NO_LOOP. */ 930 931 static void 932 substitute_args (struct macro_buffer *dest, 933 struct macro_definition *def, 934 int is_varargs, const struct macro_buffer *va_arg_name, 935 int argc, struct macro_buffer *argv, 936 struct macro_name_list *no_loop, 937 macro_lookup_ftype *lookup_func, 938 void *lookup_baton) 939 { 940 /* A macro buffer for the macro's replacement list. */ 941 struct macro_buffer replacement_list; 942 /* The token we are currently considering. */ 943 struct macro_buffer tok; 944 /* The replacement list's pointer from just before TOK was lexed. */ 945 char *original_rl_start; 946 /* We have a single lookahead token to handle token splicing. */ 947 struct macro_buffer lookahead; 948 /* The lookahead token might not be valid. */ 949 int lookahead_valid; 950 /* The replacement list's pointer from just before LOOKAHEAD was 951 lexed. */ 952 char *lookahead_rl_start; 953 954 init_shared_buffer (&replacement_list, (char *) def->replacement, 955 strlen (def->replacement)); 956 957 gdb_assert (dest->len == 0); 958 dest->last_token = 0; 959 960 original_rl_start = replacement_list.text; 961 if (! get_token (&tok, &replacement_list)) 962 return; 963 lookahead_rl_start = replacement_list.text; 964 lookahead_valid = get_token (&lookahead, &replacement_list); 965 966 for (;;) 967 { 968 /* Just for aesthetics. If we skipped some whitespace, copy 969 that to DEST. */ 970 if (tok.text > original_rl_start) 971 { 972 appendmem (dest, original_rl_start, tok.text - original_rl_start); 973 dest->last_token = dest->len; 974 } 975 976 /* Is this token the stringification operator? */ 977 if (tok.len == 1 978 && tok.text[0] == '#') 979 { 980 int arg; 981 982 if (!lookahead_valid) 983 error (_("Stringification operator requires an argument.")); 984 985 arg = find_parameter (&lookahead, is_varargs, va_arg_name, 986 def->argc, def->argv); 987 if (arg == -1) 988 error (_("Argument to stringification operator must name " 989 "a macro parameter.")); 990 991 stringify (dest, argv[arg].text, argv[arg].len); 992 993 /* Read one token and let the loop iteration code handle the 994 rest. */ 995 lookahead_rl_start = replacement_list.text; 996 lookahead_valid = get_token (&lookahead, &replacement_list); 997 } 998 /* Is this token the splicing operator? */ 999 else if (tok.len == 2 1000 && tok.text[0] == '#' 1001 && tok.text[1] == '#') 1002 error (_("Stray splicing operator")); 1003 /* Is the next token the splicing operator? */ 1004 else if (lookahead_valid 1005 && lookahead.len == 2 1006 && lookahead.text[0] == '#' 1007 && lookahead.text[1] == '#') 1008 { 1009 int finished = 0; 1010 int prev_was_comma = 0; 1011 1012 /* Note that GCC warns if the result of splicing is not a 1013 token. In the debugger there doesn't seem to be much 1014 benefit from doing this. */ 1015 1016 /* Insert the first token. */ 1017 if (tok.len == 1 && tok.text[0] == ',') 1018 prev_was_comma = 1; 1019 else 1020 { 1021 int arg = find_parameter (&tok, is_varargs, va_arg_name, 1022 def->argc, def->argv); 1023 1024 if (arg != -1) 1025 appendmem (dest, argv[arg].text, argv[arg].len); 1026 else 1027 appendmem (dest, tok.text, tok.len); 1028 } 1029 1030 /* Apply a possible sequence of ## operators. */ 1031 for (;;) 1032 { 1033 if (! get_token (&tok, &replacement_list)) 1034 error (_("Splicing operator at end of macro")); 1035 1036 /* Handle a comma before a ##. If we are handling 1037 varargs, and the token on the right hand side is the 1038 varargs marker, and the final argument is empty or 1039 missing, then drop the comma. This is a GNU 1040 extension. There is one ambiguous case here, 1041 involving pedantic behavior with an empty argument, 1042 but we settle that in favor of GNU-style (GCC uses an 1043 option). If we aren't dealing with varargs, we 1044 simply insert the comma. */ 1045 if (prev_was_comma) 1046 { 1047 if (! (is_varargs 1048 && tok.len == va_arg_name->len 1049 && !memcmp (tok.text, va_arg_name->text, tok.len) 1050 && argv[argc - 1].len == 0)) 1051 appendmem (dest, ",", 1); 1052 prev_was_comma = 0; 1053 } 1054 1055 /* Insert the token. If it is a parameter, insert the 1056 argument. If it is a comma, treat it specially. */ 1057 if (tok.len == 1 && tok.text[0] == ',') 1058 prev_was_comma = 1; 1059 else 1060 { 1061 int arg = find_parameter (&tok, is_varargs, va_arg_name, 1062 def->argc, def->argv); 1063 1064 if (arg != -1) 1065 appendmem (dest, argv[arg].text, argv[arg].len); 1066 else 1067 appendmem (dest, tok.text, tok.len); 1068 } 1069 1070 /* Now read another token. If it is another splice, we 1071 loop. */ 1072 original_rl_start = replacement_list.text; 1073 if (! get_token (&tok, &replacement_list)) 1074 { 1075 finished = 1; 1076 break; 1077 } 1078 1079 if (! (tok.len == 2 1080 && tok.text[0] == '#' 1081 && tok.text[1] == '#')) 1082 break; 1083 } 1084 1085 if (prev_was_comma) 1086 { 1087 /* We saw a comma. Insert it now. */ 1088 appendmem (dest, ",", 1); 1089 } 1090 1091 dest->last_token = dest->len; 1092 if (finished) 1093 lookahead_valid = 0; 1094 else 1095 { 1096 /* Set up for the loop iterator. */ 1097 lookahead = tok; 1098 lookahead_rl_start = original_rl_start; 1099 lookahead_valid = 1; 1100 } 1101 } 1102 else 1103 { 1104 /* Is this token an identifier? */ 1105 int substituted = 0; 1106 int arg = find_parameter (&tok, is_varargs, va_arg_name, 1107 def->argc, def->argv); 1108 1109 if (arg != -1) 1110 { 1111 struct macro_buffer arg_src; 1112 1113 /* Expand any macro invocations in the argument text, 1114 and append the result to dest. Remember that scan 1115 mutates its source, so we need to scan a new buffer 1116 referring to the argument's text, not the argument 1117 itself. */ 1118 init_shared_buffer (&arg_src, argv[arg].text, argv[arg].len); 1119 scan (dest, &arg_src, no_loop, lookup_func, lookup_baton); 1120 substituted = 1; 1121 } 1122 1123 /* If it wasn't a parameter, then just copy it across. */ 1124 if (! substituted) 1125 append_tokens_without_splicing (dest, &tok); 1126 } 1127 1128 if (! lookahead_valid) 1129 break; 1130 1131 tok = lookahead; 1132 original_rl_start = lookahead_rl_start; 1133 1134 lookahead_rl_start = replacement_list.text; 1135 lookahead_valid = get_token (&lookahead, &replacement_list); 1136 } 1137 } 1138 1139 1140 /* Expand a call to a macro named ID, whose definition is DEF. Append 1141 its expansion to DEST. SRC is the input text following the ID 1142 token. We are currently rescanning the expansions of the macros 1143 named in NO_LOOP; don't re-expand them. Use LOOKUP_FUNC and 1144 LOOKUP_BATON to find definitions for any nested macro references. 1145 1146 Return 1 if we decided to expand it, zero otherwise. (If it's a 1147 function-like macro name that isn't followed by an argument list, 1148 we don't expand it.) If we return zero, leave SRC unchanged. */ 1149 static int 1150 expand (const char *id, 1151 struct macro_definition *def, 1152 struct macro_buffer *dest, 1153 struct macro_buffer *src, 1154 struct macro_name_list *no_loop, 1155 macro_lookup_ftype *lookup_func, 1156 void *lookup_baton) 1157 { 1158 struct macro_name_list new_no_loop; 1159 1160 /* Create a new node to be added to the front of the no-expand list. 1161 This list is appropriate for re-scanning replacement lists, but 1162 it is *not* appropriate for scanning macro arguments; invocations 1163 of the macro whose arguments we are gathering *do* get expanded 1164 there. */ 1165 new_no_loop.name = id; 1166 new_no_loop.next = no_loop; 1167 1168 /* What kind of macro are we expanding? */ 1169 if (def->kind == macro_object_like) 1170 { 1171 struct macro_buffer replacement_list; 1172 1173 init_shared_buffer (&replacement_list, (char *) def->replacement, 1174 strlen (def->replacement)); 1175 1176 scan (dest, &replacement_list, &new_no_loop, lookup_func, lookup_baton); 1177 return 1; 1178 } 1179 else if (def->kind == macro_function_like) 1180 { 1181 struct cleanup *back_to = make_cleanup (null_cleanup, 0); 1182 int argc = 0; 1183 struct macro_buffer *argv = NULL; 1184 struct macro_buffer substituted; 1185 struct macro_buffer substituted_src; 1186 struct macro_buffer va_arg_name = {0}; 1187 int is_varargs = 0; 1188 1189 if (def->argc >= 1) 1190 { 1191 if (strcmp (def->argv[def->argc - 1], "...") == 0) 1192 { 1193 /* In C99-style varargs, substitution is done using 1194 __VA_ARGS__. */ 1195 init_shared_buffer (&va_arg_name, "__VA_ARGS__", 1196 strlen ("__VA_ARGS__")); 1197 is_varargs = 1; 1198 } 1199 else 1200 { 1201 int len = strlen (def->argv[def->argc - 1]); 1202 1203 if (len > 3 1204 && strcmp (def->argv[def->argc - 1] + len - 3, "...") == 0) 1205 { 1206 /* In GNU-style varargs, the name of the 1207 substitution parameter is the name of the formal 1208 argument without the "...". */ 1209 init_shared_buffer (&va_arg_name, 1210 (char *) def->argv[def->argc - 1], 1211 len - 3); 1212 is_varargs = 1; 1213 } 1214 } 1215 } 1216 1217 make_cleanup (free_current_contents, &argv); 1218 argv = gather_arguments (id, src, is_varargs ? def->argc : -1, 1219 &argc); 1220 1221 /* If we couldn't find any argument list, then we don't expand 1222 this macro. */ 1223 if (! argv) 1224 { 1225 do_cleanups (back_to); 1226 return 0; 1227 } 1228 1229 /* Check that we're passing an acceptable number of arguments for 1230 this macro. */ 1231 if (argc != def->argc) 1232 { 1233 if (is_varargs && argc >= def->argc - 1) 1234 { 1235 /* Ok. */ 1236 } 1237 /* Remember that a sequence of tokens like "foo()" is a 1238 valid invocation of a macro expecting either zero or one 1239 arguments. */ 1240 else if (! (argc == 1 1241 && argv[0].len == 0 1242 && def->argc == 0)) 1243 error (_("Wrong number of arguments to macro `%s' " 1244 "(expected %d, got %d)."), 1245 id, def->argc, argc); 1246 } 1247 1248 /* Note that we don't expand macro invocations in the arguments 1249 yet --- we let subst_args take care of that. Parameters that 1250 appear as operands of the stringifying operator "#" or the 1251 splicing operator "##" don't get macro references expanded, 1252 so we can't really tell whether it's appropriate to macro- 1253 expand an argument until we see how it's being used. */ 1254 init_buffer (&substituted, 0); 1255 make_cleanup (cleanup_macro_buffer, &substituted); 1256 substitute_args (&substituted, def, is_varargs, &va_arg_name, 1257 argc, argv, no_loop, lookup_func, lookup_baton); 1258 1259 /* Now `substituted' is the macro's replacement list, with all 1260 argument values substituted into it properly. Re-scan it for 1261 macro references, but don't expand invocations of this macro. 1262 1263 We create a new buffer, `substituted_src', which points into 1264 `substituted', and scan that. We can't scan `substituted' 1265 itself, since the tokenization process moves the buffer's 1266 text pointer around, and we still need to be able to find 1267 `substituted's original text buffer after scanning it so we 1268 can free it. */ 1269 init_shared_buffer (&substituted_src, substituted.text, substituted.len); 1270 scan (dest, &substituted_src, &new_no_loop, lookup_func, lookup_baton); 1271 1272 do_cleanups (back_to); 1273 1274 return 1; 1275 } 1276 else 1277 internal_error (__FILE__, __LINE__, _("bad macro definition kind")); 1278 } 1279 1280 1281 /* If the single token in SRC_FIRST followed by the tokens in SRC_REST 1282 constitute a macro invokation not forbidden in NO_LOOP, append its 1283 expansion to DEST and return non-zero. Otherwise, return zero, and 1284 leave DEST unchanged. 1285 1286 SRC_FIRST and SRC_REST must be shared buffers; DEST must not be one. 1287 SRC_FIRST must be a string built by get_token. */ 1288 static int 1289 maybe_expand (struct macro_buffer *dest, 1290 struct macro_buffer *src_first, 1291 struct macro_buffer *src_rest, 1292 struct macro_name_list *no_loop, 1293 macro_lookup_ftype *lookup_func, 1294 void *lookup_baton) 1295 { 1296 gdb_assert (src_first->shared); 1297 gdb_assert (src_rest->shared); 1298 gdb_assert (! dest->shared); 1299 1300 /* Is this token an identifier? */ 1301 if (src_first->is_identifier) 1302 { 1303 /* Make a null-terminated copy of it, since that's what our 1304 lookup function expects. */ 1305 char *id = xmalloc (src_first->len + 1); 1306 struct cleanup *back_to = make_cleanup (xfree, id); 1307 1308 memcpy (id, src_first->text, src_first->len); 1309 id[src_first->len] = 0; 1310 1311 /* If we're currently re-scanning the result of expanding 1312 this macro, don't expand it again. */ 1313 if (! currently_rescanning (no_loop, id)) 1314 { 1315 /* Does this identifier have a macro definition in scope? */ 1316 struct macro_definition *def = lookup_func (id, lookup_baton); 1317 1318 if (def && expand (id, def, dest, src_rest, no_loop, 1319 lookup_func, lookup_baton)) 1320 { 1321 do_cleanups (back_to); 1322 return 1; 1323 } 1324 } 1325 1326 do_cleanups (back_to); 1327 } 1328 1329 return 0; 1330 } 1331 1332 1333 /* Expand macro references in SRC, appending the results to DEST. 1334 Assume we are re-scanning the result of expanding the macros named 1335 in NO_LOOP, and don't try to re-expand references to them. 1336 1337 SRC must be a shared buffer; DEST must not be one. */ 1338 static void 1339 scan (struct macro_buffer *dest, 1340 struct macro_buffer *src, 1341 struct macro_name_list *no_loop, 1342 macro_lookup_ftype *lookup_func, 1343 void *lookup_baton) 1344 { 1345 gdb_assert (src->shared); 1346 gdb_assert (! dest->shared); 1347 1348 for (;;) 1349 { 1350 struct macro_buffer tok; 1351 char *original_src_start = src->text; 1352 1353 /* Find the next token in SRC. */ 1354 if (! get_token (&tok, src)) 1355 break; 1356 1357 /* Just for aesthetics. If we skipped some whitespace, copy 1358 that to DEST. */ 1359 if (tok.text > original_src_start) 1360 { 1361 appendmem (dest, original_src_start, tok.text - original_src_start); 1362 dest->last_token = dest->len; 1363 } 1364 1365 if (! maybe_expand (dest, &tok, src, no_loop, lookup_func, lookup_baton)) 1366 /* We didn't end up expanding tok as a macro reference, so 1367 simply append it to dest. */ 1368 append_tokens_without_splicing (dest, &tok); 1369 } 1370 1371 /* Just for aesthetics. If there was any trailing whitespace in 1372 src, copy it to dest. */ 1373 if (src->len) 1374 { 1375 appendmem (dest, src->text, src->len); 1376 dest->last_token = dest->len; 1377 } 1378 } 1379 1380 1381 char * 1382 macro_expand (const char *source, 1383 macro_lookup_ftype *lookup_func, 1384 void *lookup_func_baton) 1385 { 1386 struct macro_buffer src, dest; 1387 struct cleanup *back_to; 1388 1389 init_shared_buffer (&src, (char *) source, strlen (source)); 1390 1391 init_buffer (&dest, 0); 1392 dest.last_token = 0; 1393 back_to = make_cleanup (cleanup_macro_buffer, &dest); 1394 1395 scan (&dest, &src, 0, lookup_func, lookup_func_baton); 1396 1397 appendc (&dest, '\0'); 1398 1399 discard_cleanups (back_to); 1400 return dest.text; 1401 } 1402 1403 1404 char * 1405 macro_expand_once (const char *source, 1406 macro_lookup_ftype *lookup_func, 1407 void *lookup_func_baton) 1408 { 1409 error (_("Expand-once not implemented yet.")); 1410 } 1411 1412 1413 char * 1414 macro_expand_next (char **lexptr, 1415 macro_lookup_ftype *lookup_func, 1416 void *lookup_baton) 1417 { 1418 struct macro_buffer src, dest, tok; 1419 struct cleanup *back_to; 1420 1421 /* Set up SRC to refer to the input text, pointed to by *lexptr. */ 1422 init_shared_buffer (&src, *lexptr, strlen (*lexptr)); 1423 1424 /* Set up DEST to receive the expansion, if there is one. */ 1425 init_buffer (&dest, 0); 1426 dest.last_token = 0; 1427 back_to = make_cleanup (cleanup_macro_buffer, &dest); 1428 1429 /* Get the text's first preprocessing token. */ 1430 if (! get_token (&tok, &src)) 1431 { 1432 do_cleanups (back_to); 1433 return 0; 1434 } 1435 1436 /* If it's a macro invocation, expand it. */ 1437 if (maybe_expand (&dest, &tok, &src, 0, lookup_func, lookup_baton)) 1438 { 1439 /* It was a macro invocation! Package up the expansion as a 1440 null-terminated string and return it. Set *lexptr to the 1441 start of the next token in the input. */ 1442 appendc (&dest, '\0'); 1443 discard_cleanups (back_to); 1444 *lexptr = src.text; 1445 return dest.text; 1446 } 1447 else 1448 { 1449 /* It wasn't a macro invocation. */ 1450 do_cleanups (back_to); 1451 return 0; 1452 } 1453 } 1454