* tree-sra.c (scalarize_lsdt): Fix thinko in testing whether

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

diff --git a/libcpp/macro.c b/libcpp/macro.c
index e118a5c..e80815b 100644 (file)
--- a/libcpp/macro.c
+++ b/libcpp/macro.c
@@ -1,6 +1,7 @@
 /* Part of CPP library.  (Macro and #define handling.)
    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1998,
 /* 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 Free Software Foundation, Inc.
+   1999, 2000, 2001, 2002, 2003, 2004, 2005,
+   2006, 2007 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
    Written by Per Bothner, 1994.
    Based on CCCP program by Paul Rubin, June 1986
    Adapted to ANSI C, Richard Stallman, Jan 1987


@@ -17,7 +18,7 @@ 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
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software

-Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 
  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


@@ -42,8 +43,6 @@ struct macro_arg
 
 static int enter_macro_context (cpp_reader *, cpp_hashnode *);
 static int builtin_macro (cpp_reader *, cpp_hashnode *);
 
 static int enter_macro_context (cpp_reader *, cpp_hashnode *);
 static int builtin_macro (cpp_reader *, cpp_hashnode *);

-static void push_token_context (cpp_reader *, cpp_hashnode *,
-                               const cpp_token *, unsigned int);

 static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *,
                                 const cpp_token **, unsigned int);
 static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *);
 static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *,
                                 const cpp_token **, unsigned int);
 static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *);


@@ -125,6 +124,44 @@ _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
                 NODE_NAME (node));
       break;
 
                 NODE_NAME (node));
       break;
 

+    case BT_TIMESTAMP:
+      {
+       cpp_buffer *pbuffer = cpp_get_buffer (pfile);
+       if (pbuffer->timestamp == NULL)
+         {
+           /* Initialize timestamp value of the assotiated file. */
+            struct _cpp_file *file = cpp_get_file (pbuffer);
+           if (file)
+             {
+               /* Generate __TIMESTAMP__ string, that represents 
+                  the date and time of the last modification 
+                  of the current source file. The string constant 
+                  looks like "Sun Sep 16 01:03:52 1973".  */
+               struct tm *tb = NULL;
+               struct stat *st = _cpp_get_file_stat (file);
+               if (st)
+                 tb = localtime (&st->st_mtime);
+               if (tb)
+                 {
+                   char *str = asctime (tb);
+                   size_t len = strlen (str);
+                   unsigned char *buf = _cpp_unaligned_alloc (pfile, len + 2);
+                   buf[0] = '"';
+                   strcpy ((char *) buf + 1, str);
+                   buf[len] = '"';
+                   pbuffer->timestamp = buf;
+                 }
+               else
+                 {
+                   cpp_errno (pfile, CPP_DL_WARNING,
+                       "could not determine file timestamp");
+                   pbuffer->timestamp = U"\"??? ??? ?? ??:??:?? ????\"";
+                 }
+             }
+         }
+       result = pbuffer->timestamp;
+      }
+      break;

     case BT_FILE:
     case BT_BASE_FILE:
       {
     case BT_FILE:
     case BT_BASE_FILE:
       {


@@ -139,7 +176,7 @@ _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
 
        name = map->to_file;
        len = strlen (name);
 
        name = map->to_file;
        len = strlen (name);

-       buf = _cpp_unaligned_alloc (pfile, len * 4 + 3);
+       buf = _cpp_unaligned_alloc (pfile, len * 2 + 3);

        result = buf;
        *buf = '"';
        buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len);
        result = buf;
        *buf = '"';
        buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len);


@@ -171,16 +208,12 @@ _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
         However, if (a) we are in a system header, (b) the option
         stdc_0_in_system_headers is true (set by target config), and
         (c) we are not in strictly conforming mode, then it has the
         However, if (a) we are in a system header, (b) the option
         stdc_0_in_system_headers is true (set by target config), and
         (c) we are not in strictly conforming mode, then it has the

-        value 0.  */
+        value 0.  (b) and (c) are already checked in cpp_init_builtins.  */

     case BT_STDC:
     case BT_STDC:

