1 /* C preprocessor macro expansion for GDB.
2 Copyright (C) 2002-2018 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;
117 if (! shared && size)
121 /* Release the text of the buffer to the caller, which is now
122 responsible for freeing it. */
125 gdb_assert (! shared);
132 /* Resize the buffer to be at least N bytes long. Raise an error if
133 the buffer shouldn't be resized. */
134 void resize_buffer (int n)
136 /* We shouldn't be trying to resize shared strings. */
137 gdb_assert (! shared);
145 text = (char *) xrealloc (text, size);
148 /* Append the character C to the buffer. */
151 int new_len = len + 1;
154 resize_buffer (new_len);
160 /* Append the COUNT bytes at ADDR to the buffer. */
161 void appendmem (const char *addr, int count)
163 int new_len = len + count;
166 resize_buffer (new_len);
168 memcpy (text + len, addr, count);
175 /* Recognizing preprocessor tokens. */
179 macro_is_whitespace (int c)
190 macro_is_digit (int c)
192 return ('0' <= c && c <= '9');
197 macro_is_identifier_nondigit (int c)
200 || ('a' <= c && c <= 'z')
201 || ('A' <= c && c <= 'Z'));
206 set_token (struct macro_buffer *tok, char *start, char *end)
208 tok->set_shared (start, end - start);
211 /* Presumed; get_identifier may overwrite this. */
212 tok->is_identifier = 0;
217 get_comment (struct macro_buffer *tok, char *p, char *end)
234 set_token (tok, tok_start, p);
238 error (_("Unterminated comment in macro expansion."));
250 set_token (tok, tok_start, p);
259 get_identifier (struct macro_buffer *tok, char *p, char *end)
262 && macro_is_identifier_nondigit (*p))
267 && (macro_is_identifier_nondigit (*p)
268 || macro_is_digit (*p)))
271 set_token (tok, tok_start, p);
272 tok->is_identifier = 1;
281 get_pp_number (struct macro_buffer *tok, char *p, char *end)
284 && (macro_is_digit (*p)
287 && macro_is_digit (p[1]))))
294 && strchr ("eEpP", *p)
295 && (p[1] == '+' || p[1] == '-'))
297 else if (macro_is_digit (*p)
298 || macro_is_identifier_nondigit (*p)
305 set_token (tok, tok_start, p);
314 /* If the text starting at P going up to (but not including) END
315 starts with a character constant, set *TOK to point to that
316 character constant, and return 1. Otherwise, return zero.
317 Signal an error if it contains a malformed or incomplete character
320 get_character_constant (struct macro_buffer *tok, char *p, char *end)
322 /* ISO/IEC 9899:1999 (E) Section 6.4.4.4 paragraph 1
323 But of course, what really matters is that we handle it the same
324 way GDB's C/C++ lexer does. So we call parse_escape in utils.c
325 to handle escape sequences. */
326 if ((p + 1 <= end && *p == '\'')
328 && (p[0] == 'L' || p[0] == 'u' || p[0] == 'U')
336 else if (*p == 'L' || *p == 'u' || *p == 'U')
339 gdb_assert_not_reached ("unexpected character constant");
344 error (_("Unmatched single quote."));
348 error (_("A character constant must contain at least one "
358 char_count += c_parse_escape (&s, NULL);
368 set_token (tok, tok_start, p);
376 /* If the text starting at P going up to (but not including) END
377 starts with a string literal, set *TOK to point to that string
378 literal, and return 1. Otherwise, return zero. Signal an error if
379 it contains a malformed or incomplete string literal. */
381 get_string_literal (struct macro_buffer *tok, char *p, char *end)
386 && (p[0] == 'L' || p[0] == 'u' || p[0] == 'U')
393 else if (*p == 'L' || *p == 'u' || *p == 'U')
396 gdb_assert_not_reached ("unexpected string literal");
401 error (_("Unterminated string in expression."));
408 error (_("Newline characters may not appear in string "
415 c_parse_escape (&s, NULL);
422 set_token (tok, tok_start, p);
431 get_punctuator (struct macro_buffer *tok, char *p, char *end)
433 /* Here, speed is much less important than correctness and clarity. */
435 /* ISO/IEC 9899:1999 (E) Section 6.4.6 Paragraph 1.
436 Note that this table is ordered in a special way. A punctuator
437 which is a prefix of another punctuator must appear after its
438 "extension". Otherwise, the wrong token will be returned. */
439 static const char * const punctuators[] = {
440 "[", "]", "(", ")", "{", "}", "?", ";", ",", "~",
442 "->", "--", "-=", "-",
448 "%>", "%:%:", "%:", "%=", "%",
453 "<<=", "<<", "<=", "<:", "<%", "<",
454 ">>=", ">>", ">=", ">",
463 for (i = 0; punctuators[i]; i++)
465 const char *punctuator = punctuators[i];
467 if (p[0] == punctuator[0])
469 int len = strlen (punctuator);
472 && ! memcmp (p, punctuator, len))
474 set_token (tok, p, p + len);
485 /* Peel the next preprocessor token off of SRC, and put it in TOK.
486 Mutate TOK to refer to the first token in SRC, and mutate SRC to
487 refer to the text after that token. SRC must be a shared buffer;
488 the resulting TOK will be shared, pointing into the same string SRC
489 does. Initialize TOK's last_token field. Return non-zero if we
490 succeed, or 0 if we didn't find any more tokens in SRC. */
492 get_token (struct macro_buffer *tok,
493 struct macro_buffer *src)
496 char *end = p + src->len;
498 gdb_assert (src->shared);
500 /* From the ISO C standard, ISO/IEC 9899:1999 (E), section 6.4:
509 each non-white-space character that cannot be one of the above
511 We don't have to deal with header-name tokens, since those can
512 only occur after a #include, which we will never see. */
515 if (macro_is_whitespace (*p))
517 else if (get_comment (tok, p, end))
519 else if (get_pp_number (tok, p, end)
520 || get_character_constant (tok, p, end)
521 || get_string_literal (tok, p, end)
522 /* Note: the grammar in the standard seems to be
523 ambiguous: L'x' can be either a wide character
524 constant, or an identifier followed by a normal
525 character constant. By trying `get_identifier' after
526 we try get_character_constant and get_string_literal,
527 we give the wide character syntax precedence. Now,
528 since GDB doesn't handle wide character constants
529 anyway, is this the right thing to do? */
530 || get_identifier (tok, p, end)
531 || get_punctuator (tok, p, end))
533 /* How many characters did we consume, including whitespace? */
534 int consumed = p - src->text + tok->len;
536 src->text += consumed;
537 src->len -= consumed;
542 /* We have found a "non-whitespace character that cannot be
543 one of the above." Make a token out of it. */
546 set_token (tok, p, p + 1);
547 consumed = p - src->text + tok->len;
548 src->text += consumed;
549 src->len -= consumed;
558 /* Appending token strings, with and without splicing */
561 /* Append the macro buffer SRC to the end of DEST, and ensure that
562 doing so doesn't splice the token at the end of SRC with the token
563 at the beginning of DEST. SRC and DEST must have their last_token
564 fields set. Upon return, DEST's last_token field is set correctly.
568 If DEST is "(" and SRC is "y", then we can return with
569 DEST set to "(y" --- we've simply appended the two buffers.
571 However, if DEST is "x" and SRC is "y", then we must not return
572 with DEST set to "xy" --- that would splice the two tokens "x" and
573 "y" together to make a single token "xy". However, it would be
574 fine to return with DEST set to "x y". Similarly, "<" and "<" must
575 yield "< <", not "<<", etc. */
577 append_tokens_without_splicing (struct macro_buffer *dest,
578 struct macro_buffer *src)
580 int original_dest_len = dest->len;
581 struct macro_buffer dest_tail, new_token;
583 gdb_assert (src->last_token != -1);
584 gdb_assert (dest->last_token != -1);
586 /* First, just try appending the two, and call get_token to see if
588 dest->appendmem (src->text, src->len);
590 /* If DEST originally had no token abutting its end, then we can't
591 have spliced anything, so we're done. */
592 if (dest->last_token == original_dest_len)
594 dest->last_token = original_dest_len + src->last_token;
598 /* Set DEST_TAIL to point to the last token in DEST, followed by
599 all the stuff we just appended. */
600 dest_tail.set_shared (dest->text + dest->last_token,
601 dest->len - dest->last_token);
603 /* Re-parse DEST's last token. We know that DEST used to contain
604 at least one token, so if it doesn't contain any after the
605 append, then we must have spliced "/" and "*" or "/" and "/" to
606 make a comment start. (Just for the record, I got this right
607 the first time. This is not a bug fix.) */
608 if (get_token (&new_token, &dest_tail)
609 && (new_token.text + new_token.len
610 == dest->text + original_dest_len))
612 /* No splice, so we're done. */
613 dest->last_token = original_dest_len + src->last_token;
617 /* Okay, a simple append caused a splice. Let's chop dest back to
618 its original length and try again, but separate the texts with a
620 dest->len = original_dest_len;
622 dest->appendmem (src->text, src->len);
624 dest_tail.set_shared (dest->text + dest->last_token,
625 dest->len - dest->last_token);
627 /* Try to re-parse DEST's last token, as above. */
628 if (get_token (&new_token, &dest_tail)
629 && (new_token.text + new_token.len
630 == dest->text + original_dest_len))
632 /* No splice, so we're done. */
633 dest->last_token = original_dest_len + 1 + src->last_token;
637 /* As far as I know, there's no case where inserting a space isn't
638 enough to prevent a splice. */
639 internal_error (__FILE__, __LINE__,
640 _("unable to avoid splicing tokens during macro expansion"));
643 /* Stringify an argument, and insert it into DEST. ARG is the text to
644 stringify; it is LEN bytes long. */
647 stringify (struct macro_buffer *dest, const char *arg, int len)
649 /* Trim initial whitespace from ARG. */
650 while (len > 0 && macro_is_whitespace (*arg))
656 /* Trim trailing whitespace from ARG. */
657 while (len > 0 && macro_is_whitespace (arg[len - 1]))
660 /* Insert the string. */
664 /* We could try to handle strange cases here, like control
665 characters, but there doesn't seem to be much point. */
666 if (macro_is_whitespace (*arg))
668 /* Replace a sequence of whitespace with a single space. */
670 while (len > 1 && macro_is_whitespace (arg[1]))
676 else if (*arg == '\\' || *arg == '"')
678 dest->appendc ('\\');
679 dest->appendc (*arg);
682 dest->appendc (*arg);
687 dest->last_token = dest->len;
690 /* See macroexp.h. */
693 macro_stringify (const char *str)
695 int len = strlen (str);
696 struct macro_buffer buffer (len);
698 stringify (&buffer, str, len);
699 buffer.appendc ('\0');
701 return buffer.release ();
705 /* Expanding macros! */
708 /* A singly-linked list of the names of the macros we are currently
709 expanding --- for detecting expansion loops. */
710 struct macro_name_list {
712 struct macro_name_list *next;
716 /* Return non-zero if we are currently expanding the macro named NAME,
717 according to LIST; otherwise, return zero.
719 You know, it would be possible to get rid of all the NO_LOOP
720 arguments to these functions by simply generating a new lookup
721 function and baton which refuses to find the definition for a
722 particular macro, and otherwise delegates the decision to another
723 function/baton pair. But that makes the linked list of excluded
724 macros chained through untyped baton pointers, which will make it
725 harder to debug. :( */
727 currently_rescanning (struct macro_name_list *list, const char *name)
729 for (; list; list = list->next)
730 if (strcmp (name, list->name) == 0)
737 /* Gather the arguments to a macro expansion.
739 NAME is the name of the macro being invoked. (It's only used for
740 printing error messages.)
742 Assume that SRC is the text of the macro invocation immediately
743 following the macro name. For example, if we're processing the
744 text foo(bar, baz), then NAME would be foo and SRC will be (bar,
747 If SRC doesn't start with an open paren ( token at all, return
748 false, leave SRC unchanged, and don't set *ARGS_PTR to anything.
750 If SRC doesn't contain a properly terminated argument list, then
753 For a variadic macro, NARGS holds the number of formal arguments to
754 the macro. For a GNU-style variadic macro, this should be the
755 number of named arguments. For a non-variadic macro, NARGS should
758 Otherwise, return true and set *ARGS_PTR to a vector of macro
759 buffers referring to the argument texts. The macro buffers share
760 their text with SRC, and their last_token fields are initialized.
762 NOTE WELL: if SRC starts with a open paren ( token followed
763 immediately by a close paren ) token (e.g., the invocation looks
764 like "foo()"), we treat that as one argument, which happens to be
765 the empty list of tokens. The caller should keep in mind that such
766 a sequence of tokens is a valid way to invoke one-parameter
767 function-like macros, but also a valid way to invoke zero-parameter
768 function-like macros. Eeew.
770 Consume the tokens from SRC; after this call, SRC contains the text
771 following the invocation. */
774 gather_arguments (const char *name, struct macro_buffer *src, int nargs,
775 std::vector<struct macro_buffer> *args_ptr)
777 struct macro_buffer tok;
778 std::vector<struct macro_buffer> args;
780 /* Does SRC start with an opening paren token? Read from a copy of
781 SRC, so SRC itself is unaffected if we don't find an opening
784 struct macro_buffer temp (src->text, src->len);
786 if (! get_token (&tok, &temp)
788 || tok.text[0] != '(')
792 /* Consume SRC's opening paren. */
793 get_token (&tok, src);
797 struct macro_buffer *arg;
800 /* Initialize the next argument. */
801 args.emplace_back ();
803 set_token (arg, src->text, src->text);
805 /* Gather the argument's tokens. */
809 if (! get_token (&tok, src))
810 error (_("Malformed argument list for macro `%s'."), name);
812 /* Is tok an opening paren? */
813 if (tok.len == 1 && tok.text[0] == '(')
816 /* Is tok is a closing paren? */
817 else if (tok.len == 1 && tok.text[0] == ')')
819 /* If it's a closing paren at the top level, then that's
820 the end of the argument list. */
823 /* In the varargs case, the last argument may be
824 missing. Add an empty argument in this case. */
825 if (nargs != -1 && args.size () == nargs - 1)
827 args.emplace_back ();
829 set_token (arg, src->text, src->text);
832 *args_ptr = std::move (args);
839 /* If tok is a comma at top level, then that's the end of
840 the current argument. However, if we are handling a
841 variadic macro and we are computing the last argument, we
842 want to include the comma and remaining tokens. */
843 else if (tok.len == 1 && tok.text[0] == ',' && depth == 0
844 && (nargs == -1 || args.size () < nargs))
847 /* Extend the current argument to enclose this token. If
848 this is the current argument's first token, leave out any
849 leading whitespace, just for aesthetics. */
852 arg->text = tok.text;
858 arg->len = (tok.text + tok.len) - arg->text;
859 arg->last_token = tok.text - arg->text;
866 /* The `expand' and `substitute_args' functions both invoke `scan'
867 recursively, so we need a forward declaration somewhere. */
868 static void scan (struct macro_buffer *dest,
869 struct macro_buffer *src,
870 struct macro_name_list *no_loop,
871 macro_lookup_ftype *lookup_func,
875 /* A helper function for substitute_args.
877 ARGV is a vector of all the arguments; ARGC is the number of
878 arguments. IS_VARARGS is true if the macro being substituted is a
879 varargs macro; in this case VA_ARG_NAME is the name of the
880 "variable" argument. VA_ARG_NAME is ignored if IS_VARARGS is
883 If the token TOK is the name of a parameter, return the parameter's
884 index. If TOK is not an argument, return -1. */
887 find_parameter (const struct macro_buffer *tok,
888 int is_varargs, const struct macro_buffer *va_arg_name,
889 int argc, const char * const *argv)
893 if (! tok->is_identifier)
896 for (i = 0; i < argc; ++i)
897 if (tok->len == strlen (argv[i])
898 && !memcmp (tok->text, argv[i], tok->len))
901 if (is_varargs && tok->len == va_arg_name->len
902 && ! memcmp (tok->text, va_arg_name->text, tok->len))
908 /* Helper function for substitute_args that gets the next token and
909 updates the passed-in state variables. */
912 get_next_token_for_substitution (struct macro_buffer *replacement_list,
913 struct macro_buffer *token,
915 struct macro_buffer *lookahead,
916 char **lookahead_start,
917 int *lookahead_valid,
920 if (!*lookahead_valid)
926 *start = *lookahead_start;
927 *lookahead_start = replacement_list->text;
928 *lookahead_valid = get_token (lookahead, replacement_list);
932 /* Given the macro definition DEF, being invoked with the actual
933 arguments given by ARGV, substitute the arguments into the
934 replacement list, and store the result in DEST.
936 IS_VARARGS should be true if DEF is a varargs macro. In this case,
937 VA_ARG_NAME should be the name of the "variable" argument -- either
938 __VA_ARGS__ for c99-style varargs, or the final argument name, for
939 GNU-style varargs. If IS_VARARGS is false, this parameter is
942 If it is necessary to expand macro invocations in one of the
943 arguments, use LOOKUP_FUNC and LOOKUP_BATON to find the macro
944 definitions, and don't expand invocations of the macros listed in
948 substitute_args (struct macro_buffer *dest,
949 struct macro_definition *def,
950 int is_varargs, const struct macro_buffer *va_arg_name,
951 const std::vector<struct macro_buffer> &argv,
952 struct macro_name_list *no_loop,
953 macro_lookup_ftype *lookup_func,
956 /* The token we are currently considering. */
957 struct macro_buffer tok;
958 /* The replacement list's pointer from just before TOK was lexed. */
959 char *original_rl_start;
960 /* We have a single lookahead token to handle token splicing. */
961 struct macro_buffer lookahead;
962 /* The lookahead token might not be valid. */
964 /* The replacement list's pointer from just before LOOKAHEAD was
966 char *lookahead_rl_start;
968 /* A macro buffer for the macro's replacement list. */
969 struct macro_buffer replacement_list (def->replacement,
970 strlen (def->replacement));
972 gdb_assert (dest->len == 0);
973 dest->last_token = 0;
975 original_rl_start = replacement_list.text;
976 if (! get_token (&tok, &replacement_list))
978 lookahead_rl_start = replacement_list.text;
979 lookahead_valid = get_token (&lookahead, &replacement_list);
981 /* __VA_OPT__ state variable. The states are:
982 0 - nothing happening
984 >= 2 in __VA_OPT__, the value encodes the parenthesis depth. */
985 unsigned vaopt_state = 0;
987 for (bool keep_going = true;
989 get_next_token_for_substitution (&replacement_list,
997 bool token_is_vaopt = (tok.len == 10
998 && strncmp (tok.text, "__VA_OPT__", 10) == 0);
1000 if (vaopt_state > 0)
1003 error (_("__VA_OPT__ cannot appear inside __VA_OPT__"));
1004 else if (tok.len == 1 && tok.text[0] == '(')
1007 /* We just entered __VA_OPT__, so don't emit this
1011 else if (vaopt_state == 1)
1012 error (_("__VA_OPT__ must be followed by an open parenthesis"));
1013 else if (tok.len == 1 && tok.text[0] == ')')
1016 if (vaopt_state == 1)
1018 /* Done with __VA_OPT__. */
1025 /* If __VA_ARGS__ is empty, then drop the contents of
1027 if (argv.back ().len == 0)
1030 else if (token_is_vaopt)
1033 error (_("__VA_OPT__ is only valid in a variadic macro"));
1035 /* Don't emit this token. */
1039 /* Just for aesthetics. If we skipped some whitespace, copy
1041 if (tok.text > original_rl_start)
1043 dest->appendmem (original_rl_start, tok.text - original_rl_start);
1044 dest->last_token = dest->len;
1047 /* Is this token the stringification operator? */
1049 && tok.text[0] == '#')
1053 if (!lookahead_valid)
1054 error (_("Stringification operator requires an argument."));
1056 arg = find_parameter (&lookahead, is_varargs, va_arg_name,
1057 def->argc, def->argv);
1059 error (_("Argument to stringification operator must name "
1060 "a macro parameter."));
1062 stringify (dest, argv[arg].text, argv[arg].len);
1064 /* Read one token and let the loop iteration code handle the
1066 lookahead_rl_start = replacement_list.text;
1067 lookahead_valid = get_token (&lookahead, &replacement_list);
1069 /* Is this token the splicing operator? */
1070 else if (tok.len == 2
1071 && tok.text[0] == '#'
1072 && tok.text[1] == '#')
1073 error (_("Stray splicing operator"));
1074 /* Is the next token the splicing operator? */
1075 else if (lookahead_valid
1076 && lookahead.len == 2
1077 && lookahead.text[0] == '#'
1078 && lookahead.text[1] == '#')
1081 int prev_was_comma = 0;
1083 /* Note that GCC warns if the result of splicing is not a
1084 token. In the debugger there doesn't seem to be much
1085 benefit from doing this. */
1087 /* Insert the first token. */
1088 if (tok.len == 1 && tok.text[0] == ',')
1092 int arg = find_parameter (&tok, is_varargs, va_arg_name,
1093 def->argc, def->argv);
1096 dest->appendmem (argv[arg].text, argv[arg].len);
1098 dest->appendmem (tok.text, tok.len);
1101 /* Apply a possible sequence of ## operators. */
1104 if (! get_token (&tok, &replacement_list))
1105 error (_("Splicing operator at end of macro"));
1107 /* Handle a comma before a ##. If we are handling
1108 varargs, and the token on the right hand side is the
1109 varargs marker, and the final argument is empty or
1110 missing, then drop the comma. This is a GNU
1111 extension. There is one ambiguous case here,
1112 involving pedantic behavior with an empty argument,
1113 but we settle that in favor of GNU-style (GCC uses an
1114 option). If we aren't dealing with varargs, we
1115 simply insert the comma. */
1119 && tok.len == va_arg_name->len
1120 && !memcmp (tok.text, va_arg_name->text, tok.len)
1121 && argv.back ().len == 0))
1122 dest->appendmem (",", 1);
1126 /* Insert the token. If it is a parameter, insert the
1127 argument. If it is a comma, treat it specially. */
1128 if (tok.len == 1 && tok.text[0] == ',')
1132 int arg = find_parameter (&tok, is_varargs, va_arg_name,
1133 def->argc, def->argv);
1136 dest->appendmem (argv[arg].text, argv[arg].len);
1138 dest->appendmem (tok.text, tok.len);
1141 /* Now read another token. If it is another splice, we
1143 original_rl_start = replacement_list.text;
1144 if (! get_token (&tok, &replacement_list))
1151 && tok.text[0] == '#'
1152 && tok.text[1] == '#'))
1158 /* We saw a comma. Insert it now. */
1159 dest->appendmem (",", 1);
1162 dest->last_token = dest->len;
1164 lookahead_valid = 0;
1167 /* Set up for the loop iterator. */
1169 lookahead_rl_start = original_rl_start;
1170 lookahead_valid = 1;
1175 /* Is this token an identifier? */
1176 int substituted = 0;
1177 int arg = find_parameter (&tok, is_varargs, va_arg_name,
1178 def->argc, def->argv);
1182 /* Expand any macro invocations in the argument text,
1183 and append the result to dest. Remember that scan
1184 mutates its source, so we need to scan a new buffer
1185 referring to the argument's text, not the argument
1187 struct macro_buffer arg_src (argv[arg].text, argv[arg].len);
1188 scan (dest, &arg_src, no_loop, lookup_func, lookup_baton);
1192 /* If it wasn't a parameter, then just copy it across. */
1194 append_tokens_without_splicing (dest, &tok);
1198 if (vaopt_state > 0)
1199 error (_("Unterminated __VA_OPT__"));
1203 /* Expand a call to a macro named ID, whose definition is DEF. Append
1204 its expansion to DEST. SRC is the input text following the ID
1205 token. We are currently rescanning the expansions of the macros
1206 named in NO_LOOP; don't re-expand them. Use LOOKUP_FUNC and
1207 LOOKUP_BATON to find definitions for any nested macro references.
1209 Return 1 if we decided to expand it, zero otherwise. (If it's a
1210 function-like macro name that isn't followed by an argument list,
1211 we don't expand it.) If we return zero, leave SRC unchanged. */
1213 expand (const char *id,
1214 struct macro_definition *def,
1215 struct macro_buffer *dest,
1216 struct macro_buffer *src,
1217 struct macro_name_list *no_loop,
1218 macro_lookup_ftype *lookup_func,
1221 struct macro_name_list new_no_loop;
1223 /* Create a new node to be added to the front of the no-expand list.
1224 This list is appropriate for re-scanning replacement lists, but
1225 it is *not* appropriate for scanning macro arguments; invocations
1226 of the macro whose arguments we are gathering *do* get expanded
1228 new_no_loop.name = id;
1229 new_no_loop.next = no_loop;
1231 /* What kind of macro are we expanding? */
1232 if (def->kind == macro_object_like)
1234 struct macro_buffer replacement_list (def->replacement,
1235 strlen (def->replacement));
1237 scan (dest, &replacement_list, &new_no_loop, lookup_func, lookup_baton);
1240 else if (def->kind == macro_function_like)
1242 struct macro_buffer va_arg_name;
1247 if (strcmp (def->argv[def->argc - 1], "...") == 0)
1249 /* In C99-style varargs, substitution is done using
1251 va_arg_name.set_shared ("__VA_ARGS__", strlen ("__VA_ARGS__"));
1256 int len = strlen (def->argv[def->argc - 1]);
1259 && strcmp (def->argv[def->argc - 1] + len - 3, "...") == 0)
1261 /* In GNU-style varargs, the name of the
1262 substitution parameter is the name of the formal
1263 argument without the "...". */
1264 va_arg_name.set_shared (def->argv[def->argc - 1], len - 3);
1270 std::vector<struct macro_buffer> argv;
1271 /* If we couldn't find any argument list, then we don't expand
1273 if (!gather_arguments (id, src, is_varargs ? def->argc : -1,
1277 /* Check that we're passing an acceptable number of arguments for
1279 if (argv.size () != def->argc)
1281 if (is_varargs && argv.size () >= def->argc - 1)
1285 /* Remember that a sequence of tokens like "foo()" is a
1286 valid invocation of a macro expecting either zero or one
1288 else if (! (argv.size () == 1
1291 error (_("Wrong number of arguments to macro `%s' "
1292 "(expected %d, got %d)."),
1293 id, def->argc, int (argv.size ()));
1296 /* Note that we don't expand macro invocations in the arguments
1297 yet --- we let subst_args take care of that. Parameters that
1298 appear as operands of the stringifying operator "#" or the
1299 splicing operator "##" don't get macro references expanded,
1300 so we can't really tell whether it's appropriate to macro-
1301 expand an argument until we see how it's being used. */
1302 struct macro_buffer substituted (0);
1303 substitute_args (&substituted, def, is_varargs, &va_arg_name,
1304 argv, no_loop, lookup_func, lookup_baton);
1306 /* Now `substituted' is the macro's replacement list, with all
1307 argument values substituted into it properly. Re-scan it for
1308 macro references, but don't expand invocations of this macro.
1310 We create a new buffer, `substituted_src', which points into
1311 `substituted', and scan that. We can't scan `substituted'
1312 itself, since the tokenization process moves the buffer's
1313 text pointer around, and we still need to be able to find
1314 `substituted's original text buffer after scanning it so we
1316 struct macro_buffer substituted_src (substituted.text, substituted.len);
1317 scan (dest, &substituted_src, &new_no_loop, lookup_func, lookup_baton);
1322 internal_error (__FILE__, __LINE__, _("bad macro definition kind"));
1326 /* If the single token in SRC_FIRST followed by the tokens in SRC_REST
1327 constitute a macro invokation not forbidden in NO_LOOP, append its
1328 expansion to DEST and return non-zero. Otherwise, return zero, and
1329 leave DEST unchanged.
1331 SRC_FIRST and SRC_REST must be shared buffers; DEST must not be one.
1332 SRC_FIRST must be a string built by get_token. */
1334 maybe_expand (struct macro_buffer *dest,
1335 struct macro_buffer *src_first,
1336 struct macro_buffer *src_rest,
1337 struct macro_name_list *no_loop,
1338 macro_lookup_ftype *lookup_func,
1341 gdb_assert (src_first->shared);
1342 gdb_assert (src_rest->shared);
1343 gdb_assert (! dest->shared);
1345 /* Is this token an identifier? */
1346 if (src_first->is_identifier)
1348 /* Make a null-terminated copy of it, since that's what our
1349 lookup function expects. */
1350 char *id = (char *) xmalloc (src_first->len + 1);
1351 struct cleanup *back_to = make_cleanup (xfree, id);
1353 memcpy (id, src_first->text, src_first->len);
1354 id[src_first->len] = 0;
1356 /* If we're currently re-scanning the result of expanding
1357 this macro, don't expand it again. */
1358 if (! currently_rescanning (no_loop, id))
1360 /* Does this identifier have a macro definition in scope? */
1361 struct macro_definition *def = lookup_func (id, lookup_baton);
1363 if (def && expand (id, def, dest, src_rest, no_loop,
1364 lookup_func, lookup_baton))
1366 do_cleanups (back_to);
1371 do_cleanups (back_to);
1378 /* Expand macro references in SRC, appending the results to DEST.
1379 Assume we are re-scanning the result of expanding the macros named
1380 in NO_LOOP, and don't try to re-expand references to them.
1382 SRC must be a shared buffer; DEST must not be one. */
1384 scan (struct macro_buffer *dest,
1385 struct macro_buffer *src,
1386 struct macro_name_list *no_loop,
1387 macro_lookup_ftype *lookup_func,
1390 gdb_assert (src->shared);
1391 gdb_assert (! dest->shared);
1395 struct macro_buffer tok;
1396 char *original_src_start = src->text;
1398 /* Find the next token in SRC. */
1399 if (! get_token (&tok, src))
1402 /* Just for aesthetics. If we skipped some whitespace, copy
1404 if (tok.text > original_src_start)
1406 dest->appendmem (original_src_start, tok.text - original_src_start);
1407 dest->last_token = dest->len;
1410 if (! maybe_expand (dest, &tok, src, no_loop, lookup_func, lookup_baton))
1411 /* We didn't end up expanding tok as a macro reference, so
1412 simply append it to dest. */
1413 append_tokens_without_splicing (dest, &tok);
1416 /* Just for aesthetics. If there was any trailing whitespace in
1417 src, copy it to dest. */
1420 dest->appendmem (src->text, src->len);
1421 dest->last_token = dest->len;
1426 gdb::unique_xmalloc_ptr<char>
1427 macro_expand (const char *source,
1428 macro_lookup_ftype *lookup_func,
1429 void *lookup_func_baton)
1431 struct macro_buffer src (source, strlen (source));
1433 struct macro_buffer dest (0);
1434 dest.last_token = 0;
1436 scan (&dest, &src, 0, lookup_func, lookup_func_baton);
1438 dest.appendc ('\0');
1440 return gdb::unique_xmalloc_ptr<char> (dest.release ());
1444 gdb::unique_xmalloc_ptr<char>
1445 macro_expand_once (const char *source,
1446 macro_lookup_ftype *lookup_func,
1447 void *lookup_func_baton)
1449 error (_("Expand-once not implemented yet."));
1454 macro_expand_next (const char **lexptr,
1455 macro_lookup_ftype *lookup_func,
1458 struct macro_buffer tok;
1460 /* Set up SRC to refer to the input text, pointed to by *lexptr. */
1461 struct macro_buffer src (*lexptr, strlen (*lexptr));
1463 /* Set up DEST to receive the expansion, if there is one. */
1464 struct macro_buffer dest (0);
1465 dest.last_token = 0;
1467 /* Get the text's first preprocessing token. */
1468 if (! get_token (&tok, &src))
1471 /* If it's a macro invocation, expand it. */
1472 if (maybe_expand (&dest, &tok, &src, 0, lookup_func, lookup_baton))
1474 /* It was a macro invocation! Package up the expansion as a
1475 null-terminated string and return it. Set *lexptr to the
1476 start of the next token in the input. */
1477 dest.appendc ('\0');
1479 return dest.release ();
1483 /* It wasn't a macro invocation. */