[gcc] GCC 4.5.0=>4.5.1

gcc/libcpp/macro.c

 /* 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, 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
@@ skipping 351 matching lines @@
   dest = BUFF_FRONT (pfile->u_buff);
   *dest++ = '"';
 
   /* Loop, reading in the argument's tokens.  */
   for (i = 0; i < arg->count; i++)
     {
       const cpp_token *token = arg->first[i];
 
       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
                    || token->type == CPP_WSTRING || token->type == CPP_WCHAR
                    || 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.  */
       len = cpp_token_len (token);
       if (escape_it)
         len *= 4;
       len += 3;
 
       if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
         {
@@ skipping 402 matching lines @@
          up more than one token when expanding macros is in general
          too difficult.  We re-insert it in its own context.  */
       _cpp_backup_tokens (pfile, 1);
       if (padding)
         _cpp_push_token_context (pfile, NULL, padding, 1);
     }
 
   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.
    If there were additionally any unexpanded deferred #pragma directives
    among macro arguments, push another context containing the
    pragma tokens before the yet-to-be-rescanned replacement list
    and return two.  Otherwise, we don't push a context and return zero.  */
 static int
 enter_macro_context (cpp_reader *pfile, cpp_hashnode *node,
                      const cpp_token *result)
@@ skipping 49 matching lines @@
       /* Disable the macro within its expansion.  */
       node->flags |= NODE_DISABLED;
 
       if (!(node->flags & NODE_USED))
         {
           node->flags |= NODE_USED;
           if (pfile->cb.used_define)
             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)
-        _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 (!pfile->state.in_directive)
             _cpp_push_token_context (pfile, NULL,
                                      padding_token (pfile, result), 1);
           do
             {
               _cpp_buff *tail = pragma_buff->next;
               pragma_buff->next = NULL;
@@ skipping 19 matching lines @@
    Expand each argument before replacing, unless it is operated upon
    by the # or ## operators.  */
 static void
 replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg *args)
 {
   unsigned int i, total;
   const cpp_token *src, *limit;
   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.  */
-  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)
       {
         /* Leading and trailing padding tokens.  */
         total += 2;
 
         /* 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 (!arg->stringified)
               arg->stringified = stringify_arg (pfile, arg);
           }
         else if ((src->flags & PASTE_LEFT)
                  || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
           total += arg->count - 1;
         else
@@ skipping 15 matching lines @@
       unsigned int count;
       const cpp_token **from, **paste_flag;
 
       if (src->type != CPP_MACRO_ARG)
         {
           *dest++ = src;
           continue;
         }
 
       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)
         count = arg->count, from = arg->first;
       else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
         {
           count = arg->count, from = arg->first;
           if (dest != first)
             {
               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.  */
                   if (from == NULL)
                     dest--;
                   else
                     paste_flag = dest - 1;
                 }
               /* Remove the paste flag if the RHS is a placemarker.  */
               else if (count == 0)
@@ skipping 20 matching lines @@
         }
       else if (CPP_PEDANTIC (pfile) && ! macro->syshdr
                && ! CPP_OPTION (pfile, c99)
                && ! cpp_in_system_header (pfile))
         {
           cpp_error (pfile, CPP_DL_PEDWARN,
                      "invoking macro %s argument %d: "
                      "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).  */
       if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
         *dest++ = &pfile->avoid_paste;
 
       /* Add a new paste flag, or remove an unwanted one.  */
       if (paste_flag)
         {
           cpp_token *token = _cpp_temp_token (pfile);
@@ skipping 205 matching lines @@
             continue;
           return &pfile->avoid_paste;
         }
 
       if (pfile->state.in_directive && result->type == CPP_COMMENT)
         continue;
 
       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->flags & NODE_DISABLED))
         {
           int ret = 0;
           /* If not in a macro context, and we're going to start an
              expansion, record the location.  */
           if (can_set && !context->macro)
@@ skipping 271 matching lines @@
 
         case CPP_NAME:
           if (prev_ident)
             {
               cpp_error (pfile, CPP_DL_ERROR,
                          "macro parameters must be comma-separated");
               return false;
             }
           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;
 
         case CPP_CLOSE_PAREN:
           if (prev_ident || macro->paramc == 0)
             return true;
 
           /* Fall through to pick up the error.  */
         case CPP_COMMA:
           if (!prev_ident)
@@ skipping 52 matching lines @@
 {
   cpp_token *token, *saved_cur_token;
 
   saved_cur_token = pfile->cur_token;
   pfile->cur_token = alloc_expansion_token (pfile, macro);
   token = _cpp_lex_direct (pfile);
   pfile->cur_token = saved_cur_token;
 
   /* 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->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))
     check_trad_stringification (pfile, macro, &token->val.str);
 
   return token;
 }
 
 static bool
 create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
 {
   cpp_token *token;
   const cpp_token *ctoken;
   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).  */
   ctoken = _cpp_lex_token (pfile);
 
   if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
     {
       bool ok = parse_params (pfile, macro);
       macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
       if (!ok)
@@ skipping 57 matching lines @@
     }
 
   for (;;)
     {
       /* Check the stringifying # constraint 6.10.3.2.1 of
          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->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[-1] = token[0];
               macro->count--;
             }
           /* Let assembler get away with murder.  */
           else if (CPP_OPTION (pfile, lang) != CLK_ASM)
             {
               cpp_error (pfile, CPP_DL_ERROR,
@@ skipping 19 matching lines @@
       if (token->type == CPP_PASTE)
         {
           /* Token-paste ##, can appear in both object-like and
              function-like macros, but not at the beginning.  */
           if (macro->count == 1)
             {
               cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
               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);
       token = lex_expansion_token (pfile, macro);
     }
 
   macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
   macro->traditional = 0;
 
   /* Don't count the CPP_EOF.  */
   macro->count--;
 
   /* Clear whitespace on first token for warn_of_redefinition().  */
   if (macro->count)
     macro->exp.tokens[0].flags &= ~PREV_WHITE;
 
   /* Commit or allocate the memory.  */
   if (pfile->hash_table->alloc_subobject)
     {
       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
     BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->exp.tokens[macro->count];
 
   return true;
 }
 
 /* Parse a macro and save its expansion.  Returns nonzero on success.  */
 bool
 _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
 {
   cpp_macro *macro;
   unsigned int i;
   bool ok;
 
   if (pfile->hash_table->alloc_subobject)
     macro = (cpp_macro *) pfile->hash_table->alloc_subobject
       (sizeof (cpp_macro));
   else
     macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
   macro->line = pfile->directive_line;
   macro->params = 0;
   macro->paramc = 0;
   macro->variadic = 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;
 
   if (CPP_OPTION (pfile, traditional))
     ok = _cpp_create_trad_definition (pfile, macro);
   else
     {
       ok = create_iso_definition (pfile, macro);
 
       /* We set the type for SEEN_EOL() in directives.c.
@@ skipping 16 matching lines @@
   if (!ok)
     return ok;
 
   if (node->type == NT_MACRO)
     {
       if (CPP_OPTION (pfile, warn_unused_macros))
         _cpp_warn_if_unused_macro (pfile, node, NULL);
 
       if (warn_of_redefinition (pfile, node, macro))
         {
-          cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->directive_line, 0,
-                               "\"%s\" redefined", NODE_NAME (node));
+          bool warned;
+          warned = cpp_error_with_line (pfile, CPP_DL_PEDWARN,
+                                        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");
         }
     }
 
   if (node->type != NT_VOID)
     _cpp_free_definition (node);
 
   /* Enter definition in hash table.  */
   node->type = NT_MACRO;
@@ skipping 84 matching lines @@
                            varargs (we have + 1 below).  */
       for (i = 0; i < macro->paramc; i++)
         len += NODE_LEN (macro->params[i]) + 1; /* "," */
     }
 
   /* This should match below where we fill in the buffer.  */
   if (CPP_OPTION (pfile, traditional))
     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)
-            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);
 
           if (token->flags & STRINGIFY_ARG)
             len++;                      /* "#" */
           if (token->flags & PASTE_LEFT)
             len += 3;           /* " ##" */
           if (token->flags & PREV_WHITE)
             len++;              /* " " */
         }
@@ skipping 38 matching lines @@
 
   /* The Dwarf spec requires a space after the macro name, even if the
      definition is the empty string.  */
   *buffer++ = ' ';
 
   if (CPP_OPTION (pfile, traditional))
     buffer = _cpp_copy_replacement_text (macro, buffer);
   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];
 
           if (token->flags & PREV_WHITE)
             *buffer++ = ' ';
           if (token->flags & STRINGIFY_ARG)
             *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);
 
           if (token->flags & PASTE_LEFT)
             {
               *buffer++ = ' ';
               *buffer++ = '#';
               *buffer++ = '#';
               /* Next has PREV_WHITE; see _cpp_create_definition.  */
             }
         }
     }
 
   *buffer = '\0';
   return pfile->macro_buffer;
 }