gdb/macroexp.c

   1 /* C preprocessor macro expansion for GDB.
   2    Copyright (C) 2002, 2007, 2008, 2009, 2010 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
 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 \f
 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 (0);
 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 (0);
 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         src->text += consumed;
 529         src->len -= consumed;
 530         return 1;
 531       }
 532     else
 533       {
 534         /* We have found a "non-whitespace character that cannot be
 535            one of the above."  Make a token out of it.  */
 536         int consumed;
 537
 538         set_token (tok, p, p + 1);
 539         consumed = p - src->text + tok->len;
 540         src->text += consumed;
 541         src->len -= consumed;
 542         return 1;
 543       }
 544
 545   return 0;
 546 }
 547
 548
 549 \f
 550 /* Appending token strings, with and without splicing  */
 551
 552
 553 /* Append the macro buffer SRC to the end of DEST, and ensure that
 554    doing so doesn't splice the token at the end of SRC with the token
 555    at the beginning of DEST.  SRC and DEST must have their last_token
 556    fields set.  Upon return, DEST's last_token field is set correctly.
 557
 558    For example:
 559
 560    If DEST is "(" and SRC is "y", then we can return with
 561    DEST set to "(y" --- we've simply appended the two buffers.
 562
 563    However, if DEST is "x" and SRC is "y", then we must not return
 564    with DEST set to "xy" --- that would splice the two tokens "x" and
 565    "y" together to make a single token "xy".  However, it would be
 566    fine to return with DEST set to "x y".  Similarly, "<" and "<" must
 567    yield "< <", not "<<", etc.  */
 568 static void
 569 append_tokens_without_splicing (struct macro_buffer *dest,
 570                                 struct macro_buffer *src)
 571 {
 572   int original_dest_len = dest->len;
 573   struct macro_buffer dest_tail, new_token;
 574
 575   gdb_assert (src->last_token != -1);
 576   gdb_assert (dest->last_token != -1);
 577
 578   /* First, just try appending the two, and call get_token to see if
 579      we got a splice.  */
 580   appendmem (dest, src->text, src->len);
 581
 582   /* If DEST originally had no token abutting its end, then we can't
 583      have spliced anything, so we're done.  */
 584   if (dest->last_token == original_dest_len)
 585     {
 586       dest->last_token = original_dest_len + src->last_token;
 587       return;
 588     }
 589
 590   /* Set DEST_TAIL to point to the last token in DEST, followed by
 591      all the stuff we just appended.  */
 592   init_shared_buffer (&dest_tail,
 593                       dest->text + dest->last_token,
 594                       dest->len - dest->last_token);
 595
 596   /* Re-parse DEST's last token.  We know that DEST used to contain
 597      at least one token, so if it doesn't contain any after the
 598      append, then we must have spliced "/" and "*" or "/" and "/" to
 599      make a comment start.  (Just for the record, I got this right
 600      the first time.  This is not a bug fix.)  */
 601   if (get_token (&new_token, &dest_tail)
 602       && (new_token.text + new_token.len
 603           == dest->text + original_dest_len))
 604     {
 605       /* No splice, so we're done.  */
 606       dest->last_token = original_dest_len + src->last_token;
 607       return;
 608     }
 609
 610   /* Okay, a simple append caused a splice.  Let's chop dest back to
 611      its original length and try again, but separate the texts with a
 612      space.  */
 613   dest->len = original_dest_len;
 614   appendc (dest, ' ');
 615   appendmem (dest, src->text, src->len);
 616
 617   init_shared_buffer (&dest_tail,
 618                       dest->text + dest->last_token,
 619                       dest->len - dest->last_token);
 620
 621   /* Try to re-parse DEST's last token, as above.  */
 622   if (get_token (&new_token, &dest_tail)
 623       && (new_token.text + new_token.len
 624           == dest->text + original_dest_len))
 625     {
 626       /* No splice, so we're done.  */
 627       dest->last_token = original_dest_len + 1 + src->last_token;
 628       return;
 629     }
 630
 631   /* As far as I know, there's no case where inserting a space isn't
 632      enough to prevent a splice.  */
 633   internal_error (__FILE__, __LINE__,
 634                   _("unable to avoid splicing tokens during macro expansion"));
 635 }
 636
 637 /* Stringify an argument, and insert it into DEST.  ARG is the text to
 638    stringify; it is LEN bytes long.  */
 639
 640 static void
 641 stringify (struct macro_buffer *dest, char *arg, int len)
 642 {
 643   /* Trim initial whitespace from ARG.  */
 644   while (len > 0 && macro_is_whitespace (*arg))
 645     {
 646       ++arg;
 647       --len;
 648     }
 649
 650   /* Trim trailing whitespace from ARG.  */
 651   while (len > 0 && macro_is_whitespace (arg[len - 1]))
 652     --len;
 653
 654   /* Insert the string.  */
 655   appendc (dest, '"');
 656   while (len > 0)
 657     {
 658       /* We could try to handle strange cases here, like control
 659          characters, but there doesn't seem to be much point.  */
 660       if (macro_is_whitespace (*arg))
 661         {
 662           /* Replace a sequence of whitespace with a single space.  */
 663           appendc (dest, ' ');
 664           while (len > 1 && macro_is_whitespace (arg[1]))
 665             {
 666               ++arg;
 667               --len;
 668             }
 669         }
 670       else if (*arg == '\\' || *arg == '"')
 671         {
 672           appendc (dest, '\\');
 673           appendc (dest, *arg);
 674         }
 675       else
 676         appendc (dest, *arg);
 677       ++arg;
 678       --len;
 679     }
 680   appendc (dest, '"');
 681   dest->last_token = dest->len;
 682 }
 683
 684 \f
 685 /* Expanding macros!  */
 686
 687
 688 /* A singly-linked list of the names of the macros we are currently
 689    expanding --- for detecting expansion loops.  */
 690 struct macro_name_list {
 691   const char *name;
 692   struct macro_name_list *next;
 693 };
 694
 695
 696 /* Return non-zero if we are currently expanding the macro named NAME,
 697    according to LIST; otherwise, return zero.
 698
 699    You know, it would be possible to get rid of all the NO_LOOP
 700    arguments to these functions by simply generating a new lookup
 701    function and baton which refuses to find the definition for a
 702    particular macro, and otherwise delegates the decision to another
 703    function/baton pair.  But that makes the linked list of excluded
 704    macros chained through untyped baton pointers, which will make it
 705    harder to debug.  :( */
 706 static int
 707 currently_rescanning (struct macro_name_list *list, const char *name)
 708 {
 709   for (; list; list = list->next)
 710     if (strcmp (name, list->name) == 0)
 711       return 1;
 712
 713   return 0;
 714 }
 715
 716
 717 /* Gather the arguments to a macro expansion.
 718
 719    NAME is the name of the macro being invoked.  (It's only used for
 720    printing error messages.)
 721
 722    Assume that SRC is the text of the macro invocation immediately
 723    following the macro name.  For example, if we're processing the
 724    text foo(bar, baz), then NAME would be foo and SRC will be (bar,
 725    baz).
 726
 727    If SRC doesn't start with an open paren ( token at all, return
 728    zero, leave SRC unchanged, and don't set *ARGC_P to anything.
 729
 730    If SRC doesn't contain a properly terminated argument list, then
 731    raise an error.
 732
 733    For a variadic macro, NARGS holds the number of formal arguments to
 734    the macro.  For a GNU-style variadic macro, this should be the
 735    number of named arguments.  For a non-variadic macro, NARGS should
 736    be -1.
 737
 738    Otherwise, return a pointer to the first element of an array of
 739    macro buffers referring to the argument texts, and set *ARGC_P to
 740    the number of arguments we found --- the number of elements in the
 741    array.  The macro buffers share their text with SRC, and their
 742    last_token fields are initialized.  The array is allocated with
 743    xmalloc, and the caller is responsible for freeing it.
 744
 745    NOTE WELL: if SRC starts with a open paren ( token followed
 746    immediately by a close paren ) token (e.g., the invocation looks
 747    like "foo()"), we treat that as one argument, which happens to be
 748    the empty list of tokens.  The caller should keep in mind that such
 749    a sequence of tokens is a valid way to invoke one-parameter
 750    function-like macros, but also a valid way to invoke zero-parameter
 751    function-like macros.  Eeew.
 752
 753    Consume the tokens from SRC; after this call, SRC contains the text
 754    following the invocation.  */
 755
 756 static struct macro_buffer *
 757 gather_arguments (const char *name, struct macro_buffer *src,
 758                   int nargs, int *argc_p)
 759 {
 760   struct macro_buffer tok;
 761   int args_len, args_size;
 762   struct macro_buffer *args = NULL;
 763   struct cleanup *back_to = make_cleanup (free_current_contents, &args);
 764
 765   /* Does SRC start with an opening paren token?  Read from a copy of
 766      SRC, so SRC itself is unaffected if we don't find an opening
 767      paren.  */
 768   {
 769     struct macro_buffer temp;
 770     init_shared_buffer (&temp, src->text, src->len);
 771
 772     if (! get_token (&tok, &temp)
 773         || tok.len != 1
 774         || tok.text[0] != '(')
 775       {
 776         discard_cleanups (back_to);
 777         return 0;
 778       }
 779   }
 780
 781   /* Consume SRC's opening paren.  */
 782   get_token (&tok, src);
 783
 784   args_len = 0;
 785   args_size = 6;
 786   args = (struct macro_buffer *) xmalloc (sizeof (*args) * args_size);
 787
 788   for (;;)
 789     {
 790       struct macro_buffer *arg;
 791       int depth;
 792
 793       /* Make sure we have room for the next argument.  */
 794       if (args_len >= args_size)
 795         {
 796           args_size *= 2;
 797           args = xrealloc (args, sizeof (*args) * args_size);
 798         }
 799
 800       /* Initialize the next argument.  */
 801       arg = &args[args_len++];
 802       set_token (arg, src->text, src->text);
 803
 804       /* Gather the argument's tokens.  */
 805       depth = 0;
 806       for (;;)
 807         {
 808           if (! get_token (&tok, src))
 809             error (_("Malformed argument list for macro `%s'."), name);
 810
 811           /* Is tok an opening paren?  */
 812           if (tok.len == 1 && tok.text[0] == '(')
 813             depth++;
 814
 815           /* Is tok is a closing paren?  */
 816           else if (tok.len == 1 && tok.text[0] == ')')
 817             {
 818               /* If it's a closing paren at the top level, then that's
 819                  the end of the argument list.  */
 820               if (depth == 0)
 821                 {
 822                   /* In the varargs case, the last argument may be
 823                      missing.  Add an empty argument in this case.  */
 824                   if (nargs != -1 && args_len == nargs - 1)
 825                     {
 826                       /* Make sure we have room for the argument.  */
 827                       if (args_len >= args_size)
 828                         {
 829                           args_size++;
 830                           args = xrealloc (args, sizeof (*args) * args_size);
 831                         }
 832                       arg = &args[args_len++];
 833                       set_token (arg, src->text, src->text);
 834                     }
 835
 836                   discard_cleanups (back_to);
 837                   *argc_p = args_len;
 838                   return args;
 839                 }
 840
 841               depth--;
 842             }
 843
 844           /* If tok is a comma at top level, then that's the end of
 845              the current argument.  However, if we are handling a
 846              variadic macro and we are computing the last argument, we
 847              want to include the comma and remaining tokens.  */
 848           else if (tok.len == 1 && tok.text[0] == ',' && depth == 0
 849                    && (nargs == -1 || args_len < nargs))
 850             break;
 851
 852           /* Extend the current argument to enclose this token.  If
 853              this is the current argument's first token, leave out any
 854              leading whitespace, just for aesthetics.  */
 855           if (arg->len == 0)
 856             {
 857               arg->text = tok.text;
 858               arg->len = tok.len;
 859               arg->last_token = 0;
 860             }
 861           else
 862             {
 863               arg->len = (tok.text + tok.len) - arg->text;
 864               arg->last_token = tok.text - arg->text;
 865             }
 866         }
 867     }
 868 }
 869
 870
 871 /* The `expand' and `substitute_args' functions both invoke `scan'
 872    recursively, so we need a forward declaration somewhere.  */
 873 static void scan (struct macro_buffer *dest,
 874                   struct macro_buffer *src,
 875                   struct macro_name_list *no_loop,
 876                   macro_lookup_ftype *lookup_func,
 877                   void *lookup_baton);
 878
 879
 880 /* A helper function for substitute_args.
 881
 882    ARGV is a vector of all the arguments; ARGC is the number of
 883    arguments.  IS_VARARGS is true if the macro being substituted is a
 884    varargs macro; in this case VA_ARG_NAME is the name of the
 885    "variable" argument.  VA_ARG_NAME is ignored if IS_VARARGS is
 886    false.
 887
 888    If the token TOK is the name of a parameter, return the parameter's
 889    index.  If TOK is not an argument, return -1.  */
 890
 891 static int
 892 find_parameter (const struct macro_buffer *tok,
 893                 int is_varargs, const struct macro_buffer *va_arg_name,
 894                 int argc, const char * const *argv)
 895 {
 896   int i;
 897
 898   if (! tok->is_identifier)
 899     return -1;
 900
 901   for (i = 0; i < argc; ++i)
 902     if (tok->len == strlen (argv[i]) && ! memcmp (tok->text, argv[i], tok->len))
 903       return i;
 904
 905   if (is_varargs && tok->len == va_arg_name->len
 906       && ! memcmp (tok->text, va_arg_name->text, tok->len))
 907     return argc - 1;
 908
 909   return -1;
 910 }
 911
 912 /* Given the macro definition DEF, being invoked with the actual
 913    arguments given by ARGC and ARGV, substitute the arguments into the
 914    replacement list, and store the result in DEST.
 915
 916    IS_VARARGS should be true if DEF is a varargs macro.  In this case,
 917    VA_ARG_NAME should be the name of the "variable" argument -- either
 918    __VA_ARGS__ for c99-style varargs, or the final argument name, for
 919    GNU-style varargs.  If IS_VARARGS is false, this parameter is
 920    ignored.
 921
 922    If it is necessary to expand macro invocations in one of the
 923    arguments, use LOOKUP_FUNC and LOOKUP_BATON to find the macro
 924    definitions, and don't expand invocations of the macros listed in
 925    NO_LOOP.  */
 926
 927 static void
 928 substitute_args (struct macro_buffer *dest,
 929                  struct macro_definition *def,
 930                  int is_varargs, const struct macro_buffer *va_arg_name,
 931                  int argc, struct macro_buffer *argv,
 932                  struct macro_name_list *no_loop,
 933                  macro_lookup_ftype *lookup_func,
 934                  void *lookup_baton)
 935 {
 936   /* A macro buffer for the macro's replacement list.  */
 937   struct macro_buffer replacement_list;
 938   /* The token we are currently considering.  */
 939   struct macro_buffer tok;
 940   /* The replacement list's pointer from just before TOK was lexed.  */
 941   char *original_rl_start;
 942   /* We have a single lookahead token to handle token splicing.  */
 943   struct macro_buffer lookahead;
 944   /* The lookahead token might not be valid.  */
 945   int lookahead_valid;
 946   /* The replacement list's pointer from just before LOOKAHEAD was
 947      lexed.  */
 948   char *lookahead_rl_start;
 949
 950   init_shared_buffer (&replacement_list, (char *) def->replacement,
 951                       strlen (def->replacement));
 952
 953   gdb_assert (dest->len == 0);
 954   dest->last_token = 0;
 955
 956   original_rl_start = replacement_list.text;
 957   if (! get_token (&tok, &replacement_list))
 958     return;
 959   lookahead_rl_start = replacement_list.text;
 960   lookahead_valid = get_token (&lookahead, &replacement_list);
 961
 962   for (;;)
 963     {
 964       /* Just for aesthetics.  If we skipped some whitespace, copy
 965          that to DEST.  */
 966       if (tok.text > original_rl_start)
 967         {
 968           appendmem (dest, original_rl_start, tok.text - original_rl_start);
 969           dest->last_token = dest->len;
 970         }
 971
 972       /* Is this token the stringification operator?  */
 973       if (tok.len == 1
 974           && tok.text[0] == '#')
 975         {
 976           int arg;
 977
 978           if (!lookahead_valid)
 979             error (_("Stringification operator requires an argument."));
 980
 981           arg = find_parameter (&lookahead, is_varargs, va_arg_name,
 982                                 def->argc, def->argv);
 983           if (arg == -1)
 984             error (_("Argument to stringification operator must name "
 985                      "a macro parameter."));
 986
 987           stringify (dest, argv[arg].text, argv[arg].len);
 988
 989           /* Read one token and let the loop iteration code handle the
 990              rest.  */
 991           lookahead_rl_start = replacement_list.text;
 992           lookahead_valid = get_token (&lookahead, &replacement_list);
 993         }
 994       /* Is this token the splicing operator?  */
 995       else if (tok.len == 2
 996                && tok.text[0] == '#'
 997                && tok.text[1] == '#')
 998         error (_("Stray splicing operator"));
 999       /* Is the next token the splicing operator?  */
1000       else if (lookahead_valid
1001                && lookahead.len == 2
1002                && lookahead.text[0] == '#'
1003                && lookahead.text[1] == '#')
1004         {
1005           int finished = 0;
1006           int prev_was_comma = 0;
1007
1008           /* Note that GCC warns if the result of splicing is not a
1009              token.  In the debugger there doesn't seem to be much
1010              benefit from doing this.  */
1011
1012           /* Insert the first token.  */
1013           if (tok.len == 1 && tok.text[0] == ',')
1014             prev_was_comma = 1;
1015           else
1016             {
1017               int arg = find_parameter (&tok, is_varargs, va_arg_name,
1018                                         def->argc, def->argv);
1019               if (arg != -1)
1020                 appendmem (dest, argv[arg].text, argv[arg].len);
1021               else
1022                 appendmem (dest, tok.text, tok.len);
1023             }
1024
1025           /* Apply a possible sequence of ## operators.  */
1026           for (;;)
1027             {
1028               if (! get_token (&tok, &replacement_list))
1029                 error (_("Splicing operator at end of macro"));
1030
1031               /* Handle a comma before a ##.  If we are handling
1032                  varargs, and the token on the right hand side is the
1033                  varargs marker, and the final argument is empty or
1034                  missing, then drop the comma.  This is a GNU
1035                  extension.  There is one ambiguous case here,
1036                  involving pedantic behavior with an empty argument,
1037                  but we settle that in favor of GNU-style (GCC uses an
1038                  option).  If we aren't dealing with varargs, we
1039                  simply insert the comma.  */
1040               if (prev_was_comma)
1041                 {
1042                   if (! (is_varargs
1043                          && tok.len == va_arg_name->len
1044                          && !memcmp (tok.text, va_arg_name->text, tok.len)
1045                          && argv[argc - 1].len == 0))
1046                     appendmem (dest, ",", 1);
1047                   prev_was_comma = 0;
1048                 }
1049
1050               /* Insert the token.  If it is a parameter, insert the
1051                  argument.  If it is a comma, treat it specially.  */
1052               if (tok.len == 1 && tok.text[0] == ',')
1053                 prev_was_comma = 1;
1054               else
1055                 {
1056                   int arg = find_parameter (&tok, is_varargs, va_arg_name,
1057                                             def->argc, def->argv);
1058                   if (arg != -1)
1059                     appendmem (dest, argv[arg].text, argv[arg].len);
1060                   else
1061                     appendmem (dest, tok.text, tok.len);
1062                 }
1063
1064               /* Now read another token.  If it is another splice, we
1065                  loop.  */
1066               original_rl_start = replacement_list.text;
1067               if (! get_token (&tok, &replacement_list))
1068                 {
1069                   finished = 1;
1070                   break;
1071                 }
1072
1073               if (! (tok.len == 2
1074                      && tok.text[0] == '#'
1075                      && tok.text[1] == '#'))
1076                 break;
1077             }
1078
1079           if (prev_was_comma)
1080             {
1081               /* We saw a comma.  Insert it now.  */
1082               appendmem (dest, ",", 1);
1083             }
1084
1085           dest->last_token = dest->len;
1086           if (finished)
1087             lookahead_valid = 0;
1088           else
1089             {
1090               /* Set up for the loop iterator.  */
1091               lookahead = tok;
1092               lookahead_rl_start = original_rl_start;
1093               lookahead_valid = 1;
1094             }
1095         }
1096       else
1097         {
1098           /* Is this token an identifier?  */
1099           int substituted = 0;
1100           int arg = find_parameter (&tok, is_varargs, va_arg_name,
1101                                     def->argc, def->argv);
1102
1103           if (arg != -1)
1104             {
1105               struct macro_buffer arg_src;
1106
1107               /* Expand any macro invocations in the argument text,
1108                  and append the result to dest.  Remember that scan
1109                  mutates its source, so we need to scan a new buffer
1110                  referring to the argument's text, not the argument
1111                  itself.  */
1112               init_shared_buffer (&arg_src, argv[arg].text, argv[arg].len);
1113               scan (dest, &arg_src, no_loop, lookup_func, lookup_baton);
1114               substituted = 1;
1115             }
1116
1117           /* If it wasn't a parameter, then just copy it across.  */
1118           if (! substituted)
1119             append_tokens_without_splicing (dest, &tok);
1120         }
1121
1122       if (! lookahead_valid)
1123         break;
1124
1125       tok = lookahead;
1126       original_rl_start = lookahead_rl_start;
1127
1128       lookahead_rl_start = replacement_list.text;
1129       lookahead_valid = get_token (&lookahead, &replacement_list);
1130     }
1131 }
1132
1133
1134 /* Expand a call to a macro named ID, whose definition is DEF.  Append
1135    its expansion to DEST.  SRC is the input text following the ID
1136    token.  We are currently rescanning the expansions of the macros
1137    named in NO_LOOP; don't re-expand them.  Use LOOKUP_FUNC and
1138    LOOKUP_BATON to find definitions for any nested macro references.
1139
1140    Return 1 if we decided to expand it, zero otherwise.  (If it's a
1141    function-like macro name that isn't followed by an argument list,
1142    we don't expand it.)  If we return zero, leave SRC unchanged.  */
1143 static int
1144 expand (const char *id,
1145         struct macro_definition *def,
1146         struct macro_buffer *dest,
1147         struct macro_buffer *src,
1148         struct macro_name_list *no_loop,
1149         macro_lookup_ftype *lookup_func,
1150         void *lookup_baton)
1151 {
1152   struct macro_name_list new_no_loop;
1153
1154   /* Create a new node to be added to the front of the no-expand list.
1155      This list is appropriate for re-scanning replacement lists, but
1156      it is *not* appropriate for scanning macro arguments; invocations
1157      of the macro whose arguments we are gathering *do* get expanded
1158      there.  */
1159   new_no_loop.name = id;
1160   new_no_loop.next = no_loop;
1161
1162   /* What kind of macro are we expanding?  */
1163   if (def->kind == macro_object_like)
1164     {
1165       struct macro_buffer replacement_list;
1166
1167       init_shared_buffer (&replacement_list, (char *) def->replacement,
1168                           strlen (def->replacement));
1169
1170       scan (dest, &replacement_list, &new_no_loop, lookup_func, lookup_baton);
1171       return 1;
1172     }
1173   else if (def->kind == macro_function_like)
1174     {
1175       struct cleanup *back_to = make_cleanup (null_cleanup, 0);
1176       int argc = 0;
1177       struct macro_buffer *argv = NULL;
1178       struct macro_buffer substituted;
1179       struct macro_buffer substituted_src;
1180       struct macro_buffer va_arg_name;
1181       int is_varargs = 0;
1182
1183       if (def->argc >= 1)
1184         {
1185           if (strcmp (def->argv[def->argc - 1], "...") == 0)
1186             {
1187               /* In C99-style varargs, substitution is done using
1188                  __VA_ARGS__.  */
1189               init_shared_buffer (&va_arg_name, "__VA_ARGS__",
1190                                   strlen ("__VA_ARGS__"));
1191               is_varargs = 1;
1192             }
1193           else
1194             {
1195               int len = strlen (def->argv[def->argc - 1]);
1196               if (len > 3
1197                   && strcmp (def->argv[def->argc - 1] + len - 3, "...") == 0)
1198                 {
1199                   /* In GNU-style varargs, the name of the
1200                      substitution parameter is the name of the formal
1201                      argument without the "...".  */
1202                   init_shared_buffer (&va_arg_name,
1203                                       (char *) def->argv[def->argc - 1],
1204                                       len - 3);
1205                   is_varargs = 1;
1206                 }
1207             }
1208         }
1209
1210       make_cleanup (free_current_contents, &argv);
1211       argv = gather_arguments (id, src, is_varargs ? def->argc : -1,
1212                                &argc);
1213
1214       /* If we couldn't find any argument list, then we don't expand
1215          this macro.  */
1216       if (! argv)
1217         {
1218           do_cleanups (back_to);
1219           return 0;
1220         }
1221
1222       /* Check that we're passing an acceptable number of arguments for
1223          this macro.  */
1224       if (argc != def->argc)
1225         {
1226           if (is_varargs && argc >= def->argc - 1)
1227             {
1228               /* Ok.  */
1229             }
1230           /* Remember that a sequence of tokens like "foo()" is a
1231              valid invocation of a macro expecting either zero or one
1232              arguments.  */
1233           else if (! (argc == 1
1234                       && argv[0].len == 0
1235                       && def->argc == 0))
1236             error (_("Wrong number of arguments to macro `%s' "
1237                    "(expected %d, got %d)."),
1238                    id, def->argc, argc);
1239         }
1240
1241       /* Note that we don't expand macro invocations in the arguments
1242          yet --- we let subst_args take care of that.  Parameters that
1243          appear as operands of the stringifying operator "#" or the
1244          splicing operator "##" don't get macro references expanded,
1245          so we can't really tell whether it's appropriate to macro-
1246          expand an argument until we see how it's being used.  */
1247       init_buffer (&substituted, 0);
1248       make_cleanup (cleanup_macro_buffer, &substituted);
1249       substitute_args (&substituted, def, is_varargs, &va_arg_name,
1250                        argc, argv, no_loop, lookup_func, lookup_baton);
1251
1252       /* Now `substituted' is the macro's replacement list, with all
1253          argument values substituted into it properly.  Re-scan it for
1254          macro references, but don't expand invocations of this macro.
1255
1256          We create a new buffer, `substituted_src', which points into
1257          `substituted', and scan that.  We can't scan `substituted'
1258          itself, since the tokenization process moves the buffer's
1259          text pointer around, and we still need to be able to find
1260          `substituted's original text buffer after scanning it so we
1261          can free it.  */
1262       init_shared_buffer (&substituted_src, substituted.text, substituted.len);
1263       scan (dest, &substituted_src, &new_no_loop, lookup_func, lookup_baton);
1264
1265       do_cleanups (back_to);
1266
1267       return 1;
1268     }
1269   else
1270     internal_error (__FILE__, __LINE__, _("bad macro definition kind"));
1271 }
1272
1273
1274 /* If the single token in SRC_FIRST followed by the tokens in SRC_REST
1275    constitute a macro invokation not forbidden in NO_LOOP, append its
1276    expansion to DEST and return non-zero.  Otherwise, return zero, and
1277    leave DEST unchanged.
1278
1279    SRC_FIRST and SRC_REST must be shared buffers; DEST must not be one.
1280    SRC_FIRST must be a string built by get_token.  */
1281 static int
1282 maybe_expand (struct macro_buffer *dest,
1283               struct macro_buffer *src_first,
1284               struct macro_buffer *src_rest,
1285               struct macro_name_list *no_loop,
1286               macro_lookup_ftype *lookup_func,
1287               void *lookup_baton)
1288 {
1289   gdb_assert (src_first->shared);
1290   gdb_assert (src_rest->shared);
1291   gdb_assert (! dest->shared);
1292
1293   /* Is this token an identifier?  */
1294   if (src_first->is_identifier)
1295     {
1296       /* Make a null-terminated copy of it, since that's what our
1297          lookup function expects.  */
1298       char *id = xmalloc (src_first->len + 1);
1299       struct cleanup *back_to = make_cleanup (xfree, id);
1300       memcpy (id, src_first->text, src_first->len);
1301       id[src_first->len] = 0;
1302
1303       /* If we're currently re-scanning the result of expanding
1304          this macro, don't expand it again.  */
1305       if (! currently_rescanning (no_loop, id))
1306         {
1307           /* Does this identifier have a macro definition in scope?  */
1308           struct macro_definition *def = lookup_func (id, lookup_baton);
1309
1310           if (def && expand (id, def, dest, src_rest, no_loop,
1311                              lookup_func, lookup_baton))
1312             {
1313               do_cleanups (back_to);
1314               return 1;
1315             }
1316         }
1317
1318       do_cleanups (back_to);
1319     }
1320
1321   return 0;
1322 }
1323
1324
1325 /* Expand macro references in SRC, appending the results to DEST.
1326    Assume we are re-scanning the result of expanding the macros named
1327    in NO_LOOP, and don't try to re-expand references to them.
1328
1329    SRC must be a shared buffer; DEST must not be one.  */
1330 static void
1331 scan (struct macro_buffer *dest,
1332       struct macro_buffer *src,
1333       struct macro_name_list *no_loop,
1334       macro_lookup_ftype *lookup_func,
1335       void *lookup_baton)
1336 {
1337   gdb_assert (src->shared);
1338   gdb_assert (! dest->shared);
1339
1340   for (;;)
1341     {
1342       struct macro_buffer tok;
1343       char *original_src_start = src->text;
1344
1345       /* Find the next token in SRC.  */
1346       if (! get_token (&tok, src))
1347         break;
1348
1349       /* Just for aesthetics.  If we skipped some whitespace, copy
1350          that to DEST.  */
1351       if (tok.text > original_src_start)
1352         {
1353           appendmem (dest, original_src_start, tok.text - original_src_start);
1354           dest->last_token = dest->len;
1355         }
1356
1357       if (! maybe_expand (dest, &tok, src, no_loop, lookup_func, lookup_baton))
1358         /* We didn't end up expanding tok as a macro reference, so
1359            simply append it to dest.  */
1360         append_tokens_without_splicing (dest, &tok);
1361     }
1362
1363   /* Just for aesthetics.  If there was any trailing whitespace in
1364      src, copy it to dest.  */
1365   if (src->len)
1366     {
1367       appendmem (dest, src->text, src->len);
1368       dest->last_token = dest->len;
1369     }
1370 }
1371
1372
1373 char *
1374 macro_expand (const char *source,
1375               macro_lookup_ftype *lookup_func,
1376               void *lookup_func_baton)
1377 {
1378   struct macro_buffer src, dest;
1379   struct cleanup *back_to;
1380
1381   init_shared_buffer (&src, (char *) source, strlen (source));
1382
1383   init_buffer (&dest, 0);
1384   dest.last_token = 0;
1385   back_to = make_cleanup (cleanup_macro_buffer, &dest);
1386
1387   scan (&dest, &src, 0, lookup_func, lookup_func_baton);
1388
1389   appendc (&dest, '\0');
1390
1391   discard_cleanups (back_to);
1392   return dest.text;
1393 }
1394
1395
1396 char *
1397 macro_expand_once (const char *source,
1398                    macro_lookup_ftype *lookup_func,
1399                    void *lookup_func_baton)
1400 {
1401   error (_("Expand-once not implemented yet."));
1402 }
1403
1404
1405 char *
1406 macro_expand_next (char **lexptr,
1407                    macro_lookup_ftype *lookup_func,
1408                    void *lookup_baton)
1409 {
1410   struct macro_buffer src, dest, tok;
1411   struct cleanup *back_to;
1412
1413   /* Set up SRC to refer to the input text, pointed to by *lexptr.  */
1414   init_shared_buffer (&src, *lexptr, strlen (*lexptr));
1415
1416   /* Set up DEST to receive the expansion, if there is one.  */
1417   init_buffer (&dest, 0);
1418   dest.last_token = 0;
1419   back_to = make_cleanup (cleanup_macro_buffer, &dest);
1420
1421   /* Get the text's first preprocessing token.  */
1422   if (! get_token (&tok, &src))
1423     {
1424       do_cleanups (back_to);
1425       return 0;
1426     }
1427
1428   /* If it's a macro invocation, expand it.  */
1429   if (maybe_expand (&dest, &tok, &src, 0, lookup_func, lookup_baton))
1430     {
1431       /* It was a macro invocation!  Package up the expansion as a
1432          null-terminated string and return it.  Set *lexptr to the
1433          start of the next token in the input.  */
1434       appendc (&dest, '\0');
1435       discard_cleanups (back_to);
1436       *lexptr = src.text;
1437       return dest.text;
1438     }
1439   else
1440     {
1441       /* It wasn't a macro invocation.  */
1442       do_cleanups (back_to);
1443       return 0;
1444     }
1445 }