-      {
-       if (cpp_in_system_header (pfile)
-           && CPP_OPTION (pfile, stdc_0_in_system_headers)
-           && !CPP_OPTION (pfile,std))
-         number = 0;
-       else
-         number = 1;
-      }
+      if (cpp_in_system_header (pfile))
+       number = 0;
+      else
+       number = 1;

       break;
 
     case BT_DATE:
       break;
 
     case BT_DATE:


@@ -230,6 +263,13 @@ _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
       else
        result = pfile->time;
       break;
       else
        result = pfile->time;
       break;

+
+    case BT_COUNTER:
+      if (CPP_OPTION (pfile, directives_only) && pfile->state.in_directive)
+       cpp_error (pfile, CPP_DL_ERROR,
+           "__COUNTER__ expanded inside directive with -fdirectives-only");
+      number = pfile->counter++;
+      break;

     }
 
   if (result == NULL)
     }
 
   if (result == NULL)


@@ -261,19 +301,12 @@ builtin_macro (cpp_reader *pfile, cpp_hashnode *node)
        return 0;
 
       _cpp_do__Pragma (pfile);
        return 0;
 
       _cpp_do__Pragma (pfile);

-      if (pfile->directive_result.type == CPP_PRAGMA) 
-       {
-         cpp_token *tok = _cpp_temp_token (pfile);
-         *tok = pfile->directive_result;
-         push_token_context (pfile, NULL, tok, 1);
-       }
-

       return 1;
     }
 
   buf = _cpp_builtin_macro_text (pfile, node);
   len = ustrlen (buf);
       return 1;
     }
 
   buf = _cpp_builtin_macro_text (pfile, node);
   len = ustrlen (buf);

-  nbuf = alloca (len + 1);
+  nbuf = (char *) alloca (len + 1);

   memcpy (nbuf, buf, len);
   nbuf[len]='\n';
 
   memcpy (nbuf, buf, len);
   nbuf[len]='\n';
 


@@ -282,7 +315,7 @@ builtin_macro (cpp_reader *pfile, cpp_hashnode *node)
 
   /* Set pfile->cur_token as required by _cpp_lex_direct.  */
   pfile->cur_token = _cpp_temp_token (pfile);
 
   /* Set pfile->cur_token as required by _cpp_lex_direct.  */
   pfile->cur_token = _cpp_temp_token (pfile);

-  push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1);
+  _cpp_push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1);

   if (pfile->buffer->cur != pfile->buffer->rlimit)
     cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
               NODE_NAME (node));
   if (pfile->buffer->cur != pfile->buffer->rlimit)
     cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
               NODE_NAME (node));


@@ -292,9 +325,8 @@ builtin_macro (cpp_reader *pfile, cpp_hashnode *node)
 }
 
 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
 }
 
 /* Copies SRC, of length LEN, to DEST, adding backslashes before all

-   backslashes and double quotes.  Non-printable characters are
-   converted to octal.  DEST must be of sufficient size.  Returns
-   a pointer to the end of the string.  */
+   backslashes and double quotes. DEST must be of sufficient size.
+   Returns a pointer to the end of the string.  */

 uchar *
 cpp_quote_string (uchar *dest, const uchar *src, unsigned int len)
 {
 uchar *
 cpp_quote_string (uchar *dest, const uchar *src, unsigned int len)
 {


@@ -308,15 +340,7 @@ cpp_quote_string (uchar *dest, const uchar *src, unsigned int len)
          *dest++ = c;
        }
       else
          *dest++ = c;
        }
       else

-       {
-         if (ISPRINT (c))
-           *dest++ = c;
-         else
-           {
-             sprintf ((char *) dest, "\\%03o", c);
-             dest += 4;
-           }
-       }
+         *dest++ = c;

     }
 
   return dest;
     }
 
   return dest;


@@ -380,12 +404,12 @@ stringify_arg (cpp_reader *pfile, macro_arg *arg)
        {
          _cpp_buff *buff = _cpp_get_buff (pfile, len);
          unsigned char *buf = BUFF_FRONT (buff);
        {
          _cpp_buff *buff = _cpp_get_buff (pfile, len);
          unsigned char *buf = BUFF_FRONT (buff);

-         len = cpp_spell_token (pfile, token, buf) - buf;
+         len = cpp_spell_token (pfile, token, buf, true) - buf;

          dest = cpp_quote_string (dest, buf, len);
          _cpp_release_buff (pfile, buff);
        }
       else
          dest = cpp_quote_string (dest, buf, len);
          _cpp_release_buff (pfile, buff);
        }
       else

