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, and we shouldn't reallocate it. */
59 /* For detecting token splicing.
61 This is the index in TEXT of the first character of the token
62 that abuts the end of TEXT. If TEXT contains no tokens, then we
63 set this equal to LEN. If TEXT ends in whitespace, then there is
64 no token abutting the end of TEXT (it's just whitespace), and
65 again, we set this equal to LEN. We set this to -1 if we don't
66 know the nature of TEXT. */
69 /* If this buffer is holding the result from get_token, then this
70 is non-zero if it is an identifier token, zero otherwise. */
75 /* Set the macro buffer *B to the empty string, guessing that its
76 final contents will fit in N bytes. (It'll get resized if it
77 doesn't, so the guess doesn't have to be right.) Allocate the
78 initial storage with xmalloc. */
80 init_buffer (struct macro_buffer *b, int n)
84 b->text = (char *) xmalloc (n);
93 /* Set the macro buffer *BUF to refer to the LEN bytes at ADDR, as a
96 init_shared_buffer (struct macro_buffer *buf, char *addr, int len)
102 buf->last_token = -1;
106 /* Free the text of the buffer B. Raise an error if B is shared. */
108 free_buffer (struct macro_buffer *b)
110 gdb_assert (! b->shared);
115 /* Like free_buffer, but return the text as an xstrdup()d string.
116 This only exists to try to make the API relatively clean. */
119 free_buffer_return_text (struct macro_buffer *b)
121 gdb_assert (! b->shared);
122 gdb_assert (b->size);
127 /* A cleanup function for macro buffers. */
129 cleanup_macro_buffer (void *untyped_buf)
131 free_buffer ((struct macro_buffer *) untyped_buf);
135 /* Resize the buffer B to be at least N bytes long. Raise an error if
136 B shouldn't be resized. */
138 resize_buffer (struct macro_buffer *b, int n)
140 /* We shouldn't be trying to resize shared strings. */
141 gdb_assert (! b->shared);
149 b->text = (char *) xrealloc (b->text, b->size);
153 /* Append the character C to the buffer B. */
155 appendc (struct macro_buffer *b, int c)
157 int new_len = b->len + 1;
159 if (new_len > b->size)
160 resize_buffer (b, new_len);
167 /* Append the LEN bytes at ADDR to the buffer B. */
169 appendmem (struct macro_buffer *b, char *addr, int len)
171 int new_len = b->len + len;
173 if (new_len > b->size)
174 resize_buffer (b, new_len);
176 memcpy (b->text + b->len, addr, len);
182 /* Recognizing preprocessor tokens. */
186 macro_is_whitespace (int c)
197 macro_is_digit (int c)
199 return ('0' <= c && c <= '9');
204 macro_is_identifier_nondigit (int c)
207 || ('a' <= c && c <= 'z')
208 || ('A' <= c && c <= 'Z'));
213 set_token (struct macro_buffer *tok, char *start, char *end)
215 init_shared_buffer (tok, start, end - start);
218 /* Presumed; get_identifier may overwrite this. */
219 tok->is_identifier = 0;
224 get_comment (struct macro_buffer *tok, char *p, char *end)
241 set_token (tok, tok_start, p);
245 error (_("Unterminated comment in macro expansion."));
257 set_token (tok, tok_start, p);
266 get_identifier (struct macro_buffer *tok, char *p, char *end)
269 && macro_is_identifier_nondigit (*p))
274 && (macro_is_identifier_nondigit (*p)
275 || macro_is_digit (*p)))
278 set_token (tok, tok_start, p);
279 tok->is_identifier = 1;
288 get_pp_number (struct macro_buffer *tok, char *p, char *end)
291 && (macro_is_digit (*p)
294 && macro_is_digit (p[1]))))
301 && strchr ("eEpP", *p)
302 && (p[1] == '+' || p[1] == '-'))
304 else if (macro_is_digit (*p)
305 || macro_is_identifier_nondigit (*p)
312 set_token (tok, tok_start, p);
321 /* If the text starting at P going up to (but not including) END
322 starts with a character constant, set *TOK to point to that
323 character constant, and return 1. Otherwise, return zero.
324 Signal an error if it contains a malformed or incomplete character
327 get_character_constant (struct macro_buffer *tok, char *p, char *end)
329 /* ISO/IEC 9899:1999 (E) Section 6.4.4.4 paragraph 1
330 But of course, what really matters is that we handle it the same
331 way GDB's C/C++ lexer does. So we call parse_escape in utils.c
332 to handle escape sequences. */
333 if ((p + 1 <= end && *p == '\'')
335 && (p[0] == 'L' || p[0] == 'u' || p[0] == 'U')
343 else if (*p == 'L' || *p == 'u' || *p == 'U')
346 gdb_assert_not_reached ("unexpected character constant");
351 error (_("Unmatched single quote."));
355 error (_("A character constant must contain at least one "
365 char_count += c_parse_escape (&s, NULL);
375 set_token (tok, tok_start, p);
383 /* If the text starting at P going up to (but not including) END
384 starts with a string literal, set *TOK to point to that string
385 literal, and return 1. Otherwise, return zero. Signal an error if
386 it contains a malformed or incomplete string literal. */
388 get_string_literal (struct macro_buffer *tok, char *p, char *end)
393 && (p[0] == 'L' || p[0] == 'u' || p[0] == 'U')
400 else if (*p == 'L' || *p == 'u' || *p == 'U')
403 gdb_assert_not_reached ("unexpected string literal");
408 error (_("Unterminated string in expression."));
415 error (_("Newline characters may not appear in string "
422 c_parse_escape (&s, NULL);
429 set_token (tok, tok_start, p);
438 get_punctuator (struct macro_buffer *tok, char *p, char *end)
440 /* Here, speed is much less important than correctness and clarity. */
442 /* ISO/IEC 9899:1999 (E) Section 6.4.6 Paragraph 1.
443 Note that this table is ordered in a special way. A punctuator
444 which is a prefix of another punctuator must appear after its
445 "extension". Otherwise, the wrong token will be returned. */
446 static const char * const punctuators[] = {
447 "[", "]", "(", ")", "{", "}", "?", ";", ",", "~",
449 "->", "--", "-=", "-",
455 "%>", "%:%:", "%:", "%=", "%",
460 "<<=", "<<", "<=", "<:", "<%", "<",
461 ">>=", ">>", ">=", ">",
470 for (i = 0; punctuators[i]; i++)
472 const char *punctuator = punctuators[i];
474 if (p[0] == punctuator[0])
476 int len = strlen (punctuator);
479 && ! memcmp (p, punctuator, len))
481 set_token (tok, p, p + len);
492 /* Peel the next preprocessor token off of SRC, and put it in TOK.
493 Mutate TOK to refer to the first token in SRC, and mutate SRC to
494 refer to the text after that token. SRC must be a shared buffer;
495 the resulting TOK will be shared, pointing into the same string SRC
496 does. Initialize TOK's last_token field. Return non-zero if we
497 succeed, or 0 if we didn't find any more tokens in SRC. */
499 get_token (struct macro_buffer *tok,
500 struct macro_buffer *src)
503 char *end = p + src->len;
505 gdb_assert (src->shared);
507 /* From the ISO C standard, ISO/IEC 9899:1999 (E), section 6.4:
516 each non-white-space character that cannot be one of the above
518 We don't have to deal with header-name tokens, since those can
519 only occur after a #include, which we will never see. */
522 if (macro_is_whitespace (*p))
524 else if (get_comment (tok, p, end))
526 else if (get_pp_number (tok, p, end)
527 || get_character_constant (tok, p, end)
528 || get_string_literal (tok, p, end)
529 /* Note: the grammar in the standard seems to be
530 ambiguous: L'x' can be either a wide character
531 constant, or an identifier followed by a normal
532 character constant. By trying `get_identifier' after
533 we try get_character_constant and get_string_literal,
534 we give the wide character syntax precedence. Now,
535 since GDB doesn't handle wide character constants
536 anyway, is this the right thing to do? */
537 || get_identifier (tok, p, end)
538 || get_punctuator (tok, p, end))
540 /* How many characters did we consume, including whitespace? */
541 int consumed = p - src->text + tok->len;
543 src->text += consumed;
544 src->len -= consumed;
549 /* We have found a "non-whitespace character that cannot be
550 one of the above." Make a token out of it. */
553 set_token (tok, p, p + 1);
554 consumed = p - src->text + tok->len;
555 src->text += consumed;
556 src->len -= consumed;
565 /* Appending token strings, with and without splicing */
568 /* Append the macro buffer SRC to the end of DEST, and ensure that
569 doing so doesn't splice the token at the end of SRC with the token
570 at the beginning of DEST. SRC and DEST must have their last_token
571 fields set. Upon return, DEST's last_token field is set correctly.
575 If DEST is "(" and SRC is "y", then we can return with
576 DEST set to "(y" --- we've simply appended the two buffers.
578 However, if DEST is "x" and SRC is "y", then we must not return
579 with DEST set to "xy" --- that would splice the two tokens "x" and
580 "y" together to make a single token "xy". However, it would be
581 fine to return with DEST set to "x y". Similarly, "<" and "<" must
582 yield "< <", not "<<", etc. */
584 append_tokens_without_splicing (struct macro_buffer *dest,
585 struct macro_buffer *src)
587 int original_dest_len = dest->len;
588 struct macro_buffer dest_tail, new_token;
590 gdb_assert (src->last_token != -1);
591 gdb_assert (dest->last_token != -1);
593 /* First, just try appending the two, and call get_token to see if
595 appendmem (dest, src->text, src->len);
597 /* If DEST originally had no token abutting its end, then we can't
598 have spliced anything, so we're done. */
599 if (dest->last_token == original_dest_len)
601 dest->last_token = original_dest_len + src->last_token;
605 /* Set DEST_TAIL to point to the last token in DEST, followed by
606 all the stuff we just appended. */
607 init_shared_buffer (&dest_tail,
608 dest->text + dest->last_token,
609 dest->len - dest->last_token);
611 /* Re-parse DEST's last token. We know that DEST used to contain
612 at least one token, so if it doesn't contain any after the
613 append, then we must have spliced "/" and "*" or "/" and "/" to
614 make a comment start. (Just for the record, I got this right
615 the first time. This is not a bug fix.) */
616 if (get_token (&new_token, &dest_tail)
617 && (new_token.text + new_token.len
618 == dest->text + original_dest_len))
620 /* No splice, so we're done. */
621 dest->last_token = original_dest_len + src->last_token;
625 /* Okay, a simple append caused a splice. Let's chop dest back to
626 its original length and try again, but separate the texts with a
628 dest->len = original_dest_len;
630 appendmem (dest, src->text, src->len);
632 init_shared_buffer (&dest_tail,
633 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 appendc (dest, '\\');
688 appendc (dest, *arg);
691 appendc (dest, *arg);
696 dest->last_token = dest->len;
699 /* See macroexp.h. */
702 macro_stringify (const char *str)
704 struct macro_buffer buffer;
705 int len = strlen (str);
707 init_buffer (&buffer, len);
708 stringify (&buffer, str, len);
709 appendc (&buffer, '\0');
711 return free_buffer_return_text (&buffer);
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 zero, leave SRC unchanged, and don't set *ARGC_P 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 a pointer to the first element of an array of
769 macro buffers referring to the argument texts, and set *ARGC_P to
770 the number of arguments we found --- the number of elements in the
771 array. The macro buffers share their text with SRC, and their
772 last_token fields are initialized. The array is allocated with
773 xmalloc, and the caller is responsible for freeing it.
775 NOTE WELL: if SRC starts with a open paren ( token followed
776 immediately by a close paren ) token (e.g., the invocation looks
777 like "foo()"), we treat that as one argument, which happens to be
778 the empty list of tokens. The caller should keep in mind that such
779 a sequence of tokens is a valid way to invoke one-parameter
780 function-like macros, but also a valid way to invoke zero-parameter
781 function-like macros. Eeew.
783 Consume the tokens from SRC; after this call, SRC contains the text
784 following the invocation. */
786 static struct macro_buffer *
787 gather_arguments (const char *name, struct macro_buffer *src,
788 int nargs, int *argc_p)
790 struct macro_buffer tok;
791 int args_len, args_size;
792 struct macro_buffer *args = NULL;
793 struct cleanup *back_to = make_cleanup (free_current_contents, &args);
795 /* Does SRC start with an opening paren token? Read from a copy of
796 SRC, so SRC itself is unaffected if we don't find an opening
799 struct macro_buffer temp;
801 init_shared_buffer (&temp, src->text, src->len);
803 if (! get_token (&tok, &temp)
805 || tok.text[0] != '(')
807 discard_cleanups (back_to);
812 /* Consume SRC's opening paren. */
813 get_token (&tok, src);
817 args = XNEWVEC (struct macro_buffer, args_size);
821 struct macro_buffer *arg;
824 /* Make sure we have room for the next argument. */
825 if (args_len >= args_size)
828 args = XRESIZEVEC (struct macro_buffer, args, args_size);
831 /* Initialize the next argument. */
832 arg = &args[args_len++];
833 set_token (arg, src->text, src->text);
835 /* Gather the argument's tokens. */
839 if (! get_token (&tok, src))
840 error (_("Malformed argument list for macro `%s'."), name);
842 /* Is tok an opening paren? */
843 if (tok.len == 1 && tok.text[0] == '(')
846 /* Is tok is a closing paren? */
847 else if (tok.len == 1 && tok.text[0] == ')')
849 /* If it's a closing paren at the top level, then that's
850 the end of the argument list. */
853 /* In the varargs case, the last argument may be
854 missing. Add an empty argument in this case. */
855 if (nargs != -1 && args_len == nargs - 1)
857 /* Make sure we have room for the argument. */
858 if (args_len >= args_size)
861 args = XRESIZEVEC (struct macro_buffer, args,
864 arg = &args[args_len++];
865 set_token (arg, src->text, src->text);
868 discard_cleanups (back_to);
876 /* If tok is a comma at top level, then that's the end of
877 the current argument. However, if we are handling a
878 variadic macro and we are computing the last argument, we
879 want to include the comma and remaining tokens. */
880 else if (tok.len == 1 && tok.text[0] == ',' && depth == 0
881 && (nargs == -1 || args_len < nargs))
884 /* Extend the current argument to enclose this token. If
885 this is the current argument's first token, leave out any
886 leading whitespace, just for aesthetics. */
889 arg->text = tok.text;
895 arg->len = (tok.text + tok.len) - arg->text;
896 arg->last_token = tok.text - arg->text;
903 /* The `expand' and `substitute_args' functions both invoke `scan'
904 recursively, so we need a forward declaration somewhere. */
905 static void scan (struct macro_buffer *dest,
906 struct macro_buffer *src,
907 struct macro_name_list *no_loop,
908 macro_lookup_ftype *lookup_func,
912 /* A helper function for substitute_args.
914 ARGV is a vector of all the arguments; ARGC is the number of
915 arguments. IS_VARARGS is true if the macro being substituted is a
916 varargs macro; in this case VA_ARG_NAME is the name of the
917 "variable" argument. VA_ARG_NAME is ignored if IS_VARARGS is
920 If the token TOK is the name of a parameter, return the parameter's
921 index. If TOK is not an argument, return -1. */
924 find_parameter (const struct macro_buffer *tok,
925 int is_varargs, const struct macro_buffer *va_arg_name,
926 int argc, const char * const *argv)
930 if (! tok->is_identifier)
933 for (i = 0; i < argc; ++i)
934 if (tok->len == strlen (argv[i])
935 && !memcmp (tok->text, argv[i], tok->len))
938 if (is_varargs && tok->len == va_arg_name->len
939 && ! memcmp (tok->text, va_arg_name->text, tok->len))
945 /* Given the macro definition DEF, being invoked with the actual
946 arguments given by ARGC and ARGV, substitute the arguments into the
947 replacement list, and store the result in DEST.
949 IS_VARARGS should be true if DEF is a varargs macro. In this case,
950 VA_ARG_NAME should be the name of the "variable" argument -- either
951 __VA_ARGS__ for c99-style varargs, or the final argument name, for
952 GNU-style varargs. If IS_VARARGS is false, this parameter is
955 If it is necessary to expand macro invocations in one of the
956 arguments, use LOOKUP_FUNC and LOOKUP_BATON to find the macro
957 definitions, and don't expand invocations of the macros listed in
961 substitute_args (struct macro_buffer *dest,
962 struct macro_definition *def,
963 int is_varargs, const struct macro_buffer *va_arg_name,
964 int argc, struct macro_buffer *argv,
965 struct macro_name_list *no_loop,
966 macro_lookup_ftype *lookup_func,
969 /* A macro buffer for the macro's replacement list. */
970 struct macro_buffer replacement_list;
971 /* The token we are currently considering. */
972 struct macro_buffer tok;
973 /* The replacement list's pointer from just before TOK was lexed. */
974 char *original_rl_start;
975 /* We have a single lookahead token to handle token splicing. */
976 struct macro_buffer lookahead;
977 /* The lookahead token might not be valid. */
979 /* The replacement list's pointer from just before LOOKAHEAD was
981 char *lookahead_rl_start;
983 init_shared_buffer (&replacement_list, (char *) def->replacement,
984 strlen (def->replacement));
986 gdb_assert (dest->len == 0);
987 dest->last_token = 0;
989 original_rl_start = replacement_list.text;
990 if (! get_token (&tok, &replacement_list))
992 lookahead_rl_start = replacement_list.text;
993 lookahead_valid = get_token (&lookahead, &replacement_list);
997 /* Just for aesthetics. If we skipped some whitespace, copy
999 if (tok.text > original_rl_start)
1001 appendmem (dest, original_rl_start, tok.text - original_rl_start);
1002 dest->last_token = dest->len;
1005 /* Is this token the stringification operator? */
1007 && tok.text[0] == '#')
1011 if (!lookahead_valid)
1012 error (_("Stringification operator requires an argument."));
1014 arg = find_parameter (&lookahead, is_varargs, va_arg_name,
1015 def->argc, def->argv);
1017 error (_("Argument to stringification operator must name "
1018 "a macro parameter."));
1020 stringify (dest, argv[arg].text, argv[arg].len);
1022 /* Read one token and let the loop iteration code handle the
1024 lookahead_rl_start = replacement_list.text;
1025 lookahead_valid = get_token (&lookahead, &replacement_list);
1027 /* Is this token the splicing operator? */
1028 else if (tok.len == 2
1029 && tok.text[0] == '#'
1030 && tok.text[1] == '#')
1031 error (_("Stray splicing operator"));
1032 /* Is the next token the splicing operator? */
1033 else if (lookahead_valid
1034 && lookahead.len == 2
1035 && lookahead.text[0] == '#'
1036 && lookahead.text[1] == '#')
1039 int prev_was_comma = 0;
1041 /* Note that GCC warns if the result of splicing is not a
1042 token. In the debugger there doesn't seem to be much
1043 benefit from doing this. */
1045 /* Insert the first token. */
1046 if (tok.len == 1 && tok.text[0] == ',')
1050 int arg = find_parameter (&tok, is_varargs, va_arg_name,
1051 def->argc, def->argv);
1054 appendmem (dest, argv[arg].text, argv[arg].len);
1056 appendmem (dest, tok.text, tok.len);
1059 /* Apply a possible sequence of ## operators. */
1062 if (! get_token (&tok, &replacement_list))
1063 error (_("Splicing operator at end of macro"));
1065 /* Handle a comma before a ##. If we are handling
1066 varargs, and the token on the right hand side is the
1067 varargs marker, and the final argument is empty or
1068 missing, then drop the comma. This is a GNU
1069 extension. There is one ambiguous case here,
1070 involving pedantic behavior with an empty argument,
1071 but we settle that in favor of GNU-style (GCC uses an
1072 option). If we aren't dealing with varargs, we
1073 simply insert the comma. */
1077 && tok.len == va_arg_name->len
1078 && !memcmp (tok.text, va_arg_name->text, tok.len)
1079 && argv[argc - 1].len == 0))
1080 appendmem (dest, ",", 1);
1084 /* Insert the token. If it is a parameter, insert the
1085 argument. If it is a comma, treat it specially. */
1086 if (tok.len == 1 && tok.text[0] == ',')
1090 int arg = find_parameter (&tok, is_varargs, va_arg_name,
1091 def->argc, def->argv);
1094 appendmem (dest, argv[arg].text, argv[arg].len);
1096 appendmem (dest, tok.text, tok.len);
1099 /* Now read another token. If it is another splice, we
1101 original_rl_start = replacement_list.text;
1102 if (! get_token (&tok, &replacement_list))
1109 && tok.text[0] == '#'
1110 && tok.text[1] == '#'))
1116 /* We saw a comma. Insert it now. */
1117 appendmem (dest, ",", 1);
1120 dest->last_token = dest->len;
1122 lookahead_valid = 0;
1125 /* Set up for the loop iterator. */
1127 lookahead_rl_start = original_rl_start;
1128 lookahead_valid = 1;
1133 /* Is this token an identifier? */
1134 int substituted = 0;
1135 int arg = find_parameter (&tok, is_varargs, va_arg_name,
1136 def->argc, def->argv);
1140 struct macro_buffer arg_src;
1142 /* Expand any macro invocations in the argument text,
1143 and append the result to dest. Remember that scan
1144 mutates its source, so we need to scan a new buffer
1145 referring to the argument's text, not the argument
1147 init_shared_buffer (&arg_src, argv[arg].text, argv[arg].len);
1148 scan (dest, &arg_src, no_loop, lookup_func, lookup_baton);
1152 /* If it wasn't a parameter, then just copy it across. */
1154 append_tokens_without_splicing (dest, &tok);
1157 if (! lookahead_valid)
1161 original_rl_start = lookahead_rl_start;
1163 lookahead_rl_start = replacement_list.text;
1164 lookahead_valid = get_token (&lookahead, &replacement_list);
1169 /* Expand a call to a macro named ID, whose definition is DEF. Append
1170 its expansion to DEST. SRC is the input text following the ID
1171 token. We are currently rescanning the expansions of the macros
1172 named in NO_LOOP; don't re-expand them. Use LOOKUP_FUNC and
1173 LOOKUP_BATON to find definitions for any nested macro references.
1175 Return 1 if we decided to expand it, zero otherwise. (If it's a
1176 function-like macro name that isn't followed by an argument list,
1177 we don't expand it.) If we return zero, leave SRC unchanged. */
1179 expand (const char *id,
1180 struct macro_definition *def,
1181 struct macro_buffer *dest,
1182 struct macro_buffer *src,
1183 struct macro_name_list *no_loop,
1184 macro_lookup_ftype *lookup_func,
1187 struct macro_name_list new_no_loop;
1189 /* Create a new node to be added to the front of the no-expand list.
1190 This list is appropriate for re-scanning replacement lists, but
1191 it is *not* appropriate for scanning macro arguments; invocations
1192 of the macro whose arguments we are gathering *do* get expanded
1194 new_no_loop.name = id;
1195 new_no_loop.next = no_loop;
1197 /* What kind of macro are we expanding? */
1198 if (def->kind == macro_object_like)
1200 struct macro_buffer replacement_list;
1202 init_shared_buffer (&replacement_list, (char *) def->replacement,
1203 strlen (def->replacement));
1205 scan (dest, &replacement_list, &new_no_loop, lookup_func, lookup_baton);
1208 else if (def->kind == macro_function_like)
1210 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
1212 struct macro_buffer *argv = NULL;
1213 struct macro_buffer substituted;
1214 struct macro_buffer substituted_src;
1215 struct macro_buffer va_arg_name = {0};
1220 if (strcmp (def->argv[def->argc - 1], "...") == 0)
1222 /* In C99-style varargs, substitution is done using
1224 init_shared_buffer (&va_arg_name, "__VA_ARGS__",
1225 strlen ("__VA_ARGS__"));
1230 int len = strlen (def->argv[def->argc - 1]);
1233 && strcmp (def->argv[def->argc - 1] + len - 3, "...") == 0)
1235 /* In GNU-style varargs, the name of the
1236 substitution parameter is the name of the formal
1237 argument without the "...". */
1238 init_shared_buffer (&va_arg_name,
1239 (char *) def->argv[def->argc - 1],
1246 make_cleanup (free_current_contents, &argv);
1247 argv = gather_arguments (id, src, is_varargs ? def->argc : -1,
1250 /* If we couldn't find any argument list, then we don't expand
1254 do_cleanups (back_to);
1258 /* Check that we're passing an acceptable number of arguments for
1260 if (argc != def->argc)
1262 if (is_varargs && argc >= def->argc - 1)
1266 /* Remember that a sequence of tokens like "foo()" is a
1267 valid invocation of a macro expecting either zero or one
1269 else if (! (argc == 1
1272 error (_("Wrong number of arguments to macro `%s' "
1273 "(expected %d, got %d)."),
1274 id, def->argc, argc);
1277 /* Note that we don't expand macro invocations in the arguments
1278 yet --- we let subst_args take care of that. Parameters that
1279 appear as operands of the stringifying operator "#" or the
1280 splicing operator "##" don't get macro references expanded,
1281 so we can't really tell whether it's appropriate to macro-
1282 expand an argument until we see how it's being used. */
1283 init_buffer (&substituted, 0);
1284 make_cleanup (cleanup_macro_buffer, &substituted);
1285 substitute_args (&substituted, def, is_varargs, &va_arg_name,
1286 argc, argv, no_loop, lookup_func, lookup_baton);
1288 /* Now `substituted' is the macro's replacement list, with all
1289 argument values substituted into it properly. Re-scan it for
1290 macro references, but don't expand invocations of this macro.
1292 We create a new buffer, `substituted_src', which points into
1293 `substituted', and scan that. We can't scan `substituted'
1294 itself, since the tokenization process moves the buffer's
1295 text pointer around, and we still need to be able to find
1296 `substituted's original text buffer after scanning it so we
1298 init_shared_buffer (&substituted_src, substituted.text, substituted.len);
1299 scan (dest, &substituted_src, &new_no_loop, lookup_func, lookup_baton);
1301 do_cleanups (back_to);
1306 internal_error (__FILE__, __LINE__, _("bad macro definition kind"));
1310 /* If the single token in SRC_FIRST followed by the tokens in SRC_REST
1311 constitute a macro invokation not forbidden in NO_LOOP, append its
1312 expansion to DEST and return non-zero. Otherwise, return zero, and
1313 leave DEST unchanged.
1315 SRC_FIRST and SRC_REST must be shared buffers; DEST must not be one.
1316 SRC_FIRST must be a string built by get_token. */
1318 maybe_expand (struct macro_buffer *dest,
1319 struct macro_buffer *src_first,
1320 struct macro_buffer *src_rest,
1321 struct macro_name_list *no_loop,
1322 macro_lookup_ftype *lookup_func,
1325 gdb_assert (src_first->shared);
1326 gdb_assert (src_rest->shared);
1327 gdb_assert (! dest->shared);
1329 /* Is this token an identifier? */
1330 if (src_first->is_identifier)
1332 /* Make a null-terminated copy of it, since that's what our
1333 lookup function expects. */
1334 char *id = (char *) xmalloc (src_first->len + 1);
1335 struct cleanup *back_to = make_cleanup (xfree, id);
1337 memcpy (id, src_first->text, src_first->len);
1338 id[src_first->len] = 0;
1340 /* If we're currently re-scanning the result of expanding
1341 this macro, don't expand it again. */
1342 if (! currently_rescanning (no_loop, id))
1344 /* Does this identifier have a macro definition in scope? */
1345 struct macro_definition *def = lookup_func (id, lookup_baton);
1347 if (def && expand (id, def, dest, src_rest, no_loop,
1348 lookup_func, lookup_baton))
1350 do_cleanups (back_to);
1355 do_cleanups (back_to);
1362 /* Expand macro references in SRC, appending the results to DEST.
1363 Assume we are re-scanning the result of expanding the macros named
1364 in NO_LOOP, and don't try to re-expand references to them.
1366 SRC must be a shared buffer; DEST must not be one. */
1368 scan (struct macro_buffer *dest,
1369 struct macro_buffer *src,
1370 struct macro_name_list *no_loop,
1371 macro_lookup_ftype *lookup_func,
1374 gdb_assert (src->shared);
1375 gdb_assert (! dest->shared);
1379 struct macro_buffer tok;
1380 char *original_src_start = src->text;
1382 /* Find the next token in SRC. */
1383 if (! get_token (&tok, src))
1386 /* Just for aesthetics. If we skipped some whitespace, copy
1388 if (tok.text > original_src_start)
1390 appendmem (dest, original_src_start, tok.text - original_src_start);
1391 dest->last_token = dest->len;
1394 if (! maybe_expand (dest, &tok, src, no_loop, lookup_func, lookup_baton))
1395 /* We didn't end up expanding tok as a macro reference, so
1396 simply append it to dest. */
1397 append_tokens_without_splicing (dest, &tok);
1400 /* Just for aesthetics. If there was any trailing whitespace in
1401 src, copy it to dest. */
1404 appendmem (dest, src->text, src->len);
1405 dest->last_token = dest->len;
1411 macro_expand (const char *source,
1412 macro_lookup_ftype *lookup_func,
1413 void *lookup_func_baton)
1415 struct macro_buffer src, dest;
1416 struct cleanup *back_to;
1418 init_shared_buffer (&src, (char *) source, strlen (source));
1420 init_buffer (&dest, 0);
1421 dest.last_token = 0;
1422 back_to = make_cleanup (cleanup_macro_buffer, &dest);
1424 scan (&dest, &src, 0, lookup_func, lookup_func_baton);
1426 appendc (&dest, '\0');
1428 discard_cleanups (back_to);
1434 macro_expand_once (const char *source,
1435 macro_lookup_ftype *lookup_func,
1436 void *lookup_func_baton)
1438 error (_("Expand-once not implemented yet."));
1443 macro_expand_next (const char **lexptr,
1444 macro_lookup_ftype *lookup_func,
1447 struct macro_buffer src, dest, tok;
1448 struct cleanup *back_to;
1450 /* Set up SRC to refer to the input text, pointed to by *lexptr. */
1451 init_shared_buffer (&src, (char *) *lexptr, strlen (*lexptr));
1453 /* Set up DEST to receive the expansion, if there is one. */
1454 init_buffer (&dest, 0);
1455 dest.last_token = 0;
1456 back_to = make_cleanup (cleanup_macro_buffer, &dest);
1458 /* Get the text's first preprocessing token. */
1459 if (! get_token (&tok, &src))
1461 do_cleanups (back_to);
1465 /* If it's a macro invocation, expand it. */
1466 if (maybe_expand (&dest, &tok, &src, 0, lookup_func, lookup_baton))
1468 /* It was a macro invocation! Package up the expansion as a
1469 null-terminated string and return it. Set *lexptr to the
1470 start of the next token in the input. */
1471 appendc (&dest, '\0');
1472 discard_cleanups (back_to);
1478 /* It wasn't a macro invocation. */
1479 do_cleanups (back_to);