/* Part of CPP library. (Macro and #define handling.)
Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1998,
- 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002, 2003 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
#include "config.h"
#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
#include "cpplib.h"
#include "cpphash.h"
cpp_macro *macro = node->value.macro;
if (!macro->used
- /* Skip front-end built-ins and command line macros. */
- && macro->line >= pfile->first_unused_line
&& MAIN_FILE_P (lookup_line (&pfile->line_maps, macro->line)))
cpp_error_with_line (pfile, DL_WARNING, macro->line, 0,
"macro \"%s\" is not used", NODE_NAME (node));
value 0. */
case BT_STDC:
{
- enum c_lang lang = CPP_OPTION (pfile, lang);
if (CPP_IN_SYSTEM_HEADER (pfile)
&& CPP_OPTION (pfile, stdc_0_in_system_headers)
- && !(lang == CLK_STDC89 || lang == CLK_STDC94
- || lang == CLK_STDC99)) /* || lang == CLK_CXX98 ? */
+ && !CPP_OPTION (pfile,std))
number = 0;
else
number = 1;
storage. We only do this once, and don't generate them
at init time, because time() and localtime() are very
slow on some systems. */
- time_t tt = time (NULL);
- struct tm *tb = localtime (&tt);
-
- pfile->date = _cpp_unaligned_alloc (pfile,
- sizeof ("\"Oct 11 1347\""));
- sprintf ((char *) pfile->date, "\"%s %2d %4d\"",
- monthnames[tb->tm_mon], tb->tm_mday, tb->tm_year + 1900);
-
- pfile->time = _cpp_unaligned_alloc (pfile, sizeof ("\"12:34:56\""));
- sprintf ((char *) pfile->time, "\"%02d:%02d:%02d\"",
- tb->tm_hour, tb->tm_min, tb->tm_sec);
+ time_t tt;
+ struct tm *tb = NULL;
+
+ /* (time_t) -1 is a legitimate value for "number of seconds
+ since the Epoch", so we have to do a little dance to
+ distinguish that from a genuine error. */
+ errno = 0;
+ tt = time(NULL);
+ if (tt != (time_t)-1 || errno == 0)
+ tb = localtime (&tt);
+
+ if (tb)
+ {
+ pfile->date = _cpp_unaligned_alloc (pfile,
+ sizeof ("\"Oct 11 1347\""));
+ sprintf ((char *) pfile->date, "\"%s %2d %4d\"",
+ monthnames[tb->tm_mon], tb->tm_mday, tb->tm_year + 1900);
+
+ pfile->time = _cpp_unaligned_alloc (pfile,
+ sizeof ("\"12:34:56\""));
+ sprintf ((char *) pfile->time, "\"%02d:%02d:%02d\"",
+ tb->tm_hour, tb->tm_min, tb->tm_sec);
+ }
+ else
+ {
+ cpp_errno (pfile, DL_WARNING,
+ "could not determine date and time");
+
+ pfile->date = U"\"??? ?? ????\"";
+ pfile->time = U"\"??:??:??\"";
+ }
}
if (node->value.builtin == BT_DATE)
cpp_hashnode *node;
{
const uchar *buf;
+ size_t len;
+ char *nbuf;
if (node->value.builtin == BT_PRAGMA)
{
}
buf = _cpp_builtin_macro_text (pfile, node);
+ len = ustrlen (buf);
+ nbuf = alloca (len + 1);
+ memcpy (nbuf, buf, len);
+ nbuf[len]='\n';
- cpp_push_buffer (pfile, buf, ustrlen (buf), /* from_stage3 */ true, 1);
-
- /* Tweak the column number the lexer will report. */
- pfile->buffer->col_adjust = pfile->cur_token[-1].col - 1;
-
- /* We don't want a leading # to be interpreted as a directive. */
- pfile->buffer->saved_flags = 0;
+ cpp_push_buffer (pfile, (uchar *) nbuf, len, /* from_stage3 */ true, 1);
+ _cpp_clean_line (pfile);
/* Set pfile->cur_token as required by _cpp_lex_direct. */
pfile->cur_token = _cpp_temp_token (pfile);
cpp_reader *pfile;
macro_arg *arg;
{
- unsigned char *dest = BUFF_FRONT (pfile->u_buff);
+ unsigned char *dest;
unsigned int i, escape_it, backslash_count = 0;
const cpp_token *source = NULL;
size_t len;
+ if (BUFF_ROOM (pfile->u_buff) < 3)
+ _cpp_extend_buff (pfile, &pfile->u_buff, 3);
+ dest = BUFF_FRONT (pfile->u_buff);
+ *dest++ = '"';
+
/* Loop, reading in the argument's tokens. */
for (i = 0; i < arg->count; i++)
{
|| token->type == CPP_CHAR || token->type == CPP_WCHAR);
/* Room for each char being written in octal, initial space and
- final NUL. */
+ final quote and NUL. */
len = cpp_token_len (token);
if (escape_it)
len *= 4;
- len += 2;
+ len += 3;
if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
{
}
/* Leading white space? */
- if (dest != BUFF_FRONT (pfile->u_buff))
+ if (dest - 1 != BUFF_FRONT (pfile->u_buff))
{
if (source == NULL)
source = token;
else
dest = cpp_spell_token (pfile, token, dest);
- if (token->type == CPP_OTHER && token->val.c == '\\')
+ if (token->type == CPP_OTHER && token->val.str.text[0] == '\\')
backslash_count++;
else
backslash_count = 0;
}
/* Commit the memory, including NUL, and return the token. */
+ *dest++ = '"';
len = dest - BUFF_FRONT (pfile->u_buff);
BUFF_FRONT (pfile->u_buff) = dest + 1;
return new_string_token (pfile, dest - len, len);
}
-/* Try to paste two tokens. On success, return non-zero. In any
+/* Try to paste two tokens. On success, return nonzero. In any
case, PLHS is updated to point to the pasted token, which is
guaranteed to not have the PASTE_LEFT flag set. */
static bool
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_MULT || rhs->type == CPP_DIV))
+ if (lhs->type == CPP_DIV && rhs->type != CPP_EQ)
*end++ = ' ';
end = cpp_spell_token (pfile, rhs, end);
- *end = '\0';
+ *end = '\n';
cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true, 1);
-
- /* Tweak the column number the lexer will report. */
- pfile->buffer->col_adjust = pfile->cur_token[-1].col - 1;
-
- /* We don't want a leading # to be interpreted as a directive. */
- pfile->buffer->saved_flags = 0;
+ _cpp_clean_line (pfile);
/* Set pfile->cur_token as required by _cpp_lex_direct. */
pfile->cur_token = _cpp_temp_token (pfile);
if (argc == 1 && macro->paramc == 0 && args[0].count == 0)
argc = 0;
if (_cpp_arguments_ok (pfile, macro, node, argc))
- return base_buff;
+ {
+ /* GCC has special semantics for , ## b where b is a varargs
+ parameter: we remove the comma if b was omitted entirely.
+ If b was merely an empty argument, the comma is retained.
+ If the macro takes just one (varargs) parameter, then we
+ retain the comma only if we are standards conforming.
+
+ If FIRST is NULL replace_args () swallows the comma. */
+ if (macro->variadic && (argc < macro->paramc
+ || (argc == 1 && args[0].count == 0
+ && !CPP_OPTION (pfile, std))))
+ args[macro->paramc - 1].first = NULL;
+ return base_buff;
+ }
}
/* An error occurred. */
count = arg->count, from = arg->first;
if (dest != first)
{
- /* GCC has special semantics for , ## b where b is a
- varargs parameter: the comma disappears if b was
- given no actual arguments (not merely if b is an
- empty argument); otherwise the paste flag is removed. */
if (dest[-1]->type == CPP_COMMA
&& macro->variadic
&& src->val.arg_no == macro->paramc)
{
- if (count == 0)
+ /* Swallow a pasted comma if from == NULL, otherwise
+ drop the paste flag. */
+ if (from == NULL)
dest--;
else
paste_flag = dest - 1;
count = arg->expanded_count, from = arg->expanded;
/* Padding on the left of an argument (unless RHS of ##). */
- if (!pfile->state.in_directive
+ if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
&& src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
*dest++ = padding_token (pfile, src);
macro_arg *arg;
{
unsigned int capacity;
+ bool saved_warn_trad;
if (arg->count == 0)
return;
+ /* Don't warn about funlike macros when pre-expanding. */
+ saved_warn_trad = CPP_WTRADITIONAL (pfile);
+ CPP_WTRADITIONAL (pfile) = 0;
+
/* Loop, reading in the arguments. */
capacity = 256;
arg->expanded = (const cpp_token **)
}
_cpp_pop_context (pfile);
+
+ CPP_WTRADITIONAL (pfile) = saved_warn_trad;
}
/* Pop the current context off the stack, re-enabling the macro if the
/* #define directive parsing and handling. */
-/* Returns non-zero if a macro redefinition warning is required. */
+/* Returns nonzero if a macro redefinition warning is required. */
static bool
warn_of_redefinition (pfile, node, macro2)
cpp_reader *pfile;
if (CPP_OPTION (pfile, traditional))
return _cpp_expansions_different_trad (macro1, macro2);
- if (macro1->count == macro2->count)
- for (i = 0; i < macro1->count; i++)
- if (!_cpp_equiv_tokens (¯o1->exp.tokens[i], ¯o2->exp.tokens[i]))
- return true;
+ if (macro1->count != macro2->count)
+ return true;
+
+ for (i = 0; i < macro1->count; i++)
+ if (!_cpp_equiv_tokens (¯o1->exp.tokens[i], ¯o2->exp.tokens[i]))
+ return true;
return false;
}
}
/* Save parameter NODE to the parameter list of macro MACRO. Returns
- zero on success, non-zero if the parameter is a duplicate. */
+ zero on success, nonzero if the parameter is a duplicate. */
bool
_cpp_save_parameter (pfile, macro, node)
cpp_reader *pfile;
cpp_macro *macro;
cpp_hashnode *node;
{
+ unsigned int len;
/* Constraint 6.10.3.6 - duplicate parameter names. */
- if (node->arg_index)
+ if (node->flags & NODE_MACRO_ARG)
{
cpp_error (pfile, DL_ERROR, "duplicate macro parameter \"%s\"",
NODE_NAME (node));
_cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
- node->arg_index = macro->paramc;
+ node->flags |= NODE_MACRO_ARG;
+ len = macro->paramc * sizeof (union _cpp_hashnode_value);
+ if (len > pfile->macro_buffer_len)
+ {
+ pfile->macro_buffer = (uchar *) xrealloc (pfile->macro_buffer, len);
+ pfile->macro_buffer_len = len;
+ }
+ ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
+ = node->value;
+
+ node->value.arg_index = macro->paramc;
return false;
}
token = _cpp_lex_direct (pfile);
/* Is this a parameter? */
- if (token->type == CPP_NAME && token->val.node->arg_index)
+ if (token->type == CPP_NAME
+ && (token->val.node->flags & NODE_MACRO_ARG) != 0)
{
token->type = CPP_MACRO_ARG;
- token->val.arg_no = token->val.node->arg_index;
+ token->val.arg_no = token->val.node->value.arg_index;
}
else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
&& (token->type == CPP_STRING || token->type == CPP_CHAR))
return true;
}
-/* Parse a macro and save its expansion. Returns non-zero on success. */
+/* Parse a macro and save its expansion. Returns nonzero on success. */
bool
_cpp_create_definition (pfile, node)
cpp_reader *pfile;
macro->params = 0;
macro->paramc = 0;
macro->variadic = 0;
- macro->used = 0;
+ macro->used = !CPP_OPTION (pfile, warn_unused_macros);
macro->count = 0;
macro->fun_like = 0;
/* To suppress some diagnostics. */
/* Clear the fast argument lookup indices. */
for (i = macro->paramc; i-- > 0; )
- macro->params[i]->arg_index = 0;
+ {
+ struct cpp_hashnode *node = macro->params[i];
+ node->flags &= ~ NODE_MACRO_ARG;
+ node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i];
+ }
if (!ok)
return ok;
- if (node->type != NT_VOID)
+ if (node->type == NT_MACRO)
{
if (CPP_OPTION (pfile, warn_unused_macros))
_cpp_warn_if_unused_macro (pfile, node, NULL);
node->value.macro->line, 0,
"this is the location of the previous definition");
}
- _cpp_free_definition (node);
}
+ if (node->type != NT_VOID)
+ _cpp_free_definition (node);
+
/* Enter definition in hash table. */
node->type = NT_MACRO;
node->value.macro = macro;
const cpp_string *string;
{
unsigned int i, len;
- const uchar *p, *q, *limit = string->text + string->len;
+ const uchar *p, *q, *limit;
/* Loop over the string. */
- for (p = string->text; p < limit; p = q)
+ limit = string->text + string->len - 1;
+ for (p = string->text + 1; p < limit; p = q)
{
/* Find the start of an identifier. */
while (p < limit && !is_idstart (*p))
if (token->type == CPP_MACRO_ARG)
len += NODE_LEN (macro->params[token->val.arg_no - 1]);
else
- len += cpp_token_len (token); /* Includes room for ' '. */
+ len += cpp_token_len (token) + 1; /* Includes room for ' '. */
if (token->flags & STRINGIFY_ARG)
len++; /* "#" */
if (token->flags & PASTE_LEFT)
OSDN Git Service