-       dest = cpp_spell_token (pfile, token, dest);
+       dest = cpp_spell_token (pfile, token, dest, true);

 
       if (token->type == CPP_OTHER && token->val.str.text[0] == '\\')
        backslash_count++;
 
       if (token->type == CPP_OTHER && token->val.str.text[0] == '\\')
        backslash_count++;


@@ -414,23 +438,21 @@ stringify_arg (cpp_reader *pfile, macro_arg *arg)
 static bool
 paste_tokens (cpp_reader *pfile, const cpp_token **plhs, const cpp_token *rhs)
 {
 static bool
 paste_tokens (cpp_reader *pfile, const cpp_token **plhs, const cpp_token *rhs)
 {

-  unsigned char *buf, *end;
-  const cpp_token *lhs;
+  unsigned char *buf, *end, *lhsend;
+  cpp_token *lhs;

   unsigned int len;
   unsigned int len;

-  bool valid;

 
 

-  lhs = *plhs;
-  len = cpp_token_len (lhs) + cpp_token_len (rhs) + 1;
-  buf = alloca (len);
-  end = cpp_spell_token (pfile, lhs, buf);
+  len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 1;
+  buf = (unsigned char *) alloca (len);
+  end = lhsend = cpp_spell_token (pfile, *plhs, buf, false);

 
   /* Avoid comment headers, since they are still processed in stage 3.
      It is simpler to insert a space here, rather than modifying the
      lexer to ignore comments in some circumstances.  Simply returning
      false doesn't work, since we want to clear the PASTE_LEFT flag.  */
 
   /* Avoid comment headers, since they are still processed in stage 3.
      It is simpler to insert a space here, rather than modifying the
      lexer to ignore comments in some circumstances.  Simply returning
      false doesn't work, since we want to clear the PASTE_LEFT flag.  */

-  if (lhs->type == CPP_DIV && rhs->type != CPP_EQ)
+  if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ)

     *end++ = ' ';
     *end++ = ' ';

-  end = cpp_spell_token (pfile, rhs, end);
+  end = cpp_spell_token (pfile, rhs, end, false);

   *end = '\n';
 
   cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);
   *end = '\n';
 
   cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);


@@ -438,11 +460,33 @@ paste_tokens (cpp_reader *pfile, const cpp_token **plhs, const cpp_token *rhs)
 
   /* Set pfile->cur_token as required by _cpp_lex_direct.  */
   pfile->cur_token = _cpp_temp_token (pfile);
 
   /* Set pfile->cur_token as required by _cpp_lex_direct.  */
   pfile->cur_token = _cpp_temp_token (pfile);

-  *plhs = _cpp_lex_direct (pfile);
-  valid = pfile->buffer->cur == pfile->buffer->rlimit;
-  _cpp_pop_buffer (pfile);
+  lhs = _cpp_lex_direct (pfile);
+  if (pfile->buffer->cur != pfile->buffer->rlimit)
+    {
+      source_location saved_loc = lhs->src_loc;
+
+      _cpp_pop_buffer (pfile);
+      _cpp_backup_tokens (pfile, 1);
+      *lhsend = '\0';
+
+      /* We have to remove the PASTE_LEFT flag from the old lhs, but
+        we want to keep the new location.  */
+      *lhs = **plhs;
+      *plhs = lhs;
+      lhs->src_loc = saved_loc;
+      lhs->flags &= ~PASTE_LEFT;
+
+      /* Mandatory error for all apart from assembler.  */
+      if (CPP_OPTION (pfile, lang) != CLK_ASM)
+       cpp_error (pfile, CPP_DL_ERROR,
+        "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
+                  buf, cpp_token_as_text (pfile, rhs));
+      return false;
+    }

 
 

