gdb/macroexp.c

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