1 /* C preprocessor macro expansion for GDB.
2 Copyright (C) 2002-2019 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, or to a string literal, and we shouldn't
60 /* For detecting token splicing.
62 This is the index in TEXT of the first character of the token
63 that abuts the end of TEXT. If TEXT contains no tokens, then we
64 set this equal to LEN. If TEXT ends in whitespace, then there is
65 no token abutting the end of TEXT (it's just whitespace), and
66 again, we set this equal to LEN. We set this to -1 if we don't
67 know the nature of TEXT. */
70 /* If this buffer is holding the result from get_token, then this
71 is non-zero if it is an identifier token, zero otherwise. */
72 int is_identifier = 0;
83 /* Set the macro buffer to the empty string, guessing that its
84 final contents will fit in N bytes. (It'll get resized if it
85 doesn't, so the guess doesn't have to be right.) Allocate the
86 initial storage with xmalloc. */
87 explicit macro_buffer (int n)
93 text = (char *) xmalloc (n);
98 /* Set the macro buffer to refer to the LEN bytes at ADDR, as a
100 macro_buffer (const char *addr, int len)
102 set_shared (addr, len);
105 /* Set the macro buffer to refer to the LEN bytes at ADDR, as a
107 void set_shared (const char *addr, int len_)
109 text = (char *) addr;
115 macro_buffer& operator= (const macro_buffer &src)
117 gdb_assert (src.shared);
119 set_shared (src.text, src.len);
120 last_token = src.last_token;
121 is_identifier = src.is_identifier;
127 if (! shared && size)
131 /* Release the text of the buffer to the caller, which is now
132 responsible for freeing it. */
133 ATTRIBUTE_UNUSED_RESULT char *release ()
135 gdb_assert (! shared);
142 /* Resize the buffer to be at least N bytes long. Raise an error if
143 the buffer shouldn't be resized. */
144 void resize_buffer (int n)
146 /* We shouldn't be trying to resize shared strings. */
147 gdb_assert (! shared);
155 text = (char *) xrealloc (text, size);
158 /* Append the character C to the buffer. */
161 int new_len = len + 1;
164 resize_buffer (new_len);
170 /* Append the COUNT bytes at ADDR to the buffer. */
171 void appendmem (const char *addr, int count)
173 int new_len = len + count;
176 resize_buffer (new_len);
178 memcpy (text + len, addr, count);
185 /* Recognizing preprocessor tokens. */
189 macro_is_whitespace (int c)
200 macro_is_digit (int c)
202 return ('0' <= c && c <= '9');
207 macro_is_identifier_nondigit (int c)
210 || ('a' <= c && c <= 'z')
211 || ('A' <= c && c <= 'Z'));
216 set_token (struct macro_buffer *tok, char *start, char *end)
218 tok->set_shared (start, end - start);
221 /* Presumed; get_identifier may overwrite this. */
222 tok->is_identifier = 0;
227 get_comment (struct macro_buffer *tok, char *p, char *end)
244 set_token (tok, tok_start, p);
248 error (_("Unterminated comment in macro expansion."));
260 set_token (tok, tok_start, p);
269 get_identifier (struct macro_buffer *tok, char *p, char *end)
272 && macro_is_identifier_nondigit (*p))
277 && (macro_is_identifier_nondigit (*p)
278 || macro_is_digit (*p)))
281 set_token (tok, tok_start, p);
282 tok->is_identifier = 1;
291 get_pp_number (struct macro_buffer *tok, char *p, char *end)
294 && (macro_is_digit (*p)
297 && macro_is_digit (p[1]))))
304 && strchr ("eEpP", *p)
305 && (p[1] == '+' || p[1] == '-'))
307 else if (macro_is_digit (*p)
308 || macro_is_identifier_nondigit (*p)
315 set_token (tok, tok_start, p);
324 /* If the text starting at P going up to (but not including) END
325 starts with a character constant, set *TOK to point to that
326 character constant, and return 1. Otherwise, return zero.
327 Signal an error if it contains a malformed or incomplete character
330 get_character_constant (struct macro_buffer *tok, char *p, char *end)
332 /* ISO/IEC 9899:1999 (E) Section 6.4.4.4 paragraph 1
333 But of course, what really matters is that we handle it the same
334 way GDB's C/C++ lexer does. So we call parse_escape in utils.c
335 to handle escape sequences. */
336 if ((p + 1 <= end && *p == '\'')
338 && (p[0] == 'L' || p[0] == 'u' || p[0] == 'U')
346 else if (*p == 'L' || *p == 'u' || *p == 'U')
349 gdb_assert_not_reached ("unexpected character constant");
354 error (_("Unmatched single quote."));
358 error (_("A character constant must contain at least one "
368 char_count += c_parse_escape (&s, NULL);
378 set_token (tok, tok_start, p);
386 /* If the text starting at P going up to (but not including) END
387 starts with a string literal, set *TOK to point to that string
388 literal, and return 1. Otherwise, return zero. Signal an error if
389 it contains a malformed or incomplete string literal. */
391 get_string_literal (struct macro_buffer *tok, char *p, char *end)
396 && (p[0] == 'L' || p[0] == 'u' || p[0] == 'U')
403 else if (*p == 'L' || *p == 'u' || *p == 'U')
406 gdb_assert_not_reached ("unexpected string literal");
411 error (_("Unterminated string in expression."));
418 error (_("Newline characters may not appear in string "
425 c_parse_escape (&s, NULL);
432 set_token (tok, tok_start, p);
441 get_punctuator (struct macro_buffer *tok, char *p, char *end)
443 /* Here, speed is much less important than correctness and clarity. */
445 /* ISO/IEC 9899:1999 (E) Section 6.4.6 Paragraph 1.
446 Note that this table is ordered in a special way. A punctuator
447 which is a prefix of another punctuator must appear after its
448 "extension". Otherwise, the wrong token will be returned. */
449 static const char * const punctuators[] = {
450 "[", "]", "(", ")", "{", "}", "?", ";", ",", "~",
452 "->", "--", "-=", "-",
458 "%>", "%:%:", "%:", "%=", "%",
463 "<<=", "<<", "<=", "<:", "<%", "<",
464 ">>=", ">>", ">=", ">",
473 for (i = 0; punctuators[i]; i++)
475 const char *punctuator = punctuators[i];
477 if (p[0] == punctuator[0])
479 int len = strlen (punctuator);
482 && ! memcmp (p, punctuator, len))
484 set_token (tok, p, p + len);
495 /* Peel the next preprocessor token off of SRC, and put it in TOK.
496 Mutate TOK to refer to the first token in SRC, and mutate SRC to
497 refer to the text after that token. SRC must be a shared buffer;
498 the resulting TOK will be shared, pointing into the same string SRC
499 does. Initialize TOK's last_token field. Return non-zero if we
500 succeed, or 0 if we didn't find any more tokens in SRC. */
502 get_token (struct macro_buffer *tok,
503 struct macro_buffer *src)
506 char *end = p + src->len;
508 gdb_assert (src->shared);
510 /* From the ISO C standard, ISO/IEC 9899:1999 (E), section 6.4:
519 each non-white-space character that cannot be one of the above
521 We don't have to deal with header-name tokens, since those can
522 only occur after a #include, which we will never see. */
525 if (macro_is_whitespace (*p))
527 else if (get_comment (tok, p, end))
529 else if (get_pp_number (tok, p, end)
530 || get_character_constant (tok, p, end)
531 || get_string_literal (tok, p, end)
532 /* Note: the grammar in the standard seems to be
533 ambiguous: L'x' can be either a wide character
534 constant, or an identifier followed by a normal
535 character constant. By trying `get_identifier' after
536 we try get_character_constant and get_string_literal,
537 we give the wide character syntax precedence. Now,
538 since GDB doesn't handle wide character constants
539 anyway, is this the right thing to do? */
540 || get_identifier (tok, p, end)
541 || get_punctuator (tok, p, end))
543 /* How many characters did we consume, including whitespace? */
544 int consumed = p - src->text + tok->len;
546 src->text += consumed;
547 src->len -= consumed;
552 /* We have found a "non-whitespace character that cannot be
553 one of the above." Make a token out of it. */
556 set_token (tok, p, p + 1);
557 consumed = p - src->text + tok->len;
558 src->text += consumed;
559 src->len -= consumed;
568 /* Appending token strings, with and without splicing */
571 /* Append the macro buffer SRC to the end of DEST, and ensure that
572 doing so doesn't splice the token at the end of SRC with the token
573 at the beginning of DEST. SRC and DEST must have their last_token
574 fields set. Upon return, DEST's last_token field is set correctly.
578 If DEST is "(" and SRC is "y", then we can return with
579 DEST set to "(y" --- we've simply appended the two buffers.
581 However, if DEST is "x" and SRC is "y", then we must not return
582 with DEST set to "xy" --- that would splice the two tokens "x" and
583 "y" together to make a single token "xy". However, it would be
584 fine to return with DEST set to "x y". Similarly, "<" and "<" must
585 yield "< <", not "<<", etc. */
587 append_tokens_without_splicing (struct macro_buffer *dest,
588 struct macro_buffer *src)
590 int original_dest_len = dest->len;
591 struct macro_buffer dest_tail, new_token;
593 gdb_assert (src->last_token != -1);
594 gdb_assert (dest->last_token != -1);
596 /* First, just try appending the two, and call get_token to see if
598 dest->appendmem (src->text, src->len);
600 /* If DEST originally had no token abutting its end, then we can't
601 have spliced anything, so we're done. */
602 if (dest->last_token == original_dest_len)
604 dest->last_token = original_dest_len + src->last_token;
608 /* Set DEST_TAIL to point to the last token in DEST, followed by
609 all the stuff we just appended. */
610 dest_tail.set_shared (dest->text + dest->last_token,
611 dest->len - dest->last_token);
613 /* Re-parse DEST's last token. We know that DEST used to contain
614 at least one token, so if it doesn't contain any after the
615 append, then we must have spliced "/" and "*" or "/" and "/" to
616 make a comment start. (Just for the record, I got this right
617 the first time. This is not a bug fix.) */
618 if (get_token (&new_token, &dest_tail)
619 && (new_token.text + new_token.len
620 == dest->text + original_dest_len))
622 /* No splice, so we're done. */
623 dest->last_token = original_dest_len + src->last_token;
627 /* Okay, a simple append caused a splice. Let's chop dest back to
628 its original length and try again, but separate the texts with a
630 dest->len = original_dest_len;
632 dest->appendmem (src->text, src->len);
634 dest_tail.set_shared (dest->text + dest->last_token,
635 dest->len - dest->last_token);
637 /* Try to re-parse DEST's last token, as above. */
638 if (get_token (&new_token, &dest_tail)
639 && (new_token.text + new_token.len
640 == dest->text + original_dest_len))
642 /* No splice, so we're done. */
643 dest->last_token = original_dest_len + 1 + src->last_token;
647 /* As far as I know, there's no case where inserting a space isn't
648 enough to prevent a splice. */
649 internal_error (__FILE__, __LINE__,
650 _("unable to avoid splicing tokens during macro expansion"));
653 /* Stringify an argument, and insert it into DEST. ARG is the text to
654 stringify; it is LEN bytes long. */
657 stringify (struct macro_buffer *dest, const char *arg, int len)
659 /* Trim initial whitespace from ARG. */
660 while (len > 0 && macro_is_whitespace (*arg))
666 /* Trim trailing whitespace from ARG. */
667 while (len > 0 && macro_is_whitespace (arg[len - 1]))
670 /* Insert the string. */
674 /* We could try to handle strange cases here, like control
675 characters, but there doesn't seem to be much point. */
676 if (macro_is_whitespace (*arg))
678 /* Replace a sequence of whitespace with a single space. */
680 while (len > 1 && macro_is_whitespace (arg[1]))
686 else if (*arg == '\\' || *arg == '"')
688 dest->appendc ('\\');
689 dest->appendc (*arg);
692 dest->appendc (*arg);
697 dest->last_token = dest->len;
700 /* See macroexp.h. */
703 macro_stringify (const char *str)
705 int len = strlen (str);
706 struct macro_buffer buffer (len);
708 stringify (&buffer, str, len);
709 buffer.appendc ('\0');
711 return buffer.release ();
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 false, leave SRC unchanged, and don't set *ARGS_PTR 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 true and set *ARGS_PTR to a vector of macro
769 buffers referring to the argument texts. The macro buffers share
770 their text with SRC, and their last_token fields are initialized.
772 NOTE WELL: if SRC starts with a open paren ( token followed
773 immediately by a close paren ) token (e.g., the invocation looks
774 like "foo()"), we treat that as one argument, which happens to be
775 the empty list of tokens. The caller should keep in mind that such
776 a sequence of tokens is a valid way to invoke one-parameter
777 function-like macros, but also a valid way to invoke zero-parameter
778 function-like macros. Eeew.
780 Consume the tokens from SRC; after this call, SRC contains the text
781 following the invocation. */
784 gather_arguments (const char *name, struct macro_buffer *src, int nargs,
785 std::vector<struct macro_buffer> *args_ptr)
787 struct macro_buffer tok;
788 std::vector<struct macro_buffer> args;
790 /* Does SRC start with an opening paren token? Read from a copy of
791 SRC, so SRC itself is unaffected if we don't find an opening
794 struct macro_buffer temp (src->text, src->len);
796 if (! get_token (&tok, &temp)
798 || tok.text[0] != '(')
802 /* Consume SRC's opening paren. */
803 get_token (&tok, src);
807 struct macro_buffer *arg;
810 /* Initialize the next argument. */
811 args.emplace_back ();
813 set_token (arg, src->text, src->text);
815 /* Gather the argument's tokens. */
819 if (! get_token (&tok, src))
820 error (_("Malformed argument list for macro `%s'."), name);
822 /* Is tok an opening paren? */
823 if (tok.len == 1 && tok.text[0] == '(')
826 /* Is tok is a closing paren? */
827 else if (tok.len == 1 && tok.text[0] == ')')
829 /* If it's a closing paren at the top level, then that's
830 the end of the argument list. */
833 /* In the varargs case, the last argument may be
834 missing. Add an empty argument in this case. */
835 if (nargs != -1 && args.size () == nargs - 1)
837 args.emplace_back ();
839 set_token (arg, src->text, src->text);
842 *args_ptr = std::move (args);
849 /* If tok is a comma at top level, then that's the end of
850 the current argument. However, if we are handling a
851 variadic macro and we are computing the last argument, we
852 want to include the comma and remaining tokens. */
853 else if (tok.len == 1 && tok.text[0] == ',' && depth == 0
854 && (nargs == -1 || args.size () < nargs))
857 /* Extend the current argument to enclose this token. If
858 this is the current argument's first token, leave out any
859 leading whitespace, just for aesthetics. */
862 arg->text = tok.text;
868 arg->len = (tok.text + tok.len) - arg->text;
869 arg->last_token = tok.text - arg->text;
876 /* The `expand' and `substitute_args' functions both invoke `scan'
877 recursively, so we need a forward declaration somewhere. */
878 static void scan (struct macro_buffer *dest,
879 struct macro_buffer *src,
880 struct macro_name_list *no_loop,
881 macro_lookup_ftype *lookup_func,
885 /* A helper function for substitute_args.
887 ARGV is a vector of all the arguments; ARGC is the number of
888 arguments. IS_VARARGS is true if the macro being substituted is a
889 varargs macro; in this case VA_ARG_NAME is the name of the
890 "variable" argument. VA_ARG_NAME is ignored if IS_VARARGS is
893 If the token TOK is the name of a parameter, return the parameter's
894 index. If TOK is not an argument, return -1. */
897 find_parameter (const struct macro_buffer *tok,
898 int is_varargs, const struct macro_buffer *va_arg_name,
899 int argc, const char * const *argv)
903 if (! tok->is_identifier)
906 for (i = 0; i < argc; ++i)
907 if (tok->len == strlen (argv[i])
908 && !memcmp (tok->text, argv[i], tok->len))
911 if (is_varargs && tok->len == va_arg_name->len
912 && ! memcmp (tok->text, va_arg_name->text, tok->len))
918 /* Helper function for substitute_args that gets the next token and
919 updates the passed-in state variables. */
922 get_next_token_for_substitution (struct macro_buffer *replacement_list,
923 struct macro_buffer *token,
925 struct macro_buffer *lookahead,
926 char **lookahead_start,
927 int *lookahead_valid,
930 if (!*lookahead_valid)
936 *start = *lookahead_start;
937 *lookahead_start = replacement_list->text;
938 *lookahead_valid = get_token (lookahead, replacement_list);
942 /* Given the macro definition DEF, being invoked with the actual
943 arguments given by ARGV, substitute the arguments into the
944 replacement list, and store the result in DEST.
946 IS_VARARGS should be true if DEF is a varargs macro. In this case,
947 VA_ARG_NAME should be the name of the "variable" argument -- either
948 __VA_ARGS__ for c99-style varargs, or the final argument name, for
949 GNU-style varargs. If IS_VARARGS is false, this parameter is
952 If it is necessary to expand macro invocations in one of the
953 arguments, use LOOKUP_FUNC and LOOKUP_BATON to find the macro
954 definitions, and don't expand invocations of the macros listed in
958 substitute_args (struct macro_buffer *dest,
959 struct macro_definition *def,
960 int is_varargs, const struct macro_buffer *va_arg_name,
961 const std::vector<struct macro_buffer> &argv,
962 struct macro_name_list *no_loop,
963 macro_lookup_ftype *lookup_func,
966 /* The token we are currently considering. */
967 struct macro_buffer tok;
968 /* The replacement list's pointer from just before TOK was lexed. */
969 char *original_rl_start;
970 /* We have a single lookahead token to handle token splicing. */
971 struct macro_buffer lookahead;
972 /* The lookahead token might not be valid. */
974 /* The replacement list's pointer from just before LOOKAHEAD was
976 char *lookahead_rl_start;
978 /* A macro buffer for the macro's replacement list. */
979 struct macro_buffer replacement_list (def->replacement,
980 strlen (def->replacement));
982 gdb_assert (dest->len == 0);
983 dest->last_token = 0;
985 original_rl_start = replacement_list.text;
986 if (! get_token (&tok, &replacement_list))
988 lookahead_rl_start = replacement_list.text;
989 lookahead_valid = get_token (&lookahead, &replacement_list);
991 /* __VA_OPT__ state variable. The states are:
992 0 - nothing happening
994 >= 2 in __VA_OPT__, the value encodes the parenthesis depth. */
995 unsigned vaopt_state = 0;
997 for (bool keep_going = true;
999 get_next_token_for_substitution (&replacement_list,
1003 &lookahead_rl_start,
1007 bool token_is_vaopt = (tok.len == 10
1008 && strncmp (tok.text, "__VA_OPT__", 10) == 0);
1010 if (vaopt_state > 0)
1013 error (_("__VA_OPT__ cannot appear inside __VA_OPT__"));
1014 else if (tok.len == 1 && tok.text[0] == '(')
1017 /* We just entered __VA_OPT__, so don't emit this
1021 else if (vaopt_state == 1)
1022 error (_("__VA_OPT__ must be followed by an open parenthesis"));
1023 else if (tok.len == 1 && tok.text[0] == ')')
1026 if (vaopt_state == 1)
1028 /* Done with __VA_OPT__. */
1035 /* If __VA_ARGS__ is empty, then drop the contents of
1037 if (argv.back ().len == 0)
1040 else if (token_is_vaopt)
1043 error (_("__VA_OPT__ is only valid in a variadic macro"));
1045 /* Don't emit this token. */
1049 /* Just for aesthetics. If we skipped some whitespace, copy
1051 if (tok.text > original_rl_start)
1053 dest->appendmem (original_rl_start, tok.text - original_rl_start);
1054 dest->last_token = dest->len;
1057 /* Is this token the stringification operator? */
1059 && tok.text[0] == '#')
1063 if (!lookahead_valid)
1064 error (_("Stringification operator requires an argument."));
1066 arg = find_parameter (&lookahead, is_varargs, va_arg_name,
1067 def->argc, def->argv);
1069 error (_("Argument to stringification operator must name "
1070 "a macro parameter."));
1072 stringify (dest, argv[arg].text, argv[arg].len);
1074 /* Read one token and let the loop iteration code handle the
1076 lookahead_rl_start = replacement_list.text;
1077 lookahead_valid = get_token (&lookahead, &replacement_list);
1079 /* Is this token the splicing operator? */
1080 else if (tok.len == 2
1081 && tok.text[0] == '#'
1082 && tok.text[1] == '#')
1083 error (_("Stray splicing operator"));
1084 /* Is the next token the splicing operator? */
1085 else if (lookahead_valid
1086 && lookahead.len == 2
1087 && lookahead.text[0] == '#'
1088 && lookahead.text[1] == '#')
1091 int prev_was_comma = 0;
1093 /* Note that GCC warns if the result of splicing is not a
1094 token. In the debugger there doesn't seem to be much
1095 benefit from doing this. */
1097 /* Insert the first token. */
1098 if (tok.len == 1 && tok.text[0] == ',')
1102 int arg = find_parameter (&tok, is_varargs, va_arg_name,
1103 def->argc, def->argv);
1106 dest->appendmem (argv[arg].text, argv[arg].len);
1108 dest->appendmem (tok.text, tok.len);
1111 /* Apply a possible sequence of ## operators. */
1114 if (! get_token (&tok, &replacement_list))
1115 error (_("Splicing operator at end of macro"));
1117 /* Handle a comma before a ##. If we are handling
1118 varargs, and the token on the right hand side is the
1119 varargs marker, and the final argument is empty or
1120 missing, then drop the comma. This is a GNU
1121 extension. There is one ambiguous case here,
1122 involving pedantic behavior with an empty argument,
1123 but we settle that in favor of GNU-style (GCC uses an
1124 option). If we aren't dealing with varargs, we
1125 simply insert the comma. */
1129 && tok.len == va_arg_name->len
1130 && !memcmp (tok.text, va_arg_name->text, tok.len)
1131 && argv.back ().len == 0))
1132 dest->appendmem (",", 1);
1136 /* Insert the token. If it is a parameter, insert the
1137 argument. If it is a comma, treat it specially. */
1138 if (tok.len == 1 && tok.text[0] == ',')
1142 int arg = find_parameter (&tok, is_varargs, va_arg_name,
1143 def->argc, def->argv);
1146 dest->appendmem (argv[arg].text, argv[arg].len);
1148 dest->appendmem (tok.text, tok.len);
1151 /* Now read another token. If it is another splice, we
1153 original_rl_start = replacement_list.text;
1154 if (! get_token (&tok, &replacement_list))
1161 && tok.text[0] == '#'
1162 && tok.text[1] == '#'))
1168 /* We saw a comma. Insert it now. */
1169 dest->appendmem (",", 1);
1172 dest->last_token = dest->len;
1174 lookahead_valid = 0;
1177 /* Set up for the loop iterator. */
1179 lookahead_rl_start = original_rl_start;
1180 lookahead_valid = 1;
1185 /* Is this token an identifier? */
1186 int substituted = 0;
1187 int arg = find_parameter (&tok, is_varargs, va_arg_name,
1188 def->argc, def->argv);
1192 /* Expand any macro invocations in the argument text,
1193 and append the result to dest. Remember that scan
1194 mutates its source, so we need to scan a new buffer
1195 referring to the argument's text, not the argument
1197 struct macro_buffer arg_src (argv[arg].text, argv[arg].len);
1198 scan (dest, &arg_src, no_loop, lookup_func, lookup_baton);
1202 /* If it wasn't a parameter, then just copy it across. */
1204 append_tokens_without_splicing (dest, &tok);
1208 if (vaopt_state > 0)
1209 error (_("Unterminated __VA_OPT__"));
1213 /* Expand a call to a macro named ID, whose definition is DEF. Append
1214 its expansion to DEST. SRC is the input text following the ID
1215 token. We are currently rescanning the expansions of the macros
1216 named in NO_LOOP; don't re-expand them. Use LOOKUP_FUNC and
1217 LOOKUP_BATON to find definitions for any nested macro references.
1219 Return 1 if we decided to expand it, zero otherwise. (If it's a
1220 function-like macro name that isn't followed by an argument list,
1221 we don't expand it.) If we return zero, leave SRC unchanged. */
1223 expand (const char *id,
1224 struct macro_definition *def,
1225 struct macro_buffer *dest,
1226 struct macro_buffer *src,
1227 struct macro_name_list *no_loop,
1228 macro_lookup_ftype *lookup_func,
1231 struct macro_name_list new_no_loop;
1233 /* Create a new node to be added to the front of the no-expand list.
1234 This list is appropriate for re-scanning replacement lists, but
1235 it is *not* appropriate for scanning macro arguments; invocations
1236 of the macro whose arguments we are gathering *do* get expanded
1238 new_no_loop.name = id;
1239 new_no_loop.next = no_loop;
1241 /* What kind of macro are we expanding? */
1242 if (def->kind == macro_object_like)
1244 struct macro_buffer replacement_list (def->replacement,
1245 strlen (def->replacement));
1247 scan (dest, &replacement_list, &new_no_loop, lookup_func, lookup_baton);
1250 else if (def->kind == macro_function_like)
1252 struct macro_buffer va_arg_name;
1257 if (strcmp (def->argv[def->argc - 1], "...") == 0)
1259 /* In C99-style varargs, substitution is done using
1261 va_arg_name.set_shared ("__VA_ARGS__", strlen ("__VA_ARGS__"));
1266 int len = strlen (def->argv[def->argc - 1]);
1269 && strcmp (def->argv[def->argc - 1] + len - 3, "...") == 0)
1271 /* In GNU-style varargs, the name of the
1272 substitution parameter is the name of the formal
1273 argument without the "...". */
1274 va_arg_name.set_shared (def->argv[def->argc - 1], len - 3);
1280 std::vector<struct macro_buffer> argv;
1281 /* If we couldn't find any argument list, then we don't expand
1283 if (!gather_arguments (id, src, is_varargs ? def->argc : -1,
1287 /* Check that we're passing an acceptable number of arguments for
1289 if (argv.size () != def->argc)
1291 if (is_varargs && argv.size () >= def->argc - 1)
1295 /* Remember that a sequence of tokens like "foo()" is a
1296 valid invocation of a macro expecting either zero or one
1298 else if (! (argv.size () == 1
1301 error (_("Wrong number of arguments to macro `%s' "
1302 "(expected %d, got %d)."),
1303 id, def->argc, int (argv.size ()));
1306 /* Note that we don't expand macro invocations in the arguments
1307 yet --- we let subst_args take care of that. Parameters that
1308 appear as operands of the stringifying operator "#" or the
1309 splicing operator "##" don't get macro references expanded,
1310 so we can't really tell whether it's appropriate to macro-
1311 expand an argument until we see how it's being used. */
1312 struct macro_buffer substituted (0);
1313 substitute_args (&substituted, def, is_varargs, &va_arg_name,
1314 argv, no_loop, lookup_func, lookup_baton);
1316 /* Now `substituted' is the macro's replacement list, with all
1317 argument values substituted into it properly. Re-scan it for
1318 macro references, but don't expand invocations of this macro.
1320 We create a new buffer, `substituted_src', which points into
1321 `substituted', and scan that. We can't scan `substituted'
1322 itself, since the tokenization process moves the buffer's
1323 text pointer around, and we still need to be able to find
1324 `substituted's original text buffer after scanning it so we
1326 struct macro_buffer substituted_src (substituted.text, substituted.len);
1327 scan (dest, &substituted_src, &new_no_loop, lookup_func, lookup_baton);
1332 internal_error (__FILE__, __LINE__, _("bad macro definition kind"));
1336 /* If the single token in SRC_FIRST followed by the tokens in SRC_REST
1337 constitute a macro invokation not forbidden in NO_LOOP, append its
1338 expansion to DEST and return non-zero. Otherwise, return zero, and
1339 leave DEST unchanged.
1341 SRC_FIRST and SRC_REST must be shared buffers; DEST must not be one.
1342 SRC_FIRST must be a string built by get_token. */
1344 maybe_expand (struct macro_buffer *dest,
1345 struct macro_buffer *src_first,
1346 struct macro_buffer *src_rest,
1347 struct macro_name_list *no_loop,
1348 macro_lookup_ftype *lookup_func,
1351 gdb_assert (src_first->shared);
1352 gdb_assert (src_rest->shared);
1353 gdb_assert (! dest->shared);
1355 /* Is this token an identifier? */
1356 if (src_first->is_identifier)
1358 /* Make a null-terminated copy of it, since that's what our
1359 lookup function expects. */
1360 std::string id (src_first->text, src_first->len);
1362 /* If we're currently re-scanning the result of expanding
1363 this macro, don't expand it again. */
1364 if (! currently_rescanning (no_loop, id.c_str ()))
1366 /* Does this identifier have a macro definition in scope? */
1367 struct macro_definition *def = lookup_func (id.c_str (),
1370 if (def && expand (id.c_str (), def, dest, src_rest, no_loop,
1371 lookup_func, lookup_baton))
1380 /* Expand macro references in SRC, appending the results to DEST.
1381 Assume we are re-scanning the result of expanding the macros named
1382 in NO_LOOP, and don't try to re-expand references to them.
1384 SRC must be a shared buffer; DEST must not be one. */
1386 scan (struct macro_buffer *dest,
1387 struct macro_buffer *src,
1388 struct macro_name_list *no_loop,
1389 macro_lookup_ftype *lookup_func,
1392 gdb_assert (src->shared);
1393 gdb_assert (! dest->shared);
1397 struct macro_buffer tok;
1398 char *original_src_start = src->text;
1400 /* Find the next token in SRC. */
1401 if (! get_token (&tok, src))
1404 /* Just for aesthetics. If we skipped some whitespace, copy
1406 if (tok.text > original_src_start)
1408 dest->appendmem (original_src_start, tok.text - original_src_start);
1409 dest->last_token = dest->len;
1412 if (! maybe_expand (dest, &tok, src, no_loop, lookup_func, lookup_baton))
1413 /* We didn't end up expanding tok as a macro reference, so
1414 simply append it to dest. */
1415 append_tokens_without_splicing (dest, &tok);
1418 /* Just for aesthetics. If there was any trailing whitespace in
1419 src, copy it to dest. */
1422 dest->appendmem (src->text, src->len);
1423 dest->last_token = dest->len;
1428 gdb::unique_xmalloc_ptr<char>
1429 macro_expand (const char *source,
1430 macro_lookup_ftype *lookup_func,
1431 void *lookup_func_baton)
1433 struct macro_buffer src (source, strlen (source));
1435 struct macro_buffer dest (0);
1436 dest.last_token = 0;
1438 scan (&dest, &src, 0, lookup_func, lookup_func_baton);
1440 dest.appendc ('\0');
1442 return gdb::unique_xmalloc_ptr<char> (dest.release ());
1446 gdb::unique_xmalloc_ptr<char>
1447 macro_expand_once (const char *source,
1448 macro_lookup_ftype *lookup_func,
1449 void *lookup_func_baton)
1451 error (_("Expand-once not implemented yet."));
1456 macro_expand_next (const char **lexptr,
1457 macro_lookup_ftype *lookup_func,
1460 struct macro_buffer tok;
1462 /* Set up SRC to refer to the input text, pointed to by *lexptr. */
1463 struct macro_buffer src (*lexptr, strlen (*lexptr));
1465 /* Set up DEST to receive the expansion, if there is one. */
1466 struct macro_buffer dest (0);
1467 dest.last_token = 0;
1469 /* Get the text's first preprocessing token. */
1470 if (! get_token (&tok, &src))
1473 /* If it's a macro invocation, expand it. */
1474 if (maybe_expand (&dest, &tok, &src, 0, lookup_func, lookup_baton))
1476 /* It was a macro invocation! Package up the expansion as a
1477 null-terminated string and return it. Set *lexptr to the
1478 start of the next token in the input. */
1479 dest.appendc ('\0');
1481 return dest.release ();
1485 /* It wasn't a macro invocation. */