-  return valid;
+  *plhs = lhs;
+  _cpp_pop_buffer (pfile);
+  return true;

 }
 
 /* Handles an arbitrarily long sequence of ## operators, with initial
 }
 
 /* Handles an arbitrarily long sequence of ## operators, with initial


@@ -474,22 +518,12 @@ paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs)
        abort ();
 
       if (!paste_tokens (pfile, &lhs, rhs))
        abort ();
 
       if (!paste_tokens (pfile, &lhs, rhs))

-       {
-         _cpp_backup_tokens (pfile, 1);
-
-         /* Mandatory error for all apart from assembler.  */
-         if (CPP_OPTION (pfile, lang) != CLK_ASM)
-           cpp_error (pfile, CPP_DL_ERROR,
-        "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
-                      cpp_token_as_text (pfile, lhs),
-                      cpp_token_as_text (pfile, rhs));
-         break;
-       }
+       break;

     }
   while (rhs->flags & PASTE_LEFT);
 
   /* Put the resulting token in its own context.  */
     }
   while (rhs->flags & PASTE_LEFT);
 
   /* Put the resulting token in its own context.  */

-  push_token_context (pfile, NULL, lhs, 1);
+  _cpp_push_token_context (pfile, NULL, lhs, 1);

 }
 
 /* Returns TRUE if the number of arguments ARGC supplied in an
 }
 
 /* Returns TRUE if the number of arguments ARGC supplied in an


@@ -703,7 +737,7 @@ funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node)
         too difficult.  We re-insert it in its own context.  */
       _cpp_backup_tokens (pfile, 1);
       if (padding)
         too difficult.  We re-insert it in its own context.  */
       _cpp_backup_tokens (pfile, 1);
       if (padding)

-       push_token_context (pfile, NULL, padding, 1);
+       _cpp_push_token_context (pfile, NULL, padding, 1);

     }
 
   return NULL;
     }
 
   return NULL;


@@ -759,7 +793,7 @@ enter_macro_context (cpp_reader *pfile, cpp_hashnode *node)
       macro->used = 1;
 
       if (macro->paramc == 0)
       macro->used = 1;
 
       if (macro->paramc == 0)

-       push_token_context (pfile, node, macro->exp.tokens, macro->count);
+       _cpp_push_token_context (pfile, node, macro->exp.tokens, macro->count);

 
       return 1;
     }
 
       return 1;
     }


@@ -886,7 +920,7 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg
        {
          cpp_token *token = _cpp_temp_token (pfile);
          token->type = (*paste_flag)->type;
        {
          cpp_token *token = _cpp_temp_token (pfile);
          token->type = (*paste_flag)->type;

-         token->val.str = (*paste_flag)->val.str;
+         token->val = (*paste_flag)->val;

          if (src->flags & PASTE_LEFT)
            token->flags = (*paste_flag)->flags | PASTE_LEFT;
          else
          if (src->flags & PASTE_LEFT)
            token->flags = (*paste_flag)->flags | PASTE_LEFT;
          else


@@ -952,9 +986,9 @@ push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
 }
 
 /* Push a list of tokens.  */
 }
 
 /* Push a list of tokens.  */

