gcc:

[pf3gnuchains/gcc-fork.git] / libcpp / macro.c

diff --git a/libcpp/macro.c b/libcpp/macro.c
index 1563d78..cbb0b0e 100644 (file)
--- a/libcpp/macro.c
+++ b/libcpp/macro.c
@@ -1,14 +1,14 @@
 /* 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, 2005,
 /* 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, 2005,

-   2006, 2007, 2008 Free Software Foundation, Inc.
+   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
    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,
 later version.
 
 This program is distributed in the hope that it will be useful,


@@ -17,8 +17,8 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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
 
  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


@@ -83,8 +83,8 @@ _cpp_warn_if_unused_macro (cpp_reader *pfile, cpp_hashnode *node,
 
       if (!macro->used
          && MAIN_FILE_P (linemap_lookup (pfile->line_table, macro->line)))
 
       if (!macro->used
          && MAIN_FILE_P (linemap_lookup (pfile->line_table, macro->line)))

-       cpp_error_with_line (pfile, CPP_DL_WARNING, macro->line, 0,
-                            "macro \"%s\" is not used", NODE_NAME (node));
+       cpp_warning_with_line (pfile, CPP_W_UNUSED_MACROS, macro->line, 0,
+                              "macro \"%s\" is not used", NODE_NAME (node));

     }
 
   return 1;
     }
 
   return 1;


@@ -118,7 +118,7 @@ _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
 {
   const struct line_map *map;
   const uchar *result = NULL;
 {
   const struct line_map *map;
   const uchar *result = NULL;

-  unsigned int number = 1;
+  linenum_type number = 1;

 
   switch (node->value.builtin)
     {
 
   switch (node->value.builtin)
     {


@@ -200,11 +200,10 @@ _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
       /* 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 __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.
       break;
 
       /* __STDC__ has the value 1 under normal circumstances.


@@ -370,15 +369,18 @@ stringify_arg (cpp_reader *pfile, macro_arg *arg)
 
       if (token->type == CPP_PADDING)
        {
 
       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_CHAR
            source = token->val.source;
          continue;
        }
 
       escape_it = (token->type == CPP_STRING || token->type == CPP_CHAR

-                  || token->type == CPP_WSTRING || token->type == CPP_STRING
+                  || token->type == CPP_WSTRING || token->type == CPP_WCHAR

                   || token->type == CPP_STRING32 || token->type == CPP_CHAR32
                   || token->type == CPP_STRING32 || token->type == CPP_CHAR32

-                  || token->type == CPP_STRING16 || token->type == CPP_CHAR16);
+                  || token->type == CPP_STRING16 || token->type == CPP_CHAR16
+                  || token->type == CPP_UTF8STRING);

 
       /* Room for each char being written in octal, initial space and
         final quote and NUL.  */
 
       /* Room for each char being written in octal, initial space and
         final quote and NUL.  */


