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/>. */
21 #include "gdb_obstack.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);
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. */
119 free_buffer_return_text (struct macro_buffer *b)
121 gdb_assert (! b->shared);
122 gdb_assert (b->size);
127 /* A cleanup function for macro buffers. */
129 cleanup_macro_buffer (void *untyped_buf)
131 free_buffer ((struct macro_buffer *) untyped_buf);
135 /* Resize the buffer B to be at least N bytes long. Raise an error if
136 B shouldn't be resized. */
138 resize_buffer (struct macro_buffer *b, int n)
140 /* We shouldn't be trying to resize shared strings. */
141 gdb_assert (! b->shared);
149 b->text = xrealloc (b->text, b->size);
153 /* Append the character C to the buffer B. */
155 appendc (struct macro_buffer *b, int c)
157 int new_len = b->len + 1;
159 if (new_len > b->size)
160 resize_buffer (b, new_len);
167 /* Append the LEN bytes at ADDR to the buffer B. */
169 appendmem (struct macro_buffer *b, char *addr, int len)
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);
182 /* Recognizing preprocessor tokens. */
186 macro_is_whitespace (int c)
197 macro_is_digit (int c)
199 return ('0' <= c && c <= '9');
204 macro_is_identifier_nondigit (int c)
207 || ('a' <= c && c <= 'z')
208 || ('A' <= c && c <= 'Z'));
213 set_token (struct macro_buffer *tok, char *start, char *end)
215 init_shared_buffer (tok, start, end - start);
218 /* Presumed; get_identifier may overwrite this. */
219 tok->is_identifier = 0;
224 get_comment (struct macro_buffer *tok, char *p, char *end)
241 set_token (tok, tok_start, p);
245 error (_("Unterminated comment in macro expansion."));
257 set_token (tok, tok_start, p);
266 get_identifier (struct macro_buffer *tok, char *p, char *end)
269 && macro_is_identifier_nondigit (*p))
274 && (macro_is_identifier_nondigit (*p)
275 || macro_is_digit (*p)))
278 set_token (tok, tok_start, p);
279 tok->is_identifier = 1;
288 get_pp_number (struct macro_buffer *tok, char *p, char *end)
291 && (macro_is_digit (*p)
294 && macro_is_digit (p[1]))))
301 && strchr ("eEpP", *p)
302 && (p[1] == '+' || p[1] == '-'))
304 else if (macro_is_digit (*p)
305 || macro_is_identifier_nondigit (*p)
312 set_token (tok, tok_start, p);
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
327 get_character_constant (struct macro_buffer *tok, char *p, char *end)
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 == '\'')
335 && (p[0] == 'L' || p[0] == 'u' || p[0] == 'U')
343 else if (*p == 'L' || *p == 'u' || *p == 'U')
346 gdb_assert_not_reached ("unexpected character constant");
351 error (_("Unmatched single quote."));
355 error (_("A character constant must contain at least one "
365 char_count += c_parse_escape (&s, NULL);
375 set_token (tok, tok_start, p);
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. */
388 get_string_literal (struct macro_buffer *tok, char *p, char *end)
393 && (p[0] == 'L' || p[0] == 'u' || p[0] == 'U')
400 else if (*p == 'L' || *p == 'u' || *p == 'U')
403 gdb_assert_not_reached ("unexpected string literal");
408 error (_("Unterminated string in expression."));
415 error (_("Newline characters may not appear in string "
422 c_parse_escape (&s, NULL);
429 set_token (tok, tok_start, p);
438 get_punctuator (struct macro_buffer *tok, char *p, char *end)
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 "[", "]", "(", ")", "{", "}", "?", ";", ",", "~",
449 "->", "--", "-=", "-",
455 "%>", "%:%:", "%:", "%=", "%",
460 "<<=", "<<", "<=", "<:", "<%", "<",
461 ">>=", ">>", ">=", ">",
470 for (i = 0; punctuators[i]; i++)
472 const char *punctuator = punctuators[i];
474 if (p[0] == punctuator[0])
476 int len = strlen (punctuator);
479 && ! memcmp (p, punctuator, len))
481 set_token (tok, p, p + len);
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. */
499 get_token (struct macro_buffer *tok,
500 struct macro_buffer *src)
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:
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. */
522 if (macro_is_whitespace (*p))
524 else if (get_comment (tok, p, end))
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))
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;
549 /* We have found a "non-whitespace character that cannot be
550 one of the above." Make a token out of it. */
553 set_token (tok, p, p + 1);
554 consumed = p - src->text + tok->len;
555 src->text += consumed;
556 src->len -= consumed;
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.
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. */
584 append_tokens_without_splicing (struct macro_buffer *dest,
585 struct macro_buffer *src)
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
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)
601 dest->last_token = original_dest_len + src->last_token;
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))
620 /* No splice, so we're done. */
621 dest->last_token = original_dest_len + src->last_token;
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
628 dest->len = original_dest_len;
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))
641 /* No splice, so we're done. */
642 dest->last_token = original_dest_len + 1 + src->last_token;
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"));
652 /* Stringify an argument, and insert it into DEST. ARG is the text to
653 stringify; it is LEN bytes long. */
656 stringify (struct macro_buffer *dest, const char *arg, int len)
658 /* Trim initial whitespace from ARG. */
659 while (len > 0 && macro_is_whitespace (*arg))
665 /* Trim trailing whitespace from ARG. */
666 while (len > 0 && macro_is_whitespace (arg[len - 1]))
669 /* Insert the string. */
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))
677 /* Replace a sequence of whitespace with a single space. */
679 while (len > 1 && macro_is_whitespace (arg[1]))
685 else if (*arg == '\\' || *arg == '"')
687 appendc (dest, '\\');
688 appendc (dest, *arg);
691 appendc (dest, *arg);
696 dest->last_token = dest->len;
699 /* See macroexp.h. */
702 macro_stringify (const char *str)
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);
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 {
722 struct macro_name_list *next;
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. :( */
737 currently_rescanning (struct macro_name_list *list, const char *name)
739 for (; list; list = list->next)
740 if (strcmp (name, list->name) == 0)
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,
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
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
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)
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
799 struct macro_buffer temp;
801 init_shared_buffer (&temp, src->text, src->len);
803 if (! get_token (&tok, &temp)
805 || tok.text[0] != '(')
807 discard_cleanups (back_to);
812 /* Consume SRC's opening paren. */
813 get_token (&tok, src);
817 args = XNEWVEC (struct macro_buffer, args_size);
821 struct macro_buffer *arg;
824 /* Make sure we have room for the next argument. */
825 if (args_len >= args_size)
828 args = xrealloc (args, sizeof (*args) * args_size);
831 /* Initialize the next argument. */
832 arg = &args[args_len++];
833 set_token (arg, src->text, src->text);
835 /* Gather the argument's tokens. */
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] == '(')
846 /* Is tok is a closing paren? */
847 else if (tok.len == 1 && tok.text[0] == ')')
849 /* If it's a closing paren at the top level, then that's
850 the end of the argument list. */
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)
857 /* Make sure we have room for the argument. */
858 if (args_len >= args_size)
861 args = xrealloc (args, sizeof (*args) * args_size);
863 arg = &args[args_len++];
864 set_token (arg, src->text, src->text);
867 discard_cleanups (back_to);
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))
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. */
888 arg->text = tok.text;
894 arg->len = (tok.text + tok.len) - arg->text;
895 arg->last_token = tok.text - arg->text;
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,
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
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. */
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)
929 if (! tok->is_identifier)
932 for (i = 0; i < argc; ++i)
933 if (tok->len == strlen (argv[i])
934 && !memcmp (tok->text, argv[i], tok->len))
937 if (is_varargs && tok->len == va_arg_name->len
938 && ! memcmp (tok->text, va_arg_name->text, tok->len))
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
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
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,
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. */
978 /* The replacement list's pointer from just before LOOKAHEAD was
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))
991 lookahead_rl_start = replacement_list.text;
992 lookahead_valid = get_token (&lookahead, &replacement_list);
996 /* Just for aesthetics. If we skipped some whitespace, copy
998 if (tok.text > original_rl_start)
1000 appendmem (dest, original_rl_start, tok.text - original_rl_start);
1001 dest->last_token = dest->len;
1004 /* Is this token the stringification operator? */
1006 && tok.text[0] == '#')
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);
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
1023 lookahead_rl_start = replacement_list.text;
1024 lookahead_valid = get_token (&lookahead, &replacement_list);
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] == '#')
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] == ',')
1049 int arg = find_parameter (&tok, is_varargs, va_arg_name,
1050 def->argc, def->argv);
1053 appendmem (dest, argv[arg].text, argv[arg].len);
1055 appendmem (dest, tok.text, tok.len);
1058 /* Apply a possible sequence of ## operators. */
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. */
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);
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] == ',')
1089 int arg = find_parameter (&tok, is_varargs, va_arg_name,
1090 def->argc, def->argv);
1093 appendmem (dest, argv[arg].text, argv[arg].len);
1095 appendmem (dest, tok.text, tok.len);
1098 /* Now read another token. If it is another splice, we
1100 original_rl_start = replacement_list.text;
1101 if (! get_token (&tok, &replacement_list))
1108 && tok.text[0] == '#'
1109 && tok.text[1] == '#'))
1115 /* We saw a comma. Insert it now. */
1116 appendmem (dest, ",", 1);
1119 dest->last_token = dest->len;
1121 lookahead_valid = 0;
1124 /* Set up for the loop iterator. */
1126 lookahead_rl_start = original_rl_start;
1127 lookahead_valid = 1;
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);
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
1146 init_shared_buffer (&arg_src, argv[arg].text, argv[arg].len);
1147 scan (dest, &arg_src, no_loop, lookup_func, lookup_baton);
1151 /* If it wasn't a parameter, then just copy it across. */
1153 append_tokens_without_splicing (dest, &tok);
1156 if (! lookahead_valid)
1160 original_rl_start = lookahead_rl_start;
1162 lookahead_rl_start = replacement_list.text;
1163 lookahead_valid = get_token (&lookahead, &replacement_list);
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. */
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,
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
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)
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);
1207 else if (def->kind == macro_function_like)
1209 struct cleanup *back_to = make_cleanup (null_cleanup, 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};
1219 if (strcmp (def->argv[def->argc - 1], "...") == 0)
1221 /* In C99-style varargs, substitution is done using
1223 init_shared_buffer (&va_arg_name, "__VA_ARGS__",
1224 strlen ("__VA_ARGS__"));
1229 int len = strlen (def->argv[def->argc - 1]);
1232 && strcmp (def->argv[def->argc - 1] + len - 3, "...") == 0)
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],
1245 make_cleanup (free_current_contents, &argv);
1246 argv = gather_arguments (id, src, is_varargs ? def->argc : -1,
1249 /* If we couldn't find any argument list, then we don't expand
1253 do_cleanups (back_to);
1257 /* Check that we're passing an acceptable number of arguments for
1259 if (argc != def->argc)
1261 if (is_varargs && argc >= def->argc - 1)
1265 /* Remember that a sequence of tokens like "foo()" is a
1266 valid invocation of a macro expecting either zero or one
1268 else if (! (argc == 1
1271 error (_("Wrong number of arguments to macro `%s' "
1272 "(expected %d, got %d)."),
1273 id, def->argc, argc);
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
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);
1305 internal_error (__FILE__, __LINE__, _("bad macro definition kind"));
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. */
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,
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)
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))
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))
1349 do_cleanups (back_to);
1354 do_cleanups (back_to);
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. */
1367 scan (struct macro_buffer *dest,
1368 struct macro_buffer *src,
1369 struct macro_name_list *no_loop,
1370 macro_lookup_ftype *lookup_func,
1373 gdb_assert (src->shared);
1374 gdb_assert (! dest->shared);
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))
1385 /* Just for aesthetics. If we skipped some whitespace, copy
1387 if (tok.text > original_src_start)
1389 appendmem (dest, original_src_start, tok.text - original_src_start);
1390 dest->last_token = dest->len;
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);
1399 /* Just for aesthetics. If there was any trailing whitespace in
1400 src, copy it to dest. */
1403 appendmem (dest, src->text, src->len);
1404 dest->last_token = dest->len;
1410 macro_expand (const char *source,
1411 macro_lookup_ftype *lookup_func,
1412 void *lookup_func_baton)
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);
1433 macro_expand_once (const char *source,
1434 macro_lookup_ftype *lookup_func,
1435 void *lookup_func_baton)
1437 error (_("Expand-once not implemented yet."));
1442 macro_expand_next (const char **lexptr,
1443 macro_lookup_ftype *lookup_func,
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))
1460 do_cleanups (back_to);
1464 /* If it's a macro invocation, expand it. */
1465 if (maybe_expand (&dest, &tok, &src, 0, lookup_func, lookup_baton))
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);
1477 /* It wasn't a macro invocation. */
1478 do_cleanups (back_to);