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