@@ -801,6 +803,19 @@ funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node,
   return NULL;
 }
 
   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.
 /* 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.


@@ -845,9 +860,9 @@ enter_macro_context (cpp_reader *pfile, cpp_hashnode *node,
          if (buff == NULL)
            {
              if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
          if (buff == NULL)
            {
              if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)

-               cpp_error (pfile, CPP_DL_WARNING,
+               cpp_warning (pfile, CPP_W_TRADITIONAL,

  "function-like macro \"%s\" must be used with arguments in traditional C",
  "function-like macro \"%s\" must be used with arguments in traditional C",

-                          NODE_NAME (node));
+                            NODE_NAME (node));

 
              if (pragma_buff)
                _cpp_release_buff (pfile, pragma_buff);
 
              if (pragma_buff)
                _cpp_release_buff (pfile, pragma_buff);


@@ -870,10 +885,14 @@ enter_macro_context (cpp_reader *pfile, cpp_hashnode *node,
            pfile->cb.used_define (pfile, pfile->directive_line, node);
        }
 
            pfile->cb.used_define (pfile, pfile->directive_line, node);
        }
 

+      if (pfile->cb.used)
+       pfile->cb.used (pfile, result->src_loc, node);
+

       macro->used = 1;
 
       if (macro->paramc == 0)
       macro->used = 1;
 
       if (macro->paramc == 0)

-       _cpp_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 (pragma_buff)
        {


@@ -913,13 +932,15 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg
   const cpp_token **dest, **first;
   macro_arg *arg;
   _cpp_buff *buff;
   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.  */
 
   /* 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)
 
   for (src = macro->exp.tokens; src < limit; src++)
     if (src->type == CPP_MACRO_ARG)


@@ -929,7 +950,7 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg
 
        /* We have an argument.  If it is not being stringified or
           pasted it is macro-replaced before insertion.  */
 
        /* 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)
          {
 
        if (src->flags & STRINGIFY_ARG)
          {


@@ -965,7 +986,7 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg
        }
 
       paste_flag = 0;
        }
 
       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 (src->flags & STRINGIFY_ARG)
        count = 1, from = &arg->stringified;
       else if (src->flags & PASTE_LEFT)


@@ -977,7 +998,7 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg
            {
              if (dest[-1]->type == CPP_COMMA
                  && macro->variadic
            {
              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.  */
                {
                  /* Swallow a pasted comma if from == NULL, otherwise
                     drop the paste flag.  */


@@ -1018,7 +1039,7 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg
                     "empty macro arguments are undefined"
                     " in ISO C90 and ISO C++98",
                     NODE_NAME (node),
                     "empty macro arguments are undefined"
                     " in ISO C90 and ISO C++98",
                     NODE_NAME (node),

-                    src->val.arg_no);
+                    src->val.macro_arg.arg_no);

        }
 
       /* Avoid paste on RHS (even case count == 0).  */
        }
 
       /* Avoid paste on RHS (even case count == 0).  */


@@ -1244,7 +1265,7 @@ cpp_get_token (cpp_reader *pfile)
       if (result->type != CPP_NAME)
        break;
 
       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->type != NT_MACRO || (result->flags & NO_EXPAND))
        break;


@@ -1261,10 +1282,36 @@ cpp_get_token (cpp_reader *pfile)
 
          /* Conditional macros require that a predicate be evaluated
             first.  */
 
          /* Conditional macros require that a predicate be evaluated
             first.  */

-         if (((!(node->flags & NODE_CONDITIONAL))
-              || (pfile->cb.macro_to_expand
-                  && (node = pfile->cb.macro_to_expand (pfile, result))))
-             && (ret = enter_macro_context (pfile, node, result)))
+         if ((node->flags & NODE_CONDITIONAL) != 0)
+           {
+             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;
            {
              if (pfile->state.in_directive || ret == 2)
                continue;


@@ -1393,6 +1440,10 @@ warn_of_redefinition (cpp_reader *pfile, const cpp_hashnode *node,
   if (node->flags & NODE_WARN)
     return true;
 
   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)
   /* Redefinitions of conditional (context-sensitive) macros, on
      the other hand, must be allowed silently.  */
   if (node->flags & NODE_CONDITIONAL)


@@ -1506,7 +1557,7 @@ parse_params (cpp_reader *pfile, cpp_macro *macro)
            }
          prev_ident = 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;
 
            return false;
          continue;
 


@@ -1534,13 +1585,14 @@ parse_params (cpp_reader *pfile, cpp_macro *macro)
              if (! CPP_OPTION (pfile, c99)
                  && CPP_OPTION (pfile, pedantic)
                  && CPP_OPTION (pfile, warn_variadic_macros))
              if (! CPP_OPTION (pfile, c99)
                  && CPP_OPTION (pfile, pedantic)
                  && CPP_OPTION (pfile, warn_variadic_macros))

-               cpp_error (pfile, CPP_DL_PEDWARN,
-                          "anonymous variadic macros were introduced in C99");
+               cpp_pedwarning
+                  (pfile, CPP_W_VARIADIC_MACROS,
+                  "anonymous variadic macros were introduced in C99");

            }
          else if (CPP_OPTION (pfile, pedantic)
                   && CPP_OPTION (pfile, warn_variadic_macros))
            }
          else if (CPP_OPTION (pfile, pedantic)
                   && CPP_OPTION (pfile, warn_variadic_macros))

