/* Part of CPP library. (Macro and #define handling.)
Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+ 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
Written by Per Bothner, 1994.
Based on CCCP program by Paul Rubin, June 1986
Adapted to ANSI C, Richard Stallman, Jan 1987
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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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
/* Macro expansion. */
-static int enter_macro_context (cpp_reader *, cpp_hashnode *);
+static int enter_macro_context (cpp_reader *, cpp_hashnode *,
+ const cpp_token *);
static int builtin_macro (cpp_reader *, cpp_hashnode *);
-static void push_token_context (cpp_reader *, cpp_hashnode *,
- const cpp_token *, unsigned int);
static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *,
const cpp_token **, unsigned int);
-static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *);
+static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *,
+ _cpp_buff **);
static cpp_context *next_context (cpp_reader *);
static const cpp_token *padding_token (cpp_reader *, const cpp_token *);
static void expand_arg (cpp_reader *, macro_arg *);
static bool paste_tokens (cpp_reader *, const cpp_token **, const cpp_token *);
static void replace_args (cpp_reader *, cpp_hashnode *, cpp_macro *,
macro_arg *);
-static _cpp_buff *funlike_invocation_p (cpp_reader *, cpp_hashnode *);
+static _cpp_buff *funlike_invocation_p (cpp_reader *, cpp_hashnode *,
+ _cpp_buff **);
static bool create_iso_definition (cpp_reader *, cpp_macro *);
/* #define directive parsing and handling. */
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
-/* Handle builtin macros like __FILE__, and push the resulting token
- on the context stack. Also handles _Pragma, for which no new token
- is created. Returns 1 if it generates a new token context, 0 to
- return the token to the caller. */
+/* Helper function for builtin_macro. Returns the text generated by
+ a builtin macro. */
const uchar *
_cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
{
const struct line_map *map;
const uchar *result = NULL;
- unsigned int number = 1;
+ linenum_type number = 1;
switch (node->value.builtin)
{
NODE_NAME (node));
break;
+ case BT_TIMESTAMP:
+ {
+ cpp_buffer *pbuffer = cpp_get_buffer (pfile);
+ if (pbuffer->timestamp == NULL)
+ {
+ /* Initialize timestamp value of the assotiated file. */
+ struct _cpp_file *file = cpp_get_file (pbuffer);
+ if (file)
+ {
+ /* Generate __TIMESTAMP__ string, that represents
+ the date and time of the last modification
+ of the current source file. The string constant
+ looks like "Sun Sep 16 01:03:52 1973". */
+ struct tm *tb = NULL;
+ struct stat *st = _cpp_get_file_stat (file);
+ if (st)
+ tb = localtime (&st->st_mtime);
+ if (tb)
+ {
+ char *str = asctime (tb);
+ size_t len = strlen (str);
+ unsigned char *buf = _cpp_unaligned_alloc (pfile, len + 2);
+ buf[0] = '"';
+ strcpy ((char *) buf + 1, str);
+ buf[len] = '"';
+ pbuffer->timestamp = buf;
+ }
+ else
+ {
+ cpp_errno (pfile, CPP_DL_WARNING,
+ "could not determine file timestamp");
+ pbuffer->timestamp = UC"\"??? ??? ?? ??:??:?? ????\"";
+ }
+ }
+ }
+ result = pbuffer->timestamp;
+ }
+ break;
case BT_FILE:
case BT_BASE_FILE:
{
name = map->to_file;
len = strlen (name);
- buf = _cpp_unaligned_alloc (pfile, len * 4 + 3);
+ buf = _cpp_unaligned_alloc (pfile, len * 2 + 3);
result = buf;
*buf = '"';
buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len);
/* If __LINE__ is embedded in a macro, it must expand to the
line of the macro's invocation, not its definition.
Otherwise things like assert() will not work properly. */
- if (CPP_OPTION (pfile, traditional))
- number = pfile->line_table->highest_line;
- else
- number = pfile->cur_token[-1].src_loc;
- number = SOURCE_LINE (map, number);
+ number = SOURCE_LINE (map,
+ CPP_OPTION (pfile, traditional)
+ ? pfile->line_table->highest_line
+ : pfile->cur_token[-1].src_loc);
break;
/* __STDC__ has the value 1 under normal circumstances.
However, if (a) we are in a system header, (b) the option
stdc_0_in_system_headers is true (set by target config), and
(c) we are not in strictly conforming mode, then it has the
- value 0. */
+ value 0. (b) and (c) are already checked in cpp_init_builtins. */
case BT_STDC:
- {
- if (cpp_in_system_header (pfile)
- && CPP_OPTION (pfile, stdc_0_in_system_headers)
- && !CPP_OPTION (pfile,std))
- number = 0;
- else
- number = 1;
- }
+ if (cpp_in_system_header (pfile))
+ number = 0;
+ else
+ number = 1;
break;
case BT_DATE:
cpp_errno (pfile, CPP_DL_WARNING,
"could not determine date and time");
- pfile->date = U"\"??? ?? ????\"";
- pfile->time = U"\"??:??:??\"";
+ pfile->date = UC"\"??? ?? ????\"";
+ pfile->time = UC"\"??:??:??\"";
}
}
else
result = pfile->time;
break;
+
+ case BT_COUNTER:
+ if (CPP_OPTION (pfile, directives_only) && pfile->state.in_directive)
+ cpp_error (pfile, CPP_DL_ERROR,
+ "__COUNTER__ expanded inside directive with -fdirectives-only");
+ number = pfile->counter++;
+ break;
}
if (result == NULL)
}
/* Convert builtin macros like __FILE__ to a token and push it on the
- context stack. Also handles _Pragma, for which no new token is
- created. Returns 1 if it generates a new token context, 0 to
+ context stack. Also handles _Pragma, for which a new token may not
+ be created. Returns 1 if it generates a new token context, 0 to
return the token to the caller. */
static int
builtin_macro (cpp_reader *pfile, cpp_hashnode *node)
if (pfile->state.in_directive)
return 0;
- _cpp_do__Pragma (pfile);
- return 1;
+ return _cpp_do__Pragma (pfile);
}
buf = _cpp_builtin_macro_text (pfile, node);
len = ustrlen (buf);
- nbuf = alloca (len + 1);
+ nbuf = (char *) alloca (len + 1);
memcpy (nbuf, buf, len);
nbuf[len]='\n';
/* Set pfile->cur_token as required by _cpp_lex_direct. */
pfile->cur_token = _cpp_temp_token (pfile);
- push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1);
+ _cpp_push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1);
if (pfile->buffer->cur != pfile->buffer->rlimit)
cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
NODE_NAME (node));
}
/* Copies SRC, of length LEN, to DEST, adding backslashes before all
- backslashes and double quotes. Non-printable characters are
- converted to octal. DEST must be of sufficient size. Returns
- a pointer to the end of the string. */
+ backslashes and double quotes. DEST must be of sufficient size.
+ Returns a pointer to the end of the string. */
uchar *
cpp_quote_string (uchar *dest, const uchar *src, unsigned int len)
{
*dest++ = c;
}
else
- {
- if (ISPRINT (c))
- *dest++ = c;
- else
- {
- sprintf ((char *) dest, "\\%03o", c);
- dest += 4;
- }
- }
+ *dest++ = c;
}
return dest;
if (token->type == CPP_PADDING)
{
- if (source == NULL)
+ if (source == NULL
+ || (!(source->flags & PREV_WHITE)
+ && token->val.source == NULL))
source = token->val.source;
continue;
}
- escape_it = (token->type == CPP_STRING || token->type == CPP_WSTRING
- || token->type == CPP_CHAR || token->type == CPP_WCHAR);
+ escape_it = (token->type == CPP_STRING || token->type == CPP_CHAR
+ || token->type == CPP_WSTRING || token->type == CPP_STRING
+ || token->type == CPP_STRING32 || token->type == CPP_CHAR32
+ || token->type == CPP_STRING16 || token->type == CPP_CHAR16);
/* Room for each char being written in octal, initial space and
final quote and NUL. */
{
_cpp_buff *buff = _cpp_get_buff (pfile, len);
unsigned char *buf = BUFF_FRONT (buff);
- len = cpp_spell_token (pfile, token, buf) - buf;
+ len = cpp_spell_token (pfile, token, buf, true) - buf;
dest = cpp_quote_string (dest, buf, len);
_cpp_release_buff (pfile, buff);
}
else
- dest = cpp_spell_token (pfile, token, dest);
+ dest = cpp_spell_token (pfile, token, dest, true);
if (token->type == CPP_OTHER && token->val.str.text[0] == '\\')
backslash_count++;
static bool
paste_tokens (cpp_reader *pfile, const cpp_token **plhs, const cpp_token *rhs)
{
- unsigned char *buf, *end;
- const cpp_token *lhs;
+ unsigned char *buf, *end, *lhsend;
+ cpp_token *lhs;
unsigned int len;
- bool valid;
- lhs = *plhs;
- len = cpp_token_len (lhs) + cpp_token_len (rhs) + 1;
- buf = alloca (len);
- end = cpp_spell_token (pfile, lhs, buf);
+ len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 1;
+ buf = (unsigned char *) alloca (len);
+ end = lhsend = cpp_spell_token (pfile, *plhs, buf, false);
/* Avoid comment headers, since they are still processed in stage 3.
It is simpler to insert a space here, rather than modifying the
lexer to ignore comments in some circumstances. Simply returning
false doesn't work, since we want to clear the PASTE_LEFT flag. */
- if (lhs->type == CPP_DIV && rhs->type != CPP_EQ)
+ if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ)
*end++ = ' ';
- end = cpp_spell_token (pfile, rhs, end);
+ /* In one obscure case we might see padding here. */
+ if (rhs->type != CPP_PADDING)
+ end = cpp_spell_token (pfile, rhs, end, false);
*end = '\n';
cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);
/* Set pfile->cur_token as required by _cpp_lex_direct. */
pfile->cur_token = _cpp_temp_token (pfile);
- *plhs = _cpp_lex_direct (pfile);
- valid = pfile->buffer->cur == pfile->buffer->rlimit;
- _cpp_pop_buffer (pfile);
+ lhs = _cpp_lex_direct (pfile);
+ if (pfile->buffer->cur != pfile->buffer->rlimit)
+ {
+ source_location saved_loc = lhs->src_loc;
+
+ _cpp_pop_buffer (pfile);
+ _cpp_backup_tokens (pfile, 1);
+ *lhsend = '\0';
+
+ /* We have to remove the PASTE_LEFT flag from the old lhs, but
+ we want to keep the new location. */
+ *lhs = **plhs;
+ *plhs = lhs;
+ lhs->src_loc = saved_loc;
+ lhs->flags &= ~PASTE_LEFT;
+
+ /* Mandatory error for all apart from assembler. */
+ if (CPP_OPTION (pfile, lang) != CLK_ASM)
+ cpp_error (pfile, CPP_DL_ERROR,
+ "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
+ buf, cpp_token_as_text (pfile, rhs));
+ return false;
+ }
- return valid;
+ *plhs = lhs;
+ _cpp_pop_buffer (pfile);
+ return true;
}
/* Handles an arbitrarily long sequence of ## operators, with initial
rhs = *FIRST (context).ptoken++;
if (rhs->type == CPP_PADDING)
- abort ();
-
- if (!paste_tokens (pfile, &lhs, rhs))
{
- _cpp_backup_tokens (pfile, 1);
-
- /* Mandatory error for all apart from assembler. */
- if (CPP_OPTION (pfile, lang) != CLK_ASM)
- cpp_error (pfile, CPP_DL_ERROR,
- "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
- cpp_token_as_text (pfile, lhs),
- cpp_token_as_text (pfile, rhs));
- break;
+ if (rhs->flags & PASTE_LEFT)
+ abort ();
}
+ if (!paste_tokens (pfile, &lhs, rhs))
+ break;
}
while (rhs->flags & PASTE_LEFT);
/* Put the resulting token in its own context. */
- push_token_context (pfile, NULL, lhs, 1);
+ _cpp_push_token_context (pfile, NULL, lhs, 1);
}
/* Returns TRUE if the number of arguments ARGC supplied in an
invocation. Assumes the opening parenthesis has been processed.
If there is an error, emits an appropriate diagnostic and returns
NULL. Each argument is terminated by a CPP_EOF token, for the
- future benefit of expand_arg(). */
+ future benefit of expand_arg(). If there are any deferred
+ #pragma directives among macro arguments, store pointers to the
+ CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer. */
static _cpp_buff *
-collect_args (cpp_reader *pfile, const cpp_hashnode *node)
+collect_args (cpp_reader *pfile, const cpp_hashnode *node,
+ _cpp_buff **pragma_buff)
{
_cpp_buff *buff, *base_buff;
cpp_macro *macro;
else if (token->type == CPP_EOF
|| (token->type == CPP_HASH && token->flags & BOL))
break;
+ else if (token->type == CPP_PRAGMA)
+ {
+ cpp_token *newtok = _cpp_temp_token (pfile);
+
+ /* CPP_PRAGMA token lives in directive_result, which will
+ be overwritten on the next directive. */
+ *newtok = *token;
+ token = newtok;
+ do
+ {
+ if (*pragma_buff == NULL
+ || BUFF_ROOM (*pragma_buff) < sizeof (cpp_token *))
+ {
+ _cpp_buff *next;
+ if (*pragma_buff == NULL)
+ *pragma_buff
+ = _cpp_get_buff (pfile, 32 * sizeof (cpp_token *));
+ else
+ {
+ next = *pragma_buff;
+ *pragma_buff
+ = _cpp_get_buff (pfile,
+ (BUFF_FRONT (*pragma_buff)
+ - (*pragma_buff)->base) * 2);
+ (*pragma_buff)->next = next;
+ }
+ }
+ *(const cpp_token **) BUFF_FRONT (*pragma_buff) = token;
+ BUFF_FRONT (*pragma_buff) += sizeof (cpp_token *);
+ if (token->type == CPP_PRAGMA_EOL)
+ break;
+ token = cpp_get_token (pfile);
+ }
+ while (token->type != CPP_EOF);
+
+ /* In deferred pragmas parsing_args and prevent_expansion
+ had been changed, reset it. */
+ pfile->state.parsing_args = 2;
+ pfile->state.prevent_expansion = 1;
+
+ if (token->type == CPP_EOF)
+ break;
+ else
+ continue;
+ }
arg->first[ntokens++] = token;
}
/* Search for an opening parenthesis to the macro of NODE, in such a
way that, if none is found, we don't lose the information in any
intervening padding tokens. If we find the parenthesis, collect
- the arguments and return the buffer containing them. */
+ the arguments and return the buffer containing them. PRAGMA_BUFF
+ argument is the same as in collect_args. */
static _cpp_buff *
-funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node)
+funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node,
+ _cpp_buff **pragma_buff)
{
const cpp_token *token, *padding = NULL;
if (token->type == CPP_OPEN_PAREN)
{
pfile->state.parsing_args = 2;
- return collect_args (pfile, node);
+ return collect_args (pfile, node, pragma_buff);
}
/* CPP_EOF can be the end of macro arguments, or the end of the
too difficult. We re-insert it in its own context. */
_cpp_backup_tokens (pfile, 1);
if (padding)
- push_token_context (pfile, NULL, padding, 1);
+ _cpp_push_token_context (pfile, NULL, padding, 1);
}
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.
- Otherwise, we don't push a context and return zero. */
+ If there were additionally any unexpanded deferred #pragma directives
+ among macro arguments, push another context containing the
+ pragma tokens before the yet-to-be-rescanned replacement list
+ and return two. Otherwise, we don't push a context and return zero. */
static int
-enter_macro_context (cpp_reader *pfile, cpp_hashnode *node)
+enter_macro_context (cpp_reader *pfile, cpp_hashnode *node,
+ const cpp_token *result)
{
/* The presence of a macro invalidates a file's controlling macro. */
pfile->mi_valid = false;
pfile->state.angled_headers = false;
+ if ((node->flags & NODE_BUILTIN) && !(node->flags & NODE_USED))
+ {
+ node->flags |= NODE_USED;
+ if (pfile->cb.used_define)
+ pfile->cb.used_define (pfile, pfile->directive_line, node);
+ }
+
/* Handle standard macros. */
if (! (node->flags & NODE_BUILTIN))
{
cpp_macro *macro = node->value.macro;
+ _cpp_buff *pragma_buff = NULL;
if (macro->fun_like)
{
pfile->state.prevent_expansion++;
pfile->keep_tokens++;
pfile->state.parsing_args = 1;
- buff = funlike_invocation_p (pfile, node);
+ buff = funlike_invocation_p (pfile, node, &pragma_buff);
pfile->state.parsing_args = 0;
pfile->keep_tokens--;
pfile->state.prevent_expansion--;
"function-like macro \"%s\" must be used with arguments in traditional C",
NODE_NAME (node));
+ if (pragma_buff)
+ _cpp_release_buff (pfile, pragma_buff);
+
return 0;
}
/* Disable the macro within its expansion. */
node->flags |= NODE_DISABLED;
+ if (!(node->flags & NODE_USED))
+ {
+ node->flags |= NODE_USED;
+ if (pfile->cb.used_define)
+ pfile->cb.used_define (pfile, pfile->directive_line, node);
+ }
+
macro->used = 1;
if (macro->paramc == 0)
- 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)
+ {
+ if (!pfile->state.in_directive)
+ _cpp_push_token_context (pfile, NULL,
+ padding_token (pfile, result), 1);
+ do
+ {
+ _cpp_buff *tail = pragma_buff->next;
+ pragma_buff->next = NULL;
+ push_ptoken_context (pfile, NULL, pragma_buff,
+ (const cpp_token **) pragma_buff->base,
+ ((const cpp_token **) BUFF_FRONT (pragma_buff)
+ - (const cpp_token **) pragma_buff->base));
+ pragma_buff = tail;
+ }
+ while (pragma_buff != NULL);
+ return 2;
+ }
return 1;
}
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. */
if (src->flags & PASTE_LEFT)
paste_flag = dest - 1;
}
+ else if (CPP_PEDANTIC (pfile) && ! macro->syshdr
+ && ! CPP_OPTION (pfile, c99)
+ && ! cpp_in_system_header (pfile))
+ {
+ cpp_error (pfile, CPP_DL_PEDWARN,
+ "invoking macro %s argument %d: "
+ "empty macro arguments are undefined"
+ " in ISO C90 and ISO C++98",
+ NODE_NAME (node),
+ src->val.macro_arg.arg_no);
+ }
/* Avoid paste on RHS (even case count == 0). */
if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
{
cpp_token *token = _cpp_temp_token (pfile);
token->type = (*paste_flag)->type;
- token->val.str = (*paste_flag)->val.str;
+ token->val = (*paste_flag)->val;
if (src->flags & PASTE_LEFT)
token->flags = (*paste_flag)->flags | PASTE_LEFT;
else
cpp_token *result = _cpp_temp_token (pfile);
result->type = CPP_PADDING;
- result->val.source = source;
+
+ /* Data in GCed data structures cannot be made const so far, so we
+ need a cast here. */
+ result->val.source = (cpp_token *) source;
result->flags = 0;
return result;
}
}
/* Push a list of tokens. */
-static void
-push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
- const cpp_token *first, unsigned int count)
+void
+_cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
+ const cpp_token *first, unsigned int count)
{
cpp_context *context = next_context (pfile);
/* Loop, reading in the arguments. */
capacity = 256;
- arg->expanded = xmalloc (capacity * sizeof (cpp_token *));
+ arg->expanded = XNEWVEC (const cpp_token *, capacity);
push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
for (;;)
if (arg->expanded_count + 1 >= capacity)
{
capacity *= 2;
- arg->expanded = xrealloc (arg->expanded,
- capacity * sizeof (cpp_token *));
+ arg->expanded = XRESIZEVEC (const cpp_token *, arg->expanded,
+ capacity);
}
token = cpp_get_token (pfile);
cpp_get_token (cpp_reader *pfile)
{
const cpp_token *result;
+ bool can_set = pfile->set_invocation_location;
+ pfile->set_invocation_location = false;
for (;;)
{
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;
if (!(node->flags & NODE_DISABLED))
{
- if (!pfile->state.prevent_expansion
- && enter_macro_context (pfile, node))
+ int ret = 0;
+ /* If not in a macro context, and we're going to start an
+ expansion, record the location. */
+ if (can_set && !context->macro)
+ pfile->invocation_location = result->src_loc;
+ if (pfile->state.prevent_expansion)
+ break;
+
+ /* Conditional macros require that a predicate be evaluated
+ first. */
+ if ((node->flags & NODE_CONDITIONAL) != 0)
{
- if (pfile->state.in_directive)
+ 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;
return padding_token (pfile, result);
}
cpp_token *t = _cpp_temp_token (pfile);
t->type = result->type;
t->flags = result->flags | NO_EXPAND;
- t->val.str = result->val.str;
+ t->val = result->val;
result = t;
}
return result;
}
+/* Like cpp_get_token, but also returns a location separate from the
+ one provided by the returned token. LOC is an out parameter; *LOC
+ is set to the location "as expected by the user". This matters
+ when a token results from macro expansion -- the token's location
+ will indicate where the macro is defined, but *LOC will be the
+ location of the start of the expansion. */
+const cpp_token *
+cpp_get_token_with_location (cpp_reader *pfile, source_location *loc)
+{
+ const cpp_token *result;
+
+ pfile->set_invocation_location = true;
+ result = cpp_get_token (pfile);
+ if (pfile->context->macro)
+ *loc = pfile->invocation_location;
+ else
+ *loc = result->src_loc;
+
+ return result;
+}
+
/* Returns true if we're expanding an object-like macro that was
defined in a system header. Just checks the macro at the top of
the stack. Used for diagnostic suppression. */
pfile->state.prevent_expansion--;
}
-/* Step back one (or more) tokens. Can only step mack more than 1 if
+/* Step back one or more tokens obtained from the lexer. */
+void
+_cpp_backup_tokens_direct (cpp_reader *pfile, unsigned int count)
+{
+ pfile->lookaheads += count;
+ while (count--)
+ {
+ pfile->cur_token--;
+ if (pfile->cur_token == pfile->cur_run->base
+ /* Possible with -fpreprocessed and no leading #line. */
+ && pfile->cur_run->prev != NULL)
+ {
+ pfile->cur_run = pfile->cur_run->prev;
+ pfile->cur_token = pfile->cur_run->limit;
+ }
+ }
+}
+
+/* Step back one (or more) tokens. Can only step back more than 1 if
they are from the lexer, and not from macro expansion. */
void
_cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
{
if (pfile->context->prev == NULL)
- {
- pfile->lookaheads += count;
- while (count--)
- {
- pfile->cur_token--;
- if (pfile->cur_token == pfile->cur_run->base
- /* Possible with -fpreprocessed and no leading #line. */
- && pfile->cur_run->prev != NULL)
- {
- pfile->cur_run = pfile->cur_run->prev;
- pfile->cur_token = pfile->cur_run->limit;
- }
- }
- }
+ _cpp_backup_tokens_direct (pfile, count);
else
{
if (count != 1)
if (node->flags & NODE_WARN)
return true;
+ /* Suppress warnings for builtins that lack the NODE_WARN flag. */
+ if (node->flags & NODE_BUILTIN)
+ return false;
+
+ /* Redefinitions of conditional (context-sensitive) macros, on
+ the other hand, must be allowed silently. */
+ if (node->flags & NODE_CONDITIONAL)
+ return false;
+
/* Redefinition of a macro is allowed if and only if the old and new
definitions are the same. (6.10.3 paragraph 2). */
macro1 = node->value.macro;
/* Macros and assertions no longer have anything to free. */
h->type = NT_VOID;
/* Clear builtin flag in case of redefinition. */
- h->flags &= ~(NODE_BUILTIN | NODE_DISABLED);
+ h->flags &= ~(NODE_BUILTIN | NODE_DISABLED | NODE_USED);
}
/* Save parameter NODE to the parameter list of macro MACRO. Returns
len = macro->paramc * sizeof (union _cpp_hashnode_value);
if (len > pfile->macro_buffer_len)
{
- pfile->macro_buffer = xrealloc (pfile->macro_buffer, len);
+ pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
+ len);
pfile->macro_buffer_len = len;
}
((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
}
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;
static cpp_token *
lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
{
- cpp_token *token;
+ cpp_token *token, *saved_cur_token;
+ saved_cur_token = pfile->cur_token;
pfile->cur_token = alloc_expansion_token (pfile, macro);
token = _cpp_lex_direct (pfile);
+ pfile->cur_token = saved_cur_token;
/* 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))
{
cpp_token *token;
const cpp_token *ctoken;
+ 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). */
/* Success. Commit or allocate the parameter array. */
if (pfile->hash_table->alloc_subobject)
{
- cpp_token *tokns = pfile->hash_table->alloc_subobject
- (sizeof (cpp_token) * macro->paramc);
- memcpy (tokns, macro->params, sizeof (cpp_token) * macro->paramc);
- macro->params = tokns;
+ cpp_hashnode **params =
+ (cpp_hashnode **) pfile->hash_table->alloc_subobject
+ (sizeof (cpp_hashnode *) * macro->paramc);
+ memcpy (params, macro->params,
+ sizeof (cpp_hashnode *) * macro->paramc);
+ macro->params = params;
}
else
BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->params[macro->paramc];
macro->fun_like = 1;
}
else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
- cpp_error (pfile, CPP_DL_PEDWARN,
- "ISO C requires whitespace after the macro name");
+ {
+ /* While ISO C99 requires whitespace before replacement text
+ in a macro definition, ISO C90 with TC1 allows there characters
+ from the basic source character set. */
+ if (CPP_OPTION (pfile, c99))
+ cpp_error (pfile, CPP_DL_PEDWARN,
+ "ISO C99 requires whitespace after the macro name");
+ else
+ {
+ int warntype = CPP_DL_WARNING;
+ switch (ctoken->type)
+ {
+ case CPP_ATSIGN:
+ case CPP_AT_NAME:
+ case CPP_OBJC_STRING:
+ /* '@' is not in basic character set. */
+ warntype = CPP_DL_PEDWARN;
+ break;
+ case CPP_OTHER:
+ /* Basic character set sans letters, digits and _. */
+ if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
+ ctoken->val.str.text[0]) == NULL)
+ warntype = CPP_DL_PEDWARN;
+ break;
+ default:
+ /* All other tokens start with a character from basic
+ character set. */
+ break;
+ }
+ cpp_error (pfile, warntype,
+ "missing whitespace after the macro name");
+ }
+ }
if (macro->fun_like)
token = lex_expansion_token (pfile, 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;
}
if (token->type == CPP_EOF)
- break;
+ {
+ /* Paste operator constraint 6.10.3.3.1:
+ Token-paste ##, can appear in both object-like and
+ function-like macros, but not at the end. */
+ if (following_paste_op)
+ {
+ cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
+ return false;
+ }
+ break;
+ }
/* Paste operator constraint 6.10.3.3.1. */
if (token->type == CPP_PASTE)
{
/* Token-paste ##, can appear in both object-like and
- function-like macros, but not at the ends. */
- if (--macro->count > 0)
- token = lex_expansion_token (pfile, macro);
-
- if (macro->count == 0 || token->type == CPP_EOF)
+ function-like macros, but not at the beginning. */
+ if (macro->count == 1)
{
- cpp_error (pfile, CPP_DL_ERROR,
- "'##' cannot appear at either end of a macro expansion");
+ cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
return false;
}
- 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);
token = lex_expansion_token (pfile, macro);
}
/* Commit or allocate the memory. */
if (pfile->hash_table->alloc_subobject)
{
- cpp_token *tokns = pfile->hash_table->alloc_subobject (sizeof (cpp_token)
- * macro->count);
- memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
+ cpp_token *tokns =
+ (cpp_token *) pfile->hash_table->alloc_subobject (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
bool ok;
if (pfile->hash_table->alloc_subobject)
- macro = pfile->hash_table->alloc_subobject (sizeof (cpp_macro));
+ macro = (cpp_macro *) pfile->hash_table->alloc_subobject
+ (sizeof (cpp_macro));
else
macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
macro->line = pfile->directive_line;
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;
ok = _cpp_create_trad_definition (pfile, macro);
else
{
- cpp_token *saved_cur_token = pfile->cur_token;
-
ok = create_iso_definition (pfile, macro);
- /* Restore lexer position because of games lex_expansion_token()
- plays lexing the macro. We set the type for SEEN_EOL() in
- cpplib.c.
+ /* We set the type for SEEN_EOL() in directives.c.
Longer term we should lex the whole line before coming here,
and just copy the expansion. */
- saved_cur_token[-1].type = pfile->cur_token[-1].type;
- pfile->cur_token = saved_cur_token;
/* Stop the lexer accepting __VA_ARGS__. */
pfile->state.va_args_ok = 0;
if (warn_of_redefinition (pfile, node, macro))
{
- cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->directive_line, 0,
- "\"%s\" redefined", NODE_NAME (node));
+ bool warned;
+ warned = cpp_error_with_line (pfile, CPP_DL_PEDWARN,
+ pfile->directive_line, 0,
+ "\"%s\" redefined", NODE_NAME (node));
- if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
- cpp_error_with_line (pfile, CPP_DL_PEDWARN,
+ if (warned && node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
+ cpp_error_with_line (pfile, CPP_DL_NOTE,
node->value.macro->line, 0,
"this is the location of the previous definition");
}
/* Enter definition in hash table. */
node->type = NT_MACRO;
node->value.macro = macro;
- if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_")))
+ if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_"))
+ && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_FORMAT_MACROS")
+ /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
+ in the C standard, as something that one must use in C++.
+ However DR#593 indicates that these aren't actually mentioned
+ in the C++ standard. We special-case them anyway. */
+ && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_LIMIT_MACROS")
+ && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_CONSTANT_MACROS"))
node->flags |= NODE_WARN;
+ /* If user defines one of the conditional macros, remove the
+ conditional flag */
+ node->flags &= ~NODE_CONDITIONAL;
+
return ok;
}
len += NODE_LEN (macro->params[i]) + 1; /* "," */
}
+ /* This should match below where we fill in the buffer. */
if (CPP_OPTION (pfile, traditional))
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) + 1; /* Includes room for ' '. */
+ len += cpp_token_len (token);
+
if (token->flags & STRINGIFY_ARG)
len++; /* "#" */
if (token->flags & PASTE_LEFT)
len += 3; /* " ##" */
+ if (token->flags & PREV_WHITE)
+ len++; /* " " */
}
}
if (len > pfile->macro_buffer_len)
{
- pfile->macro_buffer = xrealloc (pfile->macro_buffer, len);
+ pfile->macro_buffer = XRESIZEVEC (unsigned char,
+ pfile->macro_buffer, len);
pfile->macro_buffer_len = len;
}
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)
{
- len = NODE_LEN (macro->params[token->val.arg_no - 1]);
memcpy (buffer,
- NODE_NAME (macro->params[token->val.arg_no - 1]), len);
- buffer += len;
+ 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);
+ buffer = cpp_spell_token (pfile, token, buffer, false);
if (token->flags & PASTE_LEFT)
{
OSDN Git Service
