gdb/macroexp.c

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