-           cpp_error (pfile, CPP_DL_PEDWARN,
-                      "ISO C does not permit named variadic macros");
+           cpp_pedwarning (pfile, CPP_W_VARIADIC_MACROS,
+                           "ISO C does not permit named variadic macros");

 
          /* We're at the end, and just expect a closing parenthesis.  */
          token = _cpp_lex_token (pfile);
 
          /* We're at the end, and just expect a closing parenthesis.  */
          token = _cpp_lex_token (pfile);


@@ -1579,10 +1631,10 @@ lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
 
   /* Is this a parameter?  */
   if (token->type == CPP_NAME
 
   /* 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->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))
     }
   else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
           && (token->type == CPP_STRING || token->type == CPP_CHAR))


@@ -1599,6 +1651,7 @@ create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
   bool following_paste_op = false;
   const char *paste_op_error_msg =
     N_("'##' cannot appear at either end of a macro expansion");
   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).  */
 
   /* Get the first token of the expansion (or the '(' of a
      function-like macro).  */


@@ -1676,6 +1729,10 @@ create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
        {
          if (token->type == CPP_MACRO_ARG)
            {
        {
          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;
              token->flags &= ~PREV_WHITE;
              token->flags |= STRINGIFY_ARG;
              token->flags |= token[-1].flags & PREV_WHITE;


@@ -1715,8 +1772,21 @@ create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
              return false;
            }
 
              return false;
            }
 

-         --macro->count;
-         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);
        }
 
       following_paste_op = (token->type == CPP_PASTE);


@@ -1739,7 +1809,27 @@ create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
       cpp_token *tokns =
         (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
                                                           * macro->count);
       cpp_token *tokns =
         (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
                                                           * macro->count);

-      memcpy (tokns, macro->exp.tokens, 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
       macro->exp.tokens = tokns;
     }
   else


@@ -1768,6 +1858,7 @@ _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
   macro->used = !CPP_OPTION (pfile, warn_unused_macros);
   macro->count = 0;
   macro->fun_like = 0;
   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;
 
   /* To suppress some diagnostics.  */
   macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
 


@@ -1804,11 +1895,17 @@ _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
 
       if (warn_of_redefinition (pfile, node, macro))
        {
 
       if (warn_of_redefinition (pfile, node, macro))
        {

-         cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->directive_line, 0,
-                              "\"%s\" redefined", NODE_NAME (node));
+          const int reason = (node->flags & NODE_BUILTIN)
+                             ? CPP_W_BUILTIN_MACRO_REDEFINED : CPP_W_NONE;
+         bool warned;
+
+         warned = cpp_pedwarning_with_line (pfile, reason,
+                                            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");
        }
                                 node->value.macro->line, 0,
                         "this is the location of the previous definition");
        }


@@ -1913,12 +2010,13 @@ cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
     len += _cpp_replacement_text_len (macro);
   else
     {
     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 = &macro->exp.tokens[i];
 
          if (token->type == CPP_MACRO_ARG)
        {
          cpp_token *token = &macro->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);
 
          else
            len += cpp_token_len (token);
 


@@ -1977,7 +2075,8 @@ cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
   else if (macro->count)
   /* Expansion tokens.  */
     {
   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 = &macro->exp.tokens[i];
 
        {
          cpp_token *token = &macro->exp.tokens[i];
 


@@ -1989,9 +2088,9 @@ cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
          if (token->type == CPP_MACRO_ARG)
            {
              memcpy (buffer,
          if (token->type == CPP_MACRO_ARG)
            {
              memcpy (buffer,

-                     NODE_NAME (macro->params[token->val.arg_no - 1]),
-                     NODE_LEN (macro->params[token->val.arg_no - 1]));
-             buffer += NODE_LEN (macro->params[token->val.arg_no - 1]);
+                     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, false);
            }
          else
            buffer = cpp_spell_token (pfile, token, buffer, false);