-static void
-push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
-                   const cpp_token *first, unsigned int count)
+void
+_cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
+                        const cpp_token *first, unsigned int count)

 {
   cpp_context *context = next_context (pfile);
 
 {
   cpp_context *context = next_context (pfile);
 


@@ -1001,7 +1035,7 @@ expand_arg (cpp_reader *pfile, macro_arg *arg)
 
   /* Loop, reading in the arguments.  */
   capacity = 256;
 
   /* Loop, reading in the arguments.  */
   capacity = 256;

-  arg->expanded = xmalloc (capacity * sizeof (cpp_token *));
+  arg->expanded = XNEWVEC (const cpp_token *, capacity);

 
   push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
   for (;;)
 
   push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
   for (;;)


@@ -1011,8 +1045,8 @@ expand_arg (cpp_reader *pfile, macro_arg *arg)
       if (arg->expanded_count + 1 >= capacity)
        {
          capacity *= 2;
       if (arg->expanded_count + 1 >= capacity)
        {
          capacity *= 2;

-         arg->expanded = xrealloc (arg->expanded,
-                                   capacity * sizeof (cpp_token *));
+         arg->expanded = XRESIZEVEC (const cpp_token *, arg->expanded,
+                                      capacity);

        }
 
       token = cpp_get_token (pfile);
        }
 
       token = cpp_get_token (pfile);


@@ -1060,6 +1094,8 @@ const cpp_token *
 cpp_get_token (cpp_reader *pfile)
 {
   const cpp_token *result;
 cpp_get_token (cpp_reader *pfile)
 {
   const cpp_token *result;

+  bool can_set = pfile->set_invocation_location;
+  pfile->set_invocation_location = false;

 
   for (;;)
     {
 
   for (;;)
     {


@@ -1105,6 +1141,10 @@ cpp_get_token (cpp_reader *pfile)
 
       if (!(node->flags & NODE_DISABLED))
        {
 
       if (!(node->flags & NODE_DISABLED))
        {

+         /* If not in a macro context, and we're going to start an
+            expansion, record the location.  */
+         if (can_set && !context->macro)
+           pfile->invocation_location = result->src_loc;

          if (!pfile->state.prevent_expansion
              && enter_macro_context (pfile, node))
            {
          if (!pfile->state.prevent_expansion
              && enter_macro_context (pfile, node))
            {


@@ -1120,7 +1160,7 @@ cpp_get_token (cpp_reader *pfile)
          cpp_token *t = _cpp_temp_token (pfile);
          t->type = result->type;
          t->flags = result->flags | NO_EXPAND;
          cpp_token *t = _cpp_temp_token (pfile);
          t->type = result->type;
          t->flags = result->flags | NO_EXPAND;

-         t->val.str = result->val.str;
+         t->val = result->val;

          result = t;
        }
 
          result = t;
        }
 


@@ -1130,6 +1170,27 @@ cpp_get_token (cpp_reader *pfile)
   return result;
 }
 
   return result;
 }
 

+/* Like cpp_get_token, but also returns a location separate from the
+   one provided by the returned token.  LOC is an out parameter; *LOC
+   is set to the location "as expected by the user".  This matters
+   when a token results from macro expansion -- the token's location
+   will indicate where the macro is defined, but *LOC will be the
+   location of the start of the expansion.  */
+const cpp_token *
+cpp_get_token_with_location (cpp_reader *pfile, source_location *loc)
+{
+  const cpp_token *result;
+
+  pfile->set_invocation_location = true;
+  result = cpp_get_token (pfile);
+  if (pfile->context->macro)
+    *loc = pfile->invocation_location;
+  else
+    *loc = result->src_loc;
+
+  return result;
+}
+

 /* 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.  */
 /* 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.  */


@@ -1164,7 +1225,7 @@ cpp_scan_nooutput (cpp_reader *pfile)
   pfile->state.prevent_expansion--;
 }
 
   pfile->state.prevent_expansion--;
 }
 

-/* Step back one (or more) tokens.  Can only step mack more than 1 if
+/* Step back one (or more) tokens.  Can only step back more than 1 if

    they are from the lexer, and not from macro expansion.  */
 void
 _cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
    they are from the lexer, and not from macro expansion.  */
 void
 _cpp_backup_tokens (cpp_reader *pfile, unsigned int count)


@@ -1272,7 +1333,8 @@ _cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node)
   len = macro->paramc * sizeof (union _cpp_hashnode_value);
   if (len > pfile->macro_buffer_len)
     {
   len = macro->paramc * sizeof (union _cpp_hashnode_value);
   if (len > pfile->macro_buffer_len)
     {

-      pfile->macro_buffer = xrealloc (pfile->macro_buffer, len);
+      pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
+                                        len);

       pfile->macro_buffer_len = len;
     }
   ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
       pfile->macro_buffer_len = len;
     }
   ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]


@@ -1380,10 +1442,12 @@ alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
 static cpp_token *
 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
 {
 static cpp_token *
 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
 {

-  cpp_token *token;
+  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 = 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
 
   /* Is this a parameter?  */
   if (token->type == CPP_NAME


@@ -1404,6 +1468,9 @@ create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
 {
   cpp_token *token;
   const cpp_token *ctoken;
 {
   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");

 
   /* 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).  */


@@ -1419,8 +1486,9 @@ create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
       /* Success.  Commit or allocate the parameter array.  */
       if (pfile->hash_table->alloc_subobject)
        {
       /* Success.  Commit or allocate the parameter array.  */
       if (pfile->hash_table->alloc_subobject)
        {

-         cpp_hashnode **params = pfile->hash_table->alloc_subobject
-           (sizeof (cpp_hashnode *) * macro->paramc);
+         cpp_hashnode **params =
+            (cpp_hashnode **) pfile->hash_table->alloc_subobject
+            (sizeof (cpp_hashnode *) * macro->paramc);

          memcpy (params, macro->params,
                  sizeof (cpp_hashnode *) * macro->paramc);
          macro->params = params;
          memcpy (params, macro->params,
                  sizeof (cpp_hashnode *) * macro->paramc);
          macro->params = params;


@@ -1430,8 +1498,39 @@ create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
       macro->fun_like = 1;
     }
   else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
       macro->fun_like = 1;
     }
   else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))

-    cpp_error (pfile, CPP_DL_PEDWARN,
-              "ISO C requires whitespace after the macro name");
+    {
+      /* While ISO C99 requires whitespace before replacement text
+        in a macro definition, ISO C90 with TC1 allows there characters
+        from the basic source character set.  */
+      if (CPP_OPTION (pfile, c99))
+       cpp_error (pfile, CPP_DL_PEDWARN,
+                  "ISO C99 requires whitespace after the macro name");
+      else
+       {
+         int warntype = CPP_DL_WARNING;
+         switch (ctoken->type)
+           {
+           case CPP_ATSIGN:
+           case CPP_AT_NAME:
+           case CPP_OBJC_STRING:
+             /* '@' is not in basic character set.  */
+             warntype = CPP_DL_PEDWARN;
+             break;
+           case CPP_OTHER:
+             /* Basic character set sans letters, digits and _.  */
+             if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
+                         ctoken->val.str.text[0]) == NULL)
+               warntype = CPP_DL_PEDWARN;
+             break;
+           default:
+             /* All other tokens start with a character from basic
+                character set.  */
+             break;
+           }
+         cpp_error (pfile, warntype,
+                    "missing whitespace after the macro name");
+       }
+    }

 
   if (macro->fun_like)
     token = lex_expansion_token (pfile, macro);
 
   if (macro->fun_like)
     token = lex_expansion_token (pfile, macro);


@@ -1465,26 +1564,34 @@ create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
        }
 
       if (token->type == CPP_EOF)
        }
 
       if (token->type == CPP_EOF)

