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 2, or (at your option) any
+Free Software Foundation; either version 3, or (at your option) any
later version.
This program is distributed in the hope that it will be useful,
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, write to the Free Software
-Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+along with this program; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>.
In other words, you are welcome to use, share and improve this program.
You are forbidden to forbid anyone else to use, share and improve
if (token->type == CPP_PADDING)
{
- if (source == NULL)
+ if (source == NULL
+ || (!(source->flags & PREV_WHITE)
+ && token->val.source == NULL))
source = token->val.source;
continue;
}
return NULL;
}
+/* Return the real number of tokens in the expansion of MACRO. */
+static inline unsigned int
+macro_real_token_count (const cpp_macro *macro)
+{
+ unsigned int i;
+ if (__builtin_expect (!macro->extra_tokens, true))
+ return macro->count;
+ for (i = 0; i < macro->count; i++)
+ if (macro->exp.tokens[i].type == CPP_PASTE)
+ return i;
+ abort ();
+}
+
/* Push the context of a macro with hash entry NODE onto the context
stack. If we can successfully expand the macro, we push a context
containing its yet-to-be-rescanned replacement list and return one.
macro->used = 1;
if (macro->paramc == 0)
- _cpp_push_token_context (pfile, node, macro->exp.tokens, macro->count);
+ _cpp_push_token_context (pfile, node, macro->exp.tokens,
+ macro_real_token_count (macro));
if (pragma_buff)
{
const cpp_token **dest, **first;
macro_arg *arg;
_cpp_buff *buff;
+ unsigned int count;
/* First, fully macro-expand arguments, calculating the number of
tokens in the final expansion as we go. The ordering of the if
statements below is subtle; we must handle stringification before
pasting. */
- total = macro->count;
- limit = macro->exp.tokens + macro->count;
+ count = macro_real_token_count (macro);
+ total = count;
+ limit = macro->exp.tokens + count;
for (src = macro->exp.tokens; src < limit; src++)
if (src->type == CPP_MACRO_ARG)
/* We have an argument. If it is not being stringified or
pasted it is macro-replaced before insertion. */
- arg = &args[src->val.arg_no - 1];
+ arg = &args[src->val.macro_arg.arg_no - 1];
if (src->flags & STRINGIFY_ARG)
{
}
paste_flag = 0;
- arg = &args[src->val.arg_no - 1];
+ arg = &args[src->val.macro_arg.arg_no - 1];
if (src->flags & STRINGIFY_ARG)
count = 1, from = &arg->stringified;
else if (src->flags & PASTE_LEFT)
{
if (dest[-1]->type == CPP_COMMA
&& macro->variadic
- && src->val.arg_no == macro->paramc)
+ && src->val.macro_arg.arg_no == macro->paramc)
{
/* Swallow a pasted comma if from == NULL, otherwise
drop the paste flag. */
"empty macro arguments are undefined"
" in ISO C90 and ISO C++98",
NODE_NAME (node),
- src->val.arg_no);
+ src->val.macro_arg.arg_no);
}
/* Avoid paste on RHS (even case count == 0). */
if (result->type != CPP_NAME)
break;
- node = result->val.node;
+ node = result->val.node.node;
if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
break;
/* Conditional macros require that a predicate be evaluated
first. */
- if (((!(node->flags & NODE_CONDITIONAL))
- || (pfile->cb.macro_to_expand
- && (node = pfile->cb.macro_to_expand (pfile, result))))
- && (ret = enter_macro_context (pfile, node, result)))
+ if ((node->flags & NODE_CONDITIONAL) != 0)
+ {
+ if (pfile->cb.macro_to_expand)
+ {
+ bool whitespace_after;
+ const cpp_token *peek_tok = cpp_peek_token (pfile, 0);
+
+ whitespace_after = (peek_tok->type == CPP_PADDING
+ || (peek_tok->flags & PREV_WHITE));
+ node = pfile->cb.macro_to_expand (pfile, result);
+ if (node)
+ ret = enter_macro_context (pfile, node, result);
+ else if (whitespace_after)
+ {
+ /* If macro_to_expand hook returned NULL and it
+ ate some tokens, see if we don't need to add
+ a padding token in between this and the
+ next token. */
+ peek_tok = cpp_peek_token (pfile, 0);
+ if (peek_tok->type != CPP_PADDING
+ && (peek_tok->flags & PREV_WHITE) == 0)
+ _cpp_push_token_context (pfile, NULL,
+ padding_token (pfile,
+ peek_tok), 1);
+ }
+ }
+ }
+ else
+ ret = enter_macro_context (pfile, node, result);
+ if (ret)
{
if (pfile->state.in_directive || ret == 2)
continue;
}
prev_ident = 1;
- if (_cpp_save_parameter (pfile, macro, token->val.node))
+ if (_cpp_save_parameter (pfile, macro, token->val.node.node))
return false;
continue;
/* Is this a parameter? */
if (token->type == CPP_NAME
- && (token->val.node->flags & NODE_MACRO_ARG) != 0)
+ && (token->val.node.node->flags & NODE_MACRO_ARG) != 0)
{
token->type = CPP_MACRO_ARG;
- token->val.arg_no = token->val.node->value.arg_index;
+ token->val.macro_arg.arg_no = token->val.node.node->value.arg_index;
}
else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
&& (token->type == CPP_STRING || token->type == CPP_CHAR))
bool following_paste_op = false;
const char *paste_op_error_msg =
N_("'##' cannot appear at either end of a macro expansion");
+ unsigned int num_extra_tokens = 0;
/* Get the first token of the expansion (or the '(' of a
function-like macro). */
{
if (token->type == CPP_MACRO_ARG)
{
+ if (token->flags & PREV_WHITE)
+ token->flags |= SP_PREV_WHITE;
+ if (token[-1].flags & DIGRAPH)
+ token->flags |= SP_DIGRAPH;
token->flags &= ~PREV_WHITE;
token->flags |= STRINGIFY_ARG;
token->flags |= token[-1].flags & PREV_WHITE;
return false;
}
- --macro->count;
- token[-1].flags |= PASTE_LEFT;
+ if (token[-1].flags & PASTE_LEFT)
+ {
+ macro->extra_tokens = 1;
+ num_extra_tokens++;
+ token->val.token_no = macro->count - 1;
+ }
+ else
+ {
+ --macro->count;
+ token[-1].flags |= PASTE_LEFT;
+ if (token->flags & DIGRAPH)
+ token[-1].flags |= SP_DIGRAPH;
+ if (token->flags & PREV_WHITE)
+ token[-1].flags |= SP_PREV_WHITE;
+ }
}
following_paste_op = (token->type == CPP_PASTE);
cpp_token *tokns =
(cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
* macro->count);
- memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
+ if (num_extra_tokens)
+ {
+ /* Place second and subsequent ## or %:%: tokens in
+ sequences of consecutive such tokens at the end of the
+ list to preserve information about where they appear, how
+ they are spelt and whether they are preceded by
+ whitespace without otherwise interfering with macro
+ expansion. */
+ cpp_token *normal_dest = tokns;
+ cpp_token *extra_dest = tokns + macro->count - num_extra_tokens;
+ unsigned int i;
+ for (i = 0; i < macro->count; i++)
+ {
+ if (macro->exp.tokens[i].type == CPP_PASTE)
+ *extra_dest++ = macro->exp.tokens[i];
+ else
+ *normal_dest++ = macro->exp.tokens[i];
+ }
+ }
+ else
+ memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
macro->exp.tokens = tokns;
}
else
macro->used = !CPP_OPTION (pfile, warn_unused_macros);
macro->count = 0;
macro->fun_like = 0;
+ macro->extra_tokens = 0;
/* To suppress some diagnostics. */
macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
len += _cpp_replacement_text_len (macro);
else
{
- for (i = 0; i < macro->count; i++)
+ unsigned int count = macro_real_token_count (macro);
+ for (i = 0; i < count; i++)
{
cpp_token *token = ¯o->exp.tokens[i];
if (token->type == CPP_MACRO_ARG)
- len += NODE_LEN (macro->params[token->val.arg_no - 1]);
+ len += NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]);
else
len += cpp_token_len (token);
else if (macro->count)
/* Expansion tokens. */
{
- for (i = 0; i < macro->count; i++)
+ unsigned int count = macro_real_token_count (macro);
+ for (i = 0; i < count; i++)
{
cpp_token *token = ¯o->exp.tokens[i];
if (token->type == CPP_MACRO_ARG)
{
memcpy (buffer,
- NODE_NAME (macro->params[token->val.arg_no - 1]),
- NODE_LEN (macro->params[token->val.arg_no - 1]));
- buffer += NODE_LEN (macro->params[token->val.arg_no - 1]);
+ NODE_NAME (macro->params[token->val.macro_arg.arg_no - 1]),
+ NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]));
+ buffer += NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]);
}
else
buffer = cpp_spell_token (pfile, token, buffer, false);
OSDN Git Service
