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. */
appendc (dest, '"');
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. */
appendc (dest, ' ');
while (len > 1 && macro_is_whitespace (arg[1]))
{
++arg;
--len;
}
}
else if (*arg == '\\' || *arg == '"')
{
appendc (dest, '\\');
appendc (dest, *arg);
}
else
appendc (dest, *arg);
++arg;
--len;
}
appendc (dest, '"');
dest->last_token = dest->len;
}
static void
skip_ws (char **expp)
{
while (macro_is_whitespace (**expp))
++*expp;
}
/* 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;
}
