1 /* C preprocessor macro expansion for GDB.
2 Copyright (C) 2002-2017 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. */
76 /* Set the macro buffer *B to the empty string, guessing that its
77 final contents will fit in N bytes. (It'll get resized if it
78 doesn't, so the guess doesn't have to be right.) Allocate the
79 initial storage with xmalloc. */
81 init_buffer (struct macro_buffer
*b
, int n
)
85 b
->text
= (char *) xmalloc (n
);
94 /* Set the macro buffer *BUF to refer to the LEN bytes at ADDR, as a
98 init_shared_buffer (struct macro_buffer
*buf
, const char *addr
, int len
)
100 /* The function accept a "const char *" addr so that clients can
101 pass in string literals without casts. */
102 buf
->text
= (char *) addr
;
106 buf
->last_token
= -1;
110 /* Free the text of the buffer B. Raise an error if B is shared. */
112 free_buffer (struct macro_buffer
*b
)
114 gdb_assert (! b
->shared
);
119 /* Like free_buffer, but return the text as an xstrdup()d string.
120 This only exists to try to make the API relatively clean. */
123 free_buffer_return_text (struct macro_buffer
*b
)
125 gdb_assert (! b
->shared
);
126 gdb_assert (b
->size
);
131 /* A cleanup function for macro buffers. */
133 cleanup_macro_buffer (void *untyped_buf
)
135 free_buffer ((struct macro_buffer
*) untyped_buf
);
139 /* Resize the buffer B to be at least N bytes long. Raise an error if
140 B shouldn't be resized. */
142 resize_buffer (struct macro_buffer
*b
, int n
)
144 /* We shouldn't be trying to resize shared strings. */
145 gdb_assert (! b
->shared
);
153 b
->text
= (char *) xrealloc (b
->text
, b
->size
);
157 /* Append the character C to the buffer B. */
159 appendc (struct macro_buffer
*b
, int c
)
161 int new_len
= b
->len
+ 1;
163 if (new_len
> b
->size
)
164 resize_buffer (b
, new_len
);
171 /* Append the LEN bytes at ADDR to the buffer B. */
173 appendmem (struct macro_buffer
*b
, const char *addr
, int len
)
175 int new_len
= b
->len
+ len
;
177 if (new_len
> b
->size
)
178 resize_buffer (b
, new_len
);
180 memcpy (b
->text
+ b
->len
, addr
, len
);
186 /* Recognizing preprocessor tokens. */
190 macro_is_whitespace (int c
)
201 macro_is_digit (int c
)
203 return ('0' <= c
&& c
<= '9');
208 macro_is_identifier_nondigit (int c
)
211 || ('a' <= c
&& c
<= 'z')
212 || ('A' <= c
&& c
<= 'Z'));
217 set_token (struct macro_buffer
*tok
, char *start
, char *end
)
219 init_shared_buffer (tok
, start
, end
- start
);
222 /* Presumed; get_identifier may overwrite this. */
223 tok
->is_identifier
= 0;
228 get_comment (struct macro_buffer
*tok
, char *p
, char *end
)
245 set_token (tok
, tok_start
, p
);
249 error (_("Unterminated comment in macro expansion."));
261 set_token (tok
, tok_start
, p
);
270 get_identifier (struct macro_buffer
*tok
, char *p
, char *end
)
273 && macro_is_identifier_nondigit (*p
))
278 && (macro_is_identifier_nondigit (*p
)
279 || macro_is_digit (*p
)))
282 set_token (tok
, tok_start
, p
);
283 tok
->is_identifier
= 1;
292 get_pp_number (struct macro_buffer
*tok
, char *p
, char *end
)
295 && (macro_is_digit (*p
)
298 && macro_is_digit (p
[1]))))
305 && strchr ("eEpP", *p
)
306 && (p
[1] == '+' || p
[1] == '-'))
308 else if (macro_is_digit (*p
)
309 || macro_is_identifier_nondigit (*p
)
316 set_token (tok
, tok_start
, p
);
325 /* If the text starting at P going up to (but not including) END
326 starts with a character constant, set *TOK to point to that
327 character constant, and return 1. Otherwise, return zero.
328 Signal an error if it contains a malformed or incomplete character
331 get_character_constant (struct macro_buffer
*tok
, char *p
, char *end
)
333 /* ISO/IEC 9899:1999 (E) Section 6.4.4.4 paragraph 1
334 But of course, what really matters is that we handle it the same
335 way GDB's C/C++ lexer does. So we call parse_escape in utils.c
336 to handle escape sequences. */
337 if ((p
+ 1 <= end
&& *p
== '\'')
339 && (p
[0] == 'L' || p
[0] == 'u' || p
[0] == 'U')
347 else if (*p
== 'L' || *p
== 'u' || *p
== 'U')
350 gdb_assert_not_reached ("unexpected character constant");
355 error (_("Unmatched single quote."));
359 error (_("A character constant must contain at least one "
369 char_count
+= c_parse_escape (&s
, NULL
);
379 set_token (tok
, tok_start
, p
);
387 /* If the text starting at P going up to (but not including) END
388 starts with a string literal, set *TOK to point to that string
389 literal, and return 1. Otherwise, return zero. Signal an error if
390 it contains a malformed or incomplete string literal. */
392 get_string_literal (struct macro_buffer
*tok
, char *p
, char *end
)
397 && (p
[0] == 'L' || p
[0] == 'u' || p
[0] == 'U')
404 else if (*p
== 'L' || *p
== 'u' || *p
== 'U')
407 gdb_assert_not_reached ("unexpected string literal");
412 error (_("Unterminated string in expression."));
419 error (_("Newline characters may not appear in string "
426 c_parse_escape (&s
, NULL
);
433 set_token (tok
, tok_start
, p
);
442 get_punctuator (struct macro_buffer
*tok
, char *p
, char *end
)
444 /* Here, speed is much less important than correctness and clarity. */
446 /* ISO/IEC 9899:1999 (E) Section 6.4.6 Paragraph 1.
447 Note that this table is ordered in a special way. A punctuator
448 which is a prefix of another punctuator must appear after its
449 "extension". Otherwise, the wrong token will be returned. */
450 static const char * const punctuators
[] = {
451 "[", "]", "(", ")", "{", "}", "?", ";", ",", "~",
453 "->", "--", "-=", "-",
459 "%>", "%:%:", "%:", "%=", "%",
464 "<<=", "<<", "<=", "<:", "<%", "<",
465 ">>=", ">>", ">=", ">",
474 for (i
= 0; punctuators
[i
]; i
++)
476 const char *punctuator
= punctuators
[i
];
478 if (p
[0] == punctuator
[0])
480 int len
= strlen (punctuator
);
483 && ! memcmp (p
, punctuator
, len
))
485 set_token (tok
, p
, p
+ len
);
496 /* Peel the next preprocessor token off of SRC, and put it in TOK.
497 Mutate TOK to refer to the first token in SRC, and mutate SRC to
498 refer to the text after that token. SRC must be a shared buffer;
499 the resulting TOK will be shared, pointing into the same string SRC
500 does. Initialize TOK's last_token field. Return non-zero if we
501 succeed, or 0 if we didn't find any more tokens in SRC. */
503 get_token (struct macro_buffer
*tok
,
504 struct macro_buffer
*src
)
507 char *end
= p
+ src
->len
;
509 gdb_assert (src
->shared
);
511 /* From the ISO C standard, ISO/IEC 9899:1999 (E), section 6.4:
520 each non-white-space character that cannot be one of the above
522 We don't have to deal with header-name tokens, since those can
523 only occur after a #include, which we will never see. */
526 if (macro_is_whitespace (*p
))
528 else if (get_comment (tok
, p
, end
))
530 else if (get_pp_number (tok
, p
, end
)
531 || get_character_constant (tok
, p
, end
)
532 || get_string_literal (tok
, p
, end
)
533 /* Note: the grammar in the standard seems to be
534 ambiguous: L'x' can be either a wide character
535 constant, or an identifier followed by a normal
536 character constant. By trying `get_identifier' after
537 we try get_character_constant and get_string_literal,
538 we give the wide character syntax precedence. Now,
539 since GDB doesn't handle wide character constants
540 anyway, is this the right thing to do? */
541 || get_identifier (tok
, p
, end
)
542 || get_punctuator (tok
, p
, end
))
544 /* How many characters did we consume, including whitespace? */
545 int consumed
= p
- src
->text
+ tok
->len
;
547 src
->text
+= consumed
;
548 src
->len
-= consumed
;
553 /* We have found a "non-whitespace character that cannot be
554 one of the above." Make a token out of it. */
557 set_token (tok
, p
, p
+ 1);
558 consumed
= p
- src
->text
+ tok
->len
;
559 src
->text
+= consumed
;
560 src
->len
-= consumed
;
569 /* Appending token strings, with and without splicing */
572 /* Append the macro buffer SRC to the end of DEST, and ensure that
573 doing so doesn't splice the token at the end of SRC with the token
574 at the beginning of DEST. SRC and DEST must have their last_token
575 fields set. Upon return, DEST's last_token field is set correctly.
579 If DEST is "(" and SRC is "y", then we can return with
580 DEST set to "(y" --- we've simply appended the two buffers.
582 However, if DEST is "x" and SRC is "y", then we must not return
583 with DEST set to "xy" --- that would splice the two tokens "x" and
584 "y" together to make a single token "xy". However, it would be
585 fine to return with DEST set to "x y". Similarly, "<" and "<" must
586 yield "< <", not "<<", etc. */
588 append_tokens_without_splicing (struct macro_buffer
*dest
,
589 struct macro_buffer
*src
)
591 int original_dest_len
= dest
->len
;
592 struct macro_buffer dest_tail
, new_token
;
594 gdb_assert (src
->last_token
!= -1);
595 gdb_assert (dest
->last_token
!= -1);
597 /* First, just try appending the two, and call get_token to see if
599 appendmem (dest
, src
->text
, src
->len
);
601 /* If DEST originally had no token abutting its end, then we can't
602 have spliced anything, so we're done. */
603 if (dest
->last_token
== original_dest_len
)
605 dest
->last_token
= original_dest_len
+ src
->last_token
;
609 /* Set DEST_TAIL to point to the last token in DEST, followed by
610 all the stuff we just appended. */
611 init_shared_buffer (&dest_tail
,
612 dest
->text
+ dest
->last_token
,
613 dest
->len
- dest
->last_token
);
615 /* Re-parse DEST's last token. We know that DEST used to contain
616 at least one token, so if it doesn't contain any after the
617 append, then we must have spliced "/" and "*" or "/" and "/" to
618 make a comment start. (Just for the record, I got this right
619 the first time. This is not a bug fix.) */
620 if (get_token (&new_token
, &dest_tail
)
621 && (new_token
.text
+ new_token
.len
622 == dest
->text
+ original_dest_len
))
624 /* No splice, so we're done. */
625 dest
->last_token
= original_dest_len
+ src
->last_token
;
629 /* Okay, a simple append caused a splice. Let's chop dest back to
630 its original length and try again, but separate the texts with a
632 dest
->len
= original_dest_len
;
634 appendmem (dest
, src
->text
, src
->len
);
636 init_shared_buffer (&dest_tail
,
637 dest
->text
+ dest
->last_token
,
638 dest
->len
- dest
->last_token
);
640 /* Try to re-parse DEST's last token, as above. */
641 if (get_token (&new_token
, &dest_tail
)
642 && (new_token
.text
+ new_token
.len
643 == dest
->text
+ original_dest_len
))
645 /* No splice, so we're done. */
646 dest
->last_token
= original_dest_len
+ 1 + src
->last_token
;
650 /* As far as I know, there's no case where inserting a space isn't
651 enough to prevent a splice. */
652 internal_error (__FILE__
, __LINE__
,
653 _("unable to avoid splicing tokens during macro expansion"));
656 /* Stringify an argument, and insert it into DEST. ARG is the text to
657 stringify; it is LEN bytes long. */
660 stringify (struct macro_buffer
*dest
, const char *arg
, int len
)
662 /* Trim initial whitespace from ARG. */
663 while (len
> 0 && macro_is_whitespace (*arg
))
669 /* Trim trailing whitespace from ARG. */
670 while (len
> 0 && macro_is_whitespace (arg
[len
- 1]))
673 /* Insert the string. */
677 /* We could try to handle strange cases here, like control
678 characters, but there doesn't seem to be much point. */
679 if (macro_is_whitespace (*arg
))
681 /* Replace a sequence of whitespace with a single space. */
683 while (len
> 1 && macro_is_whitespace (arg
[1]))
689 else if (*arg
== '\\' || *arg
== '"')
691 appendc (dest
, '\\');
692 appendc (dest
, *arg
);
695 appendc (dest
, *arg
);
700 dest
->last_token
= dest
->len
;
703 /* See macroexp.h. */
706 macro_stringify (const char *str
)
708 struct macro_buffer buffer
;
709 int len
= strlen (str
);
711 init_buffer (&buffer
, len
);
712 stringify (&buffer
, str
, len
);
713 appendc (&buffer
, '\0');
715 return free_buffer_return_text (&buffer
);
719 /* Expanding macros! */
722 /* A singly-linked list of the names of the macros we are currently
723 expanding --- for detecting expansion loops. */
724 struct macro_name_list
{
726 struct macro_name_list
*next
;
730 /* Return non-zero if we are currently expanding the macro named NAME,
731 according to LIST; otherwise, return zero.
733 You know, it would be possible to get rid of all the NO_LOOP
734 arguments to these functions by simply generating a new lookup
735 function and baton which refuses to find the definition for a
736 particular macro, and otherwise delegates the decision to another
737 function/baton pair. But that makes the linked list of excluded
738 macros chained through untyped baton pointers, which will make it
739 harder to debug. :( */
741 currently_rescanning (struct macro_name_list
*list
, const char *name
)
743 for (; list
; list
= list
->next
)
744 if (strcmp (name
, list
->name
) == 0)
751 /* Gather the arguments to a macro expansion.
753 NAME is the name of the macro being invoked. (It's only used for
754 printing error messages.)
756 Assume that SRC is the text of the macro invocation immediately
757 following the macro name. For example, if we're processing the
758 text foo(bar, baz), then NAME would be foo and SRC will be (bar,
761 If SRC doesn't start with an open paren ( token at all, return
762 zero, leave SRC unchanged, and don't set *ARGC_P to anything.
764 If SRC doesn't contain a properly terminated argument list, then
767 For a variadic macro, NARGS holds the number of formal arguments to
768 the macro. For a GNU-style variadic macro, this should be the
769 number of named arguments. For a non-variadic macro, NARGS should
772 Otherwise, return a pointer to the first element of an array of
773 macro buffers referring to the argument texts, and set *ARGC_P to
774 the number of arguments we found --- the number of elements in the
775 array. The macro buffers share their text with SRC, and their
776 last_token fields are initialized. The array is allocated with
777 xmalloc, and the caller is responsible for freeing it.
779 NOTE WELL: if SRC starts with a open paren ( token followed
780 immediately by a close paren ) token (e.g., the invocation looks
781 like "foo()"), we treat that as one argument, which happens to be
782 the empty list of tokens. The caller should keep in mind that such
783 a sequence of tokens is a valid way to invoke one-parameter
784 function-like macros, but also a valid way to invoke zero-parameter
785 function-like macros. Eeew.
787 Consume the tokens from SRC; after this call, SRC contains the text
788 following the invocation. */
790 static struct macro_buffer
*
791 gather_arguments (const char *name
, struct macro_buffer
*src
,
792 int nargs
, int *argc_p
)
794 struct macro_buffer tok
;
795 int args_len
, args_size
;
796 struct macro_buffer
*args
= NULL
;
797 struct cleanup
*back_to
= make_cleanup (free_current_contents
, &args
);
799 /* Does SRC start with an opening paren token? Read from a copy of
800 SRC, so SRC itself is unaffected if we don't find an opening
803 struct macro_buffer temp
;
805 init_shared_buffer (&temp
, src
->text
, src
->len
);
807 if (! get_token (&tok
, &temp
)
809 || tok
.text
[0] != '(')
811 discard_cleanups (back_to
);
816 /* Consume SRC's opening paren. */
817 get_token (&tok
, src
);
821 args
= XNEWVEC (struct macro_buffer
, args_size
);
825 struct macro_buffer
*arg
;
828 /* Make sure we have room for the next argument. */
829 if (args_len
>= args_size
)
832 args
= XRESIZEVEC (struct macro_buffer
, args
, args_size
);
835 /* Initialize the next argument. */
836 arg
= &args
[args_len
++];
837 set_token (arg
, src
->text
, src
->text
);
839 /* Gather the argument's tokens. */
843 if (! get_token (&tok
, src
))
844 error (_("Malformed argument list for macro `%s'."), name
);
846 /* Is tok an opening paren? */
847 if (tok
.len
== 1 && tok
.text
[0] == '(')
850 /* Is tok is a closing paren? */
851 else if (tok
.len
== 1 && tok
.text
[0] == ')')
853 /* If it's a closing paren at the top level, then that's
854 the end of the argument list. */
857 /* In the varargs case, the last argument may be
858 missing. Add an empty argument in this case. */
859 if (nargs
!= -1 && args_len
== nargs
- 1)
861 /* Make sure we have room for the argument. */
862 if (args_len
>= args_size
)
865 args
= XRESIZEVEC (struct macro_buffer
, args
,
868 arg
= &args
[args_len
++];
869 set_token (arg
, src
->text
, src
->text
);
872 discard_cleanups (back_to
);
880 /* If tok is a comma at top level, then that's the end of
881 the current argument. However, if we are handling a
882 variadic macro and we are computing the last argument, we
883 want to include the comma and remaining tokens. */
884 else if (tok
.len
== 1 && tok
.text
[0] == ',' && depth
== 0
885 && (nargs
== -1 || args_len
< nargs
))
888 /* Extend the current argument to enclose this token. If
889 this is the current argument's first token, leave out any
890 leading whitespace, just for aesthetics. */
893 arg
->text
= tok
.text
;
899 arg
->len
= (tok
.text
+ tok
.len
) - arg
->text
;
900 arg
->last_token
= tok
.text
- arg
->text
;
907 /* The `expand' and `substitute_args' functions both invoke `scan'
908 recursively, so we need a forward declaration somewhere. */
909 static void scan (struct macro_buffer
*dest
,
910 struct macro_buffer
*src
,
911 struct macro_name_list
*no_loop
,
912 macro_lookup_ftype
*lookup_func
,
916 /* A helper function for substitute_args.
918 ARGV is a vector of all the arguments; ARGC is the number of
919 arguments. IS_VARARGS is true if the macro being substituted is a
920 varargs macro; in this case VA_ARG_NAME is the name of the
921 "variable" argument. VA_ARG_NAME is ignored if IS_VARARGS is
924 If the token TOK is the name of a parameter, return the parameter's
925 index. If TOK is not an argument, return -1. */
928 find_parameter (const struct macro_buffer
*tok
,
929 int is_varargs
, const struct macro_buffer
*va_arg_name
,
930 int argc
, const char * const *argv
)
934 if (! tok
->is_identifier
)
937 for (i
= 0; i
< argc
; ++i
)
938 if (tok
->len
== strlen (argv
[i
])
939 && !memcmp (tok
->text
, argv
[i
], tok
->len
))
942 if (is_varargs
&& tok
->len
== va_arg_name
->len
943 && ! memcmp (tok
->text
, va_arg_name
->text
, tok
->len
))
949 /* Helper function for substitute_args that gets the next token and
950 updates the passed-in state variables. */
953 get_next_token_for_substitution (struct macro_buffer
*replacement_list
,
954 struct macro_buffer
*token
,
956 struct macro_buffer
*lookahead
,
957 char **lookahead_start
,
958 int *lookahead_valid
,
961 if (!*lookahead_valid
)
967 *start
= *lookahead_start
;
968 *lookahead_start
= replacement_list
->text
;
969 *lookahead_valid
= get_token (lookahead
, replacement_list
);
973 /* Given the macro definition DEF, being invoked with the actual
974 arguments given by ARGC and ARGV, substitute the arguments into the
975 replacement list, and store the result in DEST.
977 IS_VARARGS should be true if DEF is a varargs macro. In this case,
978 VA_ARG_NAME should be the name of the "variable" argument -- either
979 __VA_ARGS__ for c99-style varargs, or the final argument name, for
980 GNU-style varargs. If IS_VARARGS is false, this parameter is
983 If it is necessary to expand macro invocations in one of the
984 arguments, use LOOKUP_FUNC and LOOKUP_BATON to find the macro
985 definitions, and don't expand invocations of the macros listed in
989 substitute_args (struct macro_buffer
*dest
,
990 struct macro_definition
*def
,
991 int is_varargs
, const struct macro_buffer
*va_arg_name
,
992 int argc
, struct macro_buffer
*argv
,
993 struct macro_name_list
*no_loop
,
994 macro_lookup_ftype
*lookup_func
,
997 /* A macro buffer for the macro's replacement list. */
998 struct macro_buffer replacement_list
;
999 /* The token we are currently considering. */
1000 struct macro_buffer tok
;
1001 /* The replacement list's pointer from just before TOK was lexed. */
1002 char *original_rl_start
;
1003 /* We have a single lookahead token to handle token splicing. */
1004 struct macro_buffer lookahead
;
1005 /* The lookahead token might not be valid. */
1006 int lookahead_valid
;
1007 /* The replacement list's pointer from just before LOOKAHEAD was
1009 char *lookahead_rl_start
;
1011 init_shared_buffer (&replacement_list
, def
->replacement
,
1012 strlen (def
->replacement
));
1014 gdb_assert (dest
->len
== 0);
1015 dest
->last_token
= 0;
1017 original_rl_start
= replacement_list
.text
;
1018 if (! get_token (&tok
, &replacement_list
))
1020 lookahead_rl_start
= replacement_list
.text
;
1021 lookahead_valid
= get_token (&lookahead
, &replacement_list
);
1023 /* __VA_OPT__ state variable. The states are:
1024 0 - nothing happening
1026 >= 2 in __VA_OPT__, the value encodes the parenthesis depth. */
1027 unsigned vaopt_state
= 0;
1029 for (bool keep_going
= true;
1031 get_next_token_for_substitution (&replacement_list
,
1035 &lookahead_rl_start
,
1039 bool token_is_vaopt
= (tok
.len
== 10
1040 && strncmp (tok
.text
, "__VA_OPT__", 10) == 0);
1042 if (vaopt_state
> 0)
1045 error (_("__VA_OPT__ cannot appear inside __VA_OPT__"));
1046 else if (tok
.len
== 1 && tok
.text
[0] == '(')
1049 /* We just entered __VA_OPT__, so don't emit this
1053 else if (vaopt_state
== 1)
1054 error (_("__VA_OPT__ must be followed by an open parenthesis"));
1055 else if (tok
.len
== 1 && tok
.text
[0] == ')')
1058 if (vaopt_state
== 1)
1060 /* Done with __VA_OPT__. */
1067 /* If __VA_ARGS__ is empty, then drop the contents of
1069 if (argv
[argc
- 1].len
== 0)
1072 else if (token_is_vaopt
)
1075 error (_("__VA_OPT__ is only valid in a variadic macro"));
1077 /* Don't emit this token. */
1081 /* Just for aesthetics. If we skipped some whitespace, copy
1083 if (tok
.text
> original_rl_start
)
1085 appendmem (dest
, original_rl_start
, tok
.text
- original_rl_start
);
1086 dest
->last_token
= dest
->len
;
1089 /* Is this token the stringification operator? */
1091 && tok
.text
[0] == '#')
1095 if (!lookahead_valid
)
1096 error (_("Stringification operator requires an argument."));
1098 arg
= find_parameter (&lookahead
, is_varargs
, va_arg_name
,
1099 def
->argc
, def
->argv
);
1101 error (_("Argument to stringification operator must name "
1102 "a macro parameter."));
1104 stringify (dest
, argv
[arg
].text
, argv
[arg
].len
);
1106 /* Read one token and let the loop iteration code handle the
1108 lookahead_rl_start
= replacement_list
.text
;
1109 lookahead_valid
= get_token (&lookahead
, &replacement_list
);
1111 /* Is this token the splicing operator? */
1112 else if (tok
.len
== 2
1113 && tok
.text
[0] == '#'
1114 && tok
.text
[1] == '#')
1115 error (_("Stray splicing operator"));
1116 /* Is the next token the splicing operator? */
1117 else if (lookahead_valid
1118 && lookahead
.len
== 2
1119 && lookahead
.text
[0] == '#'
1120 && lookahead
.text
[1] == '#')
1123 int prev_was_comma
= 0;
1125 /* Note that GCC warns if the result of splicing is not a
1126 token. In the debugger there doesn't seem to be much
1127 benefit from doing this. */
1129 /* Insert the first token. */
1130 if (tok
.len
== 1 && tok
.text
[0] == ',')
1134 int arg
= find_parameter (&tok
, is_varargs
, va_arg_name
,
1135 def
->argc
, def
->argv
);
1138 appendmem (dest
, argv
[arg
].text
, argv
[arg
].len
);
1140 appendmem (dest
, tok
.text
, tok
.len
);
1143 /* Apply a possible sequence of ## operators. */
1146 if (! get_token (&tok
, &replacement_list
))
1147 error (_("Splicing operator at end of macro"));
1149 /* Handle a comma before a ##. If we are handling
1150 varargs, and the token on the right hand side is the
1151 varargs marker, and the final argument is empty or
1152 missing, then drop the comma. This is a GNU
1153 extension. There is one ambiguous case here,
1154 involving pedantic behavior with an empty argument,
1155 but we settle that in favor of GNU-style (GCC uses an
1156 option). If we aren't dealing with varargs, we
1157 simply insert the comma. */
1161 && tok
.len
== va_arg_name
->len
1162 && !memcmp (tok
.text
, va_arg_name
->text
, tok
.len
)
1163 && argv
[argc
- 1].len
== 0))
1164 appendmem (dest
, ",", 1);
1168 /* Insert the token. If it is a parameter, insert the
1169 argument. If it is a comma, treat it specially. */
1170 if (tok
.len
== 1 && tok
.text
[0] == ',')
1174 int arg
= find_parameter (&tok
, is_varargs
, va_arg_name
,
1175 def
->argc
, def
->argv
);
1178 appendmem (dest
, argv
[arg
].text
, argv
[arg
].len
);
1180 appendmem (dest
, tok
.text
, tok
.len
);
1183 /* Now read another token. If it is another splice, we
1185 original_rl_start
= replacement_list
.text
;
1186 if (! get_token (&tok
, &replacement_list
))
1193 && tok
.text
[0] == '#'
1194 && tok
.text
[1] == '#'))
1200 /* We saw a comma. Insert it now. */
1201 appendmem (dest
, ",", 1);
1204 dest
->last_token
= dest
->len
;
1206 lookahead_valid
= 0;
1209 /* Set up for the loop iterator. */
1211 lookahead_rl_start
= original_rl_start
;
1212 lookahead_valid
= 1;
1217 /* Is this token an identifier? */
1218 int substituted
= 0;
1219 int arg
= find_parameter (&tok
, is_varargs
, va_arg_name
,
1220 def
->argc
, def
->argv
);
1224 struct macro_buffer arg_src
;
1226 /* Expand any macro invocations in the argument text,
1227 and append the result to dest. Remember that scan
1228 mutates its source, so we need to scan a new buffer
1229 referring to the argument's text, not the argument
1231 init_shared_buffer (&arg_src
, argv
[arg
].text
, argv
[arg
].len
);
1232 scan (dest
, &arg_src
, no_loop
, lookup_func
, lookup_baton
);
1236 /* If it wasn't a parameter, then just copy it across. */
1238 append_tokens_without_splicing (dest
, &tok
);
1242 if (vaopt_state
> 0)
1243 error (_("Unterminated __VA_OPT__"));
1247 /* Expand a call to a macro named ID, whose definition is DEF. Append
1248 its expansion to DEST. SRC is the input text following the ID
1249 token. We are currently rescanning the expansions of the macros
1250 named in NO_LOOP; don't re-expand them. Use LOOKUP_FUNC and
1251 LOOKUP_BATON to find definitions for any nested macro references.
1253 Return 1 if we decided to expand it, zero otherwise. (If it's a
1254 function-like macro name that isn't followed by an argument list,
1255 we don't expand it.) If we return zero, leave SRC unchanged. */
1257 expand (const char *id
,
1258 struct macro_definition
*def
,
1259 struct macro_buffer
*dest
,
1260 struct macro_buffer
*src
,
1261 struct macro_name_list
*no_loop
,
1262 macro_lookup_ftype
*lookup_func
,
1265 struct macro_name_list new_no_loop
;
1267 /* Create a new node to be added to the front of the no-expand list.
1268 This list is appropriate for re-scanning replacement lists, but
1269 it is *not* appropriate for scanning macro arguments; invocations
1270 of the macro whose arguments we are gathering *do* get expanded
1272 new_no_loop
.name
= id
;
1273 new_no_loop
.next
= no_loop
;
1275 /* What kind of macro are we expanding? */
1276 if (def
->kind
== macro_object_like
)
1278 struct macro_buffer replacement_list
;
1280 init_shared_buffer (&replacement_list
, def
->replacement
,
1281 strlen (def
->replacement
));
1283 scan (dest
, &replacement_list
, &new_no_loop
, lookup_func
, lookup_baton
);
1286 else if (def
->kind
== macro_function_like
)
1288 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
1290 struct macro_buffer
*argv
= NULL
;
1291 struct macro_buffer substituted
;
1292 struct macro_buffer substituted_src
;
1293 struct macro_buffer va_arg_name
= {0};
1298 if (strcmp (def
->argv
[def
->argc
- 1], "...") == 0)
1300 /* In C99-style varargs, substitution is done using
1302 init_shared_buffer (&va_arg_name
, "__VA_ARGS__",
1303 strlen ("__VA_ARGS__"));
1308 int len
= strlen (def
->argv
[def
->argc
- 1]);
1311 && strcmp (def
->argv
[def
->argc
- 1] + len
- 3, "...") == 0)
1313 /* In GNU-style varargs, the name of the
1314 substitution parameter is the name of the formal
1315 argument without the "...". */
1316 init_shared_buffer (&va_arg_name
,
1317 def
->argv
[def
->argc
- 1],
1324 make_cleanup (free_current_contents
, &argv
);
1325 argv
= gather_arguments (id
, src
, is_varargs
? def
->argc
: -1,
1328 /* If we couldn't find any argument list, then we don't expand
1332 do_cleanups (back_to
);
1336 /* Check that we're passing an acceptable number of arguments for
1338 if (argc
!= def
->argc
)
1340 if (is_varargs
&& argc
>= def
->argc
- 1)
1344 /* Remember that a sequence of tokens like "foo()" is a
1345 valid invocation of a macro expecting either zero or one
1347 else if (! (argc
== 1
1350 error (_("Wrong number of arguments to macro `%s' "
1351 "(expected %d, got %d)."),
1352 id
, def
->argc
, argc
);
1355 /* Note that we don't expand macro invocations in the arguments
1356 yet --- we let subst_args take care of that. Parameters that
1357 appear as operands of the stringifying operator "#" or the
1358 splicing operator "##" don't get macro references expanded,
1359 so we can't really tell whether it's appropriate to macro-
1360 expand an argument until we see how it's being used. */
1361 init_buffer (&substituted
, 0);
1362 make_cleanup (cleanup_macro_buffer
, &substituted
);
1363 substitute_args (&substituted
, def
, is_varargs
, &va_arg_name
,
1364 argc
, argv
, no_loop
, lookup_func
, lookup_baton
);
1366 /* Now `substituted' is the macro's replacement list, with all
1367 argument values substituted into it properly. Re-scan it for
1368 macro references, but don't expand invocations of this macro.
1370 We create a new buffer, `substituted_src', which points into
1371 `substituted', and scan that. We can't scan `substituted'
1372 itself, since the tokenization process moves the buffer's
1373 text pointer around, and we still need to be able to find
1374 `substituted's original text buffer after scanning it so we
1376 init_shared_buffer (&substituted_src
, substituted
.text
, substituted
.len
);
1377 scan (dest
, &substituted_src
, &new_no_loop
, lookup_func
, lookup_baton
);
1379 do_cleanups (back_to
);
1384 internal_error (__FILE__
, __LINE__
, _("bad macro definition kind"));
1388 /* If the single token in SRC_FIRST followed by the tokens in SRC_REST
1389 constitute a macro invokation not forbidden in NO_LOOP, append its
1390 expansion to DEST and return non-zero. Otherwise, return zero, and
1391 leave DEST unchanged.
1393 SRC_FIRST and SRC_REST must be shared buffers; DEST must not be one.
1394 SRC_FIRST must be a string built by get_token. */
1396 maybe_expand (struct macro_buffer
*dest
,
1397 struct macro_buffer
*src_first
,
1398 struct macro_buffer
*src_rest
,
1399 struct macro_name_list
*no_loop
,
1400 macro_lookup_ftype
*lookup_func
,
1403 gdb_assert (src_first
->shared
);
1404 gdb_assert (src_rest
->shared
);
1405 gdb_assert (! dest
->shared
);
1407 /* Is this token an identifier? */
1408 if (src_first
->is_identifier
)
1410 /* Make a null-terminated copy of it, since that's what our
1411 lookup function expects. */
1412 char *id
= (char *) xmalloc (src_first
->len
+ 1);
1413 struct cleanup
*back_to
= make_cleanup (xfree
, id
);
1415 memcpy (id
, src_first
->text
, src_first
->len
);
1416 id
[src_first
->len
] = 0;
1418 /* If we're currently re-scanning the result of expanding
1419 this macro, don't expand it again. */
1420 if (! currently_rescanning (no_loop
, id
))
1422 /* Does this identifier have a macro definition in scope? */
1423 struct macro_definition
*def
= lookup_func (id
, lookup_baton
);
1425 if (def
&& expand (id
, def
, dest
, src_rest
, no_loop
,
1426 lookup_func
, lookup_baton
))
1428 do_cleanups (back_to
);
1433 do_cleanups (back_to
);
1440 /* Expand macro references in SRC, appending the results to DEST.
1441 Assume we are re-scanning the result of expanding the macros named
1442 in NO_LOOP, and don't try to re-expand references to them.
1444 SRC must be a shared buffer; DEST must not be one. */
1446 scan (struct macro_buffer
*dest
,
1447 struct macro_buffer
*src
,
1448 struct macro_name_list
*no_loop
,
1449 macro_lookup_ftype
*lookup_func
,
1452 gdb_assert (src
->shared
);
1453 gdb_assert (! dest
->shared
);
1457 struct macro_buffer tok
;
1458 char *original_src_start
= src
->text
;
1460 /* Find the next token in SRC. */
1461 if (! get_token (&tok
, src
))
1464 /* Just for aesthetics. If we skipped some whitespace, copy
1466 if (tok
.text
> original_src_start
)
1468 appendmem (dest
, original_src_start
, tok
.text
- original_src_start
);
1469 dest
->last_token
= dest
->len
;
1472 if (! maybe_expand (dest
, &tok
, src
, no_loop
, lookup_func
, lookup_baton
))
1473 /* We didn't end up expanding tok as a macro reference, so
1474 simply append it to dest. */
1475 append_tokens_without_splicing (dest
, &tok
);
1478 /* Just for aesthetics. If there was any trailing whitespace in
1479 src, copy it to dest. */
1482 appendmem (dest
, src
->text
, src
->len
);
1483 dest
->last_token
= dest
->len
;
1489 macro_expand (const char *source
,
1490 macro_lookup_ftype
*lookup_func
,
1491 void *lookup_func_baton
)
1493 struct macro_buffer src
, dest
;
1494 struct cleanup
*back_to
;
1496 init_shared_buffer (&src
, source
, strlen (source
));
1498 init_buffer (&dest
, 0);
1499 dest
.last_token
= 0;
1500 back_to
= make_cleanup (cleanup_macro_buffer
, &dest
);
1502 scan (&dest
, &src
, 0, lookup_func
, lookup_func_baton
);
1504 appendc (&dest
, '\0');
1506 discard_cleanups (back_to
);
1512 macro_expand_once (const char *source
,
1513 macro_lookup_ftype
*lookup_func
,
1514 void *lookup_func_baton
)
1516 error (_("Expand-once not implemented yet."));
1521 macro_expand_next (const char **lexptr
,
1522 macro_lookup_ftype
*lookup_func
,
1525 struct macro_buffer src
, dest
, tok
;
1526 struct cleanup
*back_to
;
1528 /* Set up SRC to refer to the input text, pointed to by *lexptr. */
1529 init_shared_buffer (&src
, *lexptr
, strlen (*lexptr
));
1531 /* Set up DEST to receive the expansion, if there is one. */
1532 init_buffer (&dest
, 0);
1533 dest
.last_token
= 0;
1534 back_to
= make_cleanup (cleanup_macro_buffer
, &dest
);
1536 /* Get the text's first preprocessing token. */
1537 if (! get_token (&tok
, &src
))
1539 do_cleanups (back_to
);
1543 /* If it's a macro invocation, expand it. */
1544 if (maybe_expand (&dest
, &tok
, &src
, 0, lookup_func
, lookup_baton
))
1546 /* It was a macro invocation! Package up the expansion as a
1547 null-terminated string and return it. Set *lexptr to the
1548 start of the next token in the input. */
1549 appendc (&dest
, '\0');
1550 discard_cleanups (back_to
);
1556 /* It wasn't a macro invocation. */
1557 do_cleanups (back_to
);