1 /* C preprocessor macro expansion for GDB.
2 Copyright (C) 2002-2020 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"
24 #include "macroscope.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 const macro_scope
&scope
);
883 /* A helper function for substitute_args.
885 ARGV is a vector of all the arguments; ARGC is the number of
886 arguments. IS_VARARGS is true if the macro being substituted is a
887 varargs macro; in this case VA_ARG_NAME is the name of the
888 "variable" argument. VA_ARG_NAME is ignored if IS_VARARGS is
891 If the token TOK is the name of a parameter, return the parameter's
892 index. If TOK is not an argument, return -1. */
895 find_parameter (const struct macro_buffer
*tok
,
896 int is_varargs
, const struct macro_buffer
*va_arg_name
,
897 int argc
, const char * const *argv
)
901 if (! tok
->is_identifier
)
904 for (i
= 0; i
< argc
; ++i
)
905 if (tok
->len
== strlen (argv
[i
])
906 && !memcmp (tok
->text
, argv
[i
], tok
->len
))
909 if (is_varargs
&& tok
->len
== va_arg_name
->len
910 && ! memcmp (tok
->text
, va_arg_name
->text
, tok
->len
))
916 /* Helper function for substitute_args that gets the next token and
917 updates the passed-in state variables. */
920 get_next_token_for_substitution (struct macro_buffer
*replacement_list
,
921 struct macro_buffer
*token
,
923 struct macro_buffer
*lookahead
,
924 char **lookahead_start
,
925 int *lookahead_valid
,
928 if (!*lookahead_valid
)
934 *start
= *lookahead_start
;
935 *lookahead_start
= replacement_list
->text
;
936 *lookahead_valid
= get_token (lookahead
, replacement_list
);
940 /* Given the macro definition DEF, being invoked with the actual
941 arguments given by ARGV, substitute the arguments into the
942 replacement list, and store the result in DEST.
944 IS_VARARGS should be true if DEF is a varargs macro. In this case,
945 VA_ARG_NAME should be the name of the "variable" argument -- either
946 __VA_ARGS__ for c99-style varargs, or the final argument name, for
947 GNU-style varargs. If IS_VARARGS is false, this parameter is
950 If it is necessary to expand macro invocations in one of the
951 arguments, use LOOKUP_FUNC and LOOKUP_BATON to find the macro
952 definitions, and don't expand invocations of the macros listed in
956 substitute_args (struct macro_buffer
*dest
,
957 struct macro_definition
*def
,
958 int is_varargs
, const struct macro_buffer
*va_arg_name
,
959 const std::vector
<struct macro_buffer
> &argv
,
960 struct macro_name_list
*no_loop
,
961 const macro_scope
&scope
)
963 /* The token we are currently considering. */
964 struct macro_buffer tok
;
965 /* The replacement list's pointer from just before TOK was lexed. */
966 char *original_rl_start
;
967 /* We have a single lookahead token to handle token splicing. */
968 struct macro_buffer lookahead
;
969 /* The lookahead token might not be valid. */
971 /* The replacement list's pointer from just before LOOKAHEAD was
973 char *lookahead_rl_start
;
975 /* A macro buffer for the macro's replacement list. */
976 struct macro_buffer
replacement_list (def
->replacement
,
977 strlen (def
->replacement
));
979 gdb_assert (dest
->len
== 0);
980 dest
->last_token
= 0;
982 original_rl_start
= replacement_list
.text
;
983 if (! get_token (&tok
, &replacement_list
))
985 lookahead_rl_start
= replacement_list
.text
;
986 lookahead_valid
= get_token (&lookahead
, &replacement_list
);
988 /* __VA_OPT__ state variable. The states are:
989 0 - nothing happening
991 >= 2 in __VA_OPT__, the value encodes the parenthesis depth. */
992 unsigned vaopt_state
= 0;
994 for (bool keep_going
= true;
996 get_next_token_for_substitution (&replacement_list
,
1000 &lookahead_rl_start
,
1004 bool token_is_vaopt
= (tok
.len
== 10
1005 && strncmp (tok
.text
, "__VA_OPT__", 10) == 0);
1007 if (vaopt_state
> 0)
1010 error (_("__VA_OPT__ cannot appear inside __VA_OPT__"));
1011 else if (tok
.len
== 1 && tok
.text
[0] == '(')
1014 /* We just entered __VA_OPT__, so don't emit this
1018 else if (vaopt_state
== 1)
1019 error (_("__VA_OPT__ must be followed by an open parenthesis"));
1020 else if (tok
.len
== 1 && tok
.text
[0] == ')')
1023 if (vaopt_state
== 1)
1025 /* Done with __VA_OPT__. */
1032 /* If __VA_ARGS__ is empty, then drop the contents of
1034 if (argv
.back ().len
== 0)
1037 else if (token_is_vaopt
)
1040 error (_("__VA_OPT__ is only valid in a variadic macro"));
1042 /* Don't emit this token. */
1046 /* Just for aesthetics. If we skipped some whitespace, copy
1048 if (tok
.text
> original_rl_start
)
1050 dest
->appendmem (original_rl_start
, tok
.text
- original_rl_start
);
1051 dest
->last_token
= dest
->len
;
1054 /* Is this token the stringification operator? */
1056 && tok
.text
[0] == '#')
1060 if (!lookahead_valid
)
1061 error (_("Stringification operator requires an argument."));
1063 arg
= find_parameter (&lookahead
, is_varargs
, va_arg_name
,
1064 def
->argc
, def
->argv
);
1066 error (_("Argument to stringification operator must name "
1067 "a macro parameter."));
1069 stringify (dest
, argv
[arg
].text
, argv
[arg
].len
);
1071 /* Read one token and let the loop iteration code handle the
1073 lookahead_rl_start
= replacement_list
.text
;
1074 lookahead_valid
= get_token (&lookahead
, &replacement_list
);
1076 /* Is this token the splicing operator? */
1077 else if (tok
.len
== 2
1078 && tok
.text
[0] == '#'
1079 && tok
.text
[1] == '#')
1080 error (_("Stray splicing operator"));
1081 /* Is the next token the splicing operator? */
1082 else if (lookahead_valid
1083 && lookahead
.len
== 2
1084 && lookahead
.text
[0] == '#'
1085 && lookahead
.text
[1] == '#')
1088 int prev_was_comma
= 0;
1090 /* Note that GCC warns if the result of splicing is not a
1091 token. In the debugger there doesn't seem to be much
1092 benefit from doing this. */
1094 /* Insert the first token. */
1095 if (tok
.len
== 1 && tok
.text
[0] == ',')
1099 int arg
= find_parameter (&tok
, is_varargs
, va_arg_name
,
1100 def
->argc
, def
->argv
);
1103 dest
->appendmem (argv
[arg
].text
, argv
[arg
].len
);
1105 dest
->appendmem (tok
.text
, tok
.len
);
1108 /* Apply a possible sequence of ## operators. */
1111 if (! get_token (&tok
, &replacement_list
))
1112 error (_("Splicing operator at end of macro"));
1114 /* Handle a comma before a ##. If we are handling
1115 varargs, and the token on the right hand side is the
1116 varargs marker, and the final argument is empty or
1117 missing, then drop the comma. This is a GNU
1118 extension. There is one ambiguous case here,
1119 involving pedantic behavior with an empty argument,
1120 but we settle that in favor of GNU-style (GCC uses an
1121 option). If we aren't dealing with varargs, we
1122 simply insert the comma. */
1126 && tok
.len
== va_arg_name
->len
1127 && !memcmp (tok
.text
, va_arg_name
->text
, tok
.len
)
1128 && argv
.back ().len
== 0))
1129 dest
->appendmem (",", 1);
1133 /* Insert the token. If it is a parameter, insert the
1134 argument. If it is a comma, treat it specially. */
1135 if (tok
.len
== 1 && tok
.text
[0] == ',')
1139 int arg
= find_parameter (&tok
, is_varargs
, va_arg_name
,
1140 def
->argc
, def
->argv
);
1143 dest
->appendmem (argv
[arg
].text
, argv
[arg
].len
);
1145 dest
->appendmem (tok
.text
, tok
.len
);
1148 /* Now read another token. If it is another splice, we
1150 original_rl_start
= replacement_list
.text
;
1151 if (! get_token (&tok
, &replacement_list
))
1158 && tok
.text
[0] == '#'
1159 && tok
.text
[1] == '#'))
1165 /* We saw a comma. Insert it now. */
1166 dest
->appendmem (",", 1);
1169 dest
->last_token
= dest
->len
;
1171 lookahead_valid
= 0;
1174 /* Set up for the loop iterator. */
1176 lookahead_rl_start
= original_rl_start
;
1177 lookahead_valid
= 1;
1182 /* Is this token an identifier? */
1183 int substituted
= 0;
1184 int arg
= find_parameter (&tok
, is_varargs
, va_arg_name
,
1185 def
->argc
, def
->argv
);
1189 /* Expand any macro invocations in the argument text,
1190 and append the result to dest. Remember that scan
1191 mutates its source, so we need to scan a new buffer
1192 referring to the argument's text, not the argument
1194 struct macro_buffer
arg_src (argv
[arg
].text
, argv
[arg
].len
);
1195 scan (dest
, &arg_src
, no_loop
, scope
);
1199 /* If it wasn't a parameter, then just copy it across. */
1201 append_tokens_without_splicing (dest
, &tok
);
1205 if (vaopt_state
> 0)
1206 error (_("Unterminated __VA_OPT__"));
1210 /* Expand a call to a macro named ID, whose definition is DEF. Append
1211 its expansion to DEST. SRC is the input text following the ID
1212 token. We are currently rescanning the expansions of the macros
1213 named in NO_LOOP; don't re-expand them. Use LOOKUP_FUNC and
1214 LOOKUP_BATON to find definitions for any nested macro references.
1216 Return 1 if we decided to expand it, zero otherwise. (If it's a
1217 function-like macro name that isn't followed by an argument list,
1218 we don't expand it.) If we return zero, leave SRC unchanged. */
1220 expand (const char *id
,
1221 struct macro_definition
*def
,
1222 struct macro_buffer
*dest
,
1223 struct macro_buffer
*src
,
1224 struct macro_name_list
*no_loop
,
1225 const macro_scope
&scope
)
1227 struct macro_name_list new_no_loop
;
1229 /* Create a new node to be added to the front of the no-expand list.
1230 This list is appropriate for re-scanning replacement lists, but
1231 it is *not* appropriate for scanning macro arguments; invocations
1232 of the macro whose arguments we are gathering *do* get expanded
1234 new_no_loop
.name
= id
;
1235 new_no_loop
.next
= no_loop
;
1237 /* What kind of macro are we expanding? */
1238 if (def
->kind
== macro_object_like
)
1240 struct macro_buffer
replacement_list (def
->replacement
,
1241 strlen (def
->replacement
));
1243 scan (dest
, &replacement_list
, &new_no_loop
, scope
);
1246 else if (def
->kind
== macro_function_like
)
1248 struct macro_buffer va_arg_name
;
1253 if (strcmp (def
->argv
[def
->argc
- 1], "...") == 0)
1255 /* In C99-style varargs, substitution is done using
1257 va_arg_name
.set_shared ("__VA_ARGS__", strlen ("__VA_ARGS__"));
1262 int len
= strlen (def
->argv
[def
->argc
- 1]);
1265 && strcmp (def
->argv
[def
->argc
- 1] + len
- 3, "...") == 0)
1267 /* In GNU-style varargs, the name of the
1268 substitution parameter is the name of the formal
1269 argument without the "...". */
1270 va_arg_name
.set_shared (def
->argv
[def
->argc
- 1], len
- 3);
1276 std::vector
<struct macro_buffer
> argv
;
1277 /* If we couldn't find any argument list, then we don't expand
1279 if (!gather_arguments (id
, src
, is_varargs
? def
->argc
: -1,
1283 /* Check that we're passing an acceptable number of arguments for
1285 if (argv
.size () != def
->argc
)
1287 if (is_varargs
&& argv
.size () >= def
->argc
- 1)
1291 /* Remember that a sequence of tokens like "foo()" is a
1292 valid invocation of a macro expecting either zero or one
1294 else if (! (argv
.size () == 1
1297 error (_("Wrong number of arguments to macro `%s' "
1298 "(expected %d, got %d)."),
1299 id
, def
->argc
, int (argv
.size ()));
1302 /* Note that we don't expand macro invocations in the arguments
1303 yet --- we let subst_args take care of that. Parameters that
1304 appear as operands of the stringifying operator "#" or the
1305 splicing operator "##" don't get macro references expanded,
1306 so we can't really tell whether it's appropriate to macro-
1307 expand an argument until we see how it's being used. */
1308 struct macro_buffer
substituted (0);
1309 substitute_args (&substituted
, def
, is_varargs
, &va_arg_name
,
1310 argv
, no_loop
, scope
);
1312 /* Now `substituted' is the macro's replacement list, with all
1313 argument values substituted into it properly. Re-scan it for
1314 macro references, but don't expand invocations of this macro.
1316 We create a new buffer, `substituted_src', which points into
1317 `substituted', and scan that. We can't scan `substituted'
1318 itself, since the tokenization process moves the buffer's
1319 text pointer around, and we still need to be able to find
1320 `substituted's original text buffer after scanning it so we
1322 struct macro_buffer
substituted_src (substituted
.text
, substituted
.len
);
1323 scan (dest
, &substituted_src
, &new_no_loop
, scope
);
1328 internal_error (__FILE__
, __LINE__
, _("bad macro definition kind"));
1332 /* If the single token in SRC_FIRST followed by the tokens in SRC_REST
1333 constitute a macro invocation not forbidden in NO_LOOP, append its
1334 expansion to DEST and return non-zero. Otherwise, return zero, and
1335 leave DEST unchanged.
1337 SRC_FIRST and SRC_REST must be shared buffers; DEST must not be one.
1338 SRC_FIRST must be a string built by get_token. */
1340 maybe_expand (struct macro_buffer
*dest
,
1341 struct macro_buffer
*src_first
,
1342 struct macro_buffer
*src_rest
,
1343 struct macro_name_list
*no_loop
,
1344 const macro_scope
&scope
)
1346 gdb_assert (src_first
->shared
);
1347 gdb_assert (src_rest
->shared
);
1348 gdb_assert (! dest
->shared
);
1350 /* Is this token an identifier? */
1351 if (src_first
->is_identifier
)
1353 /* Make a null-terminated copy of it, since that's what our
1354 lookup function expects. */
1355 std::string
id (src_first
->text
, src_first
->len
);
1357 /* If we're currently re-scanning the result of expanding
1358 this macro, don't expand it again. */
1359 if (! currently_rescanning (no_loop
, id
.c_str ()))
1361 /* Does this identifier have a macro definition in scope? */
1362 macro_definition
*def
= standard_macro_lookup (id
.c_str (), scope
);
1364 if (def
&& expand (id
.c_str (), def
, dest
, src_rest
, no_loop
, scope
))
1373 /* Expand macro references in SRC, appending the results to DEST.
1374 Assume we are re-scanning the result of expanding the macros named
1375 in NO_LOOP, and don't try to re-expand references to them.
1377 SRC must be a shared buffer; DEST must not be one. */
1379 scan (struct macro_buffer
*dest
,
1380 struct macro_buffer
*src
,
1381 struct macro_name_list
*no_loop
,
1382 const macro_scope
&scope
)
1384 gdb_assert (src
->shared
);
1385 gdb_assert (! dest
->shared
);
1389 struct macro_buffer tok
;
1390 char *original_src_start
= src
->text
;
1392 /* Find the next token in SRC. */
1393 if (! get_token (&tok
, src
))
1396 /* Just for aesthetics. If we skipped some whitespace, copy
1398 if (tok
.text
> original_src_start
)
1400 dest
->appendmem (original_src_start
, tok
.text
- original_src_start
);
1401 dest
->last_token
= dest
->len
;
1404 if (! maybe_expand (dest
, &tok
, src
, no_loop
, scope
))
1405 /* We didn't end up expanding tok as a macro reference, so
1406 simply append it to dest. */
1407 append_tokens_without_splicing (dest
, &tok
);
1410 /* Just for aesthetics. If there was any trailing whitespace in
1411 src, copy it to dest. */
1414 dest
->appendmem (src
->text
, src
->len
);
1415 dest
->last_token
= dest
->len
;
1420 gdb::unique_xmalloc_ptr
<char>
1421 macro_expand (const char *source
, const macro_scope
&scope
)
1423 struct macro_buffer
src (source
, strlen (source
));
1425 struct macro_buffer
dest (0);
1426 dest
.last_token
= 0;
1428 scan (&dest
, &src
, 0, scope
);
1430 dest
.appendc ('\0');
1432 return gdb::unique_xmalloc_ptr
<char> (dest
.release ());
1436 gdb::unique_xmalloc_ptr
<char>
1437 macro_expand_once (const char *source
, const macro_scope
&scope
)
1439 error (_("Expand-once not implemented yet."));
1444 macro_expand_next (const char **lexptr
, const macro_scope
&scope
)
1446 struct macro_buffer tok
;
1448 /* Set up SRC to refer to the input text, pointed to by *lexptr. */
1449 struct macro_buffer
src (*lexptr
, strlen (*lexptr
));
1451 /* Set up DEST to receive the expansion, if there is one. */
1452 struct macro_buffer
dest (0);
1453 dest
.last_token
= 0;
1455 /* Get the text's first preprocessing token. */
1456 if (! get_token (&tok
, &src
))
1459 /* If it's a macro invocation, expand it. */
1460 if (maybe_expand (&dest
, &tok
, &src
, 0, scope
))
1462 /* It was a macro invocation! Package up the expansion as a
1463 null-terminated string and return it. Set *lexptr to the
1464 start of the next token in the input. */
1465 dest
.appendc ('\0');
1467 return dest
.release ();
1471 /* It wasn't a macro invocation. */