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. */
132 gdb::unique_xmalloc_ptr
<char> release ()
134 gdb_assert (! shared
);
138 return gdb::unique_xmalloc_ptr
<char> (result
);
141 /* Resize the buffer to be at least N bytes long. Raise an error if
142 the buffer shouldn't be resized. */
143 void resize_buffer (int n
)
145 /* We shouldn't be trying to resize shared strings. */
146 gdb_assert (! shared
);
154 text
= (char *) xrealloc (text
, size
);
157 /* Append the character C to the buffer. */
160 int new_len
= len
+ 1;
163 resize_buffer (new_len
);
169 /* Append the COUNT bytes at ADDR to the buffer. */
170 void appendmem (const char *addr
, int count
)
172 int new_len
= len
+ count
;
175 resize_buffer (new_len
);
177 memcpy (text
+ len
, addr
, count
);
184 /* Recognizing preprocessor tokens. */
188 macro_is_whitespace (int c
)
199 macro_is_digit (int c
)
201 return ('0' <= c
&& c
<= '9');
206 macro_is_identifier_nondigit (int c
)
209 || ('a' <= c
&& c
<= 'z')
210 || ('A' <= c
&& c
<= 'Z'));
215 set_token (struct macro_buffer
*tok
, char *start
, char *end
)
217 tok
->set_shared (start
, end
- start
);
220 /* Presumed; get_identifier may overwrite this. */
221 tok
->is_identifier
= 0;
226 get_comment (struct macro_buffer
*tok
, char *p
, char *end
)
243 set_token (tok
, tok_start
, p
);
247 error (_("Unterminated comment in macro expansion."));
259 set_token (tok
, tok_start
, p
);
268 get_identifier (struct macro_buffer
*tok
, char *p
, char *end
)
271 && macro_is_identifier_nondigit (*p
))
276 && (macro_is_identifier_nondigit (*p
)
277 || macro_is_digit (*p
)))
280 set_token (tok
, tok_start
, p
);
281 tok
->is_identifier
= 1;
290 get_pp_number (struct macro_buffer
*tok
, char *p
, char *end
)
293 && (macro_is_digit (*p
)
296 && macro_is_digit (p
[1]))))
303 && strchr ("eEpP", *p
)
304 && (p
[1] == '+' || p
[1] == '-'))
306 else if (macro_is_digit (*p
)
307 || macro_is_identifier_nondigit (*p
)
314 set_token (tok
, tok_start
, p
);
323 /* If the text starting at P going up to (but not including) END
324 starts with a character constant, set *TOK to point to that
325 character constant, and return 1. Otherwise, return zero.
326 Signal an error if it contains a malformed or incomplete character
329 get_character_constant (struct macro_buffer
*tok
, char *p
, char *end
)
331 /* ISO/IEC 9899:1999 (E) Section 6.4.4.4 paragraph 1
332 But of course, what really matters is that we handle it the same
333 way GDB's C/C++ lexer does. So we call parse_escape in utils.c
334 to handle escape sequences. */
335 if ((p
+ 1 <= end
&& *p
== '\'')
337 && (p
[0] == 'L' || p
[0] == 'u' || p
[0] == 'U')
345 else if (*p
== 'L' || *p
== 'u' || *p
== 'U')
348 gdb_assert_not_reached ("unexpected character constant");
353 error (_("Unmatched single quote."));
357 error (_("A character constant must contain at least one "
367 char_count
+= c_parse_escape (&s
, NULL
);
377 set_token (tok
, tok_start
, p
);
385 /* If the text starting at P going up to (but not including) END
386 starts with a string literal, set *TOK to point to that string
387 literal, and return 1. Otherwise, return zero. Signal an error if
388 it contains a malformed or incomplete string literal. */
390 get_string_literal (struct macro_buffer
*tok
, char *p
, char *end
)
395 && (p
[0] == 'L' || p
[0] == 'u' || p
[0] == 'U')
402 else if (*p
== 'L' || *p
== 'u' || *p
== 'U')
405 gdb_assert_not_reached ("unexpected string literal");
410 error (_("Unterminated string in expression."));
417 error (_("Newline characters may not appear in string "
424 c_parse_escape (&s
, NULL
);
431 set_token (tok
, tok_start
, p
);
440 get_punctuator (struct macro_buffer
*tok
, char *p
, char *end
)
442 /* Here, speed is much less important than correctness and clarity. */
444 /* ISO/IEC 9899:1999 (E) Section 6.4.6 Paragraph 1.
445 Note that this table is ordered in a special way. A punctuator
446 which is a prefix of another punctuator must appear after its
447 "extension". Otherwise, the wrong token will be returned. */
448 static const char * const punctuators
[] = {
449 "[", "]", "(", ")", "{", "}", "?", ";", ",", "~",
451 "->", "--", "-=", "-",
457 "%>", "%:%:", "%:", "%=", "%",
462 "<<=", "<<", "<=", "<:", "<%", "<",
463 ">>=", ">>", ">=", ">",
472 for (i
= 0; punctuators
[i
]; i
++)
474 const char *punctuator
= punctuators
[i
];
476 if (p
[0] == punctuator
[0])
478 int len
= strlen (punctuator
);
481 && ! memcmp (p
, punctuator
, len
))
483 set_token (tok
, p
, p
+ len
);
494 /* Peel the next preprocessor token off of SRC, and put it in TOK.
495 Mutate TOK to refer to the first token in SRC, and mutate SRC to
496 refer to the text after that token. SRC must be a shared buffer;
497 the resulting TOK will be shared, pointing into the same string SRC
498 does. Initialize TOK's last_token field. Return non-zero if we
499 succeed, or 0 if we didn't find any more tokens in SRC. */
501 get_token (struct macro_buffer
*tok
,
502 struct macro_buffer
*src
)
505 char *end
= p
+ src
->len
;
507 gdb_assert (src
->shared
);
509 /* From the ISO C standard, ISO/IEC 9899:1999 (E), section 6.4:
518 each non-white-space character that cannot be one of the above
520 We don't have to deal with header-name tokens, since those can
521 only occur after a #include, which we will never see. */
524 if (macro_is_whitespace (*p
))
526 else if (get_comment (tok
, p
, end
))
528 else if (get_pp_number (tok
, p
, end
)
529 || get_character_constant (tok
, p
, end
)
530 || get_string_literal (tok
, p
, end
)
531 /* Note: the grammar in the standard seems to be
532 ambiguous: L'x' can be either a wide character
533 constant, or an identifier followed by a normal
534 character constant. By trying `get_identifier' after
535 we try get_character_constant and get_string_literal,
536 we give the wide character syntax precedence. Now,
537 since GDB doesn't handle wide character constants
538 anyway, is this the right thing to do? */
539 || get_identifier (tok
, p
, end
)
540 || get_punctuator (tok
, p
, end
))
542 /* How many characters did we consume, including whitespace? */
543 int consumed
= p
- src
->text
+ tok
->len
;
545 src
->text
+= consumed
;
546 src
->len
-= consumed
;
551 /* We have found a "non-whitespace character that cannot be
552 one of the above." Make a token out of it. */
555 set_token (tok
, p
, p
+ 1);
556 consumed
= p
- src
->text
+ tok
->len
;
557 src
->text
+= consumed
;
558 src
->len
-= consumed
;
567 /* Appending token strings, with and without splicing */
570 /* Append the macro buffer SRC to the end of DEST, and ensure that
571 doing so doesn't splice the token at the end of SRC with the token
572 at the beginning of DEST. SRC and DEST must have their last_token
573 fields set. Upon return, DEST's last_token field is set correctly.
577 If DEST is "(" and SRC is "y", then we can return with
578 DEST set to "(y" --- we've simply appended the two buffers.
580 However, if DEST is "x" and SRC is "y", then we must not return
581 with DEST set to "xy" --- that would splice the two tokens "x" and
582 "y" together to make a single token "xy". However, it would be
583 fine to return with DEST set to "x y". Similarly, "<" and "<" must
584 yield "< <", not "<<", etc. */
586 append_tokens_without_splicing (struct macro_buffer
*dest
,
587 struct macro_buffer
*src
)
589 int original_dest_len
= dest
->len
;
590 struct macro_buffer dest_tail
, new_token
;
592 gdb_assert (src
->last_token
!= -1);
593 gdb_assert (dest
->last_token
!= -1);
595 /* First, just try appending the two, and call get_token to see if
597 dest
->appendmem (src
->text
, src
->len
);
599 /* If DEST originally had no token abutting its end, then we can't
600 have spliced anything, so we're done. */
601 if (dest
->last_token
== original_dest_len
)
603 dest
->last_token
= original_dest_len
+ src
->last_token
;
607 /* Set DEST_TAIL to point to the last token in DEST, followed by
608 all the stuff we just appended. */
609 dest_tail
.set_shared (dest
->text
+ dest
->last_token
,
610 dest
->len
- dest
->last_token
);
612 /* Re-parse DEST's last token. We know that DEST used to contain
613 at least one token, so if it doesn't contain any after the
614 append, then we must have spliced "/" and "*" or "/" and "/" to
615 make a comment start. (Just for the record, I got this right
616 the first time. This is not a bug fix.) */
617 if (get_token (&new_token
, &dest_tail
)
618 && (new_token
.text
+ new_token
.len
619 == dest
->text
+ original_dest_len
))
621 /* No splice, so we're done. */
622 dest
->last_token
= original_dest_len
+ src
->last_token
;
626 /* Okay, a simple append caused a splice. Let's chop dest back to
627 its original length and try again, but separate the texts with a
629 dest
->len
= original_dest_len
;
631 dest
->appendmem (src
->text
, src
->len
);
633 dest_tail
.set_shared (dest
->text
+ dest
->last_token
,
634 dest
->len
- dest
->last_token
);
636 /* Try to re-parse DEST's last token, as above. */
637 if (get_token (&new_token
, &dest_tail
)
638 && (new_token
.text
+ new_token
.len
639 == dest
->text
+ original_dest_len
))
641 /* No splice, so we're done. */
642 dest
->last_token
= original_dest_len
+ 1 + src
->last_token
;
646 /* As far as I know, there's no case where inserting a space isn't
647 enough to prevent a splice. */
648 internal_error (__FILE__
, __LINE__
,
649 _("unable to avoid splicing tokens during macro expansion"));
652 /* Stringify an argument, and insert it into DEST. ARG is the text to
653 stringify; it is LEN bytes long. */
656 stringify (struct macro_buffer
*dest
, const char *arg
, int len
)
658 /* Trim initial whitespace from ARG. */
659 while (len
> 0 && macro_is_whitespace (*arg
))
665 /* Trim trailing whitespace from ARG. */
666 while (len
> 0 && macro_is_whitespace (arg
[len
- 1]))
669 /* Insert the string. */
673 /* We could try to handle strange cases here, like control
674 characters, but there doesn't seem to be much point. */
675 if (macro_is_whitespace (*arg
))
677 /* Replace a sequence of whitespace with a single space. */
679 while (len
> 1 && macro_is_whitespace (arg
[1]))
685 else if (*arg
== '\\' || *arg
== '"')
687 dest
->appendc ('\\');
688 dest
->appendc (*arg
);
691 dest
->appendc (*arg
);
696 dest
->last_token
= dest
->len
;
699 /* See macroexp.h. */
702 macro_stringify (const char *str
)
704 int len
= strlen (str
);
705 struct macro_buffer
buffer (len
);
707 stringify (&buffer
, str
, len
);
708 buffer
.appendc ('\0');
710 return buffer
.release ().release ();
714 /* Expanding macros! */
717 /* A singly-linked list of the names of the macros we are currently
718 expanding --- for detecting expansion loops. */
719 struct macro_name_list
{
721 struct macro_name_list
*next
;
725 /* Return non-zero if we are currently expanding the macro named NAME,
726 according to LIST; otherwise, return zero.
728 You know, it would be possible to get rid of all the NO_LOOP
729 arguments to these functions by simply generating a new lookup
730 function and baton which refuses to find the definition for a
731 particular macro, and otherwise delegates the decision to another
732 function/baton pair. But that makes the linked list of excluded
733 macros chained through untyped baton pointers, which will make it
734 harder to debug. :( */
736 currently_rescanning (struct macro_name_list
*list
, const char *name
)
738 for (; list
; list
= list
->next
)
739 if (strcmp (name
, list
->name
) == 0)
746 /* Gather the arguments to a macro expansion.
748 NAME is the name of the macro being invoked. (It's only used for
749 printing error messages.)
751 Assume that SRC is the text of the macro invocation immediately
752 following the macro name. For example, if we're processing the
753 text foo(bar, baz), then NAME would be foo and SRC will be (bar,
756 If SRC doesn't start with an open paren ( token at all, return
757 false, leave SRC unchanged, and don't set *ARGS_PTR to anything.
759 If SRC doesn't contain a properly terminated argument list, then
762 For a variadic macro, NARGS holds the number of formal arguments to
763 the macro. For a GNU-style variadic macro, this should be the
764 number of named arguments. For a non-variadic macro, NARGS should
767 Otherwise, return true and set *ARGS_PTR to a vector of macro
768 buffers referring to the argument texts. The macro buffers share
769 their text with SRC, and their last_token fields are initialized.
771 NOTE WELL: if SRC starts with a open paren ( token followed
772 immediately by a close paren ) token (e.g., the invocation looks
773 like "foo()"), we treat that as one argument, which happens to be
774 the empty list of tokens. The caller should keep in mind that such
775 a sequence of tokens is a valid way to invoke one-parameter
776 function-like macros, but also a valid way to invoke zero-parameter
777 function-like macros. Eeew.
779 Consume the tokens from SRC; after this call, SRC contains the text
780 following the invocation. */
783 gather_arguments (const char *name
, struct macro_buffer
*src
, int nargs
,
784 std::vector
<struct macro_buffer
> *args_ptr
)
786 struct macro_buffer tok
;
787 std::vector
<struct macro_buffer
> args
;
789 /* Does SRC start with an opening paren token? Read from a copy of
790 SRC, so SRC itself is unaffected if we don't find an opening
793 struct macro_buffer
temp (src
->text
, src
->len
);
795 if (! get_token (&tok
, &temp
)
797 || tok
.text
[0] != '(')
801 /* Consume SRC's opening paren. */
802 get_token (&tok
, src
);
806 struct macro_buffer
*arg
;
809 /* Initialize the next argument. */
810 args
.emplace_back ();
812 set_token (arg
, src
->text
, src
->text
);
814 /* Gather the argument's tokens. */
818 if (! get_token (&tok
, src
))
819 error (_("Malformed argument list for macro `%s'."), name
);
821 /* Is tok an opening paren? */
822 if (tok
.len
== 1 && tok
.text
[0] == '(')
825 /* Is tok is a closing paren? */
826 else if (tok
.len
== 1 && tok
.text
[0] == ')')
828 /* If it's a closing paren at the top level, then that's
829 the end of the argument list. */
832 /* In the varargs case, the last argument may be
833 missing. Add an empty argument in this case. */
834 if (nargs
!= -1 && args
.size () == nargs
- 1)
836 args
.emplace_back ();
838 set_token (arg
, src
->text
, src
->text
);
841 *args_ptr
= std::move (args
);
848 /* If tok is a comma at top level, then that's the end of
849 the current argument. However, if we are handling a
850 variadic macro and we are computing the last argument, we
851 want to include the comma and remaining tokens. */
852 else if (tok
.len
== 1 && tok
.text
[0] == ',' && depth
== 0
853 && (nargs
== -1 || args
.size () < nargs
))
856 /* Extend the current argument to enclose this token. If
857 this is the current argument's first token, leave out any
858 leading whitespace, just for aesthetics. */
861 arg
->text
= tok
.text
;
867 arg
->len
= (tok
.text
+ tok
.len
) - arg
->text
;
868 arg
->last_token
= tok
.text
- arg
->text
;
875 /* The `expand' and `substitute_args' functions both invoke `scan'
876 recursively, so we need a forward declaration somewhere. */
877 static void scan (struct macro_buffer
*dest
,
878 struct macro_buffer
*src
,
879 struct macro_name_list
*no_loop
,
880 const macro_scope
&scope
);
882 /* A helper function for substitute_args.
884 ARGV is a vector of all the arguments; ARGC is the number of
885 arguments. IS_VARARGS is true if the macro being substituted is a
886 varargs macro; in this case VA_ARG_NAME is the name of the
887 "variable" argument. VA_ARG_NAME is ignored if IS_VARARGS is
890 If the token TOK is the name of a parameter, return the parameter's
891 index. If TOK is not an argument, return -1. */
894 find_parameter (const struct macro_buffer
*tok
,
895 int is_varargs
, const struct macro_buffer
*va_arg_name
,
896 int argc
, const char * const *argv
)
900 if (! tok
->is_identifier
)
903 for (i
= 0; i
< argc
; ++i
)
904 if (tok
->len
== strlen (argv
[i
])
905 && !memcmp (tok
->text
, argv
[i
], tok
->len
))
908 if (is_varargs
&& tok
->len
== va_arg_name
->len
909 && ! memcmp (tok
->text
, va_arg_name
->text
, tok
->len
))
915 /* Helper function for substitute_args that gets the next token and
916 updates the passed-in state variables. */
919 get_next_token_for_substitution (struct macro_buffer
*replacement_list
,
920 struct macro_buffer
*token
,
922 struct macro_buffer
*lookahead
,
923 char **lookahead_start
,
924 int *lookahead_valid
,
927 if (!*lookahead_valid
)
933 *start
= *lookahead_start
;
934 *lookahead_start
= replacement_list
->text
;
935 *lookahead_valid
= get_token (lookahead
, replacement_list
);
939 /* Given the macro definition DEF, being invoked with the actual
940 arguments given by ARGV, substitute the arguments into the
941 replacement list, and store the result in DEST.
943 IS_VARARGS should be true if DEF is a varargs macro. In this case,
944 VA_ARG_NAME should be the name of the "variable" argument -- either
945 __VA_ARGS__ for c99-style varargs, or the final argument name, for
946 GNU-style varargs. If IS_VARARGS is false, this parameter is
949 If it is necessary to expand macro invocations in one of the
950 arguments, use LOOKUP_FUNC and LOOKUP_BATON to find the macro
951 definitions, and don't expand invocations of the macros listed in
955 substitute_args (struct macro_buffer
*dest
,
956 struct macro_definition
*def
,
957 int is_varargs
, const struct macro_buffer
*va_arg_name
,
958 const std::vector
<struct macro_buffer
> &argv
,
959 struct macro_name_list
*no_loop
,
960 const macro_scope
&scope
)
962 /* The token we are currently considering. */
963 struct macro_buffer tok
;
964 /* The replacement list's pointer from just before TOK was lexed. */
965 char *original_rl_start
;
966 /* We have a single lookahead token to handle token splicing. */
967 struct macro_buffer lookahead
;
968 /* The lookahead token might not be valid. */
970 /* The replacement list's pointer from just before LOOKAHEAD was
972 char *lookahead_rl_start
;
974 /* A macro buffer for the macro's replacement list. */
975 struct macro_buffer
replacement_list (def
->replacement
,
976 strlen (def
->replacement
));
978 gdb_assert (dest
->len
== 0);
979 dest
->last_token
= 0;
981 original_rl_start
= replacement_list
.text
;
982 if (! get_token (&tok
, &replacement_list
))
984 lookahead_rl_start
= replacement_list
.text
;
985 lookahead_valid
= get_token (&lookahead
, &replacement_list
);
987 /* __VA_OPT__ state variable. The states are:
988 0 - nothing happening
990 >= 2 in __VA_OPT__, the value encodes the parenthesis depth. */
991 unsigned vaopt_state
= 0;
993 for (bool keep_going
= true;
995 get_next_token_for_substitution (&replacement_list
,
1003 bool token_is_vaopt
= (tok
.len
== 10
1004 && strncmp (tok
.text
, "__VA_OPT__", 10) == 0);
1006 if (vaopt_state
> 0)
1009 error (_("__VA_OPT__ cannot appear inside __VA_OPT__"));
1010 else if (tok
.len
== 1 && tok
.text
[0] == '(')
1013 /* We just entered __VA_OPT__, so don't emit this
1017 else if (vaopt_state
== 1)
1018 error (_("__VA_OPT__ must be followed by an open parenthesis"));
1019 else if (tok
.len
== 1 && tok
.text
[0] == ')')
1022 if (vaopt_state
== 1)
1024 /* Done with __VA_OPT__. */
1031 /* If __VA_ARGS__ is empty, then drop the contents of
1033 if (argv
.back ().len
== 0)
1036 else if (token_is_vaopt
)
1039 error (_("__VA_OPT__ is only valid in a variadic macro"));
1041 /* Don't emit this token. */
1045 /* Just for aesthetics. If we skipped some whitespace, copy
1047 if (tok
.text
> original_rl_start
)
1049 dest
->appendmem (original_rl_start
, tok
.text
- original_rl_start
);
1050 dest
->last_token
= dest
->len
;
1053 /* Is this token the stringification operator? */
1055 && tok
.text
[0] == '#')
1059 if (!lookahead_valid
)
1060 error (_("Stringification operator requires an argument."));
1062 arg
= find_parameter (&lookahead
, is_varargs
, va_arg_name
,
1063 def
->argc
, def
->argv
);
1065 error (_("Argument to stringification operator must name "
1066 "a macro parameter."));
1068 stringify (dest
, argv
[arg
].text
, argv
[arg
].len
);
1070 /* Read one token and let the loop iteration code handle the
1072 lookahead_rl_start
= replacement_list
.text
;
1073 lookahead_valid
= get_token (&lookahead
, &replacement_list
);
1075 /* Is this token the splicing operator? */
1076 else if (tok
.len
== 2
1077 && tok
.text
[0] == '#'
1078 && tok
.text
[1] == '#')
1079 error (_("Stray splicing operator"));
1080 /* Is the next token the splicing operator? */
1081 else if (lookahead_valid
1082 && lookahead
.len
== 2
1083 && lookahead
.text
[0] == '#'
1084 && lookahead
.text
[1] == '#')
1087 int prev_was_comma
= 0;
1089 /* Note that GCC warns if the result of splicing is not a
1090 token. In the debugger there doesn't seem to be much
1091 benefit from doing this. */
1093 /* Insert the first token. */
1094 if (tok
.len
== 1 && tok
.text
[0] == ',')
1098 int arg
= find_parameter (&tok
, is_varargs
, va_arg_name
,
1099 def
->argc
, def
->argv
);
1102 dest
->appendmem (argv
[arg
].text
, argv
[arg
].len
);
1104 dest
->appendmem (tok
.text
, tok
.len
);
1107 /* Apply a possible sequence of ## operators. */
1110 if (! get_token (&tok
, &replacement_list
))
1111 error (_("Splicing operator at end of macro"));
1113 /* Handle a comma before a ##. If we are handling
1114 varargs, and the token on the right hand side is the
1115 varargs marker, and the final argument is empty or
1116 missing, then drop the comma. This is a GNU
1117 extension. There is one ambiguous case here,
1118 involving pedantic behavior with an empty argument,
1119 but we settle that in favor of GNU-style (GCC uses an
1120 option). If we aren't dealing with varargs, we
1121 simply insert the comma. */
1125 && tok
.len
== va_arg_name
->len
1126 && !memcmp (tok
.text
, va_arg_name
->text
, tok
.len
)
1127 && argv
.back ().len
== 0))
1128 dest
->appendmem (",", 1);
1132 /* Insert the token. If it is a parameter, insert the
1133 argument. If it is a comma, treat it specially. */
1134 if (tok
.len
== 1 && tok
.text
[0] == ',')
1138 int arg
= find_parameter (&tok
, is_varargs
, va_arg_name
,
1139 def
->argc
, def
->argv
);
1142 dest
->appendmem (argv
[arg
].text
, argv
[arg
].len
);
1144 dest
->appendmem (tok
.text
, tok
.len
);
1147 /* Now read another token. If it is another splice, we
1149 original_rl_start
= replacement_list
.text
;
1150 if (! get_token (&tok
, &replacement_list
))
1157 && tok
.text
[0] == '#'
1158 && tok
.text
[1] == '#'))
1164 /* We saw a comma. Insert it now. */
1165 dest
->appendmem (",", 1);
1168 dest
->last_token
= dest
->len
;
1170 lookahead_valid
= 0;
1173 /* Set up for the loop iterator. */
1175 lookahead_rl_start
= original_rl_start
;
1176 lookahead_valid
= 1;
1181 /* Is this token an identifier? */
1182 int substituted
= 0;
1183 int arg
= find_parameter (&tok
, is_varargs
, va_arg_name
,
1184 def
->argc
, def
->argv
);
1188 /* Expand any macro invocations in the argument text,
1189 and append the result to dest. Remember that scan
1190 mutates its source, so we need to scan a new buffer
1191 referring to the argument's text, not the argument
1193 struct macro_buffer
arg_src (argv
[arg
].text
, argv
[arg
].len
);
1194 scan (dest
, &arg_src
, no_loop
, scope
);
1198 /* If it wasn't a parameter, then just copy it across. */
1200 append_tokens_without_splicing (dest
, &tok
);
1204 if (vaopt_state
> 0)
1205 error (_("Unterminated __VA_OPT__"));
1209 /* Expand a call to a macro named ID, whose definition is DEF. Append
1210 its expansion to DEST. SRC is the input text following the ID
1211 token. We are currently rescanning the expansions of the macros
1212 named in NO_LOOP; don't re-expand them. Use LOOKUP_FUNC and
1213 LOOKUP_BATON to find definitions for any nested macro references.
1215 Return 1 if we decided to expand it, zero otherwise. (If it's a
1216 function-like macro name that isn't followed by an argument list,
1217 we don't expand it.) If we return zero, leave SRC unchanged. */
1219 expand (const char *id
,
1220 struct macro_definition
*def
,
1221 struct macro_buffer
*dest
,
1222 struct macro_buffer
*src
,
1223 struct macro_name_list
*no_loop
,
1224 const macro_scope
&scope
)
1226 struct macro_name_list new_no_loop
;
1228 /* Create a new node to be added to the front of the no-expand list.
1229 This list is appropriate for re-scanning replacement lists, but
1230 it is *not* appropriate for scanning macro arguments; invocations
1231 of the macro whose arguments we are gathering *do* get expanded
1233 new_no_loop
.name
= id
;
1234 new_no_loop
.next
= no_loop
;
1236 /* What kind of macro are we expanding? */
1237 if (def
->kind
== macro_object_like
)
1239 struct macro_buffer
replacement_list (def
->replacement
,
1240 strlen (def
->replacement
));
1242 scan (dest
, &replacement_list
, &new_no_loop
, scope
);
1245 else if (def
->kind
== macro_function_like
)
1247 struct macro_buffer va_arg_name
;
1252 if (strcmp (def
->argv
[def
->argc
- 1], "...") == 0)
1254 /* In C99-style varargs, substitution is done using
1256 va_arg_name
.set_shared ("__VA_ARGS__", strlen ("__VA_ARGS__"));
1261 int len
= strlen (def
->argv
[def
->argc
- 1]);
1264 && strcmp (def
->argv
[def
->argc
- 1] + len
- 3, "...") == 0)
1266 /* In GNU-style varargs, the name of the
1267 substitution parameter is the name of the formal
1268 argument without the "...". */
1269 va_arg_name
.set_shared (def
->argv
[def
->argc
- 1], len
- 3);
1275 std::vector
<struct macro_buffer
> argv
;
1276 /* If we couldn't find any argument list, then we don't expand
1278 if (!gather_arguments (id
, src
, is_varargs
? def
->argc
: -1,
1282 /* Check that we're passing an acceptable number of arguments for
1284 if (argv
.size () != def
->argc
)
1286 if (is_varargs
&& argv
.size () >= def
->argc
- 1)
1290 /* Remember that a sequence of tokens like "foo()" is a
1291 valid invocation of a macro expecting either zero or one
1293 else if (! (argv
.size () == 1
1296 error (_("Wrong number of arguments to macro `%s' "
1297 "(expected %d, got %d)."),
1298 id
, def
->argc
, int (argv
.size ()));
1301 /* Note that we don't expand macro invocations in the arguments
1302 yet --- we let subst_args take care of that. Parameters that
1303 appear as operands of the stringifying operator "#" or the
1304 splicing operator "##" don't get macro references expanded,
1305 so we can't really tell whether it's appropriate to macro-
1306 expand an argument until we see how it's being used. */
1307 struct macro_buffer
substituted (0);
1308 substitute_args (&substituted
, def
, is_varargs
, &va_arg_name
,
1309 argv
, no_loop
, scope
);
1311 /* Now `substituted' is the macro's replacement list, with all
1312 argument values substituted into it properly. Re-scan it for
1313 macro references, but don't expand invocations of this macro.
1315 We create a new buffer, `substituted_src', which points into
1316 `substituted', and scan that. We can't scan `substituted'
1317 itself, since the tokenization process moves the buffer's
1318 text pointer around, and we still need to be able to find
1319 `substituted's original text buffer after scanning it so we
1321 struct macro_buffer
substituted_src (substituted
.text
, substituted
.len
);
1322 scan (dest
, &substituted_src
, &new_no_loop
, scope
);
1327 internal_error (__FILE__
, __LINE__
, _("bad macro definition kind"));
1331 /* If the single token in SRC_FIRST followed by the tokens in SRC_REST
1332 constitute a macro invocation not forbidden in NO_LOOP, append its
1333 expansion to DEST and return non-zero. Otherwise, return zero, and
1334 leave DEST unchanged.
1336 SRC_FIRST and SRC_REST must be shared buffers; DEST must not be one.
1337 SRC_FIRST must be a string built by get_token. */
1339 maybe_expand (struct macro_buffer
*dest
,
1340 struct macro_buffer
*src_first
,
1341 struct macro_buffer
*src_rest
,
1342 struct macro_name_list
*no_loop
,
1343 const macro_scope
&scope
)
1345 gdb_assert (src_first
->shared
);
1346 gdb_assert (src_rest
->shared
);
1347 gdb_assert (! dest
->shared
);
1349 /* Is this token an identifier? */
1350 if (src_first
->is_identifier
)
1352 /* Make a null-terminated copy of it, since that's what our
1353 lookup function expects. */
1354 std::string
id (src_first
->text
, src_first
->len
);
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
.c_str ()))
1360 /* Does this identifier have a macro definition in scope? */
1361 macro_definition
*def
= standard_macro_lookup (id
.c_str (), scope
);
1363 if (def
&& expand (id
.c_str (), def
, dest
, src_rest
, no_loop
, scope
))
1372 /* Expand macro references in SRC, appending the results to DEST.
1373 Assume we are re-scanning the result of expanding the macros named
1374 in NO_LOOP, and don't try to re-expand references to them.
1376 SRC must be a shared buffer; DEST must not be one. */
1378 scan (struct macro_buffer
*dest
,
1379 struct macro_buffer
*src
,
1380 struct macro_name_list
*no_loop
,
1381 const macro_scope
&scope
)
1383 gdb_assert (src
->shared
);
1384 gdb_assert (! dest
->shared
);
1388 struct macro_buffer tok
;
1389 char *original_src_start
= src
->text
;
1391 /* Find the next token in SRC. */
1392 if (! get_token (&tok
, src
))
1395 /* Just for aesthetics. If we skipped some whitespace, copy
1397 if (tok
.text
> original_src_start
)
1399 dest
->appendmem (original_src_start
, tok
.text
- original_src_start
);
1400 dest
->last_token
= dest
->len
;
1403 if (! maybe_expand (dest
, &tok
, src
, no_loop
, scope
))
1404 /* We didn't end up expanding tok as a macro reference, so
1405 simply append it to dest. */
1406 append_tokens_without_splicing (dest
, &tok
);
1409 /* Just for aesthetics. If there was any trailing whitespace in
1410 src, copy it to dest. */
1413 dest
->appendmem (src
->text
, src
->len
);
1414 dest
->last_token
= dest
->len
;
1419 gdb::unique_xmalloc_ptr
<char>
1420 macro_expand (const char *source
, const macro_scope
&scope
)
1422 struct macro_buffer
src (source
, strlen (source
));
1424 struct macro_buffer
dest (0);
1425 dest
.last_token
= 0;
1427 scan (&dest
, &src
, 0, scope
);
1429 dest
.appendc ('\0');
1431 return dest
.release ();
1435 gdb::unique_xmalloc_ptr
<char>
1436 macro_expand_once (const char *source
, const macro_scope
&scope
)
1438 error (_("Expand-once not implemented yet."));
1441 gdb::unique_xmalloc_ptr
<char>
1442 macro_expand_next (const char **lexptr
, const macro_scope
&scope
)
1444 struct macro_buffer tok
;
1446 /* Set up SRC to refer to the input text, pointed to by *lexptr. */
1447 struct macro_buffer
src (*lexptr
, strlen (*lexptr
));
1449 /* Set up DEST to receive the expansion, if there is one. */
1450 struct macro_buffer
dest (0);
1451 dest
.last_token
= 0;
1453 /* Get the text's first preprocessing token. */
1454 if (! get_token (&tok
, &src
))
1457 /* If it's a macro invocation, expand it. */
1458 if (maybe_expand (&dest
, &tok
, &src
, 0, scope
))
1460 /* It was a macro invocation! Package up the expansion as a
1461 null-terminated string and return it. Set *lexptr to the
1462 start of the next token in the input. */
1463 dest
.appendc ('\0');
1465 return dest
.release ();
1469 /* It wasn't a macro invocation. */