-       break;
+       {
+         /* Paste operator constraint 6.10.3.3.1:
+            Token-paste ##, can appear in both object-like and
+            function-like macros, but not at the end.  */
+         if (following_paste_op)
+           {
+             cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
+             return false;
+           }
+         break;
+       }

 
       /* Paste operator constraint 6.10.3.3.1.  */
       if (token->type == CPP_PASTE)
        {
          /* Token-paste ##, can appear in both object-like and
 
       /* Paste operator constraint 6.10.3.3.1.  */
       if (token->type == CPP_PASTE)
        {
          /* Token-paste ##, can appear in both object-like and

-            function-like macros, but not at the ends.  */
-         if (--macro->count > 0)
-           token = lex_expansion_token (pfile, macro);
-
-         if (macro->count == 0 || token->type == CPP_EOF)
+            function-like macros, but not at the beginning.  */
+         if (macro->count == 1)

            {
            {

-             cpp_error (pfile, CPP_DL_ERROR,
-                "'##' cannot appear at either end of a macro expansion");
+             cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);

              return false;
            }
 
              return false;
            }
 

+         --macro->count;

          token[-1].flags |= PASTE_LEFT;
        }
 
          token[-1].flags |= PASTE_LEFT;
        }
 

+      following_paste_op = (token->type == CPP_PASTE);

       token = lex_expansion_token (pfile, macro);
     }
 
       token = lex_expansion_token (pfile, macro);
     }
 


