Variadic macros cannot occur with traditional cpp. */
struct cpp_macro
{
- cpp_hashnode **params; /* Parameters, if any. */
+ /* Parameters, if any. */
+ cpp_hashnode **params;
+
+ /* Replacement tokens (ISO) or replacement text (traditional). See
+ comment at top of cpptrad.c for how traditional function-like
+ macros are encoded. */
union
{
- cpp_token *tokens; /* Tokens of replacement list (ISO). */
- const uchar *text; /* Expansion text (traditional). */
+ cpp_token *tokens;
+ const uchar *text;
} exp;
- unsigned int line; /* Starting line number. */
- unsigned int count; /* Number of tokens / bytes in expansion. */
- unsigned short paramc; /* Number of parameters. */
- unsigned int fun_like : 1; /* If a function-like macro. */
- unsigned int variadic : 1; /* If a variadic macro. */
- unsigned int syshdr : 1; /* If macro defined in system header. */
+
+ /* Definition line number. */
+ unsigned int line;
+
+ /* Number of tokens in expansion, or bytes for traditional macros. */
+ unsigned int count;
+
+ /* Number of parameters. */
+ unsigned short paramc;
+
+ /* If a function-like macro. */
+ unsigned int fun_like : 1;
+
+ /* If a variadic macro. */
+ unsigned int variadic : 1;
+
+ /* If macro defined in system header. */
+ unsigned int syshdr : 1;
};
/* A generic memory buffer, and operations on it. */
extern cpp_hashnode *_cpp_lex_identifier_trad PARAMS ((cpp_reader *));
extern void _cpp_set_trad_context PARAMS ((cpp_reader *));
extern bool _cpp_create_trad_definition PARAMS ((cpp_reader *, cpp_macro *));
+extern bool _cpp_expansions_different_trad PARAMS ((cpp_macro *, cpp_macro *));
/* Utility routines and macros. */
#define DSC(str) (const uchar *)str, sizeof str - 1
definitions are the same. (6.10.3 paragraph 2). */
macro1 = node->value.macro;
- /* The quick failures. */
- if (macro1->count != macro2->count
- || macro1->paramc != macro2->paramc
+ /* Don't check count here as it can be different in valid
+ traditional redefinitions with just whitespace differences. */
+ if (macro1->paramc != macro2->paramc
|| macro1->fun_like != macro2->fun_like
|| macro1->variadic != macro2->variadic)
return true;
/* Check the replacement text or tokens. */
if (CPP_OPTION (pfile, traditional))
- return memcmp (macro1->exp.text, macro2->exp.text, macro1->count);
+ return _cpp_expansions_different_trad (macro1, macro2);
- 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)
+ for (i = 0; i < macro1->count; i++)
+ if (!_cpp_equiv_tokens (¯o1->exp.tokens[i], ¯o2->exp.tokens[i]))
+ return true;
return false;
}
const uchar *, struct fun_macro *));
static void save_argument PARAMS ((struct fun_macro *, size_t));
static void replace_args_and_push PARAMS ((cpp_reader *, struct fun_macro *));
+static size_t canonicalize_text PARAMS ((uchar *, const uchar *, size_t,
+ uchar *));
/* Ensures we have N bytes' space in the output buffer, and
reallocates it if not. */
pfile->state.parsing_args = 0;
save_argument (&fmacro, out - pfile->trad_out_base);
- /* A single whitespace argument is no argument. */
- if (fmacro.argc == 1 && m->paramc == 0)
- {
- const uchar *p = pfile->trad_out_base;
- p += fmacro.args[0];
- while (is_space (*p))
- p++;
- if (p == pfile->trad_out_base + fmacro.args[1])
- fmacro.argc = 0;
- }
+ /* A single zero-length argument is no argument. */
+ if (fmacro.argc == 1
+ && m->paramc == 0
+ && out == pfile->trad_out_base + 1)
+ fmacro.argc = 0;
if (_cpp_arguments_ok (pfile, m, fmacro.node, fmacro.argc))
{
/* Lex the rest into the start of the output buffer. */
pfile->trad_out_cur = pfile->trad_out_base;
- /* If this is the end of the macro, count up the bytes of text
- in the replacement list, excluding the parameter names, and
- save this in macro->count, else store the total bytes in the
- replacement text so far (including block headers). */
macro->count += blen;
+
+ /* If we've finished, commit the memory. */
+ if (arg_index == 0)
+ BUFF_FRONT (pfile->a_buff) += macro->count;
}
}
return true;
}
+/* Copy SRC of length LEN to DEST, but convert all contiguous
+ whitespace to a single space, provided it is not in quotes. The
+ quote currently in effect is pointed to by PQUOTE, and is updated
+ by the function. Returns the number of bytes copied. */
+static size_t
+canonicalize_text (dest, src, len, pquote)
+ uchar *dest;
+ const uchar *src;
+ size_t len;
+ uchar *pquote;
+{
+ uchar *orig_dest = dest;
+ uchar quote = *pquote;
+
+ while (len)
+ {
+ if (is_space (*src) && !quote)
+ {
+ do
+ src++, len--;
+ while (len && is_space (*src));
+ *dest++ = ' ';
+ }
+ else
+ {
+ if (*src == '\'' || *src == '"')
+ {
+ if (!quote)
+ quote = *src;
+ else if (quote == *src)
+ quote = 0;
+ }
+ *dest++ = *src++, len--;
+ }
+ }
+
+ *pquote = quote;
+ return dest - orig_dest;
+}
+
+/* Returns true if MACRO1 and MACRO2 have expansions different other
+ than in the form of their whitespace. */
+bool
+_cpp_expansions_different_trad (macro1, macro2)
+ cpp_macro *macro1, *macro2;
+{
+ uchar *p1 = xmalloc (macro1->count + macro2->count);
+ uchar *p2 = p1 + macro1->count;
+ uchar quote1 = 0, quote2;
+ bool mismatch;
+ size_t len1, len2;
+
+ if (macro1->paramc > 0)
+ {
+ const uchar *exp1 = macro1->exp.text, *exp2 = macro2->exp.text;
+
+ mismatch = true;
+ for (;;)
+ {
+ struct block *b1 = (struct block *) exp1;
+ struct block *b2 = (struct block *) exp2;
+
+ if (b1->arg_index != b2->arg_index)
+ break;
+
+ len1 = canonicalize_text (p1, b1->text, b1->text_len, "e1);
+ len2 = canonicalize_text (p2, b2->text, b2->text_len, "e2);
+ if (len1 != len2 || memcmp (p1, p2, len1))
+ break;
+ if (b1->arg_index == 0)
+ {
+ mismatch = false;
+ break;
+ }
+ exp1 += BLOCK_LEN (b1->text_len);
+ exp2 += BLOCK_LEN (b2->text_len);
+ }
+ }
+ else
+ {
+ len1 = canonicalize_text (p1, macro1->exp.text, macro1->count, "e1);
+ len2 = canonicalize_text (p2, macro2->exp.text, macro2->count, "e2);
+ mismatch = (len1 != len2 || memcmp (p1, p2, len1));
+ }
+
+ free (p1);
+ return mismatch;
+}
+
/* Prepare to be able to scan the current buffer. */
void
_cpp_set_trad_context (pfile)
OSDN Git Service
