gdb/macroexp.c - gdb

Data types defined

Functions defined

Source code

  1. /* C preprocessor macro expansion for GDB.
  2.    Copyright (C) 2002-2015 Free Software Foundation, Inc.
  3.    Contributed by Red Hat, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  20. #include "defs.h"
  21. #include "gdb_obstack.h"
  22. #include "bcache.h"
  23. #include "macrotab.h"
  24. #include "macroexp.h"
  25. #include "c-lang.h"



  29. /* A resizeable, substringable string type.  */


  32. /* A string type that we can resize, quickly append to, and use to
  33.    refer to substrings of other strings.  */
  34. ‌struct macro_buffer
  35. {
  36.   /* An array of characters.  The first LEN bytes are the real text,
  37.      but there are SIZE bytes allocated to the array.  If SIZE is
  38.      zero, then this doesn't point to a malloc'ed block.  If SHARED is
  39.      non-zero, then this buffer is actually a pointer into some larger
  40.      string, and we shouldn't append characters to it, etc.  Because
  41.      of sharing, we can't assume in general that the text is
  42.      null-terminated.  */
  43.   char *text;

  45.   /* The number of characters in the string.  */
  46.   int len;

  48.   /* The number of characters allocated to the string.  If SHARED is
  49.      non-zero, this is meaningless; in this case, we set it to zero so
  50.      that any "do we have room to append something?" tests will fail,
  51.      so we don't always have to check SHARED before using this field.  */
  52.   int size;

  54.   /* Zero if TEXT can be safely realloc'ed (i.e., it's its own malloc
  55.      block).  Non-zero if TEXT is actually pointing into the middle of
  56.      some other block, and we shouldn't reallocate it.  */
  57.   int shared;

  59.   /* For detecting token splicing.

  61.      This is the index in TEXT of the first character of the token
  62.      that abuts the end of TEXT.  If TEXT contains no tokens, then we
  63.      set this equal to LEN.  If TEXT ends in whitespace, then there is
  64.      no token abutting the end of TEXT (it's just whitespace), and
  65.      again, we set this equal to LEN.  We set this to -1 if we don't
  66.      know the nature of TEXT.  */
  67.   int last_token;

  69.   /* If this buffer is holding the result from get_token, then this
  70.      is non-zero if it is an identifier token, zero otherwise.  */
  71.   int is_identifier;
  72. };


  75. /* Set the macro buffer *B to the empty string, guessing that its
  76.    final contents will fit in N bytes.  (It'll get resized if it
  77.    doesn't, so the guess doesn't have to be right.)  Allocate the
  78.    initial storage with xmalloc.  */
  79. static void
  80. ‌init_buffer (struct macro_buffer *b, int n)
  81. {
  82.   b->size = n;
  83.   if (n > 0)
  84.     b->text = (char *) xmalloc (n);
  85.   else
  86.     b->text = NULL;
  87.   b->len = 0;
  88.   b->shared = 0;
  89.   b->last_token = -1;
  90. }


  93. /* Set the macro buffer *BUF to refer to the LEN bytes at ADDR, as a
  94.    shared substring.  */
  95. static void
  96. ‌init_shared_buffer (struct macro_buffer *buf, char *addr, int len)
  97. {
  98.   buf->text = addr;
  99.   buf->len = len;
  100.   buf->shared = 1;
  101.   buf->size = 0;
  102.   buf->last_token = -1;
  103. }


  106. /* Free the text of the buffer B.  Raise an error if B is shared.  */
  107. static void
  108. ‌free_buffer (struct macro_buffer *b)
  109. {
  110.   gdb_assert (! b->shared);
  111.   if (b->size)
  112.     xfree (b->text);
  113. }

  115. /* Like free_buffer, but return the text as an xstrdup()d string.
  116.    This only exists to try to make the API relatively clean.  */

  118. static char *
  119. ‌free_buffer_return_text (struct macro_buffer *b)
  120. {
  121.   gdb_assert (! b->shared);
  122.   gdb_assert (b->size);
  123.   /* Nothing to do.  */
  124.   return b->text;
  125. }

  127. /* A cleanup function for macro buffers.  */
  128. static void
  129. ‌cleanup_macro_buffer (void *untyped_buf)
  130. {
  131.   free_buffer ((struct macro_buffer *) untyped_buf);
  132. }


  135. /* Resize the buffer B to be at least N bytes long.  Raise an error if
  136.    B shouldn't be resized.  */
  137. static void
  138. ‌resize_buffer (struct macro_buffer *b, int n)
  139. {
  140.   /* We shouldn't be trying to resize shared strings.  */
  141.   gdb_assert (! b->shared);

  143.   if (b->size == 0)
  144.     b->size = n;
  145.   else
  146.     while (b->size <= n)
  147.       b->size *= 2;

  149.   b->text = xrealloc (b->text, b->size);
  150. }


  153. /* Append the character C to the buffer B.  */
  154. static void
  155. ‌appendc (struct macro_buffer *b, int c)
  156. {
  157.   int new_len = b->len + 1;

  159.   if (new_len > b->size)
  160.     resize_buffer (b, new_len);

  162.   b->text[b->len] = c;
  163.   b->len = new_len;
  164. }


  167. /* Append the LEN bytes at ADDR to the buffer B.  */
  168. static void
  169. ‌appendmem (struct macro_buffer *b, char *addr, int len)
  170. {
  171.   int new_len = b->len + len;

  173.   if (new_len > b->size)
  174.     resize_buffer (b, new_len);

  176.   memcpy (b->text + b->len, addr, len);
  177.   b->len = new_len;
  178. }



  182. /* Recognizing preprocessor tokens.  */


  185. int
  186. ‌macro_is_whitespace (int c)
  187. {
  188.   return (c == ' '
  189.           || c == '\t'
  190.           || c == '\n'
  191.           || c == '\v'
  192.           || c == '\f');
  193. }


  196. int
  197. ‌macro_is_digit (int c)
  198. {
  199.   return ('0' <= c && c <= '9');
  200. }


  203. int
  204. ‌macro_is_identifier_nondigit (int c)
  205. {
  206.   return (c == '_'
  207.           || ('a' <= c && c <= 'z')
  208.           || ('A' <= c && c <= 'Z'));
  209. }


  212. static void
  213. ‌set_token (struct macro_buffer *tok, char *start, char *end)
  214. {
  215.   init_shared_buffer (tok, start, end - start);
  216.   tok->last_token = 0;

  218.   /* Presumed; get_identifier may overwrite this.  */
  219.   tok->is_identifier = 0;
  220. }


  223. static int
  224. ‌get_comment (struct macro_buffer *tok, char *p, char *end)
  225. {
  226.   if (p + 2 > end)
  227.     return 0;
  228.   else if (p[0] == '/'
  229.            && p[1] == '*')
  230.     {
  231.       char *tok_start = p;

  233.       p += 2;

  235.       for (; p < end; p++)
  236.         if (p + 2 <= end
  237.             && p[0] == '*'
  238.             && p[1] == '/')
  239.           {
  240.             p += 2;
  241.             set_token (tok, tok_start, p);
  242.             return 1;
  243.           }

  245.       error (_("Unterminated comment in macro expansion."));
  246.     }
  247.   else if (p[0] == '/'
  248.            && p[1] == '/')
  249.     {
  250.       char *tok_start = p;

  252.       p += 2;
  253.       for (; p < end; p++)
  254.         if (*p == '\n')
  255.           break;

  257.       set_token (tok, tok_start, p);
  258.       return 1;
  259.     }
  260.   else
  261.     return 0;
  262. }


  265. static int
  266. ‌get_identifier (struct macro_buffer *tok, char *p, char *end)
  267. {
  268.   if (p < end
  269.       && macro_is_identifier_nondigit (*p))
  270.     {
  271.       char *tok_start = p;

  273.       while (p < end
  274.              && (macro_is_identifier_nondigit (*p)
  275.                  || macro_is_digit (*p)))
  276.         p++;

  278.       set_token (tok, tok_start, p);
  279.       tok->is_identifier = 1;
  280.       return 1;
  281.     }
  282.   else
  283.     return 0;
  284. }


  287. static int
  288. ‌get_pp_number (struct macro_buffer *tok, char *p, char *end)
  289. {
  290.   if (p < end
  291.       && (macro_is_digit (*p)
  292.           || (*p == '.'
  293.               && p + 2 <= end
  294.               && macro_is_digit (p[1]))))
  295.     {
  296.       char *tok_start = p;

  298.       while (p < end)
  299.         {
  300.           if (p + 2 <= end
  301.               && strchr ("eEpP", *p)
  302.               && (p[1] == '+' || p[1] == '-'))
  303.             p += 2;
  304.           else if (macro_is_digit (*p)
  305.                    || macro_is_identifier_nondigit (*p)
  306.                    || *p == '.')
  307.             p++;
  308.           else
  309.             break;
  310.         }

  312.       set_token (tok, tok_start, p);
  313.       return 1;
  314.     }
  315.   else
  316.     return 0;
  317. }



  321. /* If the text starting at P going up to (but not including) END
  322.    starts with a character constant, set *TOK to point to that
  323.    character constant, and return 1.  Otherwise, return zero.
  324.    Signal an error if it contains a malformed or incomplete character
  325.    constant.  */
  326. static int
  327. ‌get_character_constant (struct macro_buffer *tok, char *p, char *end)
  328. {
  329.   /* ISO/IEC 9899:1999 (E)  Section 6.4.4.4  paragraph 1
  330.      But of course, what really matters is that we handle it the same
  331.      way GDB's C/C++ lexer does.  So we call parse_escape in utils.c
  332.      to handle escape sequences.  */
  333.   if ((p + 1 <= end && *p == '\'')
  334.       || (p + 2 <= end
  335.           && (p[0] == 'L' || p[0] == 'u' || p[0] == 'U')
  336.           && p[1] == '\''))
  337.     {
  338.       char *tok_start = p;
  339.       int char_count = 0;

  341.       if (*p == '\'')
  342.         p++;
  343.       else if (*p == 'L' || *p == 'u' || *p == 'U')
  344.         p += 2;
  345.       else
  346.         gdb_assert_not_reached ("unexpected character constant");

  348.       for (;;)
  349.         {
  350.           if (p >= end)
  351.             error (_("Unmatched single quote."));
  352.           else if (*p == '\'')
  353.             {
  354.               if (!char_count)
  355.                 error (_("A character constant must contain at least one "
  356.                        "character."));
  357.               p++;
  358.               break;
  359.             }
  360.           else if (*p == '\\')
  361.             {
  362.               const char *s, *o;

  364.               s = o = ++p;
  365.               char_count += c_parse_escape (&s, NULL);
  366.               p += s - o;
  367.             }
  368.           else
  369.             {
  370.               p++;
  371.               char_count++;
  372.             }
  373.         }

  375.       set_token (tok, tok_start, p);
  376.       return 1;
  377.     }
  378.   else
  379.     return 0;
  380. }


  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;

  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");

  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.               const char *s, *o;

  421.               s = o = ++p;
  422.               c_parse_escape (&s, NULL);
  423.               p += s - o;
  424.             }
  425.           else
  426.             p++;
  427.         }

  429.       set_token (tok, tok_start, p);
  430.       return 1;
  431.     }
  432.   else
  433.     return 0;
  434. }


  437. static int
  438. ‌get_punctuator (struct macro_buffer *tok, char *p, char *end)
  439. {
  440.   /* Here, speed is much less important than correctness and clarity.  */

  442.   /* ISO/IEC 9899:1999 (E)  Section 6.4.6  Paragraph 1.
  443.      Note that this table is ordered in a special way.  A punctuator
  444.      which is a prefix of another punctuator must appear after its
  445.      "extension".  Otherwise, the wrong token will be returned.  */
  446.   static const char * const punctuators[] = {
  447.     "[", "]", "(", ")", "{", "}", "?", ";", ",", "~",
  448.     "...", ".",
  449.     "->", "--", "-=", "-",
  450.     "++", "+=", "+",
  451.     "*=", "*",
  452.     "!=", "!",
  453.     "&&", "&=", "&",
  454.     "/=", "/",
  455.     "%>", "%:%:", "%:", "%=", "%",
  456.     "^=", "^",
  457.     "##", "#",
  458.     ":>", ":",
  459.     "||", "|=", "|",
  460.     "<<=", "<<", "<=", "<:", "<%", "<",
  461.     ">>=", ">>", ">=", ">",
  462.     "==", "=",
  463.     0
  464.   };

  466.   int i;

  468.   if (p + 1 <= end)
  469.     {
  470.       for (i = 0; punctuators[i]; i++)
  471.         {
  472.           const char *punctuator = punctuators[i];

  474.           if (p[0] == punctuator[0])
  475.             {
  476.               int len = strlen (punctuator);

  478.               if (p + len <= end
  479.                   && ! memcmp (p, punctuator, len))
  480.                 {
  481.                   set_token (tok, p, p + len);
  482.                   return 1;
  483.                 }
  484.             }
  485.         }
  486.     }

  488.   return 0;
  489. }


  492. /* Peel the next preprocessor token off of SRC, and put it in TOK.
  493.    Mutate TOK to refer to the first token in SRC, and mutate SRC to
  494.    refer to the text after that token.  SRC must be a shared buffer;
  495.    the resulting TOK will be shared, pointing into the same string SRC
  496.    does.  Initialize TOK's last_token field.  Return non-zero if we
  497.    succeed, or 0 if we didn't find any more tokens in SRC.  */
  498. static int
  499. ‌get_token (struct macro_buffer *tok,
  500.            struct macro_buffer *src)
  501. {
  502.   char *p = src->text;
  503.   char *end = p + src->len;

  505.   gdb_assert (src->shared);

  507.   /* From the ISO C standard, ISO/IEC 9899:1999 (E), section 6.4:

  509.      preprocessing-token:
  510.          header-name
  511.          identifier
  512.          pp-number
  513.          character-constant
  514.          string-literal
  515.          punctuator
  516.          each non-white-space character that cannot be one of the above

  518.      We don't have to deal with header-name tokens, since those can
  519.      only occur after a #include, which we will never see.  */

  521.   while (p < end)
  522.     if (macro_is_whitespace (*p))
  523.       p++;
  524.     else if (get_comment (tok, p, end))
  525.       p += tok->len;
  526.     else if (get_pp_number (tok, p, end)
  527.              || get_character_constant (tok, p, end)
  528.              || get_string_literal (tok, p, end)
  529.              /* Note: the grammar in the standard seems to be
  530.                 ambiguous: L'x' can be either a wide character
  531.                 constant, or an identifier followed by a normal
  532.                 character constant.  By trying `get_identifier' after
  533.                 we try get_character_constant and get_string_literal,
  534.                 we give the wide character syntax precedence.  Now,
  535.                 since GDB doesn't handle wide character constants
  536.                 anyway, is this the right thing to do?  */
  537.              || get_identifier (tok, p, end)
  538.              || get_punctuator (tok, p, end))
  539.       {
  540.         /* How many characters did we consume, including whitespace?  */
  541.         int consumed = p - src->text + tok->len;

  543.         src->text += consumed;
  544.         src->len -= consumed;
  545.         return 1;
  546.       }
  547.     else
  548.       {
  549.         /* We have found a "non-whitespace character that cannot be
  550.            one of the above."  Make a token out of it.  */
  551.         int consumed;

  553.         set_token (tok, p, p + 1);
  554.         consumed = p - src->text + tok->len;
  555.         src->text += consumed;
  556.         src->len -= consumed;
  557.         return 1;
  558.       }

  560.   return 0;
  561. }



  565. /* Appending token strings, with and without splicing  */


  568. /* Append the macro buffer SRC to the end of DEST, and ensure that
  569.    doing so doesn't splice the token at the end of SRC with the token
  570.    at the beginning of DEST.  SRC and DEST must have their last_token
  571.    fields set.  Upon return, DEST's last_token field is set correctly.

  573.    For example:

  575.    If DEST is "(" and SRC is "y", then we can return with
  576.    DEST set to "(y" --- we've simply appended the two buffers.

  578.    However, if DEST is "x" and SRC is "y", then we must not return
  579.    with DEST set to "xy" --- that would splice the two tokens "x" and
  580.    "y" together to make a single token "xy".  However, it would be
  581.    fine to return with DEST set to "x y".  Similarly, "<" and "<" must
  582.    yield "< <", not "<<", etc.  */
  583. static void
  584. ‌append_tokens_without_splicing (struct macro_buffer *dest,
  585.                                 struct macro_buffer *src)
  586. {
  587.   int original_dest_len = dest->len;
  588.   struct macro_buffer dest_tail, new_token;

  590.   gdb_assert (src->last_token != -1);
  591.   gdb_assert (dest->last_token != -1);

  593.   /* First, just try appending the two, and call get_token to see if
  594.      we got a splice.  */
  595.   appendmem (dest, src->text, src->len);

  597.   /* If DEST originally had no token abutting its end, then we can't
  598.      have spliced anything, so we're done.  */
  599.   if (dest->last_token == original_dest_len)
  600.     {
  601.       dest->last_token = original_dest_len + src->last_token;
  602.       return;
  603.     }

  605.   /* Set DEST_TAIL to point to the last token in DEST, followed by
  606.      all the stuff we just appended.  */
  607.   init_shared_buffer (&dest_tail,
  608.                       dest->text + dest->last_token,
  609.                       dest->len - dest->last_token);

  611.   /* Re-parse DEST's last token.  We know that DEST used to contain
  612.      at least one token, so if it doesn't contain any after the
  613.      append, then we must have spliced "/" and "*" or "/" and "/" to
  614.      make a comment start.  (Just for the record, I got this right
  615.      the first time.  This is not a bug fix.)  */
  616.   if (get_token (&new_token, &dest_tail)
  617.       && (new_token.text + new_token.len
  618.           == dest->text + original_dest_len))
  619.     {
  620.       /* No splice, so we're done.  */
  621.       dest->last_token = original_dest_len + src->last_token;
  622.       return;
  623.     }

  625.   /* Okay, a simple append caused a splice.  Let's chop dest back to
  626.      its original length and try again, but separate the texts with a
  627.      space.  */
  628.   dest->len = original_dest_len;
  629.   appendc (dest, ' ');
  630.   appendmem (dest, src->text, src->len);

  632.   init_shared_buffer (&dest_tail,
  633.                       dest->text + dest->last_token,
  634.                       dest->len - dest->last_token);

  636.   /* Try to re-parse DEST's last token, as above.  */
  637.   if (get_token (&new_token, &dest_tail)
  638.       && (new_token.text + new_token.len
  639.           == dest->text + original_dest_len))
  640.     {
  641.       /* No splice, so we're done.  */
  642.       dest->last_token = original_dest_len + 1 + src->last_token;
  643.       return;
  644.     }

  646.   /* As far as I know, there's no case where inserting a space isn't
  647.      enough to prevent a splice.  */
  648.   internal_error (__FILE__, __LINE__,
  649.                   _("unable to avoid splicing tokens during macro expansion"));
  650. }

  652. /* Stringify an argument, and insert it into DEST.  ARG is the text to
  653.    stringify; it is LEN bytes long.  */

  655. static void
  656. ‌stringify (struct macro_buffer *dest, const char *arg, int len)
  657. {
  658.   /* Trim initial whitespace from ARG.  */
  659.   while (len > 0 && macro_is_whitespace (*arg))
  660.     {
  661.       ++arg;
  662.       --len;
  663.     }

  665.   /* Trim trailing whitespace from ARG.  */
  666.   while (len > 0 && macro_is_whitespace (arg[len - 1]))
  667.     --len;

  669.   /* Insert the string.  */
  670.   appendc (dest, '"');
  671.   while (len > 0)
  672.     {
  673.       /* We could try to handle strange cases here, like control
  674.          characters, but there doesn't seem to be much point.  */
  675.       if (macro_is_whitespace (*arg))
  676.         {
  677.           /* Replace a sequence of whitespace with a single space.  */
  678.           appendc (dest, ' ');
  679.           while (len > 1 && macro_is_whitespace (arg[1]))
  680.             {
  681.               ++arg;
  682.               --len;
  683.             }
  684.         }
  685.       else if (*arg == '\\' || *arg == '"')
  686.         {
  687.           appendc (dest, '\\');
  688.           appendc (dest, *arg);
  689.         }
  690.       else
  691.         appendc (dest, *arg);
  692.       ++arg;
  693.       --len;
  694.     }
  695.   appendc (dest, '"');
  696.   dest->last_token = dest->len;
  697. }

  699. /* See macroexp.h.  */

  701. char *
  702. ‌macro_stringify (const char *str)
  703. {
  704.   struct macro_buffer buffer;
  705.   int len = strlen (str);

  707.   init_buffer (&buffer, len);
  708.   stringify (&buffer, str, len);
  709.   appendc (&buffer, '\0');

  711.   return free_buffer_return_text (&buffer);
  712. }


  715. /* Expanding macros!  */


  718. /* A singly-linked list of the names of the macros we are currently
  719.    expanding --- for detecting expansion loops.  */
  720. ‌struct macro_name_list {
  721.   const char *name;
  722.   struct macro_name_list *next;
  723. };


  726. /* Return non-zero if we are currently expanding the macro named NAME,
  727.    according to LIST; otherwise, return zero.

  729.    You know, it would be possible to get rid of all the NO_LOOP
  730.    arguments to these functions by simply generating a new lookup
  731.    function and baton which refuses to find the definition for a
  732.    particular macro, and otherwise delegates the decision to another
  733.    function/baton pair.  But that makes the linked list of excluded
  734.    macros chained through untyped baton pointers, which will make it
  735.    harder to debug.  :(  */
  736. static int
  737. ‌currently_rescanning (struct macro_name_list *list, const char *name)
  738. {
  739.   for (; list; list = list->next)
  740.     if (strcmp (name, list->name) == 0)
  741.       return 1;

  743.   return 0;
  744. }


  747. /* Gather the arguments to a macro expansion.

  749.    NAME is the name of the macro being invoked.  (It's only used for
  750.    printing error messages.)

  752.    Assume that SRC is the text of the macro invocation immediately
  753.    following the macro name.  For example, if we're processing the
  754.    text foo(bar, baz), then NAME would be foo and SRC will be (bar,
  755.    baz).

  757.    If SRC doesn't start with an open paren ( token at all, return
  758.    zero, leave SRC unchanged, and don't set *ARGC_P to anything.

  760.    If SRC doesn't contain a properly terminated argument list, then
  761.    raise an error.

  763.    For a variadic macro, NARGS holds the number of formal arguments to
  764.    the macro.  For a GNU-style variadic macro, this should be the
  765.    number of named arguments.  For a non-variadic macro, NARGS should
  766.    be -1.

  768.    Otherwise, return a pointer to the first element of an array of
  769.    macro buffers referring to the argument texts, and set *ARGC_P to
  770.    the number of arguments we found --- the number of elements in the
  771.    array.  The macro buffers share their text with SRC, and their
  772.    last_token fields are initialized.  The array is allocated with
  773.    xmalloc, and the caller is responsible for freeing it.

  775.    NOTE WELL: if SRC starts with a open paren ( token followed
  776.    immediately by a close paren ) token (e.g., the invocation looks
  777.    like "foo()"), we treat that as one argument, which happens to be
  778.    the empty list of tokens.  The caller should keep in mind that such
  779.    a sequence of tokens is a valid way to invoke one-parameter
  780.    function-like macros, but also a valid way to invoke zero-parameter
  781.    function-like macros.  Eeew.

  783.    Consume the tokens from SRC; after this call, SRC contains the text
  784.    following the invocation.  */

  786. static struct macro_buffer *
  787. ‌gather_arguments (const char *name, struct macro_buffer *src,
  788.                   int nargs, int *argc_p)
  789. {
  790.   struct macro_buffer tok;
  791.   int args_len, args_size;
  792.   struct macro_buffer *args = NULL;
  793.   struct cleanup *back_to = make_cleanup (free_current_contents, &args);

  795.   /* Does SRC start with an opening paren token?  Read from a copy of
  796.      SRC, so SRC itself is unaffected if we don't find an opening
  797.      paren.  */
  798.   {
  799.     struct macro_buffer temp;

  801.     init_shared_buffer (&temp, src->text, src->len);

  803.     if (! get_token (&tok, &temp)
  804.         || tok.len != 1
  805.         || tok.text[0] != '(')
  806.       {
  807.         discard_cleanups (back_to);
  808.         return 0;
  809.       }
  810.   }

  812.   /* Consume SRC's opening paren.  */
  813.   get_token (&tok, src);

  815.   args_len = 0;
  816.   args_size = 6;
  817.   args = (struct macro_buffer *) xmalloc (sizeof (*args) * args_size);

  819.   for (;;)
  820.     {
  821.       struct macro_buffer *arg;
  822.       int depth;

  824.       /* Make sure we have room for the next argument.  */
  825.       if (args_len >= args_size)
  826.         {
  827.           args_size *= 2;
  828.           args = xrealloc (args, sizeof (*args) * args_size);
  829.         }

  831.       /* Initialize the next argument.  */
  832.       arg = &args[args_len++];
  833.       set_token (arg, src->text, src->text);

  835.       /* Gather the argument's tokens.  */
  836.       depth = 0;
  837.       for (;;)
  838.         {
  839.           if (! get_token (&tok, src))
  840.             error (_("Malformed argument list for macro `%s'."), name);

  842.           /* Is tok an opening paren?  */
  843.           if (tok.len == 1 && tok.text[0] == '(')
  844.             depth++;

  846.           /* Is tok is a closing paren?  */
  847.           else if (tok.len == 1 && tok.text[0] == ')')
  848.             {
  849.               /* If it's a closing paren at the top level, then that's
  850.                  the end of the argument list.  */
  851.               if (depth == 0)
  852.                 {
  853.                   /* In the varargs case, the last argument may be
  854.                      missing.  Add an empty argument in this case.  */
  855.                   if (nargs != -1 && args_len == nargs - 1)
  856.                     {
  857.                       /* Make sure we have room for the argument.  */
  858.                       if (args_len >= args_size)
  859.                         {
  860.                           args_size++;
  861.                           args = xrealloc (args, sizeof (*args) * args_size);
  862.                         }
  863.                       arg = &args[args_len++];
  864.                       set_token (arg, src->text, src->text);
  865.                     }

  867.                   discard_cleanups (back_to);
  868.                   *argc_p = args_len;
  869.                   return args;
  870.                 }

  872.               depth--;
  873.             }

  875.           /* If tok is a comma at top level, then that's the end of
  876.              the current argument.  However, if we are handling a
  877.              variadic macro and we are computing the last argument, we
  878.              want to include the comma and remaining tokens.  */
  879.           else if (tok.len == 1 && tok.text[0] == ',' && depth == 0
  880.                    && (nargs == -1 || args_len < nargs))
  881.             break;

  883.           /* Extend the current argument to enclose this token.  If
  884.              this is the current argument's first token, leave out any
  885.              leading whitespace, just for aesthetics.  */
  886.           if (arg->len == 0)
  887.             {
  888.               arg->text = tok.text;
  889.               arg->len = tok.len;
  890.               arg->last_token = 0;
  891.             }
  892.           else
  893.             {
  894.               arg->len = (tok.text + tok.len) - arg->text;
  895.               arg->last_token = tok.text - arg->text;
  896.             }
  897.         }
  898.     }
  899. }


  902. /* The `expand' and `substitute_args' functions both invoke `scan'
  903.    recursively, so we need a forward declaration somewhere.  */
  904. static void scan (struct macro_buffer *dest,
  905.                   struct macro_buffer *src,
  906.                   struct macro_name_list *no_loop,
  907.                   macro_lookup_ftype *lookup_func,
  908.                   void *lookup_baton);


  911. /* A helper function for substitute_args.

  913.    ARGV is a vector of all the arguments; ARGC is the number of
  914.    arguments.  IS_VARARGS is true if the macro being substituted is a
  915.    varargs macro; in this case VA_ARG_NAME is the name of the
  916.    "variable" argument.  VA_ARG_NAME is ignored if IS_VARARGS is
  917.    false.

  919.    If the token TOK is the name of a parameter, return the parameter's
  920.    index.  If TOK is not an argument, return -1.  */

  922. static int
  923. ‌find_parameter (const struct macro_buffer *tok,
  924.                 int is_varargs, const struct macro_buffer *va_arg_name,
  925.                 int argc, const char * const *argv)
  926. {
  927.   int i;

  929.   if (! tok->is_identifier)
  930.     return -1;

  932.   for (i = 0; i < argc; ++i)
  933.     if (tok->len == strlen (argv[i])
  934.         && !memcmp (tok->text, argv[i], tok->len))
  935.       return i;

  937.   if (is_varargs && tok->len == va_arg_name->len
  938.       && ! memcmp (tok->text, va_arg_name->text, tok->len))
  939.     return argc - 1;

  941.   return -1;
  942. }

  944. /* Given the macro definition DEF, being invoked with the actual
  945.    arguments given by ARGC and ARGV, substitute the arguments into the
  946.    replacement list, and store the result in DEST.

  948.    IS_VARARGS should be true if DEF is a varargs macro.  In this case,
  949.    VA_ARG_NAME should be the name of the "variable" argument -- either
  950.    __VA_ARGS__ for c99-style varargs, or the final argument name, for
  951.    GNU-style varargs.  If IS_VARARGS is false, this parameter is
  952.    ignored.

  954.    If it is necessary to expand macro invocations in one of the
  955.    arguments, use LOOKUP_FUNC and LOOKUP_BATON to find the macro
  956.    definitions, and don't expand invocations of the macros listed in
  957.    NO_LOOP.  */

  959. static void
  960. ‌substitute_args (struct macro_buffer *dest,
  961.                  struct macro_definition *def,
  962.                  int is_varargs, const struct macro_buffer *va_arg_name,
  963.                  int argc, struct macro_buffer *argv,
  964.                  struct macro_name_list *no_loop,
  965.                  macro_lookup_ftype *lookup_func,
  966.                  void *lookup_baton)
  967. {
  968.   /* A macro buffer for the macro's replacement list.  */
  969.   struct macro_buffer replacement_list;
  970.   /* The token we are currently considering.  */
  971.   struct macro_buffer tok;
  972.   /* The replacement list's pointer from just before TOK was lexed.  */
  973.   char *original_rl_start;
  974.   /* We have a single lookahead token to handle token splicing.  */
  975.   struct macro_buffer lookahead;
  976.   /* The lookahead token might not be valid.  */
  977.   int lookahead_valid;
  978.   /* The replacement list's pointer from just before LOOKAHEAD was
  979.      lexed.  */
  980.   char *lookahead_rl_start;

  982.   init_shared_buffer (&replacement_list, (char *) def->replacement,
  983.                       strlen (def->replacement));

  985.   gdb_assert (dest->len == 0);
  986.   dest->last_token = 0;

  988.   original_rl_start = replacement_list.text;
  989.   if (! get_token (&tok, &replacement_list))
  990.     return;
  991.   lookahead_rl_start = replacement_list.text;
  992.   lookahead_valid = get_token (&lookahead, &replacement_list);

  994.   for (;;)
  995.     {
  996.       /* Just for aesthetics.  If we skipped some whitespace, copy
  997.          that to DEST.  */
  998.       if (tok.text > original_rl_start)
  999.         {
  1000.           appendmem (dest, original_rl_start, tok.text - original_rl_start);
  1001.           dest->last_token = dest->len;
  1002.         }

  1004.       /* Is this token the stringification operator?  */
  1005.       if (tok.len == 1
  1006.           && tok.text[0] == '#')
  1007.         {
  1008.           int arg;

  1010.           if (!lookahead_valid)
  1011.             error (_("Stringification operator requires an argument."));

  1013.           arg = find_parameter (&lookahead, is_varargs, va_arg_name,
  1014.                                 def->argc, def->argv);
  1015.           if (arg == -1)
  1016.             error (_("Argument to stringification operator must name "
  1017.                      "a macro parameter."));

  1019.           stringify (dest, argv[arg].text, argv[arg].len);

  1021.           /* Read one token and let the loop iteration code handle the
  1022.              rest.  */
  1023.           lookahead_rl_start = replacement_list.text;
  1024.           lookahead_valid = get_token (&lookahead, &replacement_list);
  1025.         }
  1026.       /* Is this token the splicing operator?  */
  1027.       else if (tok.len == 2
  1028.                && tok.text[0] == '#'
  1029.                && tok.text[1] == '#')
  1030.         error (_("Stray splicing operator"));
  1031.       /* Is the next token the splicing operator?  */
  1032.       else if (lookahead_valid
  1033.                && lookahead.len == 2
  1034.                && lookahead.text[0] == '#'
  1035.                && lookahead.text[1] == '#')
  1036.         {
  1037.           int finished = 0;
  1038.           int prev_was_comma = 0;

  1040.           /* Note that GCC warns if the result of splicing is not a
  1041.              token.  In the debugger there doesn't seem to be much
  1042.              benefit from doing this.  */

  1044.           /* Insert the first token.  */
  1045.           if (tok.len == 1 && tok.text[0] == ',')
  1046.             prev_was_comma = 1;
  1047.           else
  1048.             {
  1049.               int arg = find_parameter (&tok, is_varargs, va_arg_name,
  1050.                                         def->argc, def->argv);

  1052.               if (arg != -1)
  1053.                 appendmem (dest, argv[arg].text, argv[arg].len);
  1054.               else
  1055.                 appendmem (dest, tok.text, tok.len);
  1056.             }

  1058.           /* Apply a possible sequence of ## operators.  */
  1059.           for (;;)
  1060.             {
  1061.               if (! get_token (&tok, &replacement_list))
  1062.                 error (_("Splicing operator at end of macro"));

  1064.               /* Handle a comma before a ##.  If we are handling
  1065.                  varargs, and the token on the right hand side is the
  1066.                  varargs marker, and the final argument is empty or
  1067.                  missing, then drop the comma.  This is a GNU
  1068.                  extension.  There is one ambiguous case here,
  1069.                  involving pedantic behavior with an empty argument,
  1070.                  but we settle that in favor of GNU-style (GCC uses an
  1071.                  option).  If we aren't dealing with varargs, we
  1072.                  simply insert the comma.  */
  1073.               if (prev_was_comma)
  1074.                 {
  1075.                   if (! (is_varargs
  1076.                          && tok.len == va_arg_name->len
  1077.                          && !memcmp (tok.text, va_arg_name->text, tok.len)
  1078.                          && argv[argc - 1].len == 0))
  1079.                     appendmem (dest, ",", 1);
  1080.                   prev_was_comma = 0;
  1081.                 }

  1083.               /* Insert the token.  If it is a parameter, insert the
  1084.                  argument.  If it is a comma, treat it specially.  */
  1085.               if (tok.len == 1 && tok.text[0] == ',')
  1086.                 prev_was_comma = 1;
  1087.               else
  1088.                 {
  1089.                   int arg = find_parameter (&tok, is_varargs, va_arg_name,
  1090.                                             def->argc, def->argv);

  1092.                   if (arg != -1)
  1093.                     appendmem (dest, argv[arg].text, argv[arg].len);
  1094.                   else
  1095.                     appendmem (dest, tok.text, tok.len);
  1096.                 }

  1098.               /* Now read another token.  If it is another splice, we
  1099.                  loop.  */
  1100.               original_rl_start = replacement_list.text;
  1101.               if (! get_token (&tok, &replacement_list))
  1102.                 {
  1103.                   finished = 1;
  1104.                   break;
  1105.                 }

  1107.               if (! (tok.len == 2
  1108.                      && tok.text[0] == '#'
  1109.                      && tok.text[1] == '#'))
  1110.                 break;
  1111.             }

  1113.           if (prev_was_comma)
  1114.             {
  1115.               /* We saw a comma.  Insert it now.  */
  1116.               appendmem (dest, ",", 1);
  1117.             }

  1119.           dest->last_token = dest->len;
  1120.           if (finished)
  1121.             lookahead_valid = 0;
  1122.           else
  1123.             {
  1124.               /* Set up for the loop iterator.  */
  1125.               lookahead = tok;
  1126.               lookahead_rl_start = original_rl_start;
  1127.               lookahead_valid = 1;
  1128.             }
  1129.         }
  1130.       else
  1131.         {
  1132.           /* Is this token an identifier?  */
  1133.           int substituted = 0;
  1134.           int arg = find_parameter (&tok, is_varargs, va_arg_name,
  1135.                                     def->argc, def->argv);

  1137.           if (arg != -1)
  1138.             {
  1139.               struct macro_buffer arg_src;

  1141.               /* Expand any macro invocations in the argument text,
  1142.                  and append the result to dest.  Remember that scan
  1143.                  mutates its source, so we need to scan a new buffer
  1144.                  referring to the argument's text, not the argument
  1145.                  itself.  */
  1146.               init_shared_buffer (&arg_src, argv[arg].text, argv[arg].len);
  1147.               scan (dest, &arg_src, no_loop, lookup_func, lookup_baton);
  1148.               substituted = 1;
  1149.             }

  1151.           /* If it wasn't a parameter, then just copy it across.  */
  1152.           if (! substituted)
  1153.             append_tokens_without_splicing (dest, &tok);
  1154.         }

  1156.       if (! lookahead_valid)
  1157.         break;

  1159.       tok = lookahead;
  1160.       original_rl_start = lookahead_rl_start;

  1162.       lookahead_rl_start = replacement_list.text;
  1163.       lookahead_valid = get_token (&lookahead, &replacement_list);
  1164.     }
  1165. }


  1168. /* Expand a call to a macro named ID, whose definition is DEF.  Append
  1169.    its expansion to DEST.  SRC is the input text following the ID
  1170.    token.  We are currently rescanning the expansions of the macros
  1171.    named in NO_LOOP; don't re-expand them.  Use LOOKUP_FUNC and
  1172.    LOOKUP_BATON to find definitions for any nested macro references.

  1174.    Return 1 if we decided to expand it, zero otherwise.  (If it's a
  1175.    function-like macro name that isn't followed by an argument list,
  1176.    we don't expand it.)  If we return zero, leave SRC unchanged.  */
  1177. static int
  1178. ‌expand (const char *id,
  1179.         struct macro_definition *def,
  1180.         struct macro_buffer *dest,
  1181.         struct macro_buffer *src,
  1182.         struct macro_name_list *no_loop,
  1183.         macro_lookup_ftype *lookup_func,
  1184.         void *lookup_baton)
  1185. {
  1186.   struct macro_name_list new_no_loop;

  1188.   /* Create a new node to be added to the front of the no-expand list.
  1189.      This list is appropriate for re-scanning replacement lists, but
  1190.      it is *not* appropriate for scanning macro arguments; invocations
  1191.      of the macro whose arguments we are gathering *do* get expanded
  1192.      there.  */
  1193.   new_no_loop.name = id;
  1194.   new_no_loop.next = no_loop;

  1196.   /* What kind of macro are we expanding?  */
  1197.   if (def->kind == macro_object_like)
  1198.     {
  1199.       struct macro_buffer replacement_list;

  1201.       init_shared_buffer (&replacement_list, (char *) def->replacement,
  1202.                           strlen (def->replacement));

  1204.       scan (dest, &replacement_list, &new_no_loop, lookup_func, lookup_baton);
  1205.       return 1;
  1206.     }
  1207.   else if (def->kind == macro_function_like)
  1208.     {
  1209.       struct cleanup *back_to = make_cleanup (null_cleanup, 0);
  1210.       int argc = 0;
  1211.       struct macro_buffer *argv = NULL;
  1212.       struct macro_buffer substituted;
  1213.       struct macro_buffer substituted_src;
  1214.       struct macro_buffer va_arg_name = {0};
  1215.       int is_varargs = 0;

  1217.       if (def->argc >= 1)
  1218.         {
  1219.           if (strcmp (def->argv[def->argc - 1], "...") == 0)
  1220.             {
  1221.               /* In C99-style varargs, substitution is done using
  1222.                  __VA_ARGS__.  */
  1223.               init_shared_buffer (&va_arg_name, "__VA_ARGS__",
  1224.                                   strlen ("__VA_ARGS__"));
  1225.               is_varargs = 1;
  1226.             }
  1227.           else
  1228.             {
  1229.               int len = strlen (def->argv[def->argc - 1]);

  1231.               if (len > 3
  1232.                   && strcmp (def->argv[def->argc - 1] + len - 3, "...") == 0)
  1233.                 {
  1234.                   /* In GNU-style varargs, the name of the
  1235.                      substitution parameter is the name of the formal
  1236.                      argument without the "...".  */
  1237.                   init_shared_buffer (&va_arg_name,
  1238.                                       (char *) def->argv[def->argc - 1],
  1239.                                       len - 3);
  1240.                   is_varargs = 1;
  1241.                 }
  1242.             }
  1243.         }

  1245.       make_cleanup (free_current_contents, &argv);
  1246.       argv = gather_arguments (id, src, is_varargs ? def->argc : -1,
  1247.                                &argc);

  1249.       /* If we couldn't find any argument list, then we don't expand
  1250.          this macro.  */
  1251.       if (! argv)
  1252.         {
  1253.           do_cleanups (back_to);
  1254.           return 0;
  1255.         }

  1257.       /* Check that we're passing an acceptable number of arguments for
  1258.          this macro.  */
  1259.       if (argc != def->argc)
  1260.         {
  1261.           if (is_varargs && argc >= def->argc - 1)
  1262.             {
  1263.               /* Ok.  */
  1264.             }
  1265.           /* Remember that a sequence of tokens like "foo()" is a
  1266.              valid invocation of a macro expecting either zero or one
  1267.              arguments.  */
  1268.           else if (! (argc == 1
  1269.                       && argv[0].len == 0
  1270.                       && def->argc == 0))
  1271.             error (_("Wrong number of arguments to macro `%s' "
  1272.                    "(expected %d, got %d)."),
  1273.                    id, def->argc, argc);
  1274.         }

  1276.       /* Note that we don't expand macro invocations in the arguments
  1277.          yet --- we let subst_args take care of that.  Parameters that
  1278.          appear as operands of the stringifying operator "#" or the
  1279.          splicing operator "##" don't get macro references expanded,
  1280.          so we can't really tell whether it's appropriate to macro-
  1281.          expand an argument until we see how it's being used.  */
  1282.       init_buffer (&substituted, 0);
  1283.       make_cleanup (cleanup_macro_buffer, &substituted);
  1284.       substitute_args (&substituted, def, is_varargs, &va_arg_name,
  1285.                        argc, argv, no_loop, lookup_func, lookup_baton);

  1287.       /* Now `substituted' is the macro's replacement list, with all
  1288.          argument values substituted into it properly.  Re-scan it for
  1289.          macro references, but don't expand invocations of this macro.

  1291.          We create a new buffer, `substituted_src', which points into
  1292.          `substituted', and scan that.  We can't scan `substituted'
  1293.          itself, since the tokenization process moves the buffer's
  1294.          text pointer around, and we still need to be able to find
  1295.          `substituted's original text buffer after scanning it so we
  1296.          can free it.  */
  1297.       init_shared_buffer (&substituted_src, substituted.text, substituted.len);
  1298.       scan (dest, &substituted_src, &new_no_loop, lookup_func, lookup_baton);

  1300.       do_cleanups (back_to);

  1302.       return 1;
  1303.     }
  1304.   else
  1305.     internal_error (__FILE__, __LINE__, _("bad macro definition kind"));
  1306. }


  1309. /* If the single token in SRC_FIRST followed by the tokens in SRC_REST
  1310.    constitute a macro invokation not forbidden in NO_LOOP, append its
  1311.    expansion to DEST and return non-zero.  Otherwise, return zero, and
  1312.    leave DEST unchanged.

  1314.    SRC_FIRST and SRC_REST must be shared buffers; DEST must not be one.
  1315.    SRC_FIRST must be a string built by get_token.  */
  1316. static int
  1317. ‌maybe_expand (struct macro_buffer *dest,
  1318.               struct macro_buffer *src_first,
  1319.               struct macro_buffer *src_rest,
  1320.               struct macro_name_list *no_loop,
  1321.               macro_lookup_ftype *lookup_func,
  1322.               void *lookup_baton)
  1323. {
  1324.   gdb_assert (src_first->shared);
  1325.   gdb_assert (src_rest->shared);
  1326.   gdb_assert (! dest->shared);

  1328.   /* Is this token an identifier?  */
  1329.   if (src_first->is_identifier)
  1330.     {
  1331.       /* Make a null-terminated copy of it, since that's what our
  1332.          lookup function expects.  */
  1333.       char *id = xmalloc (src_first->len + 1);
  1334.       struct cleanup *back_to = make_cleanup (xfree, id);

  1336.       memcpy (id, src_first->text, src_first->len);
  1337.       id[src_first->len] = 0;

  1339.       /* If we're currently re-scanning the result of expanding
  1340.          this macro, don't expand it again.  */
  1341.       if (! currently_rescanning (no_loop, id))
  1342.         {
  1343.           /* Does this identifier have a macro definition in scope?  */
  1344.           struct macro_definition *def = lookup_func (id, lookup_baton);

  1346.           if (def && expand (id, def, dest, src_rest, no_loop,
  1347.                              lookup_func, lookup_baton))
  1348.             {
  1349.               do_cleanups (back_to);
  1350.               return 1;
  1351.             }
  1352.         }

  1354.       do_cleanups (back_to);
  1355.     }

  1357.   return 0;
  1358. }


  1361. /* Expand macro references in SRC, appending the results to DEST.
  1362.    Assume we are re-scanning the result of expanding the macros named
  1363.    in NO_LOOP, and don't try to re-expand references to them.

  1365.    SRC must be a shared buffer; DEST must not be one.  */
  1366. static void
  1367. ‌scan (struct macro_buffer *dest,
  1368.       struct macro_buffer *src,
  1369.       struct macro_name_list *no_loop,
  1370.       macro_lookup_ftype *lookup_func,
  1371.       void *lookup_baton)
  1372. {
  1373.   gdb_assert (src->shared);
  1374.   gdb_assert (! dest->shared);

  1376.   for (;;)
  1377.     {
  1378.       struct macro_buffer tok;
  1379.       char *original_src_start = src->text;

  1381.       /* Find the next token in SRC.  */
  1382.       if (! get_token (&tok, src))
  1383.         break;

  1385.       /* Just for aesthetics.  If we skipped some whitespace, copy
  1386.          that to DEST.  */
  1387.       if (tok.text > original_src_start)
  1388.         {
  1389.           appendmem (dest, original_src_start, tok.text - original_src_start);
  1390.           dest->last_token = dest->len;
  1391.         }

  1393.       if (! maybe_expand (dest, &tok, src, no_loop, lookup_func, lookup_baton))
  1394.         /* We didn't end up expanding tok as a macro reference, so
  1395.            simply append it to dest.  */
  1396.         append_tokens_without_splicing (dest, &tok);
  1397.     }

  1399.   /* Just for aesthetics.  If there was any trailing whitespace in
  1400.      src, copy it to dest.  */
  1401.   if (src->len)
  1402.     {
  1403.       appendmem (dest, src->text, src->len);
  1404.       dest->last_token = dest->len;
  1405.     }
  1406. }


  1409. char *
  1410. ‌macro_expand (const char *source,
  1411.               macro_lookup_ftype *lookup_func,
  1412.               void *lookup_func_baton)
  1413. {
  1414.   struct macro_buffer src, dest;
  1415.   struct cleanup *back_to;

  1417.   init_shared_buffer (&src, (char *) source, strlen (source));

  1419.   init_buffer (&dest, 0);
  1420.   dest.last_token = 0;
  1421.   back_to = make_cleanup (cleanup_macro_buffer, &dest);

  1423.   scan (&dest, &src, 0, lookup_func, lookup_func_baton);

  1425.   appendc (&dest, '\0');

  1427.   discard_cleanups (back_to);
  1428.   return dest.text;
  1429. }


  1432. char *
  1433. ‌macro_expand_once (const char *source,
  1434.                    macro_lookup_ftype *lookup_func,
  1435.                    void *lookup_func_baton)
  1436. {
  1437.   error (_("Expand-once not implemented yet."));
  1438. }


  1441. char *
  1442. ‌macro_expand_next (const char **lexptr,
  1443.                    macro_lookup_ftype *lookup_func,
  1444.                    void *lookup_baton)
  1445. {
  1446.   struct macro_buffer src, dest, tok;
  1447.   struct cleanup *back_to;

  1449.   /* Set up SRC to refer to the input text, pointed to by *lexptr.  */
  1450.   init_shared_buffer (&src, (char *) *lexptr, strlen (*lexptr));

  1452.   /* Set up DEST to receive the expansion, if there is one.  */
  1453.   init_buffer (&dest, 0);
  1454.   dest.last_token = 0;
  1455.   back_to = make_cleanup (cleanup_macro_buffer, &dest);

  1457.   /* Get the text's first preprocessing token.  */
  1458.   if (! get_token (&tok, &src))
  1459.     {
  1460.       do_cleanups (back_to);
  1461.       return 0;
  1462.     }

  1464.   /* If it's a macro invocation, expand it.  */
  1465.   if (maybe_expand (&dest, &tok, &src, 0, lookup_func, lookup_baton))
  1466.     {
  1467.       /* It was a macro invocation!  Package up the expansion as a
  1468.          null-terminated string and return it.  Set *lexptr to the
  1469.          start of the next token in the input.  */
  1470.       appendc (&dest, '\0');
  1471.       discard_cleanups (back_to);
  1472.       *lexptr = src.text;
  1473.       return dest.text;
  1474.     }
  1475.   else
  1476.     {
  1477.       /* It wasn't a macro invocation.  */
  1478.       do_cleanups (back_to);
  1479.       return 0;
  1480.     }
  1481. }