1488 lines
42 KiB
C
1488 lines
42 KiB
C
|
/* C preprocessor macro expansion for GDB.
|
|||
|
Copyright (C) 2002-2020 Free Software Foundation, Inc.
|
|||
|
Contributed by Red Hat, Inc.
|
|||
|
|
|||
|
This file is part of GDB.
|
|||
|
|
|||
|
This program is free software; you can redistribute it and/or modify
|
|||
|
it under the terms of the GNU General Public License as published by
|
|||
|
the Free Software Foundation; either version 3 of the License, or
|
|||
|
(at your option) any later version.
|
|||
|
|
|||
|
This program is distributed in the hope that it will be useful,
|
|||
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|||
|
GNU General Public License for more details.
|
|||
|
|
|||
|
You should have received a copy of the GNU General Public License
|
|||
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|||
|
|
|||
|
#include "defs.h"
|
|||
|
#include "gdb_obstack.h"
|
|||
|
#include "macrotab.h"
|
|||
|
#include "macroexp.h"
|
|||
|
#include "c-lang.h"
|
|||
|
|
|||
|
|
|||
|
|
|||
|
/* A resizeable, substringable string type. */
|
|||
|
|
|||
|
|
|||
|
/* A string type that we can resize, quickly append to, and use to
|
|||
|
refer to substrings of other strings. */
|
|||
|
struct macro_buffer
|
|||
|
{
|
|||
|
/* An array of characters. The first LEN bytes are the real text,
|
|||
|
but there are SIZE bytes allocated to the array. If SIZE is
|
|||
|
zero, then this doesn't point to a malloc'ed block. If SHARED is
|
|||
|
non-zero, then this buffer is actually a pointer into some larger
|
|||
|
string, and we shouldn't append characters to it, etc. Because
|
|||
|
of sharing, we can't assume in general that the text is
|
|||
|
null-terminated. */
|
|||
|
char *text;
|
|||
|
|
|||
|
/* The number of characters in the string. */
|
|||
|
int len;
|
|||
|
|
|||
|
/* The number of characters allocated to the string. If SHARED is
|
|||
|
non-zero, this is meaningless; in this case, we set it to zero so
|
|||
|
that any "do we have room to append something?" tests will fail,
|
|||
|
so we don't always have to check SHARED before using this field. */
|
|||
|
int size;
|
|||
|
|
|||
|
/* Zero if TEXT can be safely realloc'ed (i.e., it's its own malloc
|
|||
|
block). Non-zero if TEXT is actually pointing into the middle of
|
|||
|
some other block, or to a string literal, and we shouldn't
|
|||
|
reallocate it. */
|
|||
|
bool shared;
|
|||
|
|
|||
|
/* For detecting token splicing.
|
|||
|
|
|||
|
This is the index in TEXT of the first character of the token
|
|||
|
that abuts the end of TEXT. If TEXT contains no tokens, then we
|
|||
|
set this equal to LEN. If TEXT ends in whitespace, then there is
|
|||
|
no token abutting the end of TEXT (it's just whitespace), and
|
|||
|
again, we set this equal to LEN. We set this to -1 if we don't
|
|||
|
know the nature of TEXT. */
|
|||
|
int last_token = -1;
|
|||
|
|
|||
|
/* If this buffer is holding the result from get_token, then this
|
|||
|
is non-zero if it is an identifier token, zero otherwise. */
|
|||
|
int is_identifier = 0;
|
|||
|
|
|||
|
|
|||
|
macro_buffer ()
|
|||
|
: text (NULL),
|
|||
|
len (0),
|
|||
|
size (0),
|
|||
|
shared (false)
|
|||
|
{
|
|||
|
}
|
|||
|
|
|||
|
/* Set the macro buffer to the empty string, guessing that its
|
|||
|
final contents will fit in N bytes. (It'll get resized if it
|
|||
|
doesn't, so the guess doesn't have to be right.) Allocate the
|
|||
|
initial storage with xmalloc. */
|
|||
|
explicit macro_buffer (int n)
|
|||
|
: len (0),
|
|||
|
size (n),
|
|||
|
shared (false)
|
|||
|
{
|
|||
|
if (n > 0)
|
|||
|
text = (char *) xmalloc (n);
|
|||
|
else
|
|||
|
text = NULL;
|
|||
|
}
|
|||
|
|
|||
|
/* Set the macro buffer to refer to the LEN bytes at ADDR, as a
|
|||
|
shared substring. */
|
|||
|
macro_buffer (const char *addr, int len)
|
|||
|
{
|
|||
|
set_shared (addr, len);
|
|||
|
}
|
|||
|
|
|||
|
/* Set the macro buffer to refer to the LEN bytes at ADDR, as a
|
|||
|
shared substring. */
|
|||
|
void set_shared (const char *addr, int len_)
|
|||
|
{
|
|||
|
text = (char *) addr;
|
|||
|
len = len_;
|
|||
|
size = 0;
|
|||
|
shared = true;
|
|||
|
}
|
|||
|
|
|||
|
macro_buffer& operator= (const macro_buffer &src)
|
|||
|
{
|
|||
|
gdb_assert (src.shared);
|
|||
|
gdb_assert (shared);
|
|||
|
set_shared (src.text, src.len);
|
|||
|
last_token = src.last_token;
|
|||
|
is_identifier = src.is_identifier;
|
|||
|
return *this;
|
|||
|
}
|
|||
|
|
|||
|
~macro_buffer ()
|
|||
|
{
|
|||
|
if (! shared && size)
|
|||
|
xfree (text);
|
|||
|
}
|
|||
|
|
|||
|
/* Release the text of the buffer to the caller, which is now
|
|||
|
responsible for freeing it. */
|
|||
|
ATTRIBUTE_UNUSED_RESULT char *release ()
|
|||
|
{
|
|||
|
gdb_assert (! shared);
|
|||
|
gdb_assert (size);
|
|||
|
char *result = text;
|
|||
|
text = NULL;
|
|||
|
return result;
|
|||
|
}
|
|||
|
|
|||
|
/* Resize the buffer to be at least N bytes long. Raise an error if
|
|||
|
the buffer shouldn't be resized. */
|
|||
|
void resize_buffer (int n)
|
|||
|
{
|
|||
|
/* We shouldn't be trying to resize shared strings. */
|
|||
|
gdb_assert (! shared);
|
|||
|
|
|||
|
if (size == 0)
|
|||
|
size = n;
|
|||
|
else
|
|||
|
while (size <= n)
|
|||
|
size *= 2;
|
|||
|
|
|||
|
text = (char *) xrealloc (text, size);
|
|||
|
}
|
|||
|
|
|||
|
/* Append the character C to the buffer. */
|
|||
|
void appendc (int c)
|
|||
|
{
|
|||
|
int new_len = len + 1;
|
|||
|
|
|||
|
if (new_len > size)
|
|||
|
resize_buffer (new_len);
|
|||
|
|
|||
|
text[len] = c;
|
|||
|
len = new_len;
|
|||
|
}
|
|||
|
|
|||
|
/* Append the COUNT bytes at ADDR to the buffer. */
|
|||
|
void appendmem (const char *addr, int count)
|
|||
|
{
|
|||
|
int new_len = len + count;
|
|||
|
|
|||
|
if (new_len > size)
|
|||
|
resize_buffer (new_len);
|
|||
|
|
|||
|
memcpy (text + len, addr, count);
|
|||
|
len = new_len;
|
|||
|
}
|
|||
|
};
|
|||
|
|
|||
|
|
|||
|
|
|||
|
/* Recognizing preprocessor tokens. */
|
|||
|
|
|||
|
|
|||
|
int
|
|||
|
macro_is_whitespace (int c)
|
|||
|
{
|
|||
|
return (c == ' '
|
|||
|
|| c == '\t'
|
|||
|
|| c == '\n'
|
|||
|
|| c == '\v'
|
|||
|
|| c == '\f');
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
int
|
|||
|
macro_is_digit (int c)
|
|||
|
{
|
|||
|
return ('0' <= c && c <= '9');
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
int
|
|||
|
macro_is_identifier_nondigit (int c)
|
|||
|
{
|
|||
|
return (c == '_'
|
|||
|
|| ('a' <= c && c <= 'z')
|
|||
|
|| ('A' <= c && c <= 'Z'));
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
static void
|
|||
|
set_token (struct macro_buffer *tok, char *start, char *end)
|
|||
|
{
|
|||
|
tok->set_shared (start, end - start);
|
|||
|
tok->last_token = 0;
|
|||
|
|
|||
|
/* Presumed; get_identifier may overwrite this. */
|
|||
|
tok->is_identifier = 0;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
static int
|
|||
|
get_comment (struct macro_buffer *tok, char *p, char *end)
|
|||
|
{
|
|||
|
if (p + 2 > end)
|
|||
|
return 0;
|
|||
|
else if (p[0] == '/'
|
|||
|
&& p[1] == '*')
|
|||
|
{
|
|||
|
char *tok_start = p;
|
|||
|
|
|||
|
p += 2;
|
|||
|
|
|||
|
for (; p < end; p++)
|
|||
|
if (p + 2 <= end
|
|||
|
&& p[0] == '*'
|
|||
|
&& p[1] == '/')
|
|||
|
{
|
|||
|
p += 2;
|
|||
|
set_token (tok, tok_start, p);
|
|||
|
return 1;
|
|||
|
}
|
|||
|
|
|||
|
error (_("Unterminated comment in macro expansion."));
|
|||
|
}
|
|||
|
else if (p[0] == '/'
|
|||
|
&& p[1] == '/')
|
|||
|
{
|
|||
|
char *tok_start = p;
|
|||
|
|
|||
|
p += 2;
|
|||
|
for (; p < end; p++)
|
|||
|
if (*p == '\n')
|
|||
|
break;
|
|||
|
|
|||
|
set_token (tok, tok_start, p);
|
|||
|
return 1;
|
|||
|
}
|
|||
|
else
|
|||
|
return 0;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
static int
|
|||
|
get_identifier (struct macro_buffer *tok, char *p, char *end)
|
|||
|
{
|
|||
|
if (p < end
|
|||
|
&& macro_is_identifier_nondigit (*p))
|
|||
|
{
|
|||
|
char *tok_start = p;
|
|||
|
|
|||
|
while (p < end
|
|||
|
&& (macro_is_identifier_nondigit (*p)
|
|||
|
|| macro_is_digit (*p)))
|
|||
|
p++;
|
|||
|
|
|||
|
set_token (tok, tok_start, p);
|
|||
|
tok->is_identifier = 1;
|
|||
|
return 1;
|
|||
|
}
|
|||
|
else
|
|||
|
return 0;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
static int
|
|||
|
get_pp_number (struct macro_buffer *tok, char *p, char *end)
|
|||
|
{
|
|||
|
if (p < end
|
|||
|
&& (macro_is_digit (*p)
|
|||
|
|| (*p == '.'
|
|||
|
&& p + 2 <= end
|
|||
|
&& macro_is_digit (p[1]))))
|
|||
|
{
|
|||
|
char *tok_start = p;
|
|||
|
|
|||
|
while (p < end)
|
|||
|
{
|
|||
|
if (p + 2 <= end
|
|||
|
&& strchr ("eEpP", *p)
|
|||
|
&& (p[1] == '+' || p[1] == '-'))
|
|||
|
p += 2;
|
|||
|
else if (macro_is_digit (*p)
|
|||
|
|| macro_is_identifier_nondigit (*p)
|
|||
|
|| *p == '.')
|
|||
|
p++;
|
|||
|
else
|
|||
|
break;
|
|||
|
}
|
|||
|
|
|||
|
set_token (tok, tok_start, p);
|
|||
|
return 1;
|
|||
|
}
|
|||
|
else
|
|||
|
return 0;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
|
|||
|
/* If the text starting at P going up to (but not including) END
|
|||
|
starts with a character constant, set *TOK to point to that
|
|||
|
character constant, and return 1. Otherwise, return zero.
|
|||
|
Signal an error if it contains a malformed or incomplete character
|
|||
|
constant. */
|
|||
|
static int
|
|||
|
get_character_constant (struct macro_buffer *tok, char *p, char *end)
|
|||
|
{
|
|||
|
/* ISO/IEC 9899:1999 (E) Section 6.4.4.4 paragraph 1
|
|||
|
But of course, what really matters is that we handle it the same
|
|||
|
way GDB's C/C++ lexer does. So we call parse_escape in utils.c
|
|||
|
to handle escape sequences. */
|
|||
|
if ((p + 1 <= end && *p == '\'')
|
|||
|
|| (p + 2 <= end
|
|||
|
&& (p[0] == 'L' || p[0] == 'u' || p[0] == 'U')
|
|||
|
&& p[1] == '\''))
|
|||
|
{
|
|||
|
char *tok_start = p;
|
|||
|
int char_count = 0;
|
|||
|
|
|||
|
if (*p == '\'')
|
|||
|
p++;
|
|||
|
else if (*p == 'L' || *p == 'u' || *p == 'U')
|
|||
|
p += 2;
|
|||
|
else
|
|||
|
gdb_assert_not_reached ("unexpected character constant");
|
|||
|
|
|||
|
for (;;)
|
|||
|
{
|
|||
|
if (p >= end)
|
|||
|
error (_("Unmatched single quote."));
|
|||
|
else if (*p == '\'')
|
|||
|
{
|
|||
|
if (!char_count)
|
|||
|
error (_("A character constant must contain at least one "
|
|||
|
"character."));
|
|||
|
p++;
|
|||
|
break;
|
|||
|
}
|
|||
|
else if (*p == '\\')
|
|||
|
{
|
|||
|
const char *s, *o;
|
|||
|
|
|||
|
s = o = ++p;
|
|||
|
char_count += c_parse_escape (&s, NULL);
|
|||
|
p += s - o;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
p++;
|
|||
|
char_count++;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
set_token (tok, tok_start, p);
|
|||
|
return 1;
|
|||
|
}
|
|||
|
else
|
|||
|
return 0;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
/* If the text starting at P going up to (but not including) END
|
|||
|
starts with a string literal, set *TOK to point to that string
|
|||
|
literal, and return 1. Otherwise, return zero. Signal an error if
|
|||
|
it contains a malformed or incomplete string literal. */
|
|||
|
static int
|
|||
|
get_string_literal (struct macro_buffer *tok, char *p, char *end)
|
|||
|
{
|
|||
|
if ((p + 1 <= end
|
|||
|
&& *p == '"')
|
|||
|
|| (p + 2 <= end
|
|||
|
&& (p[0] == 'L' || p[0] == 'u' || p[0] == 'U')
|
|||
|
&& p[1] == '"'))
|
|||
|
{
|
|||
|
char *tok_start = p;
|
|||
|
|
|||
|
if (*p == '"')
|
|||
|
p++;
|
|||
|
else if (*p == 'L' || *p == 'u' || *p == 'U')
|
|||
|
p += 2;
|
|||
|
else
|
|||
|
gdb_assert_not_reached ("unexpected string literal");
|
|||
|
|
|||
|
for (;;)
|
|||
|
{
|
|||
|
if (p >= end)
|
|||
|
error (_("Unterminated string in expression."));
|
|||
|
else if (*p == '"')
|
|||
|
{
|
|||
|
p++;
|
|||
|
break;
|
|||
|
}
|
|||
|
else if (*p == '\n')
|
|||
|
error (_("Newline characters may not appear in string "
|
|||
|
"constants."));
|
|||
|
else if (*p == '\\')
|
|||
|
{
|
|||
|
const char *s, *o;
|
|||
|
|
|||
|
s = o = ++p;
|
|||
|
c_parse_escape (&s, NULL);
|
|||
|
p += s - o;
|
|||
|
}
|
|||
|
else
|
|||
|
p++;
|
|||
|
}
|
|||
|
|
|||
|
set_token (tok, tok_start, p);
|
|||
|
return 1;
|
|||
|
}
|
|||
|
else
|
|||
|
return 0;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
static int
|
|||
|
get_punctuator (struct macro_buffer *tok, char *p, char *end)
|
|||
|
{
|
|||
|
/* Here, speed is much less important than correctness and clarity. */
|
|||
|
|
|||
|
/* ISO/IEC 9899:1999 (E) Section 6.4.6 Paragraph 1.
|
|||
|
Note that this table is ordered in a special way. A punctuator
|
|||
|
which is a prefix of another punctuator must appear after its
|
|||
|
"extension". Otherwise, the wrong token will be returned. */
|
|||
|
static const char * const punctuators[] = {
|
|||
|
"[", "]", "(", ")", "{", "}", "?", ";", ",", "~",
|
|||
|
"...", ".",
|
|||
|
"->", "--", "-=", "-",
|
|||
|
"++", "+=", "+",
|
|||
|
"*=", "*",
|
|||
|
"!=", "!",
|
|||
|
"&&", "&=", "&",
|
|||
|
"/=", "/",
|
|||
|
"%>", "%:%:", "%:", "%=", "%",
|
|||
|
"^=", "^",
|
|||
|
"##", "#",
|
|||
|
":>", ":",
|
|||
|
"||", "|=", "|",
|
|||
|
"<<=", "<<", "<=", "<:", "<%", "<",
|
|||
|
">>=", ">>", ">=", ">",
|
|||
|
"==", "=",
|
|||
|
0
|
|||
|
};
|
|||
|
|
|||
|
int i;
|
|||
|
|
|||
|
if (p + 1 <= end)
|
|||
|
{
|
|||
|
for (i = 0; punctuators[i]; i++)
|
|||
|
{
|
|||
|
const char *punctuator = punctuators[i];
|
|||
|
|
|||
|
if (p[0] == punctuator[0])
|
|||
|
{
|
|||
|
int len = strlen (punctuator);
|
|||
|
|
|||
|
if (p + len <= end
|
|||
|
&& ! memcmp (p, punctuator, len))
|
|||
|
{
|
|||
|
set_token (tok, p, p + len);
|
|||
|
return 1;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
return 0;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
/* Peel the next preprocessor token off of SRC, and put it in TOK.
|
|||
|
Mutate TOK to refer to the first token in SRC, and mutate SRC to
|
|||
|
refer to the text after that token. SRC must be a shared buffer;
|
|||
|
the resulting TOK will be shared, pointing into the same string SRC
|
|||
|
does. Initialize TOK's last_token field. Return non-zero if we
|
|||
|
succeed, or 0 if we didn't find any more tokens in SRC. */
|
|||
|
static int
|
|||
|
get_token (struct macro_buffer *tok,
|
|||
|
struct macro_buffer *src)
|
|||
|
{
|
|||
|
char *p = src->text;
|
|||
|
char *end = p + src->len;
|
|||
|
|
|||
|
gdb_assert (src->shared);
|
|||
|
|
|||
|
/* From the ISO C standard, ISO/IEC 9899:1999 (E), section 6.4:
|
|||
|
|
|||
|
preprocessing-token:
|
|||
|
header-name
|
|||
|
identifier
|
|||
|
pp-number
|
|||
|
character-constant
|
|||
|
string-literal
|
|||
|
punctuator
|
|||
|
each non-white-space character that cannot be one of the above
|
|||
|
|
|||
|
We don't have to deal with header-name tokens, since those can
|
|||
|
only occur after a #include, which we will never see. */
|
|||
|
|
|||
|
while (p < end)
|
|||
|
if (macro_is_whitespace (*p))
|
|||
|
p++;
|
|||
|
else if (get_comment (tok, p, end))
|
|||
|
p += tok->len;
|
|||
|
else if (get_pp_number (tok, p, end)
|
|||
|
|| get_character_constant (tok, p, end)
|
|||
|
|| get_string_literal (tok, p, end)
|
|||
|
/* Note: the grammar in the standard seems to be
|
|||
|
ambiguous: L'x' can be either a wide character
|
|||
|
constant, or an identifier followed by a normal
|
|||
|
character constant. By trying `get_identifier' after
|
|||
|
we try get_character_constant and get_string_literal,
|
|||
|
we give the wide character syntax precedence. Now,
|
|||
|
since GDB doesn't handle wide character constants
|
|||
|
anyway, is this the right thing to do? */
|
|||
|
|| get_identifier (tok, p, end)
|
|||
|
|| get_punctuator (tok, p, end))
|
|||
|
{
|
|||
|
/* How many characters did we consume, including whitespace? */
|
|||
|
int consumed = p - src->text + tok->len;
|
|||
|
|
|||
|
src->text += consumed;
|
|||
|
src->len -= consumed;
|
|||
|
return 1;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
/* We have found a "non-whitespace character that cannot be
|
|||
|
one of the above." Make a token out of it. */
|
|||
|
int consumed;
|
|||
|
|
|||
|
set_token (tok, p, p + 1);
|
|||
|
consumed = p - src->text + tok->len;
|
|||
|
src->text += consumed;
|
|||
|
src->len -= consumed;
|
|||
|
return 1;
|
|||
|
}
|
|||
|
|
|||
|
return 0;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
|
|||
|
/* Appending token strings, with and without splicing */
|
|||
|
|
|||
|
|
|||
|
/* Append the macro buffer SRC to the end of DEST, and ensure that
|
|||
|
doing so doesn't splice the token at the end of SRC with the token
|
|||
|
at the beginning of DEST. SRC and DEST must have their last_token
|
|||
|
fields set. Upon return, DEST's last_token field is set correctly.
|
|||
|
|
|||
|
For example:
|
|||
|
|
|||
|
If DEST is "(" and SRC is "y", then we can return with
|
|||
|
DEST set to "(y" --- we've simply appended the two buffers.
|
|||
|
|
|||
|
However, if DEST is "x" and SRC is "y", then we must not return
|
|||
|
with DEST set to "xy" --- that would splice the two tokens "x" and
|
|||
|
"y" together to make a single token "xy". However, it would be
|
|||
|
fine to return with DEST set to "x y". Similarly, "<" and "<" must
|
|||
|
yield "< <", not "<<", etc. */
|
|||
|
static void
|
|||
|
append_tokens_without_splicing (struct macro_buffer *dest,
|
|||
|
struct macro_buffer *src)
|
|||
|
{
|
|||
|
int original_dest_len = dest->len;
|
|||
|
struct macro_buffer dest_tail, new_token;
|
|||
|
|
|||
|
gdb_assert (src->last_token != -1);
|
|||
|
gdb_assert (dest->last_token != -1);
|
|||
|
|
|||
|
/* First, just try appending the two, and call get_token to see if
|
|||
|
we got a splice. */
|
|||
|
dest->appendmem (src->text, src->len);
|
|||
|
|
|||
|
/* If DEST originally had no token abutting its end, then we can't
|
|||
|
have spliced anything, so we're done. */
|
|||
|
if (dest->last_token == original_dest_len)
|
|||
|
{
|
|||
|
dest->last_token = original_dest_len + src->last_token;
|
|||
|
return;
|
|||
|
}
|
|||
|
|
|||
|
/* Set DEST_TAIL to point to the last token in DEST, followed by
|
|||
|
all the stuff we just appended. */
|
|||
|
dest_tail.set_shared (dest->text + dest->last_token,
|
|||
|
dest->len - dest->last_token);
|
|||
|
|
|||
|
/* Re-parse DEST's last token. We know that DEST used to contain
|
|||
|
at least one token, so if it doesn't contain any after the
|
|||
|
append, then we must have spliced "/" and "*" or "/" and "/" to
|
|||
|
make a comment start. (Just for the record, I got this right
|
|||
|
the first time. This is not a bug fix.) */
|
|||
|
if (get_token (&new_token, &dest_tail)
|
|||
|
&& (new_token.text + new_token.len
|
|||
|
== dest->text + original_dest_len))
|
|||
|
{
|
|||
|
/* No splice, so we're done. */
|
|||
|
dest->last_token = original_dest_len + src->last_token;
|
|||
|
return;
|
|||
|
}
|
|||
|
|
|||
|
/* Okay, a simple append caused a splice. Let's chop dest back to
|
|||
|
its original length and try again, but separate the texts with a
|
|||
|
space. */
|
|||
|
dest->len = original_dest_len;
|
|||
|
dest->appendc (' ');
|
|||
|
dest->appendmem (src->text, src->len);
|
|||
|
|
|||
|
dest_tail.set_shared (dest->text + dest->last_token,
|
|||
|
dest->len - dest->last_token);
|
|||
|
|
|||
|
/* Try to re-parse DEST's last token, as above. */
|
|||
|
if (get_token (&new_token, &dest_tail)
|
|||
|
&& (new_token.text + new_token.len
|
|||
|
== dest->text + original_dest_len))
|
|||
|
{
|
|||
|
/* No splice, so we're done. */
|
|||
|
dest->last_token = original_dest_len + 1 + src->last_token;
|
|||
|
return;
|
|||
|
}
|
|||
|
|
|||
|
/* As far as I know, there's no case where inserting a space isn't
|
|||
|
enough to prevent a splice. */
|
|||
|
internal_error (__FILE__, __LINE__,
|
|||
|
_("unable to avoid splicing tokens during macro expansion"));
|
|||
|
}
|
|||
|
|
|||
|
/* Stringify an argument, and insert it into DEST. ARG is the text to
|
|||
|
stringify; it is LEN bytes long. */
|
|||
|
|
|||
|
static void
|
|||
|
stringify (struct macro_buffer *dest, const char *arg, int len)
|
|||
|
{
|
|||
|
/* Trim initial whitespace from ARG. */
|
|||
|
while (len > 0 && macro_is_whitespace (*arg))
|
|||
|
{
|
|||
|
++arg;
|
|||
|
--len;
|
|||
|
}
|
|||
|
|
|||
|
/* Trim trailing whitespace from ARG. */
|
|||
|
while (len > 0 && macro_is_whitespace (arg[len - 1]))
|
|||
|
--len;
|
|||
|
|
|||
|
/* Insert the string. */
|
|||
|
dest->appendc ('"');
|
|||
|
while (len > 0)
|
|||
|
{
|
|||
|
/* We could try to handle strange cases here, like control
|
|||
|
characters, but there doesn't seem to be much point. */
|
|||
|
if (macro_is_whitespace (*arg))
|
|||
|
{
|
|||
|
/* Replace a sequence of whitespace with a single space. */
|
|||
|
dest->appendc (' ');
|
|||
|
while (len > 1 && macro_is_whitespace (arg[1]))
|
|||
|
{
|
|||
|
++arg;
|
|||
|
--len;
|
|||
|
}
|
|||
|
}
|
|||
|
else if (*arg == '\\' || *arg == '"')
|
|||
|
{
|
|||
|
dest->appendc ('\\');
|
|||
|
dest->appendc (*arg);
|
|||
|
}
|
|||
|
else
|
|||
|
dest->appendc (*arg);
|
|||
|
++arg;
|
|||
|
--len;
|
|||
|
}
|
|||
|
dest->appendc ('"');
|
|||
|
dest->last_token = dest->len;
|
|||
|
}
|
|||
|
|
|||
|
/* See macroexp.h. */
|
|||
|
|
|||
|
char *
|
|||
|
macro_stringify (const char *str)
|
|||
|
{
|
|||
|
int len = strlen (str);
|
|||
|
struct macro_buffer buffer (len);
|
|||
|
|
|||
|
stringify (&buffer, str, len);
|
|||
|
buffer.appendc ('\0');
|
|||
|
|
|||
|
return buffer.release ();
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
/* Expanding macros! */
|
|||
|
|
|||
|
|
|||
|
/* A singly-linked list of the names of the macros we are currently
|
|||
|
expanding --- for detecting expansion loops. */
|
|||
|
struct macro_name_list {
|
|||
|
const char *name;
|
|||
|
struct macro_name_list *next;
|
|||
|
};
|
|||
|
|
|||
|
|
|||
|
/* Return non-zero if we are currently expanding the macro named NAME,
|
|||
|
according to LIST; otherwise, return zero.
|
|||
|
|
|||
|
You know, it would be possible to get rid of all the NO_LOOP
|
|||
|
arguments to these functions by simply generating a new lookup
|
|||
|
function and baton which refuses to find the definition for a
|
|||
|
particular macro, and otherwise delegates the decision to another
|
|||
|
function/baton pair. But that makes the linked list of excluded
|
|||
|
macros chained through untyped baton pointers, which will make it
|
|||
|
harder to debug. :( */
|
|||
|
static int
|
|||
|
currently_rescanning (struct macro_name_list *list, const char *name)
|
|||
|
{
|
|||
|
for (; list; list = list->next)
|
|||
|
if (strcmp (name, list->name) == 0)
|
|||
|
return 1;
|
|||
|
|
|||
|
return 0;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
/* Gather the arguments to a macro expansion.
|
|||
|
|
|||
|
NAME is the name of the macro being invoked. (It's only used for
|
|||
|
printing error messages.)
|
|||
|
|
|||
|
Assume that SRC is the text of the macro invocation immediately
|
|||
|
following the macro name. For example, if we're processing the
|
|||
|
text foo(bar, baz), then NAME would be foo and SRC will be (bar,
|
|||
|
baz).
|
|||
|
|
|||
|
If SRC doesn't start with an open paren ( token at all, return
|
|||
|
false, leave SRC unchanged, and don't set *ARGS_PTR to anything.
|
|||
|
|
|||
|
If SRC doesn't contain a properly terminated argument list, then
|
|||
|
raise an error.
|
|||
|
|
|||
|
For a variadic macro, NARGS holds the number of formal arguments to
|
|||
|
the macro. For a GNU-style variadic macro, this should be the
|
|||
|
number of named arguments. For a non-variadic macro, NARGS should
|
|||
|
be -1.
|
|||
|
|
|||
|
Otherwise, return true and set *ARGS_PTR to a vector of macro
|
|||
|
buffers referring to the argument texts. The macro buffers share
|
|||
|
their text with SRC, and their last_token fields are initialized.
|
|||
|
|
|||
|
NOTE WELL: if SRC starts with a open paren ( token followed
|
|||
|
immediately by a close paren ) token (e.g., the invocation looks
|
|||
|
like "foo()"), we treat that as one argument, which happens to be
|
|||
|
the empty list of tokens. The caller should keep in mind that such
|
|||
|
a sequence of tokens is a valid way to invoke one-parameter
|
|||
|
function-like macros, but also a valid way to invoke zero-parameter
|
|||
|
function-like macros. Eeew.
|
|||
|
|
|||
|
Consume the tokens from SRC; after this call, SRC contains the text
|
|||
|
following the invocation. */
|
|||
|
|
|||
|
static bool
|
|||
|
gather_arguments (const char *name, struct macro_buffer *src, int nargs,
|
|||
|
std::vector<struct macro_buffer> *args_ptr)
|
|||
|
{
|
|||
|
struct macro_buffer tok;
|
|||
|
std::vector<struct macro_buffer> args;
|
|||
|
|
|||
|
/* Does SRC start with an opening paren token? Read from a copy of
|
|||
|
SRC, so SRC itself is unaffected if we don't find an opening
|
|||
|
paren. */
|
|||
|
{
|
|||
|
struct macro_buffer temp (src->text, src->len);
|
|||
|
|
|||
|
if (! get_token (&tok, &temp)
|
|||
|
|| tok.len != 1
|
|||
|
|| tok.text[0] != '(')
|
|||
|
return false;
|
|||
|
}
|
|||
|
|
|||
|
/* Consume SRC's opening paren. */
|
|||
|
get_token (&tok, src);
|
|||
|
|
|||
|
for (;;)
|
|||
|
{
|
|||
|
struct macro_buffer *arg;
|
|||
|
int depth;
|
|||
|
|
|||
|
/* Initialize the next argument. */
|
|||
|
args.emplace_back ();
|
|||
|
arg = &args.back ();
|
|||
|
set_token (arg, src->text, src->text);
|
|||
|
|
|||
|
/* Gather the argument's tokens. */
|
|||
|
depth = 0;
|
|||
|
for (;;)
|
|||
|
{
|
|||
|
if (! get_token (&tok, src))
|
|||
|
error (_("Malformed argument list for macro `%s'."), name);
|
|||
|
|
|||
|
/* Is tok an opening paren? */
|
|||
|
if (tok.len == 1 && tok.text[0] == '(')
|
|||
|
depth++;
|
|||
|
|
|||
|
/* Is tok is a closing paren? */
|
|||
|
else if (tok.len == 1 && tok.text[0] == ')')
|
|||
|
{
|
|||
|
/* If it's a closing paren at the top level, then that's
|
|||
|
the end of the argument list. */
|
|||
|
if (depth == 0)
|
|||
|
{
|
|||
|
/* In the varargs case, the last argument may be
|
|||
|
missing. Add an empty argument in this case. */
|
|||
|
if (nargs != -1 && args.size () == nargs - 1)
|
|||
|
{
|
|||
|
args.emplace_back ();
|
|||
|
arg = &args.back ();
|
|||
|
set_token (arg, src->text, src->text);
|
|||
|
}
|
|||
|
|
|||
|
*args_ptr = std::move (args);
|
|||
|
return true;
|
|||
|
}
|
|||
|
|
|||
|
depth--;
|
|||
|
}
|
|||
|
|
|||
|
/* If tok is a comma at top level, then that's the end of
|
|||
|
the current argument. However, if we are handling a
|
|||
|
variadic macro and we are computing the last argument, we
|
|||
|
want to include the comma and remaining tokens. */
|
|||
|
else if (tok.len == 1 && tok.text[0] == ',' && depth == 0
|
|||
|
&& (nargs == -1 || args.size () < nargs))
|
|||
|
break;
|
|||
|
|
|||
|
/* Extend the current argument to enclose this token. If
|
|||
|
this is the current argument's first token, leave out any
|
|||
|
leading whitespace, just for aesthetics. */
|
|||
|
if (arg->len == 0)
|
|||
|
{
|
|||
|
arg->text = tok.text;
|
|||
|
arg->len = tok.len;
|
|||
|
arg->last_token = 0;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
arg->len = (tok.text + tok.len) - arg->text;
|
|||
|
arg->last_token = tok.text - arg->text;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
/* The `expand' and `substitute_args' functions both invoke `scan'
|
|||
|
recursively, so we need a forward declaration somewhere. */
|
|||
|
static void scan (struct macro_buffer *dest,
|
|||
|
struct macro_buffer *src,
|
|||
|
struct macro_name_list *no_loop,
|
|||
|
macro_lookup_ftype *lookup_func,
|
|||
|
void *lookup_baton);
|
|||
|
|
|||
|
|
|||
|
/* A helper function for substitute_args.
|
|||
|
|
|||
|
ARGV is a vector of all the arguments; ARGC is the number of
|
|||
|
arguments. IS_VARARGS is true if the macro being substituted is a
|
|||
|
varargs macro; in this case VA_ARG_NAME is the name of the
|
|||
|
"variable" argument. VA_ARG_NAME is ignored if IS_VARARGS is
|
|||
|
false.
|
|||
|
|
|||
|
If the token TOK is the name of a parameter, return the parameter's
|
|||
|
index. If TOK is not an argument, return -1. */
|
|||
|
|
|||
|
static int
|
|||
|
find_parameter (const struct macro_buffer *tok,
|
|||
|
int is_varargs, const struct macro_buffer *va_arg_name,
|
|||
|
int argc, const char * const *argv)
|
|||
|
{
|
|||
|
int i;
|
|||
|
|
|||
|
if (! tok->is_identifier)
|
|||
|
return -1;
|
|||
|
|
|||
|
for (i = 0; i < argc; ++i)
|
|||
|
if (tok->len == strlen (argv[i])
|
|||
|
&& !memcmp (tok->text, argv[i], tok->len))
|
|||
|
return i;
|
|||
|
|
|||
|
if (is_varargs && tok->len == va_arg_name->len
|
|||
|
&& ! memcmp (tok->text, va_arg_name->text, tok->len))
|
|||
|
return argc - 1;
|
|||
|
|
|||
|
return -1;
|
|||
|
}
|
|||
|
|
|||
|
/* Helper function for substitute_args that gets the next token and
|
|||
|
updates the passed-in state variables. */
|
|||
|
|
|||
|
static void
|
|||
|
get_next_token_for_substitution (struct macro_buffer *replacement_list,
|
|||
|
struct macro_buffer *token,
|
|||
|
char **start,
|
|||
|
struct macro_buffer *lookahead,
|
|||
|
char **lookahead_start,
|
|||
|
int *lookahead_valid,
|
|||
|
bool *keep_going)
|
|||
|
{
|
|||
|
if (!*lookahead_valid)
|
|||
|
*keep_going = false;
|
|||
|
else
|
|||
|
{
|
|||
|
*keep_going = true;
|
|||
|
*token = *lookahead;
|
|||
|
*start = *lookahead_start;
|
|||
|
*lookahead_start = replacement_list->text;
|
|||
|
*lookahead_valid = get_token (lookahead, replacement_list);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/* Given the macro definition DEF, being invoked with the actual
|
|||
|
arguments given by ARGV, substitute the arguments into the
|
|||
|
replacement list, and store the result in DEST.
|
|||
|
|
|||
|
IS_VARARGS should be true if DEF is a varargs macro. In this case,
|
|||
|
VA_ARG_NAME should be the name of the "variable" argument -- either
|
|||
|
__VA_ARGS__ for c99-style varargs, or the final argument name, for
|
|||
|
GNU-style varargs. If IS_VARARGS is false, this parameter is
|
|||
|
ignored.
|
|||
|
|
|||
|
If it is necessary to expand macro invocations in one of the
|
|||
|
arguments, use LOOKUP_FUNC and LOOKUP_BATON to find the macro
|
|||
|
definitions, and don't expand invocations of the macros listed in
|
|||
|
NO_LOOP. */
|
|||
|
|
|||
|
static void
|
|||
|
substitute_args (struct macro_buffer *dest,
|
|||
|
struct macro_definition *def,
|
|||
|
int is_varargs, const struct macro_buffer *va_arg_name,
|
|||
|
const std::vector<struct macro_buffer> &argv,
|
|||
|
struct macro_name_list *no_loop,
|
|||
|
macro_lookup_ftype *lookup_func,
|
|||
|
void *lookup_baton)
|
|||
|
{
|
|||
|
/* The token we are currently considering. */
|
|||
|
struct macro_buffer tok;
|
|||
|
/* The replacement list's pointer from just before TOK was lexed. */
|
|||
|
char *original_rl_start;
|
|||
|
/* We have a single lookahead token to handle token splicing. */
|
|||
|
struct macro_buffer lookahead;
|
|||
|
/* The lookahead token might not be valid. */
|
|||
|
int lookahead_valid;
|
|||
|
/* The replacement list's pointer from just before LOOKAHEAD was
|
|||
|
lexed. */
|
|||
|
char *lookahead_rl_start;
|
|||
|
|
|||
|
/* A macro buffer for the macro's replacement list. */
|
|||
|
struct macro_buffer replacement_list (def->replacement,
|
|||
|
strlen (def->replacement));
|
|||
|
|
|||
|
gdb_assert (dest->len == 0);
|
|||
|
dest->last_token = 0;
|
|||
|
|
|||
|
original_rl_start = replacement_list.text;
|
|||
|
if (! get_token (&tok, &replacement_list))
|
|||
|
return;
|
|||
|
lookahead_rl_start = replacement_list.text;
|
|||
|
lookahead_valid = get_token (&lookahead, &replacement_list);
|
|||
|
|
|||
|
/* __VA_OPT__ state variable. The states are:
|
|||
|
0 - nothing happening
|
|||
|
1 - saw __VA_OPT__
|
|||
|
>= 2 in __VA_OPT__, the value encodes the parenthesis depth. */
|
|||
|
unsigned vaopt_state = 0;
|
|||
|
|
|||
|
for (bool keep_going = true;
|
|||
|
keep_going;
|
|||
|
get_next_token_for_substitution (&replacement_list,
|
|||
|
&tok,
|
|||
|
&original_rl_start,
|
|||
|
&lookahead,
|
|||
|
&lookahead_rl_start,
|
|||
|
&lookahead_valid,
|
|||
|
&keep_going))
|
|||
|
{
|
|||
|
bool token_is_vaopt = (tok.len == 10
|
|||
|
&& strncmp (tok.text, "__VA_OPT__", 10) == 0);
|
|||
|
|
|||
|
if (vaopt_state > 0)
|
|||
|
{
|
|||
|
if (token_is_vaopt)
|
|||
|
error (_("__VA_OPT__ cannot appear inside __VA_OPT__"));
|
|||
|
else if (tok.len == 1 && tok.text[0] == '(')
|
|||
|
{
|
|||
|
++vaopt_state;
|
|||
|
/* We just entered __VA_OPT__, so don't emit this
|
|||
|
token. */
|
|||
|
continue;
|
|||
|
}
|
|||
|
else if (vaopt_state == 1)
|
|||
|
error (_("__VA_OPT__ must be followed by an open parenthesis"));
|
|||
|
else if (tok.len == 1 && tok.text[0] == ')')
|
|||
|
{
|
|||
|
--vaopt_state;
|
|||
|
if (vaopt_state == 1)
|
|||
|
{
|
|||
|
/* Done with __VA_OPT__. */
|
|||
|
vaopt_state = 0;
|
|||
|
/* Don't emit. */
|
|||
|
continue;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/* If __VA_ARGS__ is empty, then drop the contents of
|
|||
|
__VA_OPT__. */
|
|||
|
if (argv.back ().len == 0)
|
|||
|
continue;
|
|||
|
}
|
|||
|
else if (token_is_vaopt)
|
|||
|
{
|
|||
|
if (!is_varargs)
|
|||
|
error (_("__VA_OPT__ is only valid in a variadic macro"));
|
|||
|
vaopt_state = 1;
|
|||
|
/* Don't emit this token. */
|
|||
|
continue;
|
|||
|
}
|
|||
|
|
|||
|
/* Just for aesthetics. If we skipped some whitespace, copy
|
|||
|
that to DEST. */
|
|||
|
if (tok.text > original_rl_start)
|
|||
|
{
|
|||
|
dest->appendmem (original_rl_start, tok.text - original_rl_start);
|
|||
|
dest->last_token = dest->len;
|
|||
|
}
|
|||
|
|
|||
|
/* Is this token the stringification operator? */
|
|||
|
if (tok.len == 1
|
|||
|
&& tok.text[0] == '#')
|
|||
|
{
|
|||
|
int arg;
|
|||
|
|
|||
|
if (!lookahead_valid)
|
|||
|
error (_("Stringification operator requires an argument."));
|
|||
|
|
|||
|
arg = find_parameter (&lookahead, is_varargs, va_arg_name,
|
|||
|
def->argc, def->argv);
|
|||
|
if (arg == -1)
|
|||
|
error (_("Argument to stringification operator must name "
|
|||
|
"a macro parameter."));
|
|||
|
|
|||
|
stringify (dest, argv[arg].text, argv[arg].len);
|
|||
|
|
|||
|
/* Read one token and let the loop iteration code handle the
|
|||
|
rest. */
|
|||
|
lookahead_rl_start = replacement_list.text;
|
|||
|
lookahead_valid = get_token (&lookahead, &replacement_list);
|
|||
|
}
|
|||
|
/* Is this token the splicing operator? */
|
|||
|
else if (tok.len == 2
|
|||
|
&& tok.text[0] == '#'
|
|||
|
&& tok.text[1] == '#')
|
|||
|
error (_("Stray splicing operator"));
|
|||
|
/* Is the next token the splicing operator? */
|
|||
|
else if (lookahead_valid
|
|||
|
&& lookahead.len == 2
|
|||
|
&& lookahead.text[0] == '#'
|
|||
|
&& lookahead.text[1] == '#')
|
|||
|
{
|
|||
|
int finished = 0;
|
|||
|
int prev_was_comma = 0;
|
|||
|
|
|||
|
/* Note that GCC warns if the result of splicing is not a
|
|||
|
token. In the debugger there doesn't seem to be much
|
|||
|
benefit from doing this. */
|
|||
|
|
|||
|
/* Insert the first token. */
|
|||
|
if (tok.len == 1 && tok.text[0] == ',')
|
|||
|
prev_was_comma = 1;
|
|||
|
else
|
|||
|
{
|
|||
|
int arg = find_parameter (&tok, is_varargs, va_arg_name,
|
|||
|
def->argc, def->argv);
|
|||
|
|
|||
|
if (arg != -1)
|
|||
|
dest->appendmem (argv[arg].text, argv[arg].len);
|
|||
|
else
|
|||
|
dest->appendmem (tok.text, tok.len);
|
|||
|
}
|
|||
|
|
|||
|
/* Apply a possible sequence of ## operators. */
|
|||
|
for (;;)
|
|||
|
{
|
|||
|
if (! get_token (&tok, &replacement_list))
|
|||
|
error (_("Splicing operator at end of macro"));
|
|||
|
|
|||
|
/* Handle a comma before a ##. If we are handling
|
|||
|
varargs, and the token on the right hand side is the
|
|||
|
varargs marker, and the final argument is empty or
|
|||
|
missing, then drop the comma. This is a GNU
|
|||
|
extension. There is one ambiguous case here,
|
|||
|
involving pedantic behavior with an empty argument,
|
|||
|
but we settle that in favor of GNU-style (GCC uses an
|
|||
|
option). If we aren't dealing with varargs, we
|
|||
|
simply insert the comma. */
|
|||
|
if (prev_was_comma)
|
|||
|
{
|
|||
|
if (! (is_varargs
|
|||
|
&& tok.len == va_arg_name->len
|
|||
|
&& !memcmp (tok.text, va_arg_name->text, tok.len)
|
|||
|
&& argv.back ().len == 0))
|
|||
|
dest->appendmem (",", 1);
|
|||
|
prev_was_comma = 0;
|
|||
|
}
|
|||
|
|
|||
|
/* Insert the token. If it is a parameter, insert the
|
|||
|
argument. If it is a comma, treat it specially. */
|
|||
|
if (tok.len == 1 && tok.text[0] == ',')
|
|||
|
prev_was_comma = 1;
|
|||
|
else
|
|||
|
{
|
|||
|
int arg = find_parameter (&tok, is_varargs, va_arg_name,
|
|||
|
def->argc, def->argv);
|
|||
|
|
|||
|
if (arg != -1)
|
|||
|
dest->appendmem (argv[arg].text, argv[arg].len);
|
|||
|
else
|
|||
|
dest->appendmem (tok.text, tok.len);
|
|||
|
}
|
|||
|
|
|||
|
/* Now read another token. If it is another splice, we
|
|||
|
loop. */
|
|||
|
original_rl_start = replacement_list.text;
|
|||
|
if (! get_token (&tok, &replacement_list))
|
|||
|
{
|
|||
|
finished = 1;
|
|||
|
break;
|
|||
|
}
|
|||
|
|
|||
|
if (! (tok.len == 2
|
|||
|
&& tok.text[0] == '#'
|
|||
|
&& tok.text[1] == '#'))
|
|||
|
break;
|
|||
|
}
|
|||
|
|
|||
|
if (prev_was_comma)
|
|||
|
{
|
|||
|
/* We saw a comma. Insert it now. */
|
|||
|
dest->appendmem (",", 1);
|
|||
|
}
|
|||
|
|
|||
|
dest->last_token = dest->len;
|
|||
|
if (finished)
|
|||
|
lookahead_valid = 0;
|
|||
|
else
|
|||
|
{
|
|||
|
/* Set up for the loop iterator. */
|
|||
|
lookahead = tok;
|
|||
|
lookahead_rl_start = original_rl_start;
|
|||
|
lookahead_valid = 1;
|
|||
|
}
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
/* Is this token an identifier? */
|
|||
|
int substituted = 0;
|
|||
|
int arg = find_parameter (&tok, is_varargs, va_arg_name,
|
|||
|
def->argc, def->argv);
|
|||
|
|
|||
|
if (arg != -1)
|
|||
|
{
|
|||
|
/* Expand any macro invocations in the argument text,
|
|||
|
and append the result to dest. Remember that scan
|
|||
|
mutates its source, so we need to scan a new buffer
|
|||
|
referring to the argument's text, not the argument
|
|||
|
itself. */
|
|||
|
struct macro_buffer arg_src (argv[arg].text, argv[arg].len);
|
|||
|
scan (dest, &arg_src, no_loop, lookup_func, lookup_baton);
|
|||
|
substituted = 1;
|
|||
|
}
|
|||
|
|
|||
|
/* If it wasn't a parameter, then just copy it across. */
|
|||
|
if (! substituted)
|
|||
|
append_tokens_without_splicing (dest, &tok);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
if (vaopt_state > 0)
|
|||
|
error (_("Unterminated __VA_OPT__"));
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
/* Expand a call to a macro named ID, whose definition is DEF. Append
|
|||
|
its expansion to DEST. SRC is the input text following the ID
|
|||
|
token. We are currently rescanning the expansions of the macros
|
|||
|
named in NO_LOOP; don't re-expand them. Use LOOKUP_FUNC and
|
|||
|
LOOKUP_BATON to find definitions for any nested macro references.
|
|||
|
|
|||
|
Return 1 if we decided to expand it, zero otherwise. (If it's a
|
|||
|
function-like macro name that isn't followed by an argument list,
|
|||
|
we don't expand it.) If we return zero, leave SRC unchanged. */
|
|||
|
static int
|
|||
|
expand (const char *id,
|
|||
|
struct macro_definition *def,
|
|||
|
struct macro_buffer *dest,
|
|||
|
struct macro_buffer *src,
|
|||
|
struct macro_name_list *no_loop,
|
|||
|
macro_lookup_ftype *lookup_func,
|
|||
|
void *lookup_baton)
|
|||
|
{
|
|||
|
struct macro_name_list new_no_loop;
|
|||
|
|
|||
|
/* Create a new node to be added to the front of the no-expand list.
|
|||
|
This list is appropriate for re-scanning replacement lists, but
|
|||
|
it is *not* appropriate for scanning macro arguments; invocations
|
|||
|
of the macro whose arguments we are gathering *do* get expanded
|
|||
|
there. */
|
|||
|
new_no_loop.name = id;
|
|||
|
new_no_loop.next = no_loop;
|
|||
|
|
|||
|
/* What kind of macro are we expanding? */
|
|||
|
if (def->kind == macro_object_like)
|
|||
|
{
|
|||
|
struct macro_buffer replacement_list (def->replacement,
|
|||
|
strlen (def->replacement));
|
|||
|
|
|||
|
scan (dest, &replacement_list, &new_no_loop, lookup_func, lookup_baton);
|
|||
|
return 1;
|
|||
|
}
|
|||
|
else if (def->kind == macro_function_like)
|
|||
|
{
|
|||
|
struct macro_buffer va_arg_name;
|
|||
|
int is_varargs = 0;
|
|||
|
|
|||
|
if (def->argc >= 1)
|
|||
|
{
|
|||
|
if (strcmp (def->argv[def->argc - 1], "...") == 0)
|
|||
|
{
|
|||
|
/* In C99-style varargs, substitution is done using
|
|||
|
__VA_ARGS__. */
|
|||
|
va_arg_name.set_shared ("__VA_ARGS__", strlen ("__VA_ARGS__"));
|
|||
|
is_varargs = 1;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
int len = strlen (def->argv[def->argc - 1]);
|
|||
|
|
|||
|
if (len > 3
|
|||
|
&& strcmp (def->argv[def->argc - 1] + len - 3, "...") == 0)
|
|||
|
{
|
|||
|
/* In GNU-style varargs, the name of the
|
|||
|
substitution parameter is the name of the formal
|
|||
|
argument without the "...". */
|
|||
|
va_arg_name.set_shared (def->argv[def->argc - 1], len - 3);
|
|||
|
is_varargs = 1;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
std::vector<struct macro_buffer> argv;
|
|||
|
/* If we couldn't find any argument list, then we don't expand
|
|||
|
this macro. */
|
|||
|
if (!gather_arguments (id, src, is_varargs ? def->argc : -1,
|
|||
|
&argv))
|
|||
|
return 0;
|
|||
|
|
|||
|
/* Check that we're passing an acceptable number of arguments for
|
|||
|
this macro. */
|
|||
|
if (argv.size () != def->argc)
|
|||
|
{
|
|||
|
if (is_varargs && argv.size () >= def->argc - 1)
|
|||
|
{
|
|||
|
/* Ok. */
|
|||
|
}
|
|||
|
/* Remember that a sequence of tokens like "foo()" is a
|
|||
|
valid invocation of a macro expecting either zero or one
|
|||
|
arguments. */
|
|||
|
else if (! (argv.size () == 1
|
|||
|
&& argv[0].len == 0
|
|||
|
&& def->argc == 0))
|
|||
|
error (_("Wrong number of arguments to macro `%s' "
|
|||
|
"(expected %d, got %d)."),
|
|||
|
id, def->argc, int (argv.size ()));
|
|||
|
}
|
|||
|
|
|||
|
/* Note that we don't expand macro invocations in the arguments
|
|||
|
yet --- we let subst_args take care of that. Parameters that
|
|||
|
appear as operands of the stringifying operator "#" or the
|
|||
|
splicing operator "##" don't get macro references expanded,
|
|||
|
so we can't really tell whether it's appropriate to macro-
|
|||
|
expand an argument until we see how it's being used. */
|
|||
|
struct macro_buffer substituted (0);
|
|||
|
substitute_args (&substituted, def, is_varargs, &va_arg_name,
|
|||
|
argv, no_loop, lookup_func, lookup_baton);
|
|||
|
|
|||
|
/* Now `substituted' is the macro's replacement list, with all
|
|||
|
argument values substituted into it properly. Re-scan it for
|
|||
|
macro references, but don't expand invocations of this macro.
|
|||
|
|
|||
|
We create a new buffer, `substituted_src', which points into
|
|||
|
`substituted', and scan that. We can't scan `substituted'
|
|||
|
itself, since the tokenization process moves the buffer's
|
|||
|
text pointer around, and we still need to be able to find
|
|||
|
`substituted's original text buffer after scanning it so we
|
|||
|
can free it. */
|
|||
|
struct macro_buffer substituted_src (substituted.text, substituted.len);
|
|||
|
scan (dest, &substituted_src, &new_no_loop, lookup_func, lookup_baton);
|
|||
|
|
|||
|
return 1;
|
|||
|
}
|
|||
|
else
|
|||
|
internal_error (__FILE__, __LINE__, _("bad macro definition kind"));
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
/* If the single token in SRC_FIRST followed by the tokens in SRC_REST
|
|||
|
constitute a macro invocation not forbidden in NO_LOOP, append its
|
|||
|
expansion to DEST and return non-zero. Otherwise, return zero, and
|
|||
|
leave DEST unchanged.
|
|||
|
|
|||
|
SRC_FIRST and SRC_REST must be shared buffers; DEST must not be one.
|
|||
|
SRC_FIRST must be a string built by get_token. */
|
|||
|
static int
|
|||
|
maybe_expand (struct macro_buffer *dest,
|
|||
|
struct macro_buffer *src_first,
|
|||
|
struct macro_buffer *src_rest,
|
|||
|
struct macro_name_list *no_loop,
|
|||
|
macro_lookup_ftype *lookup_func,
|
|||
|
void *lookup_baton)
|
|||
|
{
|
|||
|
gdb_assert (src_first->shared);
|
|||
|
gdb_assert (src_rest->shared);
|
|||
|
gdb_assert (! dest->shared);
|
|||
|
|
|||
|
/* Is this token an identifier? */
|
|||
|
if (src_first->is_identifier)
|
|||
|
{
|
|||
|
/* Make a null-terminated copy of it, since that's what our
|
|||
|
lookup function expects. */
|
|||
|
std::string id (src_first->text, src_first->len);
|
|||
|
|
|||
|
/* If we're currently re-scanning the result of expanding
|
|||
|
this macro, don't expand it again. */
|
|||
|
if (! currently_rescanning (no_loop, id.c_str ()))
|
|||
|
{
|
|||
|
/* Does this identifier have a macro definition in scope? */
|
|||
|
struct macro_definition *def = lookup_func (id.c_str (),
|
|||
|
lookup_baton);
|
|||
|
|
|||
|
if (def && expand (id.c_str (), def, dest, src_rest, no_loop,
|
|||
|
lookup_func, lookup_baton))
|
|||
|
return 1;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
return 0;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
/* Expand macro references in SRC, appending the results to DEST.
|
|||
|
Assume we are re-scanning the result of expanding the macros named
|
|||
|
in NO_LOOP, and don't try to re-expand references to them.
|
|||
|
|
|||
|
SRC must be a shared buffer; DEST must not be one. */
|
|||
|
static void
|
|||
|
scan (struct macro_buffer *dest,
|
|||
|
struct macro_buffer *src,
|
|||
|
struct macro_name_list *no_loop,
|
|||
|
macro_lookup_ftype *lookup_func,
|
|||
|
void *lookup_baton)
|
|||
|
{
|
|||
|
gdb_assert (src->shared);
|
|||
|
gdb_assert (! dest->shared);
|
|||
|
|
|||
|
for (;;)
|
|||
|
{
|
|||
|
struct macro_buffer tok;
|
|||
|
char *original_src_start = src->text;
|
|||
|
|
|||
|
/* Find the next token in SRC. */
|
|||
|
if (! get_token (&tok, src))
|
|||
|
break;
|
|||
|
|
|||
|
/* Just for aesthetics. If we skipped some whitespace, copy
|
|||
|
that to DEST. */
|
|||
|
if (tok.text > original_src_start)
|
|||
|
{
|
|||
|
dest->appendmem (original_src_start, tok.text - original_src_start);
|
|||
|
dest->last_token = dest->len;
|
|||
|
}
|
|||
|
|
|||
|
if (! maybe_expand (dest, &tok, src, no_loop, lookup_func, lookup_baton))
|
|||
|
/* We didn't end up expanding tok as a macro reference, so
|
|||
|
simply append it to dest. */
|
|||
|
append_tokens_without_splicing (dest, &tok);
|
|||
|
}
|
|||
|
|
|||
|
/* Just for aesthetics. If there was any trailing whitespace in
|
|||
|
src, copy it to dest. */
|
|||
|
if (src->len)
|
|||
|
{
|
|||
|
dest->appendmem (src->text, src->len);
|
|||
|
dest->last_token = dest->len;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
gdb::unique_xmalloc_ptr<char>
|
|||
|
macro_expand (const char *source,
|
|||
|
macro_lookup_ftype *lookup_func,
|
|||
|
void *lookup_func_baton)
|
|||
|
{
|
|||
|
struct macro_buffer src (source, strlen (source));
|
|||
|
|
|||
|
struct macro_buffer dest (0);
|
|||
|
dest.last_token = 0;
|
|||
|
|
|||
|
scan (&dest, &src, 0, lookup_func, lookup_func_baton);
|
|||
|
|
|||
|
dest.appendc ('\0');
|
|||
|
|
|||
|
return gdb::unique_xmalloc_ptr<char> (dest.release ());
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
gdb::unique_xmalloc_ptr<char>
|
|||
|
macro_expand_once (const char *source,
|
|||
|
macro_lookup_ftype *lookup_func,
|
|||
|
void *lookup_func_baton)
|
|||
|
{
|
|||
|
error (_("Expand-once not implemented yet."));
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
char *
|
|||
|
macro_expand_next (const char **lexptr,
|
|||
|
macro_lookup_ftype *lookup_func,
|
|||
|
void *lookup_baton)
|
|||
|
{
|
|||
|
struct macro_buffer tok;
|
|||
|
|
|||
|
/* Set up SRC to refer to the input text, pointed to by *lexptr. */
|
|||
|
struct macro_buffer src (*lexptr, strlen (*lexptr));
|
|||
|
|
|||
|
/* Set up DEST to receive the expansion, if there is one. */
|
|||
|
struct macro_buffer dest (0);
|
|||
|
dest.last_token = 0;
|
|||
|
|
|||
|
/* Get the text's first preprocessing token. */
|
|||
|
if (! get_token (&tok, &src))
|
|||
|
return 0;
|
|||
|
|
|||
|
/* If it's a macro invocation, expand it. */
|
|||
|
if (maybe_expand (&dest, &tok, &src, 0, lookup_func, lookup_baton))
|
|||
|
{
|
|||
|
/* It was a macro invocation! Package up the expansion as a
|
|||
|
null-terminated string and return it. Set *lexptr to the
|
|||
|
start of the next token in the input. */
|
|||
|
dest.appendc ('\0');
|
|||
|
*lexptr = src.text;
|
|||
|
return dest.release ();
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
/* It wasn't a macro invocation. */
|
|||
|
return 0;
|
|||
|
}
|
|||
|
}
|