+2000-07-18 Zack Weinberg <zack@wolery.cumb.org>
+
+ * cpplib.h (TTYPE_TABLE): Rearrange to use only two per-entry
+ macros, not five.
+
+ * cpphash.h (TOKEN_NAME): New macro.
+ (_cpp_spell_operator): Deleted.
+ (token_spellings): Now _cpp_token_spellings.
+
+ * cppexp.c: Use TOKEN_NAME or TYPE_NAME, not _cpp_spell_operator.
+ * cpplex.c: Use OP and TK macros when expanding the
+ TTYPE_TABLE. Eliminate token_names. For non-OPERATOR tokens,
+ store the stringification of the enumeration name (CPP_CHAR,
+ etc.) in the name slot of token_spellings.
+ Use TOKEN_NAME and/or TOKEN_SPELL, do not reference
+ token_spellings directly.
+ * cpplib.c: Use TOKEN_SPELL.
+
+ * cpplex.c (_cpp_push_token): If the token being pushed back
+ is the previous token in this context, just subtract one from
+ context->posn.
+ * cppmacro.c (save_expansion): Clear aux field when storing a
+ placemarker.
+
2000-07-18 Jakub Jelinek <jakub@redhat.com>
* cpplex.c (cpp_scan_buffer): Output line command even at the stop
switch (tok->type)
{
case CPP_PLACEMARKER:
- /* XXX These shouldn't be visible outside cpplex.c. */
goto retry;
case CPP_INT:
return op;
}
- SYNTAX_ERROR2("'%s' is not valid in #if expressions",
- _cpp_spell_operator (tok->type));
+ SYNTAX_ERROR2("'%s' is not valid in #if expressions", TOKEN_NAME (tok));
}
syntax_error:
/* Parse and evaluate a C expression, reading from PFILE.
Returns the truth value of the expression. */
+#define TYPE_NAME(t) _cpp_token_spellings[t].name
+
int
_cpp_parse_expr (pfile)
cpp_reader *pfile;
SYNTAX_ERROR ("void expression between '(' and ')'");
else
SYNTAX_ERROR2 ("operator '%s' has no right operand",
- _cpp_spell_operator (top->op));
+ TYPE_NAME (top->op));
}
unsigned2 = top->unsignedp, v2 = top->value;
switch (top[1].op)
{
default:
- cpp_ice (pfile, "impossible operator type %s",
- _cpp_spell_operator (op.op));
+ cpp_ice (pfile, "impossible operator type %s", TYPE_NAME (op.op));
goto syntax_error;
case CPP_NOT: UNARY(!); break;
{
if (top->flags & HAVE_VALUE)
SYNTAX_ERROR2 ("missing binary operator before '%s'",
- _cpp_spell_operator (op.op));
+ TYPE_NAME (op.op));
}
else
{
if (!(top->flags & HAVE_VALUE))
SYNTAX_ERROR2 ("operator '%s' has no left operand",
- _cpp_spell_operator (op.op));
+ TYPE_NAME (op.op));
}
/* Check for and handle stack overflow. */
struct token_spelling
{
- ENUM_BITFIELD(spell_type) type : CHAR_BIT;
- const U_CHAR *spelling;
+ enum spell_type category;
+ const U_CHAR *name;
};
-extern const struct token_spelling token_spellings[];
-#define TOKEN_SPELL(token) (token_spellings[(token)->type].type)
+extern const struct token_spelling _cpp_token_spellings[];
+#define TOKEN_SPELL(token) (_cpp_token_spellings[(token)->type].category)
+#define TOKEN_NAME(token) (_cpp_token_spellings[(token)->type].name)
/* Chained list of answers to an assertion. */
struct answer
extern const cpp_token *_cpp_get_raw_token PARAMS ((cpp_reader *));
extern void _cpp_push_token PARAMS ((cpp_reader *, const cpp_token*));
extern const cpp_token *_cpp_glue_header_name PARAMS ((cpp_reader *));
-extern const U_CHAR *_cpp_spell_operator PARAMS ((enum cpp_ttype));
/* In cpplib.c */
extern const struct directive *_cpp_check_directive
if ((f) & BOL) {(d)->col = (s)->col; (d)->line = (s)->line;} \
} while (0)
-#define T(e, s) {SPELL_OPERATOR, (const U_CHAR *) s},
-#define I(e, s) {SPELL_IDENT, s},
-#define S(e, s) {SPELL_STRING, s},
-#define C(e, s) {SPELL_CHAR, s},
-#define N(e, s) {SPELL_NONE, s},
+#define OP(e, s) { SPELL_OPERATOR, U s },
+#define TK(e, s) { s, U STRINGX (e) },
const struct token_spelling
-token_spellings [N_TTYPES + 1] = {TTYPE_TABLE {0, 0} };
+_cpp_token_spellings [N_TTYPES] = {TTYPE_TABLE };
-#undef T
-#undef I
-#undef S
-#undef C
-#undef N
-
-/* For debugging: the internal names of the tokens. */
-#define T(e, s) U STRINGX(e),
-#define I(e, s) U STRINGX(e),
-#define S(e, s) U STRINGX(e),
-#define C(e, s) U STRINGX(e),
-#define N(e, s) U STRINGX(e),
-
-const U_CHAR *const token_names[N_TTYPES] = { TTYPE_TABLE };
-
-#undef T
-#undef I
-#undef S
-#undef C
-#undef N
+#undef OP
+#undef TK
/* The following table is used by trigraph_ok/trigraph_replace. If we
have designated initializers, it can be constant data; otherwise,
unsigned int i;
for (i = 0; i < list->tokens_used; i++)
- if (token_spellings[list->tokens[i].type].type == SPELL_STRING)
+ if (TOKEN_SPELL (&list->tokens[i]) == SPELL_STRING)
list->tokens[i].val.str.text += (list->namebuf - old_namebuf);
}
}
const cpp_token *a, *b;
{
if (a->type == b->type && a->flags == b->flags)
- switch (token_spellings[a->type].type)
+ switch (TOKEN_SPELL (a))
{
default: /* Keep compiler happy. */
case SPELL_OPERATOR:
const cpp_token *token;
unsigned char *buffer;
{
- switch (token_spellings[token->type].type)
+ switch (TOKEN_SPELL (token))
{
case SPELL_OPERATOR:
{
if (token->flags & DIGRAPH)
spelling = digraph_spellings[token->type - CPP_FIRST_DIGRAPH];
else
- spelling = token_spellings[token->type].spelling;
+ spelling = TOKEN_NAME (token);
while ((c = *spelling++) != '\0')
*buffer++ = c;
break;
case SPELL_NONE:
- cpp_ice (pfile, "Unspellable token %s", token_names[token->type]);
+ cpp_ice (pfile, "Unspellable token %s", TOKEN_NAME (token));
break;
}
return buffer;
}
-/* Return the spelling of a token known to be an operator.
- Does not distinguish digraphs from their counterparts. */
-const unsigned char *
-_cpp_spell_operator (type)
- enum cpp_ttype type;
-{
- if (token_spellings[type].type == SPELL_OPERATOR)
- return token_spellings[type].spelling;
- else
- return token_names[type];
-}
-
-
/* Macro expansion algorithm.
Macro expansion is implemented by a single-pass algorithm; there are
{
cpp_token *token = pfile->temp_tokens[--pfile->temp_used];
- if (token_spellings[token->type].type == SPELL_STRING)
+ if (TOKEN_SPELL (token) == SPELL_STRING)
{
free ((char *) token->val.str.text);
token->val.str.text = 0;
cpp_token *result = get_temp_token (pfile);
*result = *token;
- if (token_spellings[token->type].type == SPELL_STRING)
+ if (TOKEN_SPELL (token) == SPELL_STRING)
{
U_CHAR *buff = (U_CHAR *) xmalloc (token->val.str.len);
memcpy (buff, token->val.str.text, token->val.str.len);
unsigned char *buf;
unsigned int len = TOKEN_LEN (token);
+ if (token->type == CPP_PLACEMARKER)
+ continue;
+
escape = (token->type == CPP_STRING || token->type == CPP_WSTRING
|| token->type == CPP_CHAR || token->type == CPP_WCHAR);
if (escape)
const cpp_token *token;
{
cpp_context *context = CURRENT_CONTEXT (pfile);
+
+ if (context->posn > 0)
+ {
+ const cpp_token *prev;
+ if (IS_ARG_CONTEXT (context))
+ prev = context->u.arg[context->posn - 1];
+ else
+ prev = &context->u.list->tokens[context->posn - 1];
+
+ if (prev == token)
+ {
+ context->posn--;
+ return;
+ }
+ }
+
if (context->pushed_token)
cpp_ice (pfile, "two tokens pushed in a row");
if (token->type != CPP_EOF)
if (token[1].type == CPP_NAME)
_cpp_get_raw_token (pfile);
else if (token[1].type != CPP_NUMBER)
- cpp_ice (pfile, "directive begins with %s?!",
- token_names[token[1].type]);
+ cpp_ice (pfile, "directive begins with %s?!", TOKEN_NAME (token));
/* Flush pending tokens at this point, in case the directive produces
output. XXX Directive output won't be visible to a direct caller of
CPP_PUTC (pfile, '#');
dump_param_spelling (pfile, list, token->val.aux);
}
- else
+ else if (token->type != CPP_PLACEMARKER)
output_token (pfile, token, prev);
if (token->flags & PASTE_LEFT)
CPP_PUTS (pfile, " ##", 3);
dest = &list->tokens[list->tokens_used++];
*dest = *token;
- if (token_spellings[token->type].type == SPELL_STRING)
+ if (TOKEN_SPELL (token) == SPELL_STRING)
{
_cpp_expand_name_space (list, token->val.str.len);
dest->val.str.text = list->namebuf + list->name_used;
#define CPP_FIRST_DIGRAPH CPP_HASH
#define TTYPE_TABLE \
- T(CPP_EQ = 0, "=") \
- T(CPP_NOT, "!") \
- T(CPP_GREATER, ">") /* compare */ \
- T(CPP_LESS, "<") \
- T(CPP_PLUS, "+") /* math */ \
- T(CPP_MINUS, "-") \
- T(CPP_MULT, "*") \
- T(CPP_DIV, "/") \
- T(CPP_MOD, "%") \
- T(CPP_AND, "&") /* bit ops */ \
- T(CPP_OR, "|") \
- T(CPP_XOR, "^") \
- T(CPP_RSHIFT, ">>") \
- T(CPP_LSHIFT, "<<") \
+ OP(CPP_EQ = 0, "=") \
+ OP(CPP_NOT, "!") \
+ OP(CPP_GREATER, ">") /* compare */ \
+ OP(CPP_LESS, "<") \
+ OP(CPP_PLUS, "+") /* math */ \
+ OP(CPP_MINUS, "-") \
+ OP(CPP_MULT, "*") \
+ OP(CPP_DIV, "/") \
+ OP(CPP_MOD, "%") \
+ OP(CPP_AND, "&") /* bit ops */ \
+ OP(CPP_OR, "|") \
+ OP(CPP_XOR, "^") \
+ OP(CPP_RSHIFT, ">>") \
+ OP(CPP_LSHIFT, "<<") \
\
- T(CPP_COMPL, "~") \
- T(CPP_AND_AND, "&&") /* logical */ \
- T(CPP_OR_OR, "||") \
- T(CPP_QUERY, "?") \
- T(CPP_COLON, ":") \
- T(CPP_COMMA, ",") /* grouping */ \
- T(CPP_OPEN_PAREN, "(") \
- T(CPP_CLOSE_PAREN, ")") \
- T(CPP_EQ_EQ, "==") /* compare */ \
- T(CPP_NOT_EQ, "!=") \
- T(CPP_GREATER_EQ, ">=") \
- T(CPP_LESS_EQ, "<=") \
+ OP(CPP_COMPL, "~") \
+ OP(CPP_AND_AND, "&&") /* logical */ \
+ OP(CPP_OR_OR, "||") \
+ OP(CPP_QUERY, "?") \
+ OP(CPP_COLON, ":") \
+ OP(CPP_COMMA, ",") /* grouping */ \
+ OP(CPP_OPEN_PAREN, "(") \
+ OP(CPP_CLOSE_PAREN, ")") \
+ OP(CPP_EQ_EQ, "==") /* compare */ \
+ OP(CPP_NOT_EQ, "!=") \
+ OP(CPP_GREATER_EQ, ">=") \
+ OP(CPP_LESS_EQ, "<=") \
\
- T(CPP_PLUS_EQ, "+=") /* math */ \
- T(CPP_MINUS_EQ, "-=") \
- T(CPP_MULT_EQ, "*=") \
- T(CPP_DIV_EQ, "/=") \
- T(CPP_MOD_EQ, "%=") \
- T(CPP_AND_EQ, "&=") /* bit ops */ \
- T(CPP_OR_EQ, "|=") \
- T(CPP_XOR_EQ, "^=") \
- T(CPP_RSHIFT_EQ, ">>=") \
- T(CPP_LSHIFT_EQ, "<<=") \
+ OP(CPP_PLUS_EQ, "+=") /* math */ \
+ OP(CPP_MINUS_EQ, "-=") \
+ OP(CPP_MULT_EQ, "*=") \
+ OP(CPP_DIV_EQ, "/=") \
+ OP(CPP_MOD_EQ, "%=") \
+ OP(CPP_AND_EQ, "&=") /* bit ops */ \
+ OP(CPP_OR_EQ, "|=") \
+ OP(CPP_XOR_EQ, "^=") \
+ OP(CPP_RSHIFT_EQ, ">>=") \
+ OP(CPP_LSHIFT_EQ, "<<=") \
/* Digraphs together, beginning with CPP_FIRST_DIGRAPH. */ \
- T(CPP_HASH, "#") /* digraphs */ \
- T(CPP_PASTE, "##") \
- T(CPP_OPEN_SQUARE, "[") \
- T(CPP_CLOSE_SQUARE, "]") \
- T(CPP_OPEN_BRACE, "{") \
- T(CPP_CLOSE_BRACE, "}") \
- /* The remainder of the punctuation. Order is not significant. */ \
- T(CPP_SEMICOLON, ";") /* structure */ \
- T(CPP_ELLIPSIS, "...") \
- T(CPP_BACKSLASH, "\\") \
- T(CPP_PLUS_PLUS, "++") /* increment */ \
- T(CPP_MINUS_MINUS, "--") \
- T(CPP_DEREF, "->") /* accessors */ \
- T(CPP_DOT, ".") \
- T(CPP_SCOPE, "::") \
- T(CPP_DEREF_STAR, "->*") \
- T(CPP_DOT_STAR, ".*") \
- T(CPP_MIN, "<?") /* extension */ \
- T(CPP_MAX, ">?") \
- T(CPP_PLACEMARKER, "") /* Placemarker token. */ \
- C(CPP_OTHER, 0) /* stray punctuation */ \
+ OP(CPP_HASH, "#") /* digraphs */ \
+ OP(CPP_PASTE, "##") \
+ OP(CPP_OPEN_SQUARE, "[") \
+ OP(CPP_CLOSE_SQUARE, "]") \
+ OP(CPP_OPEN_BRACE, "{") \
+ OP(CPP_CLOSE_BRACE, "}") \
+ /* The remainder of the punctuation. Order is not significant. */ \
+ OP(CPP_SEMICOLON, ";") /* structure */ \
+ OP(CPP_ELLIPSIS, "...") \
+ OP(CPP_BACKSLASH, "\\") \
+ OP(CPP_PLUS_PLUS, "++") /* increment */ \
+ OP(CPP_MINUS_MINUS, "--") \
+ OP(CPP_DEREF, "->") /* accessors */ \
+ OP(CPP_DOT, ".") \
+ OP(CPP_SCOPE, "::") \
+ OP(CPP_DEREF_STAR, "->*") \
+ OP(CPP_DOT_STAR, ".*") \
+ OP(CPP_MIN, "<?") /* extension */ \
+ OP(CPP_MAX, ">?") \
\
- I(CPP_NAME, 0) /* word */ \
- S(CPP_INT, 0) /* 23 */ \
- S(CPP_FLOAT, 0) /* 3.14159 */ \
- S(CPP_NUMBER, 0) /* 34_be+ta */ \
- S(CPP_CHAR, 0) /* 'char' */ \
- S(CPP_WCHAR, 0) /* L'char' */ \
- S(CPP_STRING, 0) /* "string" */ \
- S(CPP_WSTRING, 0) /* L"string" */ \
+ TK(CPP_NAME, SPELL_IDENT) /* word */ \
+ TK(CPP_INT, SPELL_STRING) /* 23 */ \
+ TK(CPP_FLOAT, SPELL_STRING) /* 3.14159 */ \
+ TK(CPP_NUMBER, SPELL_STRING) /* 34_be+ta */ \
\
- S(CPP_COMMENT, 0) /* Only if output comments. */ \
- N(CPP_MACRO_ARG, 0) /* Macro argument. */ \
- N(CPP_EOF, 0) /* End of file. */ \
- S(CPP_HEADER_NAME, 0) /* <stdio.h> in #include */
-
-#define T(e, s) e,
-#define I(e, s) e,
-#define S(e, s) e,
-#define C(e, s) e,
-#define N(e, s) e,
+ TK(CPP_CHAR, SPELL_STRING) /* 'char' */ \
+ TK(CPP_WCHAR, SPELL_STRING) /* L'char' */ \
+ TK(CPP_OTHER, SPELL_CHAR) /* stray punctuation */ \
+\
+ TK(CPP_STRING, SPELL_STRING) /* "string" */ \
+ TK(CPP_WSTRING, SPELL_STRING) /* L"string" */ \
+ TK(CPP_HEADER_NAME, SPELL_STRING) /* <stdio.h> in #include */ \
+\
+ TK(CPP_COMMENT, SPELL_STRING) /* Only if output comments. */ \
+ TK(CPP_MACRO_ARG, SPELL_NONE) /* Macro argument. */ \
+ TK(CPP_PLACEMARKER, SPELL_NONE) /* Placemarker token. */ \
+ TK(CPP_EOF, SPELL_NONE) /* End of file. */
+
+#define OP(e, s) e,
+#define TK(e, s) e,
enum cpp_ttype
{
TTYPE_TABLE
N_TTYPES
};
-#undef T
-#undef I
-#undef S
-#undef C
-#undef N
+#undef OP
+#undef TK
/* Payload of a NUMBER, FLOAT, STRING, or COMMENT token. */
struct cpp_string
{
dest->type = CPP_PLACEMARKER;
dest->flags = 0;
+ dest->val.aux = 0;
}
return list;
+2000-07-18 Zack Weinberg <zack@wolery.cumb.org>
+
+ * cpplex.c (_cpp_push_token): If the token being pushed back
+ is the previous token in this context, just subtract one from
+ context->posn.
+ * cppmacro.c (save_expansion): Clear aux field when storing a
+ placemarker.
+
2000-07-18 Alexandre Oliva <aoliva@redhat.com>
* gcc.dg/noncompile/redecl-1.c: New test.
--- /dev/null
+/* Regression test for bug in convoluted situation involving token paste
+ plus function-like macros used outside function context. It may be
+ easier to understand if you mentally replace 'struct' with 'A'
+ throughout this file; 'struct' is used only to get the code to compile
+ when preprocessed correctly.
+
+ The original problem was seen in the Linux kernel and reported by
+ Jakub Jelinek <jakub@redhat.com>; this test is synthetic. */
+
+/* { dg-do compile } */
+
+#define glue(a,b) a##b
+#define struct(x) B(x)
+#define E(x) struct x
+#define FG (22)
+
+extern void B(int);
+
+void foo(void)
+{
+ E(glue(F,*)) dummy; /* { dg-warning "valid preprocessing token" } */
+
+ E(glue(F,G)) ;
+}
--- /dev/null
+/* Test for changed behavior of the GNU varargs extension.
+ ##args, where args is a rest argument which received zero tokens,
+ used to delete the previous sequence of nonwhitespace characters.
+ Now it deletes the previous token. */
+
+/* { dg-do run } */
+/* { dg-options -w } */
+
+#include <string.h>
+
+#define S(str, args...) " " str "\n", ##args
+
+int
+main()
+{
+ const char *s = S("foo");
+ return strchr (s, '\n') == NULL;
+}
+
projects / platform / upstream / linaro-gcc.git / commitdiff