@@ -1501,8 +1608,9 @@ create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
   /* Commit or allocate the memory.  */
   if (pfile->hash_table->alloc_subobject)
     {
   /* Commit or allocate the memory.  */
   if (pfile->hash_table->alloc_subobject)
     {

-      cpp_token *tokns = 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);
       macro->exp.tokens = tokns;
     }
       memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
       macro->exp.tokens = tokns;
     }


@@ -1521,7 +1629,8 @@ _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
   bool ok;
 
   if (pfile->hash_table->alloc_subobject)
   bool ok;
 
   if (pfile->hash_table->alloc_subobject)

-    macro = pfile->hash_table->alloc_subobject (sizeof (cpp_macro));
+    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;
   else
     macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
   macro->line = pfile->directive_line;


@@ -1538,18 +1647,12 @@ _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
     ok = _cpp_create_trad_definition (pfile, macro);
   else
     {
     ok = _cpp_create_trad_definition (pfile, macro);
   else
     {

-      cpp_token *saved_cur_token = pfile->cur_token;
-

       ok = create_iso_definition (pfile, macro);
 
       ok = create_iso_definition (pfile, macro);
 

-      /* Restore lexer position because of games lex_expansion_token()
-        plays lexing the macro.  We set the type for SEEN_EOL() in
-        directives.c.
+      /* We set the type for SEEN_EOL() in directives.c.

 
         Longer term we should lex the whole line before coming here,
         and just copy the expansion.  */
 
         Longer term we should lex the whole line before coming here,
         and just copy the expansion.  */

-      saved_cur_token[-1].type = pfile->cur_token[-1].type;
-      pfile->cur_token = saved_cur_token;

 
       /* Stop the lexer accepting __VA_ARGS__.  */
       pfile->state.va_args_ok = 0;
 
       /* Stop the lexer accepting __VA_ARGS__.  */
       pfile->state.va_args_ok = 0;


@@ -1666,6 +1769,7 @@ cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
        len += NODE_LEN (macro->params[i]) + 1; /* "," */
     }
 
        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
   if (CPP_OPTION (pfile, traditional))
     len += _cpp_replacement_text_len (macro);
   else


@@ -1677,17 +1781,21 @@ cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
          if (token->type == CPP_MACRO_ARG)
            len += NODE_LEN (macro->params[token->val.arg_no - 1]);
          else
          if (token->type == CPP_MACRO_ARG)
            len += NODE_LEN (macro->params[token->val.arg_no - 1]);
          else

-           len += cpp_token_len (token) + 1; /* Includes room for ' '.  */
+           len += cpp_token_len (token);
+

          if (token->flags & STRINGIFY_ARG)
            len++;                      /* "#" */
          if (token->flags & PASTE_LEFT)
            len += 3;           /* " ##" */
          if (token->flags & STRINGIFY_ARG)
            len++;                      /* "#" */
          if (token->flags & PASTE_LEFT)
            len += 3;           /* " ##" */

+         if (token->flags & PREV_WHITE)
+           len++;              /* " " */

        }
     }
 
   if (len > pfile->macro_buffer_len)
     {
        }
     }
 
   if (len > pfile->macro_buffer_len)
     {

-      pfile->macro_buffer = xrealloc (pfile->macro_buffer, len);
+      pfile->macro_buffer = XRESIZEVEC (unsigned char,
+                                        pfile->macro_buffer, len);

       pfile->macro_buffer_len = len;
     }
 
       pfile->macro_buffer_len = len;
     }
 


@@ -1741,13 +1849,13 @@ cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
 
          if (token->type == CPP_MACRO_ARG)
            {
 
          if (token->type == CPP_MACRO_ARG)
            {

-             len = NODE_LEN (macro->params[token->val.arg_no - 1]);

              memcpy (buffer,
              memcpy (buffer,

-                     NODE_NAME (macro->params[token->val.arg_no - 1]), len);
-             buffer += len;
+                     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]);

            }
          else
            }
          else

-           buffer = cpp_spell_token (pfile, token, buffer);
+           buffer = cpp_spell_token (pfile, token, buffer, false);

 
          if (token->flags & PASTE_LEFT)
            {
 
          if (token->flags & PASTE_LEFT)
            {