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