1 /* C preprocessor macro expansion for GDB.
2 Copyright (C) 2002, 2007, 2008 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/>. */
21 #include "gdb_obstack.h"
25 #include "gdb_assert.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. */
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
45 /* The number of characters in the string. */
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. */
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. */
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. */
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. */
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. */
80 init_buffer (struct macro_buffer *b, int n)
84 b->text = (char *) xmalloc (n);
93 /* Set the macro buffer *BUF to refer to the LEN bytes at ADDR, as a
96 init_shared_buffer (struct macro_buffer *buf, char *addr, int len)
102 buf->last_token = -1;
106 /* Free the text of the buffer B. Raise an error if B is shared. */
108 free_buffer (struct macro_buffer *b)
110 gdb_assert (! b->shared);
116 /* A cleanup function for macro buffers. */
118 cleanup_macro_buffer (void *untyped_buf)
120 free_buffer ((struct macro_buffer *) untyped_buf);
124 /* Resize the buffer B to be at least N bytes long. Raise an error if
125 B shouldn't be resized. */
127 resize_buffer (struct macro_buffer *b, int n)
129 /* We shouldn't be trying to resize shared strings. */
130 gdb_assert (! b->shared);
138 b->text = xrealloc (b->text, b->size);
142 /* Append the character C to the buffer B. */
144 appendc (struct macro_buffer *b, int c)
146 int new_len = b->len + 1;
148 if (new_len > b->size)
149 resize_buffer (b, new_len);
156 /* Append the LEN bytes at ADDR to the buffer B. */
158 appendmem (struct macro_buffer *b, char *addr, int len)
160 int new_len = b->len + len;
162 if (new_len > b->size)
163 resize_buffer (b, new_len);
165 memcpy (b->text + b->len, addr, len);
171 /* Recognizing preprocessor tokens. */
175 macro_is_whitespace (int c)
186 macro_is_digit (int c)
188 return ('0' <= c && c <= '9');
193 macro_is_identifier_nondigit (int c)
196 || ('a' <= c && c <= 'z')
197 || ('A' <= c && c <= 'Z'));
202 set_token (struct macro_buffer *tok, char *start, char *end)
204 init_shared_buffer (tok, start, end - start);
207 /* Presumed; get_identifier may overwrite this. */
208 tok->is_identifier = 0;
213 get_comment (struct macro_buffer *tok, char *p, char *end)
230 set_token (tok, tok_start, p);
234 error (_("Unterminated comment in macro expansion."));
246 set_token (tok, tok_start, p);
255 get_identifier (struct macro_buffer *tok, char *p, char *end)
258 && macro_is_identifier_nondigit (*p))
263 && (macro_is_identifier_nondigit (*p)
264 || macro_is_digit (*p)))
267 set_token (tok, tok_start, p);
268 tok->is_identifier = 1;
277 get_pp_number (struct macro_buffer *tok, char *p, char *end)
280 && (macro_is_digit (*p)
287 if (macro_is_digit (*p)
288 || macro_is_identifier_nondigit (*p)
291 else if (p + 2 <= end
292 && strchr ("eEpP.", *p)
293 && (p[1] == '+' || p[1] == '-'))
299 set_token (tok, tok_start, p);
308 /* If the text starting at P going up to (but not including) END
309 starts with a character constant, set *TOK to point to that
310 character constant, and return 1. Otherwise, return zero.
311 Signal an error if it contains a malformed or incomplete character
314 get_character_constant (struct macro_buffer *tok, char *p, char *end)
316 /* ISO/IEC 9899:1999 (E) Section 6.4.4.4 paragraph 1
317 But of course, what really matters is that we handle it the same
318 way GDB's C/C++ lexer does. So we call parse_escape in utils.c
319 to handle escape sequences. */
320 if ((p + 1 <= end && *p == '\'')
321 || (p + 2 <= end && p[0] == 'L' && p[1] == '\''))
337 error (_("Unmatched single quote."));
341 error (_("A character constant must contain at least one "
355 set_token (tok, tok_start, p);
363 /* If the text starting at P going up to (but not including) END
364 starts with a string literal, set *TOK to point to that string
365 literal, and return 1. Otherwise, return zero. Signal an error if
366 it contains a malformed or incomplete string literal. */
368 get_string_literal (struct macro_buffer *tok, char *p, char *end)
388 error (_("Unterminated string in expression."));
395 error (_("Newline characters may not appear in string "
406 set_token (tok, tok_start, p);
415 get_punctuator (struct macro_buffer *tok, char *p, char *end)
417 /* Here, speed is much less important than correctness and clarity. */
419 /* ISO/IEC 9899:1999 (E) Section 6.4.6 Paragraph 1 */
420 static const char * const punctuators[] = {
421 "[", "]", "(", ")", "{", "}", ".", "->",
422 "++", "--", "&", "*", "+", "-", "~", "!",
423 "/", "%", "<<", ">>", "<", ">", "<=", ">=", "==", "!=",
424 "^", "|", "&&", "||",
425 "?", ":", ";", "...",
426 "=", "*=", "/=", "%=", "+=", "-=", "<<=", ">>=", "&=", "^=", "|=",
428 "<:", ":>", "<%", "%>", "%:", "%:%:",
436 for (i = 0; punctuators[i]; i++)
438 const char *punctuator = punctuators[i];
440 if (p[0] == punctuator[0])
442 int len = strlen (punctuator);
445 && ! memcmp (p, punctuator, len))
447 set_token (tok, p, p + len);
458 /* Peel the next preprocessor token off of SRC, and put it in TOK.
459 Mutate TOK to refer to the first token in SRC, and mutate SRC to
460 refer to the text after that token. SRC must be a shared buffer;
461 the resulting TOK will be shared, pointing into the same string SRC
462 does. Initialize TOK's last_token field. Return non-zero if we
463 succeed, or 0 if we didn't find any more tokens in SRC. */
465 get_token (struct macro_buffer *tok,
466 struct macro_buffer *src)
469 char *end = p + src->len;
471 gdb_assert (src->shared);
473 /* From the ISO C standard, ISO/IEC 9899:1999 (E), section 6.4:
482 each non-white-space character that cannot be one of the above
484 We don't have to deal with header-name tokens, since those can
485 only occur after a #include, which we will never see. */
488 if (macro_is_whitespace (*p))
490 else if (get_comment (tok, p, end))
492 else if (get_pp_number (tok, p, end)
493 || get_character_constant (tok, p, end)
494 || get_string_literal (tok, p, end)
495 /* Note: the grammar in the standard seems to be
496 ambiguous: L'x' can be either a wide character
497 constant, or an identifier followed by a normal
498 character constant. By trying `get_identifier' after
499 we try get_character_constant and get_string_literal,
500 we give the wide character syntax precedence. Now,
501 since GDB doesn't handle wide character constants
502 anyway, is this the right thing to do? */
503 || get_identifier (tok, p, end)
504 || get_punctuator (tok, p, end))
506 /* How many characters did we consume, including whitespace? */
507 int consumed = p - src->text + tok->len;
508 src->text += consumed;
509 src->len -= consumed;
514 /* We have found a "non-whitespace character that cannot be
515 one of the above." Make a token out of it. */
518 set_token (tok, p, p + 1);
519 consumed = p - src->text + tok->len;
520 src->text += consumed;
521 src->len -= consumed;
530 /* Appending token strings, with and without splicing */
533 /* Append the macro buffer SRC to the end of DEST, and ensure that
534 doing so doesn't splice the token at the end of SRC with the token
535 at the beginning of DEST. SRC and DEST must have their last_token
536 fields set. Upon return, DEST's last_token field is set correctly.
540 If DEST is "(" and SRC is "y", then we can return with
541 DEST set to "(y" --- we've simply appended the two buffers.
543 However, if DEST is "x" and SRC is "y", then we must not return
544 with DEST set to "xy" --- that would splice the two tokens "x" and
545 "y" together to make a single token "xy". However, it would be
546 fine to return with DEST set to "x y". Similarly, "<" and "<" must
547 yield "< <", not "<<", etc. */
549 append_tokens_without_splicing (struct macro_buffer *dest,
550 struct macro_buffer *src)
552 int original_dest_len = dest->len;
553 struct macro_buffer dest_tail, new_token;
555 gdb_assert (src->last_token != -1);
556 gdb_assert (dest->last_token != -1);
558 /* First, just try appending the two, and call get_token to see if
560 appendmem (dest, src->text, src->len);
562 /* If DEST originally had no token abutting its end, then we can't
563 have spliced anything, so we're done. */
564 if (dest->last_token == original_dest_len)
566 dest->last_token = original_dest_len + src->last_token;
570 /* Set DEST_TAIL to point to the last token in DEST, followed by
571 all the stuff we just appended. */
572 init_shared_buffer (&dest_tail,
573 dest->text + dest->last_token,
574 dest->len - dest->last_token);
576 /* Re-parse DEST's last token. We know that DEST used to contain
577 at least one token, so if it doesn't contain any after the
578 append, then we must have spliced "/" and "*" or "/" and "/" to
579 make a comment start. (Just for the record, I got this right
580 the first time. This is not a bug fix.) */
581 if (get_token (&new_token, &dest_tail)
582 && (new_token.text + new_token.len
583 == dest->text + original_dest_len))
585 /* No splice, so we're done. */
586 dest->last_token = original_dest_len + src->last_token;
590 /* Okay, a simple append caused a splice. Let's chop dest back to
591 its original length and try again, but separate the texts with a
593 dest->len = original_dest_len;
595 appendmem (dest, src->text, src->len);
597 init_shared_buffer (&dest_tail,
598 dest->text + dest->last_token,
599 dest->len - dest->last_token);
601 /* Try to re-parse DEST's last token, as above. */
602 if (get_token (&new_token, &dest_tail)
603 && (new_token.text + new_token.len
604 == dest->text + original_dest_len))
606 /* No splice, so we're done. */
607 dest->last_token = original_dest_len + 1 + src->last_token;
611 /* As far as I know, there's no case where inserting a space isn't
612 enough to prevent a splice. */
613 internal_error (__FILE__, __LINE__,
614 _("unable to avoid splicing tokens during macro expansion"));
619 /* Expanding macros! */
622 /* A singly-linked list of the names of the macros we are currently
623 expanding --- for detecting expansion loops. */
624 struct macro_name_list {
626 struct macro_name_list *next;
630 /* Return non-zero if we are currently expanding the macro named NAME,
631 according to LIST; otherwise, return zero.
633 You know, it would be possible to get rid of all the NO_LOOP
634 arguments to these functions by simply generating a new lookup
635 function and baton which refuses to find the definition for a
636 particular macro, and otherwise delegates the decision to another
637 function/baton pair. But that makes the linked list of excluded
638 macros chained through untyped baton pointers, which will make it
639 harder to debug. :( */
641 currently_rescanning (struct macro_name_list *list, const char *name)
643 for (; list; list = list->next)
644 if (strcmp (name, list->name) == 0)
651 /* Gather the arguments to a macro expansion.
653 NAME is the name of the macro being invoked. (It's only used for
654 printing error messages.)
656 Assume that SRC is the text of the macro invocation immediately
657 following the macro name. For example, if we're processing the
658 text foo(bar, baz), then NAME would be foo and SRC will be (bar,
661 If SRC doesn't start with an open paren ( token at all, return
662 zero, leave SRC unchanged, and don't set *ARGC_P to anything.
664 If SRC doesn't contain a properly terminated argument list, then
667 Otherwise, return a pointer to the first element of an array of
668 macro buffers referring to the argument texts, and set *ARGC_P to
669 the number of arguments we found --- the number of elements in the
670 array. The macro buffers share their text with SRC, and their
671 last_token fields are initialized. The array is allocated with
672 xmalloc, and the caller is responsible for freeing it.
674 NOTE WELL: if SRC starts with a open paren ( token followed
675 immediately by a close paren ) token (e.g., the invocation looks
676 like "foo()"), we treat that as one argument, which happens to be
677 the empty list of tokens. The caller should keep in mind that such
678 a sequence of tokens is a valid way to invoke one-parameter
679 function-like macros, but also a valid way to invoke zero-parameter
680 function-like macros. Eeew.
682 Consume the tokens from SRC; after this call, SRC contains the text
683 following the invocation. */
685 static struct macro_buffer *
686 gather_arguments (const char *name, struct macro_buffer *src, int *argc_p)
688 struct macro_buffer tok;
689 int args_len, args_size;
690 struct macro_buffer *args = NULL;
691 struct cleanup *back_to = make_cleanup (free_current_contents, &args);
693 /* Does SRC start with an opening paren token? Read from a copy of
694 SRC, so SRC itself is unaffected if we don't find an opening
697 struct macro_buffer temp;
698 init_shared_buffer (&temp, src->text, src->len);
700 if (! get_token (&tok, &temp)
702 || tok.text[0] != '(')
704 discard_cleanups (back_to);
709 /* Consume SRC's opening paren. */
710 get_token (&tok, src);
714 args = (struct macro_buffer *) xmalloc (sizeof (*args) * args_size);
718 struct macro_buffer *arg;
721 /* Make sure we have room for the next argument. */
722 if (args_len >= args_size)
725 args = xrealloc (args, sizeof (*args) * args_size);
728 /* Initialize the next argument. */
729 arg = &args[args_len++];
730 set_token (arg, src->text, src->text);
732 /* Gather the argument's tokens. */
736 char *start = src->text;
738 if (! get_token (&tok, src))
739 error (_("Malformed argument list for macro `%s'."), name);
741 /* Is tok an opening paren? */
742 if (tok.len == 1 && tok.text[0] == '(')
745 /* Is tok is a closing paren? */
746 else if (tok.len == 1 && tok.text[0] == ')')
748 /* If it's a closing paren at the top level, then that's
749 the end of the argument list. */
752 discard_cleanups (back_to);
760 /* If tok is a comma at top level, then that's the end of
761 the current argument. */
762 else if (tok.len == 1 && tok.text[0] == ',' && depth == 0)
765 /* Extend the current argument to enclose this token. If
766 this is the current argument's first token, leave out any
767 leading whitespace, just for aesthetics. */
770 arg->text = tok.text;
776 arg->len = (tok.text + tok.len) - arg->text;
777 arg->last_token = tok.text - arg->text;
784 /* The `expand' and `substitute_args' functions both invoke `scan'
785 recursively, so we need a forward declaration somewhere. */
786 static void scan (struct macro_buffer *dest,
787 struct macro_buffer *src,
788 struct macro_name_list *no_loop,
789 macro_lookup_ftype *lookup_func,
793 /* Given the macro definition DEF, being invoked with the actual
794 arguments given by ARGC and ARGV, substitute the arguments into the
795 replacement list, and store the result in DEST.
797 If it is necessary to expand macro invocations in one of the
798 arguments, use LOOKUP_FUNC and LOOKUP_BATON to find the macro
799 definitions, and don't expand invocations of the macros listed in
802 substitute_args (struct macro_buffer *dest,
803 struct macro_definition *def,
804 int argc, struct macro_buffer *argv,
805 struct macro_name_list *no_loop,
806 macro_lookup_ftype *lookup_func,
809 /* A macro buffer for the macro's replacement list. */
810 struct macro_buffer replacement_list;
812 init_shared_buffer (&replacement_list, (char *) def->replacement,
813 strlen (def->replacement));
815 gdb_assert (dest->len == 0);
816 dest->last_token = 0;
820 struct macro_buffer tok;
821 char *original_rl_start = replacement_list.text;
824 /* Find the next token in the replacement list. */
825 if (! get_token (&tok, &replacement_list))
828 /* Just for aesthetics. If we skipped some whitespace, copy
830 if (tok.text > original_rl_start)
832 appendmem (dest, original_rl_start, tok.text - original_rl_start);
833 dest->last_token = dest->len;
836 /* Is this token the stringification operator? */
838 && tok.text[0] == '#')
839 error (_("Stringification is not implemented yet."));
841 /* Is this token the splicing operator? */
843 && tok.text[0] == '#'
844 && tok.text[1] == '#')
845 error (_("Token splicing is not implemented yet."));
847 /* Is this token an identifier? */
848 if (tok.is_identifier)
852 /* Is it the magic varargs parameter? */
854 && ! memcmp (tok.text, "__VA_ARGS__", 11))
855 error (_("Variable-arity macros not implemented yet."));
857 /* Is it one of the parameters? */
858 for (i = 0; i < def->argc; i++)
859 if (tok.len == strlen (def->argv[i])
860 && ! memcmp (tok.text, def->argv[i], tok.len))
862 struct macro_buffer arg_src;
864 /* Expand any macro invocations in the argument text,
865 and append the result to dest. Remember that scan
866 mutates its source, so we need to scan a new buffer
867 referring to the argument's text, not the argument
869 init_shared_buffer (&arg_src, argv[i].text, argv[i].len);
870 scan (dest, &arg_src, no_loop, lookup_func, lookup_baton);
876 /* If it wasn't a parameter, then just copy it across. */
878 append_tokens_without_splicing (dest, &tok);
883 /* Expand a call to a macro named ID, whose definition is DEF. Append
884 its expansion to DEST. SRC is the input text following the ID
885 token. We are currently rescanning the expansions of the macros
886 named in NO_LOOP; don't re-expand them. Use LOOKUP_FUNC and
887 LOOKUP_BATON to find definitions for any nested macro references.
889 Return 1 if we decided to expand it, zero otherwise. (If it's a
890 function-like macro name that isn't followed by an argument list,
891 we don't expand it.) If we return zero, leave SRC unchanged. */
893 expand (const char *id,
894 struct macro_definition *def,
895 struct macro_buffer *dest,
896 struct macro_buffer *src,
897 struct macro_name_list *no_loop,
898 macro_lookup_ftype *lookup_func,
901 struct macro_name_list new_no_loop;
903 /* Create a new node to be added to the front of the no-expand list.
904 This list is appropriate for re-scanning replacement lists, but
905 it is *not* appropriate for scanning macro arguments; invocations
906 of the macro whose arguments we are gathering *do* get expanded
908 new_no_loop.name = id;
909 new_no_loop.next = no_loop;
911 /* What kind of macro are we expanding? */
912 if (def->kind == macro_object_like)
914 struct macro_buffer replacement_list;
916 init_shared_buffer (&replacement_list, (char *) def->replacement,
917 strlen (def->replacement));
919 scan (dest, &replacement_list, &new_no_loop, lookup_func, lookup_baton);
922 else if (def->kind == macro_function_like)
924 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
926 struct macro_buffer *argv = NULL;
927 struct macro_buffer substituted;
928 struct macro_buffer substituted_src;
931 && strcmp (def->argv[def->argc - 1], "...") == 0)
932 error (_("Varargs macros not implemented yet."));
934 make_cleanup (free_current_contents, &argv);
935 argv = gather_arguments (id, src, &argc);
937 /* If we couldn't find any argument list, then we don't expand
941 do_cleanups (back_to);
945 /* Check that we're passing an acceptable number of arguments for
947 if (argc != def->argc)
949 /* Remember that a sequence of tokens like "foo()" is a
950 valid invocation of a macro expecting either zero or one
955 error (_("Wrong number of arguments to macro `%s' "
956 "(expected %d, got %d)."),
957 id, def->argc, argc);
960 /* Note that we don't expand macro invocations in the arguments
961 yet --- we let subst_args take care of that. Parameters that
962 appear as operands of the stringifying operator "#" or the
963 splicing operator "##" don't get macro references expanded,
964 so we can't really tell whether it's appropriate to macro-
965 expand an argument until we see how it's being used. */
966 init_buffer (&substituted, 0);
967 make_cleanup (cleanup_macro_buffer, &substituted);
968 substitute_args (&substituted, def, argc, argv, no_loop,
969 lookup_func, lookup_baton);
971 /* Now `substituted' is the macro's replacement list, with all
972 argument values substituted into it properly. Re-scan it for
973 macro references, but don't expand invocations of this macro.
975 We create a new buffer, `substituted_src', which points into
976 `substituted', and scan that. We can't scan `substituted'
977 itself, since the tokenization process moves the buffer's
978 text pointer around, and we still need to be able to find
979 `substituted's original text buffer after scanning it so we
981 init_shared_buffer (&substituted_src, substituted.text, substituted.len);
982 scan (dest, &substituted_src, &new_no_loop, lookup_func, lookup_baton);
984 do_cleanups (back_to);
989 internal_error (__FILE__, __LINE__, _("bad macro definition kind"));
993 /* If the single token in SRC_FIRST followed by the tokens in SRC_REST
994 constitute a macro invokation not forbidden in NO_LOOP, append its
995 expansion to DEST and return non-zero. Otherwise, return zero, and
996 leave DEST unchanged.
998 SRC_FIRST and SRC_REST must be shared buffers; DEST must not be one.
999 SRC_FIRST must be a string built by get_token. */
1001 maybe_expand (struct macro_buffer *dest,
1002 struct macro_buffer *src_first,
1003 struct macro_buffer *src_rest,
1004 struct macro_name_list *no_loop,
1005 macro_lookup_ftype *lookup_func,
1008 gdb_assert (src_first->shared);
1009 gdb_assert (src_rest->shared);
1010 gdb_assert (! dest->shared);
1012 /* Is this token an identifier? */
1013 if (src_first->is_identifier)
1015 /* Make a null-terminated copy of it, since that's what our
1016 lookup function expects. */
1017 char *id = xmalloc (src_first->len + 1);
1018 struct cleanup *back_to = make_cleanup (xfree, id);
1019 memcpy (id, src_first->text, src_first->len);
1020 id[src_first->len] = 0;
1022 /* If we're currently re-scanning the result of expanding
1023 this macro, don't expand it again. */
1024 if (! currently_rescanning (no_loop, id))
1026 /* Does this identifier have a macro definition in scope? */
1027 struct macro_definition *def = lookup_func (id, lookup_baton);
1029 if (def && expand (id, def, dest, src_rest, no_loop,
1030 lookup_func, lookup_baton))
1032 do_cleanups (back_to);
1037 do_cleanups (back_to);
1044 /* Expand macro references in SRC, appending the results to DEST.
1045 Assume we are re-scanning the result of expanding the macros named
1046 in NO_LOOP, and don't try to re-expand references to them.
1048 SRC must be a shared buffer; DEST must not be one. */
1050 scan (struct macro_buffer *dest,
1051 struct macro_buffer *src,
1052 struct macro_name_list *no_loop,
1053 macro_lookup_ftype *lookup_func,
1056 gdb_assert (src->shared);
1057 gdb_assert (! dest->shared);
1061 struct macro_buffer tok;
1062 char *original_src_start = src->text;
1064 /* Find the next token in SRC. */
1065 if (! get_token (&tok, src))
1068 /* Just for aesthetics. If we skipped some whitespace, copy
1070 if (tok.text > original_src_start)
1072 appendmem (dest, original_src_start, tok.text - original_src_start);
1073 dest->last_token = dest->len;
1076 if (! maybe_expand (dest, &tok, src, no_loop, lookup_func, lookup_baton))
1077 /* We didn't end up expanding tok as a macro reference, so
1078 simply append it to dest. */
1079 append_tokens_without_splicing (dest, &tok);
1082 /* Just for aesthetics. If there was any trailing whitespace in
1083 src, copy it to dest. */
1086 appendmem (dest, src->text, src->len);
1087 dest->last_token = dest->len;
1093 macro_expand (const char *source,
1094 macro_lookup_ftype *lookup_func,
1095 void *lookup_func_baton)
1097 struct macro_buffer src, dest;
1098 struct cleanup *back_to;
1100 init_shared_buffer (&src, (char *) source, strlen (source));
1102 init_buffer (&dest, 0);
1103 dest.last_token = 0;
1104 back_to = make_cleanup (cleanup_macro_buffer, &dest);
1106 scan (&dest, &src, 0, lookup_func, lookup_func_baton);
1108 appendc (&dest, '\0');
1110 discard_cleanups (back_to);
1116 macro_expand_once (const char *source,
1117 macro_lookup_ftype *lookup_func,
1118 void *lookup_func_baton)
1120 error (_("Expand-once not implemented yet."));
1125 macro_expand_next (char **lexptr,
1126 macro_lookup_ftype *lookup_func,
1129 struct macro_buffer src, dest, tok;
1130 struct cleanup *back_to;
1132 /* Set up SRC to refer to the input text, pointed to by *lexptr. */
1133 init_shared_buffer (&src, *lexptr, strlen (*lexptr));
1135 /* Set up DEST to receive the expansion, if there is one. */
1136 init_buffer (&dest, 0);
1137 dest.last_token = 0;
1138 back_to = make_cleanup (cleanup_macro_buffer, &dest);
1140 /* Get the text's first preprocessing token. */
1141 if (! get_token (&tok, &src))
1143 do_cleanups (back_to);
1147 /* If it's a macro invocation, expand it. */
1148 if (maybe_expand (&dest, &tok, &src, 0, lookup_func, lookup_baton))
1150 /* It was a macro invocation! Package up the expansion as a
1151 null-terminated string and return it. Set *lexptr to the
1152 start of the next token in the input. */
1153 appendc (&dest, '\0');
1154 discard_cleanups (back_to);
1160 /* It wasn't a macro invocation. */
1161 do_cleanups (back_to);