From 1a9b3f04c11eb467a8dc504a37dad57a371a0d4c Mon Sep 17 00:00:00 2001 From: Christophe Lyon Date: Thu, 20 May 2021 08:10:50 +0000 Subject: c: Add support for __FILE_NAME__ macro (PR c/42579) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The toolchain provided by ST for stm32 has had support for __FILENAME__ for a while, but clang/llvm has recently implemented support for __FILE_NAME__, so it seems better to use the same macro name in GCC. It happens that the ST patch is similar to the one proposed in PR c/42579. Given these input files: :::::::::::::: mydir/myinc.h :::::::::::::: char* mystringh_file = __FILE__; char* mystringh_filename = __FILE_NAME__; char* mystringh_base_file = __BASE_FILE__; :::::::::::::: mydir/mysrc.c :::::::::::::: char* mystring_file = __FILE__; char* mystring_filename = __FILE_NAME__; char* mystring_base_file = __BASE_FILE__; we produce: $ gcc mydir/mysrc.c -I . -E char* mystringh_file = "./mydir/myinc.h"; char* mystringh_filename = "myinc.h"; char* mystringh_base_file = "mydir/mysrc.c"; char* mystring_file = "mydir/mysrc.c"; char* mystring_filename = "mysrc.c"; char* mystring_base_file = "mydir/mysrc.c"; 2021-05-20 Christophe Lyon Torbjörn Svensson PR c/42579 libcpp/ * include/cpplib.h (cpp_builtin_type): Add BT_FILE_NAME entry. * init.c (builtin_array): Likewise. * macro.c (_cpp_builtin_macro_text): Add support for BT_FILE_NAME. gcc/ * doc/cpp.texi (Common Predefined Macros): Document __FILE_NAME__. gcc/testsuite/ * c-c++-common/spellcheck-reserved.c: Add tests for __FILE_NAME__. * c-c++-common/cpp/file-name-1.c: New test. --- libcpp/macro.c | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) (limited to 'libcpp/macro.c') diff --git a/libcpp/macro.c b/libcpp/macro.c index dff7c98..4fc5f83 100644 --- a/libcpp/macro.c +++ b/libcpp/macro.c @@ -531,15 +531,21 @@ _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node, } break; case BT_FILE: + case BT_FILE_NAME: case BT_BASE_FILE: { unsigned int len; const char *name; uchar *buf; - - if (node->value.builtin == BT_FILE) - name = linemap_get_expansion_filename (pfile->line_table, - pfile->line_table->highest_line); + + if (node->value.builtin == BT_FILE + || node->value.builtin == BT_FILE_NAME) + { + name = linemap_get_expansion_filename (pfile->line_table, + pfile->line_table->highest_line); + if ((node->value.builtin == BT_FILE_NAME) && name) + name = lbasename (name); + } else { name = _cpp_get_file_name (pfile->main_file); -- cgit v1.1 From 408d88af60e3268f7fad59fa393ec7e28922c435 Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Thu, 12 Aug 2021 22:38:18 +0200 Subject: libcpp: Fix ICE with -Wtraditional preprocessing [PR101638] The following testcase ICEs in cpp_sys_macro_p, because cpp_sys_macro_p is called for a builtin macro which doesn't use node->value.macro union member but a different one and so dereferencing it ICEs. As the testcase is distilled from contemporary glibc headers, it means basically -Wtraditional now ICEs on almost everything. The fix can be either the patch below, return true for builtin macros, or we could instead return false for builtin macros, or the fix could be also (untested): --- libcpp/expr.c 2021-05-07 10:34:46.345122608 +0200 +++ libcpp/expr.c 2021-08-12 09:54:01.837556365 +0200 @@ -783,13 +783,13 @@ cpp_classify_number (cpp_reader *pfile, /* Traditional C only accepted the 'L' suffix. Suppress warning about 'LL' with -Wno-long-long. */ - if (CPP_WTRADITIONAL (pfile) && ! cpp_sys_macro_p (pfile)) + if (CPP_WTRADITIONAL (pfile)) { int u_or_i = (result & (CPP_N_UNSIGNED|CPP_N_IMAGINARY)); int large = (result & CPP_N_WIDTH) == CPP_N_LARGE && CPP_OPTION (pfile, cpp_warn_long_long); - if (u_or_i || large) + if ((u_or_i || large) && ! cpp_sys_macro_p (pfile)) cpp_warning_with_line (pfile, large ? CPP_W_LONG_LONG : CPP_W_TRADITIONAL, virtual_location, 0, "traditional C rejects the \"%.*s\" suffix", The builtin macros at least currently don't add any suffixes or numbers -Wtraditional would like to warn about. For floating point suffixes, -Wtraditional calls cpp_sys_macro_p only right away before emitting the warning, but in the above case the ICE is because cpp_sys_macro_p is called even if the number doesn't have any suffixes (that is I think always for builtin macros right now). 2021-08-12 Jakub Jelinek PR preprocessor/101638 * macro.c (cpp_sys_macro_p): Return true instead of crashing on builtin macros. * gcc.dg/cpp/pr101638.c: New test. --- libcpp/macro.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) (limited to 'libcpp/macro.c') diff --git a/libcpp/macro.c b/libcpp/macro.c index 4fc5f83..fab6779 100644 --- a/libcpp/macro.c +++ b/libcpp/macro.c @@ -3116,7 +3116,8 @@ cpp_get_token_with_location (cpp_reader *pfile, location_t *loc) /* 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. */ + the stack. Used for diagnostic suppression. + Also return true for builtin macros. */ int cpp_sys_macro_p (cpp_reader *pfile) { @@ -3127,7 +3128,11 @@ cpp_sys_macro_p (cpp_reader *pfile) else node = pfile->context->c.macro; - return node && node->value.macro && node->value.macro->syshdr; + if (!node) + return false; + if (cpp_builtin_macro_p (node)) + return true; + return node->value.macro && node->value.macro->syshdr; } /* Read each token in, until end of the current file. Directives are -- cgit v1.1 From d56599979211266b2f7b7535311205dd758353ac Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Tue, 17 Aug 2021 09:25:56 +0200 Subject: c++: Add C++20 #__VA_OPT__ support The following patch implements C++20 # __VA_OPT__ (...) support. Testcases cover what I came up with myself and what LLVM has for #__VA_OPT__ in its testsuite and the string literals are identical between the two compilers on the va-opt-5.c testcase. 2021-08-17 Jakub Jelinek libcpp/ * macro.c (vaopt_state): Add m_stringify member. (vaopt_state::vaopt_state): Initialize it. (vaopt_state::update): Overwrite it. (vaopt_state::stringify): New method. (stringify_arg): Replace arg argument with first, count arguments and add va_opt argument. Use first instead of arg->first and count instead of arg->count, for va_opt add paste_tokens handling. (paste_tokens): Fix up len calculation. Don't spell rhs twice, instead use %.*s to supply lhs and rhs spelling lengths. Don't call _cpp_backup_tokens here. (paste_all_tokens): Call it here instead. (replace_args): Adjust stringify_arg caller. For vaopt_state::END if stringify is true handle __VA_OPT__ stringification. (create_iso_definition): Handle # __VA_OPT__ similarly to # macro_arg. gcc/testsuite/ * c-c++-common/cpp/va-opt-5.c: New test. * c-c++-common/cpp/va-opt-6.c: New test. --- libcpp/macro.c | 88 ++++++++++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 73 insertions(+), 15 deletions(-) (limited to 'libcpp/macro.c') diff --git a/libcpp/macro.c b/libcpp/macro.c index fab6779..c317a43 100644 --- a/libcpp/macro.c +++ b/libcpp/macro.c @@ -118,6 +118,7 @@ class vaopt_state { m_arg (arg), m_variadic (is_variadic), m_last_was_paste (false), + m_stringify (false), m_state (0), m_paste_location (0), m_location (0), @@ -145,6 +146,7 @@ class vaopt_state { } ++m_state; m_location = token->src_loc; + m_stringify = (token->flags & STRINGIFY_ARG) != 0; return BEGIN; } else if (m_state == 1) @@ -234,6 +236,12 @@ class vaopt_state { return m_state == 0; } + /* Return true for # __VA_OPT__. */ + bool stringify () const + { + return m_stringify; + } + private: /* The cpp_reader. */ @@ -247,6 +255,8 @@ class vaopt_state { /* If true, the previous token was ##. This is used to detect when a paste occurs at the end of the sequence. */ bool m_last_was_paste; + /* True for #__VA_OPT__. */ + bool m_stringify; /* The state variable: 0 means not parsing @@ -284,7 +294,8 @@ static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *, static cpp_context *next_context (cpp_reader *); static const cpp_token *padding_token (cpp_reader *, const cpp_token *); static const cpp_token *new_string_token (cpp_reader *, uchar *, unsigned int); -static const cpp_token *stringify_arg (cpp_reader *, macro_arg *); +static const cpp_token *stringify_arg (cpp_reader *, const cpp_token **, + unsigned int, bool); static void paste_all_tokens (cpp_reader *, const cpp_token *); static bool paste_tokens (cpp_reader *, location_t, const cpp_token **, const cpp_token *); @@ -818,10 +829,11 @@ cpp_quote_string (uchar *dest, const uchar *src, unsigned int len) return dest; } -/* Convert a token sequence ARG to a single string token according to - the rules of the ISO C #-operator. */ +/* Convert a token sequence FIRST to FIRST+COUNT-1 to a single string token + according to the rules of the ISO C #-operator. */ static const cpp_token * -stringify_arg (cpp_reader *pfile, macro_arg *arg) +stringify_arg (cpp_reader *pfile, const cpp_token **first, unsigned int count, + bool va_opt) { unsigned char *dest; unsigned int i, escape_it, backslash_count = 0; @@ -834,9 +846,27 @@ stringify_arg (cpp_reader *pfile, macro_arg *arg) *dest++ = '"'; /* Loop, reading in the argument's tokens. */ - for (i = 0; i < arg->count; i++) + for (i = 0; i < count; i++) { - const cpp_token *token = arg->first[i]; + const cpp_token *token = first[i]; + + if (va_opt && (token->flags & PASTE_LEFT)) + { + location_t virt_loc = pfile->invocation_location; + const cpp_token *rhs; + do + { + if (i == count) + abort (); + rhs = first[++i]; + if (!paste_tokens (pfile, virt_loc, &token, rhs)) + { + --i; + break; + } + } + while (rhs->flags & PASTE_LEFT); + } if (token->type == CPP_PADDING) { @@ -923,7 +953,7 @@ paste_tokens (cpp_reader *pfile, location_t location, cpp_token *lhs; unsigned int len; - len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 1; + len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 2; buf = (unsigned char *) alloca (len); end = lhsend = cpp_spell_token (pfile, *plhs, buf, true); @@ -949,8 +979,10 @@ paste_tokens (cpp_reader *pfile, location_t location, location_t saved_loc = lhs->src_loc; _cpp_pop_buffer (pfile); - _cpp_backup_tokens (pfile, 1); - *lhsend = '\0'; + + unsigned char *rhsstart = lhsend; + if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ) + rhsstart++; /* We have to remove the PASTE_LEFT flag from the old lhs, but we want to keep the new location. */ @@ -962,8 +994,10 @@ paste_tokens (cpp_reader *pfile, location_t location, /* Mandatory error for all apart from assembler. */ if (CPP_OPTION (pfile, lang) != CLK_ASM) cpp_error_with_line (pfile, CPP_DL_ERROR, location, 0, - "pasting \"%s\" and \"%s\" does not give a valid preprocessing token", - buf, cpp_token_as_text (pfile, rhs)); + "pasting \"%.*s\" and \"%.*s\" does not give " + "a valid preprocessing token", + (int) (lhsend - buf), buf, + (int) (end - rhsstart), rhsstart); return false; } @@ -1039,7 +1073,10 @@ paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs) abort (); } if (!paste_tokens (pfile, virt_loc, &lhs, rhs)) - break; + { + _cpp_backup_tokens (pfile, 1); + break; + } } while (rhs->flags & PASTE_LEFT); @@ -1906,7 +1943,8 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, if (src->flags & STRINGIFY_ARG) { if (!arg->stringified) - arg->stringified = stringify_arg (pfile, arg); + arg->stringified = stringify_arg (pfile, arg->first, arg->count, + false); } else if ((src->flags & PASTE_LEFT) || (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))) @@ -2029,7 +2067,24 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, paste_flag = tokens_buff_last_token_ptr (buff); } - if (src->flags & PASTE_LEFT) + if (vaopt_tracker.stringify ()) + { + unsigned int count + = start ? paste_flag - start : tokens_buff_count (buff); + const cpp_token *t + = stringify_arg (pfile, + start ? start + 1 + : (const cpp_token **) (buff->base), + count, true); + while (count--) + tokens_buff_remove_last_token (buff); + if (src->flags & PASTE_LEFT) + copy_paste_flag (pfile, &t, src); + tokens_buff_add_token (buff, virt_locs, + t, t->src_loc, t->src_loc, + NULL, 0); + } + else if (src->flags & PASTE_LEFT) { /* With a non-empty __VA_OPT__ on the LHS of ##, the last token should be flagged PASTE_LEFT. */ @@ -3585,7 +3640,10 @@ create_iso_definition (cpp_reader *pfile) function-like macros when lexing the subsequent token. */ if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like) { - if (token->type == CPP_MACRO_ARG) + if (token->type == CPP_MACRO_ARG + || (macro->variadic + && token->type == CPP_NAME + && token->val.node.node == pfile->spec_nodes.n__VA_OPT__)) { if (token->flags & PREV_WHITE) token->flags |= SP_PREV_WHITE; -- cgit v1.1 From e928cf47f350e46eacb48ed954112e603ef3800a Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Wed, 1 Sep 2021 21:31:25 +0200 Subject: libcpp: __VA_OPT__ p1042r1 placemarker changes [PR101488] So, besides missing #__VA_OPT__ patch for which I've posted patch last week, P1042R1 introduced some placemarker changes for __VA_OPT__, most notably the addition of before "removal of placemarker tokens," rescanning ... and the #define H4(X, ...) __VA_OPT__(a X ## X) ## b H4(, 1) // replaced by a b example mentioned there where we replace it currently with ab The following patch are the minimum changes (except for the __builtin_expect) that achieve the same preprocessing between current clang++ and patched gcc on all the testcases I've tried (i.e. gcc __VA_OPT__ testsuite in c-c++-common/cpp/va-opt* including the new test and the clang clang/test/Preprocessor/macro_va_opt* testcases). At one point I was trying to implement the __VA_OPT__(args) case as if for non-empty __VA_ARGS__ it expanded as if __VA_OPT__( and ) were missing, but from the tests it seems that is not how it should work, in particular if after (or before) we have some macro argument and it is not followed (or preceded) by ##, then it should be macro expanded even when __VA_OPT__ is after ## or ) is followed by ##. And it seems that not removing any padding tokens isn't possible either, because the expansion of the arguments typically has a padding token at the start and end and those at least according to the testsuite need to go. It is unclear if it would be enough to remove just one or if all padding tokens should be removed. Anyway, e.g. the previous removal of all padding tokens at the end of __VA_OPT__ is undesirable, as it e.g. eats also the padding tokens needed for the H4 example from the paper. 2021-09-01 Jakub Jelinek PR preprocessor/101488 * macro.c (replace_args): Fix up handling of CPP_PADDING tokens at the start or end of __VA_OPT__ arguments when preceeded or followed by ##. * c-c++-common/cpp/va-opt-3.c: Adjust expected output. * c-c++-common/cpp/va-opt-7.c: New test. --- libcpp/macro.c | 30 ++++++++++++++++++------------ 1 file changed, 18 insertions(+), 12 deletions(-) (limited to 'libcpp/macro.c') diff --git a/libcpp/macro.c b/libcpp/macro.c index c317a43..b3ba352 100644 --- a/libcpp/macro.c +++ b/libcpp/macro.c @@ -2026,6 +2026,7 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, i = 0; vaopt_state vaopt_tracker (pfile, macro->variadic, &args[macro->paramc - 1]); const cpp_token **vaopt_start = NULL; + unsigned vaopt_padding_tokens = 0; for (src = macro->exp.tokens; src < limit; src++) { unsigned int arg_tokens_count; @@ -2035,7 +2036,7 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, /* __VA_OPT__ handling. */ vaopt_state::update_type vostate = vaopt_tracker.update (src); - if (vostate != vaopt_state::INCLUDE) + if (__builtin_expect (vostate != vaopt_state::INCLUDE, false)) { if (vostate == vaopt_state::BEGIN) { @@ -2060,7 +2061,9 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, /* Remove any tail padding from inside the __VA_OPT__. */ paste_flag = tokens_buff_last_token_ptr (buff); - while (paste_flag && paste_flag != start + while (vaopt_padding_tokens-- + && paste_flag + && paste_flag != start && (*paste_flag)->type == CPP_PADDING) { tokens_buff_remove_last_token (buff); @@ -2104,6 +2107,7 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, continue; } + vaopt_padding_tokens = 0; if (src->type != CPP_MACRO_ARG) { /* Allocate a virtual location for token SRC, and add that @@ -2181,11 +2185,8 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, else paste_flag = tmp_token_ptr; } - /* Remove the paste flag if the RHS is a placemarker, unless the - previous emitted token is at the beginning of __VA_OPT__; - placemarkers within __VA_OPT__ are ignored in that case. */ - else if (arg_tokens_count == 0 - && tmp_token_ptr != vaopt_start) + /* Remove the paste flag if the RHS is a placemarker. */ + else if (arg_tokens_count == 0) paste_flag = tmp_token_ptr; } } @@ -2215,7 +2216,8 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, /* Padding on the left of an argument (unless RHS of ##). */ if ((!pfile->state.in_directive || pfile->state.directive_wants_padding) - && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT) + && src != macro->exp.tokens + && !(src[-1].flags & PASTE_LEFT) && !last_token_is (buff, vaopt_start)) { const cpp_token *t = padding_token (pfile, src); @@ -2260,8 +2262,12 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, token_index += j; index = expanded_token_index (pfile, macro, src, token_index); - tokens_buff_add_token (buff, virt_locs, - macro_arg_token_iter_get_token (&from), + const cpp_token *tok = macro_arg_token_iter_get_token (&from); + if (tok->type == CPP_PADDING) + vaopt_padding_tokens++; + else + vaopt_padding_tokens = 0; + tokens_buff_add_token (buff, virt_locs, tok, macro_arg_token_iter_get_location (&from), src->src_loc, map, index); macro_arg_token_iter_forward (&from); @@ -2301,13 +2307,13 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, 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) - && !last_token_is (buff, vaopt_start)) + if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT)) { const cpp_token *t = &pfile->avoid_paste; tokens_buff_add_token (buff, virt_locs, t, t->src_loc, t->src_loc, NULL, 0); + vaopt_padding_tokens++; } /* Add a new paste flag, or remove an unwanted one. */ -- cgit v1.1 From ac6e77aacfb6581f5e84e4430628152b9b98da2e Mon Sep 17 00:00:00 2001 From: Jason Merrill Date: Wed, 1 Sep 2021 21:33:30 +0200 Subject: libcpp: __VA_OPT__ tweak > We want to remove the latter but not the former one, and > the patch adds the vaopt_padding_tokens counter for it to control > how many placemarkers are removed on vaopt_state::END. > As can be seen in #c1 and #c2 of the PR, I've tried various approaches, > but neither worked out for all the cases except the posted one. I notice that the second placemarker you mention is avoid_paste, which seems relevant. This seems to also work, at least it doesn't seem to break any of the va_opt tests. 2021-09-01 Jason Merrill * macro.c (replace_args): When __VA_OPT__ is on the LHS of ##, remove trailing avoid_paste tokens. --- libcpp/macro.c | 24 ++++++++---------------- 1 file changed, 8 insertions(+), 16 deletions(-) (limited to 'libcpp/macro.c') diff --git a/libcpp/macro.c b/libcpp/macro.c index b3ba352..f214548 100644 --- a/libcpp/macro.c +++ b/libcpp/macro.c @@ -2026,7 +2026,6 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, i = 0; vaopt_state vaopt_tracker (pfile, macro->variadic, &args[macro->paramc - 1]); const cpp_token **vaopt_start = NULL; - unsigned vaopt_padding_tokens = 0; for (src = macro->exp.tokens; src < limit; src++) { unsigned int arg_tokens_count; @@ -2059,16 +2058,7 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, const cpp_token **start = vaopt_start; vaopt_start = NULL; - /* Remove any tail padding from inside the __VA_OPT__. */ paste_flag = tokens_buff_last_token_ptr (buff); - while (vaopt_padding_tokens-- - && paste_flag - && paste_flag != start - && (*paste_flag)->type == CPP_PADDING) - { - tokens_buff_remove_last_token (buff); - paste_flag = tokens_buff_last_token_ptr (buff); - } if (vaopt_tracker.stringify ()) { @@ -2089,6 +2079,14 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, } else if (src->flags & PASTE_LEFT) { + /* Don't avoid paste after all. */ + while (paste_flag && paste_flag != start + && *paste_flag == &pfile->avoid_paste) + { + tokens_buff_remove_last_token (buff); + paste_flag = tokens_buff_last_token_ptr (buff); + } + /* With a non-empty __VA_OPT__ on the LHS of ##, the last token should be flagged PASTE_LEFT. */ if (paste_flag && (*paste_flag)->type != CPP_PADDING) @@ -2107,7 +2105,6 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, continue; } - vaopt_padding_tokens = 0; if (src->type != CPP_MACRO_ARG) { /* Allocate a virtual location for token SRC, and add that @@ -2263,10 +2260,6 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, index = expanded_token_index (pfile, macro, src, token_index); const cpp_token *tok = macro_arg_token_iter_get_token (&from); - if (tok->type == CPP_PADDING) - vaopt_padding_tokens++; - else - vaopt_padding_tokens = 0; tokens_buff_add_token (buff, virt_locs, tok, macro_arg_token_iter_get_location (&from), src->src_loc, map, index); @@ -2313,7 +2306,6 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, tokens_buff_add_token (buff, virt_locs, t, t->src_loc, t->src_loc, NULL, 0); - vaopt_padding_tokens++; } /* Add a new paste flag, or remove an unwanted one. */ -- cgit v1.1