[rpms/gcc] rhel-f41-base: 4.4.0-0.15

[Jakub Jelinek <jakub@fedoraproject.org>]

A new commit has been pushed.

Repo   : rpms/gcc
Branch : rhel-f41-base
Commit : d02d0c24e1419080258ac5814a5c5cbd7280103b
Author : Jakub Jelinek <jakub@fedoraproject.org>
Date   : 2009-02-04T22:38:29+00:00
Stats  : +1505/-5 in 4 file(s)
URL    : https://src.fedoraproject.org/rpms/gcc/c/d02d0c24e1419080258ac5814a5c5cbd7280103b?branch=rhel-f41-base

Log:
4.4.0-0.15

---
diff --git a/.cvsignore b/.cvsignore
index a7d3e79..578d400 100644
--- a/.cvsignore
+++ b/.cvsignore
@@ -1,3 +1,3 @@
 fastjar-0.97.tar.gz
-gcc-4.4.0-20090203.tar.bz2
+gcc-4.4.0-20090204.tar.bz2
 cloog-ppl-0.15.tar.gz

diff --git a/gcc.spec b/gcc.spec
index 171a639..9933be0 100644
--- a/gcc.spec
+++ b/gcc.spec
@@ -1,9 +1,9 @@
-%define DATE 20090203
-%define SVNREV 143904
+%define DATE 20090204
+%define SVNREV 143941
 %define gcc_version 4.4.0
 # Note, gcc_release must be integer, if you want to add suffixes to
 # %{release}, append them after %{gcc_release} on Release: line.
-%define gcc_release 0.14
+%define gcc_release 0.15
 %define _unpackaged_files_terminate_build 0
 %define multilib_64_archs sparc64 ppc64 s390x x86_64
 %define include_gappletviewer 1
@@ -139,6 +139,7 @@ Patch15: gcc44-sparc-config-detection.patch
 Patch16: gcc44-libgomp-omp_h-multilib.patch
 Patch20: gcc44-libtool-no-rpath.patch
 Patch21: gcc44-cloog-dl.patch
+Patch22: gcc44-raw-string.patch
 
 Patch1000: fastjar-0.97-segfault.patch
 
@@ -424,6 +425,7 @@ which are required to compile with the GNAT.
 %if %{build_cloog}
 %patch21 -p0 -b .cloog-dl~
 %endif
+%patch22 -p0 -b .raw-string~
 
 # This testcase doesn't compile.
 rm libjava/testsuite/libjava.lang/PR35020*
@@ -1759,6 +1761,12 @@ fi
 %doc rpm.doc/changelogs/libmudflap/ChangeLog*
 
 %changelog
+* Wed Feb  4 2009 Jakub Jelinek <jakub@redhat.com> 4.4.0-0.15
+- update from trunk
+  - C++ mangling fix (PR c++/39095)
+  - only complain about calling main in C++ if -pedantic
+- add raw string support
+
 * Tue Feb  3 2009 Jakub Jelinek <jakub@redhat.com> 4.4.0-0.14
 - update from trunk
 - when compiling with -march=i386, don't use __sync_* builtins in

diff --git a/gcc44-raw-string.patch b/gcc44-raw-string.patch
new file mode 100644
index 0000000..b1edad1
--- /dev/null
+++ b/gcc44-raw-string.patch
@@ -0,0 +1,1492 @@
+2008-09-12  Jakub Jelinek  <jakub@redhat.com>
+
+	* charset.c (cpp_init_iconv): Initialize utf8_cset_desc.
+	(_cpp_destroy_iconv): Destroy utf8_cset_desc, char16_cset_desc
+	and char32_cset_desc.
+	(converter_for_type): Handle CPP_UTF8STRING.
+	(cpp_interpret_string): Handle CPP_UTF8STRING and raw-strings.
+	* directives.c (get__Pragma_string): Handle CPP_UTF8STRING.
+	* include/cpplib.h (CPP_UTF8STRING): New token type.
+	* internal.h (struct cpp_reader): Add utf8_cset_desc field.
+	* lex.c (lex_raw_string): New function.
+	(lex_string): Handle u8 string literals, call lex_raw_string
+	for raw string literals.
+	(_cpp_lex_direct): Call lex_string even for u8" and {,u,U,L,u8}R"
+	sequences.
+	* macro.c (stringify_arg): Handle CPP_UTF8STRING.
+
+	* c-common.c (c_parse_error): Handle CPP_UTF8STRING.
+	* c-lex.c (c_lex_with_flags, lex_string): Likewise.
+	* c-parser.c (c_parser_postfix_expression): Likewise.
+
+	* parser.c (cp_lexer_print_token, cp_parser_is_string_literal,
+	cp_parser_string_literal, cp_parser_primary_expression): Likewise.
+
+	* gcc.dg/raw-string-1.c: New test.
+	* gcc.dg/raw-string-2.c: New test.
+	* gcc.dg/raw-string-3.c: New test.
+	* gcc.dg/raw-string-4.c: New test.
+	* gcc.dg/raw-string-5.c: New test.
+	* gcc.dg/raw-string-6.c: New test.
+	* gcc.dg/raw-string-7.c: New test.
+	* gcc.dg/utf8-1.c: New test.
+	* gcc.dg/utf8-2.c: New test.
+	* gcc.dg/utf-badconcat2.c: New test.
+	* gcc.dg/utf-dflt2.c: New test.
+	* g++.dg/ext/raw-string-1.C: New test.
+	* g++.dg/ext/raw-string-2.C: New test.
+	* g++.dg/ext/raw-string-3.C: New test.
+	* g++.dg/ext/raw-string-4.C: New test.
+	* g++.dg/ext/raw-string-5.C: New test.
+	* g++.dg/ext/raw-string-6.C: New test.
+	* g++.dg/ext/raw-string-7.C: New test.
+	* g++.dg/ext/utf8-1.C: New test.
+	* g++.dg/ext/utf8-2.C: New test.
+	* g++.dg/ext/utf-badconcat2.C: New test.
+	* g++.dg/ext/utf-dflt2.C: New test.
+
+--- libcpp/charset.c.jj	2008-09-05 12:59:49.000000000 +0200
++++ libcpp/charset.c	2008-09-11 22:11:02.000000000 +0200
+@@ -721,6 +721,8 @@ cpp_init_iconv (cpp_reader *pfile)
+ 
+   pfile->narrow_cset_desc = init_iconv_desc (pfile, ncset, SOURCE_CHARSET);
+   pfile->narrow_cset_desc.width = CPP_OPTION (pfile, char_precision);
++  pfile->utf8_cset_desc = init_iconv_desc (pfile, "UTF-8", SOURCE_CHARSET);
++  pfile->utf8_cset_desc.width = CPP_OPTION (pfile, char_precision);
+   pfile->char16_cset_desc = init_iconv_desc (pfile,
+ 					     be ? "UTF-16BE" : "UTF-16LE",
+ 					     SOURCE_CHARSET);
+@@ -741,6 +743,12 @@ _cpp_destroy_iconv (cpp_reader *pfile)
+     {
+       if (pfile->narrow_cset_desc.func == convert_using_iconv)
+ 	iconv_close (pfile->narrow_cset_desc.cd);
++      if (pfile->utf8_cset_desc.func == convert_using_iconv)
++	iconv_close (pfile->utf8_cset_desc.cd);
++      if (pfile->char16_cset_desc.func == convert_using_iconv)
++	iconv_close (pfile->char16_cset_desc.cd);
++      if (pfile->char32_cset_desc.func == convert_using_iconv)
++	iconv_close (pfile->char32_cset_desc.cd);
+       if (pfile->wide_cset_desc.func == convert_using_iconv)
+ 	iconv_close (pfile->wide_cset_desc.cd);
+     }
+@@ -1330,6 +1338,8 @@ converter_for_type (cpp_reader *pfile, e
+     {
+     default:
+ 	return pfile->narrow_cset_desc;
++    case CPP_UTF8STRING:
++	return pfile->utf8_cset_desc;
+     case CPP_CHAR16:
+     case CPP_STRING16:
+ 	return pfile->char16_cset_desc;
+@@ -1364,7 +1374,47 @@ cpp_interpret_string (cpp_reader *pfile,
+   for (i = 0; i < count; i++)
+     {
+       p = from[i].text;
+-      if (*p == 'L' || *p == 'u' || *p == 'U') p++;
++      if (*p == 'u')
++	{
++	  if (*++p == '8')
++	    p++;
++	}
++      else if (*p == 'L' || *p == 'U') p++;
++      if (*p == 'R')
++	{
++	  const uchar *prefix;
++
++	  /* Skip over 'R"'.  */
++	  p += 2;
++	  prefix = p;
++	  while (*p != '[')
++	    p++;
++	  p++;
++	  limit = from[i].text + from[i].len;
++	  if (limit >= p + (p - prefix) + 1)
++	    limit -= (p - prefix) + 1;
++
++	  for (;;)
++	    {
++	      base = p;
++	      while (p < limit && (*p != '\\' || (p[1] != 'u' && p[1] != 'U')))
++		p++;
++	      if (p > base)
++		{
++		  /* We have a run of normal characters; these can be fed
++		     directly to convert_cset.  */
++		  if (!APPLY_CONVERSION (cvt, base, p - base, &tbuf))
++		    goto fail;
++		}
++	      if (p == limit)
++		break;
++
++	      p = convert_ucn (pfile, p + 1, limit, &tbuf, cvt);
++	    }
++
++	  continue;
++	}
++
+       p++; /* Skip leading quote.  */
+       limit = from[i].text + from[i].len - 1; /* Skip trailing quote.  */
+ 
+--- libcpp/directives.c.jj	2008-09-05 12:59:49.000000000 +0200
++++ libcpp/directives.c	2008-09-11 20:27:32.000000000 +0200
+@@ -1519,7 +1519,8 @@ get__Pragma_string (cpp_reader *pfile)
+   if (string->type == CPP_EOF)
+     _cpp_backup_tokens (pfile, 1);
+   if (string->type != CPP_STRING && string->type != CPP_WSTRING
+-      && string->type != CPP_STRING32 && string->type != CPP_STRING16)
++      && string->type != CPP_STRING32 && string->type != CPP_STRING16
++      && string->type != CPP_UTF8STRING)
+     return NULL;
+ 
+   paren = get_token_no_padding (pfile);
+--- libcpp/include/cpplib.h.jj	2008-09-05 12:59:47.000000000 +0200
++++ libcpp/include/cpplib.h	2008-09-11 20:23:53.000000000 +0200
+@@ -131,6 +131,7 @@ struct _cpp_file;
+   TK(WSTRING,		LITERAL) /* L"string" */			\
+   TK(STRING16,		LITERAL) /* u"string" */			\
+   TK(STRING32,		LITERAL) /* U"string" */			\
++  TK(UTF8STRING,	LITERAL) /* u8"string" */			\
+   TK(OBJC_STRING,	LITERAL) /* @"string" - Objective-C */		\
+   TK(HEADER_NAME,	LITERAL) /* <stdio.h> in #include */		\
+ 									\
+@@ -724,10 +725,10 @@ extern const unsigned char *cpp_macro_de
+ extern void _cpp_backup_tokens (cpp_reader *, unsigned int);
+ extern const cpp_token *cpp_peek_token (cpp_reader *, int);
+ 
+-/* Evaluate a CPP_CHAR or CPP_WCHAR token.  */
++/* Evaluate a CPP_*CHAR* token.  */
+ extern cppchar_t cpp_interpret_charconst (cpp_reader *, const cpp_token *,
+ 					  unsigned int *, int *);
+-/* Evaluate a vector of CPP_STRING or CPP_WSTRING tokens.  */
++/* Evaluate a vector of CPP_*STRING* tokens.  */
+ extern bool cpp_interpret_string (cpp_reader *,
+ 				  const cpp_string *, size_t,
+ 				  cpp_string *, enum cpp_ttype);
+--- libcpp/internal.h.jj	2008-09-05 12:59:49.000000000 +0200
++++ libcpp/internal.h	2008-09-11 18:23:02.000000000 +0200
+@@ -400,6 +400,10 @@ struct cpp_reader
+   struct cset_converter narrow_cset_desc;
+ 
+   /* Descriptor for converting from the source character set to the
++     UTF-8 execution character set.  */
++  struct cset_converter utf8_cset_desc;
++
++  /* Descriptor for converting from the source character set to the
+      UTF-16 execution character set.  */
+   struct cset_converter char16_cset_desc;
+ 
+--- libcpp/lex.c.jj	2008-09-05 12:59:49.000000000 +0200
++++ libcpp/lex.c	2008-09-12 13:54:01.000000000 +0200
+@@ -609,10 +609,185 @@ create_literal (cpp_reader *pfile, cpp_t
+   token->val.str.text = dest;
+ }
+ 
++/* Lexes raw a string.  The stored string contains the spelling, including
++   double quotes, delimiter string, '[' and ']', any leading
++   'L', 'u', 'U' or 'u8' and 'R' modifier.  It returns the type of the
++   literal, or CPP_OTHER if it was not properly terminated.
++
++   The spelling is NUL-terminated, but it is not guaranteed that this
++   is the first NUL since embedded NULs are preserved.  */
++
++static void
++lex_raw_string (cpp_reader *pfile, cpp_token *token, const uchar *base,
++		const uchar *cur)
++{
++  bool saw_NUL = false;
++  const uchar *raw_prefix;
++  unsigned int raw_prefix_len = 0;
++  enum cpp_ttype type;
++  size_t total_len = 0;
++  _cpp_buff *first_buff = NULL, *last_buff = NULL;
++
++  type = (*base == 'L' ? CPP_WSTRING :
++	  *base == 'U' ? CPP_STRING32 :
++	  *base == 'u' ? (base[1] == '8' ? CPP_UTF8STRING : CPP_STRING16)
++	  : CPP_STRING);
++
++  raw_prefix = cur + 1;
++  while (raw_prefix_len < 16)
++    {
++      switch (raw_prefix[raw_prefix_len])
++	{
++	case ' ': case '[': case ']': case '\t':
++	case '\v': case '\f': case '\n': default:
++	  break;
++	/* Basic source charset except the above chars.  */
++	case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
++	case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
++	case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
++	case 's': case 't': case 'u': case 'v': case 'w': case 'x':
++	case 'y': case 'z':
++	case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
++	case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
++	case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
++	case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
++	case 'Y': case 'Z':
++	case '0': case '1': case '2': case '3': case '4': case '5':
++	case '6': case '7': case '8': case '9':
++	case '_': case '{': case '}': case '#': case '(': case ')':
++	case '<': case '>': case '%': case ':': case ';': case '.':
++	case '?': case '*': case '+': case '-': case '/': case '^':
++	case '&': case '|': case '~': case '!': case '=': case ',':
++	case '\\': case '"': case '\'':
++	  raw_prefix_len++;
++	  continue;
++	}
++      break;
++    }
++
++  if (raw_prefix[raw_prefix_len] != '[')
++    {
++      if (raw_prefix_len == 16)
++	cpp_error (pfile, CPP_DL_ERROR,
++		   "raw string delimiter longer than 16 characters");
++      else
++	cpp_error (pfile, CPP_DL_ERROR,
++		   "invalid character '%c' in raw string delimiter",
++		   (int) raw_prefix[raw_prefix_len]);
++      pfile->buffer->cur = raw_prefix - 1;
++      create_literal (pfile, token, base, raw_prefix - 1 - base, CPP_OTHER);
++      return;
++    }
++
++  cur = raw_prefix + raw_prefix_len + 1;
++  for (;;)
++    {
++      cppchar_t c = *cur++;
++
++      if (c == ']'
++	  && strncmp ((const char *) cur, (const char *) raw_prefix,
++		      raw_prefix_len) == 0
++	  && cur[raw_prefix_len] == '"')
++	{
++	  cur += raw_prefix_len + 1;
++	  break;
++	}
++      else if (c == '\n')
++	{
++	  if (pfile->state.in_directive
++	      || pfile->state.parsing_args
++	      || pfile->state.in_deferred_pragma)
++	    {
++	      cur--;
++	      type = CPP_OTHER;
++	      cpp_error (pfile, CPP_DL_ERROR, "unterminated raw string");
++	      break;
++	    }
++
++	  /* raw strings allow embedded non-escaped newlines, which
++	     complicates this routine a lot.  */
++	  if (first_buff == NULL)
++	    {
++	      total_len = cur - base;
++	      first_buff = last_buff = _cpp_get_buff (pfile, total_len);
++	      memcpy (BUFF_FRONT (last_buff), base, total_len);
++	      raw_prefix = BUFF_FRONT (last_buff) + (raw_prefix - base);
++	      BUFF_FRONT (last_buff) += total_len;
++	    }
++	  else
++	    {
++	      size_t len = cur - base;
++	      size_t cur_len = len > BUFF_ROOM (last_buff)
++			       ? BUFF_ROOM (last_buff) : len;
++
++	      total_len += len;
++	      memcpy (BUFF_FRONT (last_buff), base, cur_len);
++	      BUFF_FRONT (last_buff) += cur_len;
++	      if (len > cur_len)
++		{
++		  last_buff = _cpp_append_extend_buff (pfile, last_buff,
++						       len - cur_len);
++		  memcpy (BUFF_FRONT (last_buff), base + cur_len,
++			  len - cur_len);
++		  BUFF_FRONT (last_buff) += len - cur_len;
++		}
++	    }
++
++	  if (pfile->buffer->cur < pfile->buffer->rlimit)
++	    CPP_INCREMENT_LINE (pfile, 0);
++	  pfile->buffer->need_line = true;
++
++	  if (!_cpp_get_fresh_line (pfile))
++	    {
++	      token->type = CPP_EOF;
++	      /* Tell the compiler the line number of the EOF token.  */
++	      token->src_loc = pfile->line_table->highest_line;
++	      token->flags = BOL;
++	      if (first_buff != NULL)
++		_cpp_release_buff (pfile, first_buff);
++	      cpp_error (pfile, CPP_DL_ERROR, "unterminated raw string");
++	      return;
++	    }
++
++	  cur = base = pfile->buffer->cur;
++	}
++      else if (c == '\0')
++	saw_NUL = true;
++    }
++
++  if (saw_NUL && !pfile->state.skipping)
++    cpp_error (pfile, CPP_DL_WARNING,
++	       "null character(s) preserved in literal");
++
++  pfile->buffer->cur = cur;
++  if (first_buff == NULL)
++    create_literal (pfile, token, base, cur - base, type);
++  else
++    {
++      uchar *dest = _cpp_unaligned_alloc (pfile, total_len + (cur - base) + 1);
++
++      token->type = type;
++      token->val.str.len = total_len + (cur - base);
++      token->val.str.text = dest;
++      last_buff = first_buff;
++      while (last_buff != NULL)
++	{
++	  memcpy (dest, last_buff->base,
++		  BUFF_FRONT (last_buff) - last_buff->base);
++	  dest += BUFF_FRONT (last_buff) - last_buff->base;
++	  last_buff = last_buff->next;
++	}
++      _cpp_release_buff (pfile, first_buff);
++      memcpy (dest, base, cur - base);
++      dest[cur - base] = '\0';
++    }
++}
++
+ /* Lexes a string, character constant, or angle-bracketed header file
+    name.  The stored string contains the spelling, including opening
+-   quote and leading any leading 'L', 'u' or 'U'.  It returns the type
+-   of the literal, or CPP_OTHER if it was not properly terminated.
++   quote and any leading 'L', 'u', 'U' or 'u8' and optional
++   'R' modifier.  It returns the type of the literal, or CPP_OTHER
++   if it was not properly terminated.
+ 
+    The spelling is NUL-terminated, but it is not guaranteed that this
+    is the first NUL since embedded NULs are preserved.  */
+@@ -626,12 +801,24 @@ lex_string (cpp_reader *pfile, cpp_token
+ 
+   cur = base;
+   terminator = *cur++;
+-  if (terminator == 'L' || terminator == 'u' || terminator == 'U')
++  if (terminator == 'L' || terminator == 'U')
+     terminator = *cur++;
+-  if (terminator == '\"')
++  else if (terminator == 'u')
++    {
++      terminator = *cur++;
++      if (terminator == '8')
++	terminator = *cur++;
++    }
++  if (terminator == 'R')
++    {
++      lex_raw_string (pfile, token, base, cur);
++      return;
++    }
++  if (terminator == '"')
+     type = (*base == 'L' ? CPP_WSTRING :
+ 	    *base == 'U' ? CPP_STRING32 :
+-	    *base == 'u' ? CPP_STRING16 : CPP_STRING);
++	    *base == 'u' ? (base[1] == '8' ? CPP_UTF8STRING : CPP_STRING16)
++			 : CPP_STRING);
+   else if (terminator == '\'')
+     type = (*base == 'L' ? CPP_WCHAR :
+ 	    *base == 'U' ? CPP_CHAR32 :
+@@ -1035,10 +1222,20 @@ _cpp_lex_direct (cpp_reader *pfile)
+     case 'L':
+     case 'u':
+     case 'U':
++    case 'R':
+       /* 'L', 'u' or 'U' may introduce wide characters or strings.  */
+       if (c == 'L' || CPP_OPTION (pfile, uliterals))
+ 	{
+-	  if (*buffer->cur == '\'' || *buffer->cur == '"')
++	  if ((*buffer->cur == '\'' && c != 'R')
++	      || *buffer->cur == '"'
++	      || (*buffer->cur == 'R'
++		  && c != 'R'
++		  && buffer->cur[1] == '"'
++		  && CPP_OPTION (pfile, uliterals))
++	      || (*buffer->cur == '8'
++		  && c == 'u'
++		  && (buffer->cur[1] == '"'
++		      || (buffer->cur[1] == 'R' && buffer->cur[2] == '"'))))
+ 	    {
+ 	      lex_string (pfile, result, buffer->cur - 1);
+ 	      break;
+@@ -1054,7 +1251,7 @@ _cpp_lex_direct (cpp_reader *pfile)
+     case 'y': case 'z':
+     case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
+     case 'G': case 'H': case 'I': case 'J': case 'K':
+-    case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
++    case 'M': case 'N': case 'O': case 'P': case 'Q':
+     case 'S': case 'T':           case 'V': case 'W': case 'X':
+     case 'Y': case 'Z':
+       result->type = CPP_NAME;
+--- libcpp/macro.c.jj	2008-09-05 12:59:49.000000000 +0200
++++ libcpp/macro.c	2008-09-11 20:25:20.000000000 +0200
+@@ -377,7 +377,8 @@ stringify_arg (cpp_reader *pfile, macro_
+       escape_it = (token->type == CPP_STRING || token->type == CPP_CHAR
+ 		   || token->type == CPP_WSTRING || token->type == CPP_STRING
+ 		   || 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.  */
+--- gcc/c-common.c.jj	2008-09-09 16:08:04.000000000 +0200
++++ gcc/c-common.c	2008-09-11 20:30:57.000000000 +0200
+@@ -7472,7 +7472,7 @@ c_parse_error (const char *gmsgid, enum 
+       message = NULL;
+     }
+   else if (token == CPP_STRING || token == CPP_WSTRING || token == CPP_STRING16
+-	   || token == CPP_STRING32)
++	   || token == CPP_STRING32 || token == CPP_UTF8STRING)
+     message = catenate_messages (gmsgid, " before string constant");
+   else if (token == CPP_NUMBER)
+     message = catenate_messages (gmsgid, " before numeric constant");
+--- gcc/c-lex.c.jj	2008-09-05 12:56:31.000000000 +0200
++++ gcc/c-lex.c	2008-09-11 20:34:06.000000000 +0200
+@@ -365,6 +365,7 @@ c_lex_with_flags (tree *value, location_
+ 	    case CPP_WSTRING:
+ 	    case CPP_STRING16:
+ 	    case CPP_STRING32:
++	    case CPP_UTF8STRING:
+ 	      type = lex_string (tok, value, true, true);
+ 	      break;
+ 
+@@ -423,6 +424,7 @@ c_lex_with_flags (tree *value, location_
+     case CPP_WSTRING:
+     case CPP_STRING16:
+     case CPP_STRING32:
++    case CPP_UTF8STRING:
+       if ((lex_flags & C_LEX_RAW_STRINGS) == 0)
+ 	{
+ 	  type = lex_string (tok, value, false,
+@@ -830,12 +832,13 @@ interpret_fixed (const cpp_token *token,
+   return value;
+ }
+ 
+-/* Convert a series of STRING, WSTRING, STRING16 and/or STRING32 tokens
+-   into a tree, performing string constant concatenation.  TOK is the
+-   first of these.  VALP is the location to write the string into.
+-   OBJC_STRING indicates whether an '@' token preceded the incoming token.
++/* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
++   UTF8STRING tokens into a tree, performing string constant
++   concatenation.  TOK is the first of these.  VALP is the location
++   to write the string into. OBJC_STRING indicates whether an '@' token
++   preceded the incoming token.
+    Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
+-   CPP_STRING32, CPP_STRING16, or CPP_OBJC_STRING).
++   CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
+ 
+    This is unfortunately more work than it should be.  If any of the
+    strings in the series has an L prefix, the result is a wide string
+@@ -880,6 +883,7 @@ lex_string (const cpp_token *tok, tree *
+     case CPP_WSTRING:
+     case CPP_STRING16:
+     case CPP_STRING32:
++    case CPP_UTF8STRING:
+       if (type != tok->type)
+ 	{
+ 	  if (type == CPP_STRING)
+@@ -925,6 +929,7 @@ lex_string (const cpp_token *tok, tree *
+ 	{
+ 	default:
+ 	case CPP_STRING:
++	case CPP_UTF8STRING:
+ 	  value = build_string (1, "");
+ 	  break;
+ 	case CPP_STRING16:
+@@ -950,6 +955,7 @@ lex_string (const cpp_token *tok, tree *
+     {
+     default:
+     case CPP_STRING:
++    case CPP_UTF8STRING:
+       TREE_TYPE (value) = char_array_type_node;
+       break;
+     case CPP_STRING16:
+--- gcc/c-parser.c.jj	2008-09-09 16:08:04.000000000 +0200
++++ gcc/c-parser.c	2008-09-11 20:34:34.000000000 +0200
+@@ -5085,6 +5085,7 @@ c_parser_postfix_expression (c_parser *p
+     case CPP_STRING16:
+     case CPP_STRING32:
+     case CPP_WSTRING:
++    case CPP_UTF8STRING:
+       expr.value = c_parser_peek_token (parser)->value;
+       expr.original_code = STRING_CST;
+       c_parser_consume_token (parser);
+--- gcc/cp/parser.c.jj	2008-09-09 16:08:03.000000000 +0200
++++ gcc/cp/parser.c	2008-09-11 20:36:10.000000000 +0200
+@@ -797,6 +797,7 @@ cp_lexer_print_token (FILE * stream, cp_
+     case CPP_STRING16:
+     case CPP_STRING32:
+     case CPP_WSTRING:
++    case CPP_UTF8STRING:
+       fprintf (stream, " \"%s\"", TREE_STRING_POINTER (token->u.value));
+       break;
+ 
+@@ -2049,7 +2050,8 @@ cp_parser_is_string_literal (cp_token* t
+   return (token->type == CPP_STRING ||
+ 	  token->type == CPP_STRING16 ||
+ 	  token->type == CPP_STRING32 ||
+-	  token->type == CPP_WSTRING);
++	  token->type == CPP_WSTRING ||
++	  token->type == CPP_UTF8STRING);
+ }
+ 
+ /* Returns nonzero if TOKEN is the indicated KEYWORD.  */
+@@ -2972,6 +2974,7 @@ cp_parser_string_literal (cp_parser *par
+ 	{
+ 	default:
+ 	case CPP_STRING:
++	case CPP_UTF8STRING:
+ 	  TREE_TYPE (value) = char_array_type_node;
+ 	  break;
+ 	case CPP_STRING16:
+@@ -3195,6 +3198,7 @@ cp_parser_primary_expression (cp_parser 
+     case CPP_STRING16:
+     case CPP_STRING32:
+     case CPP_WSTRING:
++    case CPP_UTF8STRING:
+       /* ??? Should wide strings be allowed when parser->translate_strings_p
+ 	 is false (i.e. in attributes)?  If not, we can kill the third
+ 	 argument to cp_parser_string_literal.  */
+--- gcc/testsuite/gcc.dg/raw-string-1.c.jj	2008-09-12 11:48:36.000000000 +0200
++++ gcc/testsuite/gcc.dg/raw-string-1.c	2008-09-12 14:01:27.000000000 +0200
+@@ -0,0 +1,101 @@
++/* { dg-do run } */
++/* { dg-options "-std=gnu99" } */
++
++#include <wchar.h>
++
++typedef __CHAR16_TYPE__	char16_t;
++typedef __CHAR32_TYPE__ char32_t;
++
++const char s0[] = R"[a\
++\u010d\U0000010D\\\'\"\?\a\b\f\n\r\t\v\0\00\000\xa\xabb
++c]";
++const char s1[] = "a\U0000010d\u010d\\\\\\'\\\"\\?\\a\\b\\f\\n\\r\\t\\v\\0\\00\\000\\xa\\xabb\nc";
++const char s2[] = R"*|*[a\
++b
++c]"
++c]*|"
++c]*|*";
++const char s3[] = "ab\nc]\"\nc]*|\"\nc";
++
++const char t0[] = u8R"[a\
++\u010d\U0000010D\\\'\"\?\a\b\f\n\r\t\v\0\00\000\xa\xabb
++c]";
++const char t1[] = u8"a\U0000010d\u010d\\\\\\'\\\"\\?\\a\\b\\f\\n\\r\\t\\v\\0\\00\\000\\xa\\xabb\nc";
++const char t2[] = u8R"*|*[a\
++b
++c]"
++c]*|"
++c]*|*";
++const char t3[] = u8"ab\nc]\"\nc]*|\"\nc";
++
++const char16_t u0[] = uR"[a\
++\u010d\U0000010D\\\'\"\?\a\b\f\n\r\t\v\0\00\000\xa\xabb
++c]";
++const char16_t u1[] = u"a\U0000010d\u010d\\\\\\'\\\"\\?\\a\\b\\f\\n\\r\\t\\v\\0\\00\\000\\xa\\xabb\nc";
++const char16_t u2[] = uR"*|*[a\
++b
++c]"
++c]*|"
++c]*|*";
++const char16_t u3[] = u"ab\nc]\"\nc]*|\"\nc";
++
++const char32_t U0[] = UR"[a\
++\u010d\U0000010D\\\'\"\?\a\b\f\n\r\t\v\0\00\000\xa\xabb
++c]";
++const char32_t U1[] = U"a\U0000010d\u010d\\\\\\'\\\"\\?\\a\\b\\f\\n\\r\\t\\v\\0\\00\\000\\xa\\xabb\nc";
++const char32_t U2[] = UR"*|*[a\
++b
++c]"
++c]*|"
++c]*|*";
++const char32_t U3[] = U"ab\nc]\"\nc]*|\"\nc";
++
++const wchar_t L0[] = LR"[a\
++\u010d\U0000010D\\\'\"\?\a\b\f\n\r\t\v\0\00\000\xa\xabb
++c]";
++const wchar_t L1[] = L"a\U0000010d\u010d\\\\\\'\\\"\\?\\a\\b\\f\\n\\r\\t\\v\\0\\00\\000\\xa\\xabb\nc";
++const wchar_t L2[] = LR"*|*[a\
++b
++c]"
++c]*|"
++c]*|*";
++const wchar_t L3[] = L"ab\nc]\"\nc]*|\"\nc";
++
++int
++main (void)
++{
++  if (sizeof (s0) != sizeof (s1)
++      || __builtin_memcmp (s0, s1, sizeof (s0)) != 0)
++    __builtin_abort ();
++  if (sizeof (s2) != sizeof (s3)
++      || __builtin_memcmp (s2, s3, sizeof (s2)) != 0)
++    __builtin_abort ();
++  if (sizeof (t0) != sizeof (t1)
++      || __builtin_memcmp (t0, t1, sizeof (t0)) != 0)
++    __builtin_abort ();
++  if (sizeof (t2) != sizeof (t3)
++      || __builtin_memcmp (t2, t3, sizeof (t2)) != 0)
++    __builtin_abort ();
++  if (sizeof (u0) != sizeof (u1)
++      || __builtin_memcmp (u0, u1, sizeof (u0)) != 0)
++    __builtin_abort ();
++  if (sizeof (u2) != sizeof (u3)
++      || __builtin_memcmp (u2, u3, sizeof (u2)) != 0)
++    __builtin_abort ();
++  if (sizeof (U0) != sizeof (U1)
++      || __builtin_memcmp (U0, U1, sizeof (U0)) != 0)
++    __builtin_abort ();
++  if (sizeof (U2) != sizeof (U3)
++      || __builtin_memcmp (U2, U3, sizeof (U2)) != 0)
++    __builtin_abort ();
++  if (sizeof (L0) != sizeof (L1)
++      || __builtin_memcmp (L0, L1, sizeof (L0)) != 0)
++    __builtin_abort ();
++  if (sizeof (L2) != sizeof (L3)
++      || __builtin_memcmp (L2, L3, sizeof (L2)) != 0)
++    __builtin_abort ();
++  if (sizeof (R"*[]*") != 1
++      || __builtin_memcmp (R"*[]*", "", 1) != 0)
++    __builtin_abort ();
++  return 0;
++}
+--- gcc/testsuite/gcc.dg/raw-string-2.c.jj	2008-09-12 12:14:42.000000000 +0200
++++ gcc/testsuite/gcc.dg/raw-string-2.c	2008-09-12 13:37:10.000000000 +0200
+@@ -0,0 +1,109 @@
++/* { dg-do run } */
++/* { dg-options "-std=gnu99" } */
++
++#include <wchar.h>
++
++typedef __CHAR16_TYPE__	char16_t;
++typedef __CHAR32_TYPE__ char32_t;
++
++#define R
++#define u
++#define uR
++#define U
++#define UR
++#define u8
++#define u8R
++#define L
++#define LR
++
++const char s00[] = R"[a]" "[b]";
++const char s01[] = "[a]" R"*[b]*";
++const char s02[] = R"[a]" R"[b]";
++const char s03[] = R"-[a]-" u8"[b]";
++const char s04[] = "[a]" u8R"MNOPQRSTUVWXYZ[b]MNOPQRSTUVWXYZ";
++const char s05[] = R"[a]" u8R"wxyzABCDEFGHIJKL[b]wxyzABCDEFGHIJKL";
++const char s06[] = u8R";([a];(" "[b]";
++const char s07[] = u8"[a]" R"[b]";
++const char s08[] = u8R"[a]" R"_{}#()<>%:;.?*+-[b]_{}#()<>%:;.?*+-";
++const char s09[] = u8R"/^&|~!=,"'\[a]/^&|~!=,"'\" u8"[b]";
++const char s10[] = u8"[a]" u8R"0123456789abcdef[b]0123456789abcdef";
++const char s11[] = u8R"ghijklmnopqrstuv[a]ghijklmnopqrstuv" u8R"w[b]w";
++
++const char16_t u03[] = R"-[a]-" u"[b]";
++const char16_t u04[] = "[a]" uR"MNOPQRSTUVWXYZ[b]MNOPQRSTUVWXYZ";
++const char16_t u05[] = R"[a]" uR"wxyzABCDEFGHIJKL[b]wxyzABCDEFGHIJKL";
++const char16_t u06[] = uR";([a];(" "[b]";
++const char16_t u07[] = u"[a]" R"[b]";
++const char16_t u08[] = uR"[a]" R"_{}#()<>%:;.?*+-[b]_{}#()<>%:;.?*+-";
++const char16_t u09[] = uR"/^&|~!=,"'\[a]/^&|~!=,"'\" u"[b]";
++const char16_t u10[] = u"[a]" uR"0123456789abcdef[b]0123456789abcdef";
++const char16_t u11[] = uR"ghijklmnopqrstuv[a]ghijklmnopqrstuv" uR"w[b]w";
++
++const char32_t U03[] = R"-[a]-" U"[b]";
++const char32_t U04[] = "[a]" UR"MNOPQRSTUVWXYZ[b]MNOPQRSTUVWXYZ";
++const char32_t U05[] = R"[a]" UR"wxyzABCDEFGHIJKL[b]wxyzABCDEFGHIJKL";
++const char32_t U06[] = UR";([a];(" "[b]";
++const char32_t U07[] = U"[a]" R"[b]";
++const char32_t U08[] = UR"[a]" R"_{}#()<>%:;.?*+-[b]_{}#()<>%:;.?*+-";
++const char32_t U09[] = UR"/^&|~!=,"'\[a]/^&|~!=,"'\" U"[b]";
++const char32_t U10[] = U"[a]" UR"0123456789abcdef[b]0123456789abcdef";
++const char32_t U11[] = UR"ghijklmnopqrstuv[a]ghijklmnopqrstuv" UR"w[b]w";
++
++const wchar_t L03[] = R"-[a]-" L"[b]";
++const wchar_t L04[] = "[a]" LR"MNOPQRSTUVWXYZ[b]MNOPQRSTUVWXYZ";
++const wchar_t L05[] = R"[a]" LR"wxyzABCDEFGHIJKL[b]wxyzABCDEFGHIJKL";
++const wchar_t L06[] = LR";([a];(" "[b]";
++const wchar_t L07[] = L"[a]" R"[b]";
++const wchar_t L08[] = LR"[a]" R"_{}#()<>%:;.?*+-[b]_{}#()<>%:;.?*+-";
++const wchar_t L09[] = LR"/^&|~!=,"'\[a]/^&|~!=,"'\" L"[b]";
++const wchar_t L10[] = L"[a]" LR"0123456789abcdef[b]0123456789abcdef";
++const wchar_t L11[] = LR"ghijklmnopqrstuv[a]ghijklmnopqrstuv" LR"w[b]w";
++
++int
++main (void)
++{
++#define TEST(str, val) \
++  if (sizeof (str) != sizeof (val) \
++      || __builtin_memcmp (str, val, sizeof (str)) != 0) \
++    __builtin_abort ()
++  TEST (s00, "a[b]");
++  TEST (s01, "[a]b");
++  TEST (s02, "ab");
++  TEST (s03, "a[b]");
++  TEST (s04, "[a]b");
++  TEST (s05, "ab");
++  TEST (s06, "a[b]");
++  TEST (s07, "[a]b");
++  TEST (s08, "ab");
++  TEST (s09, "a[b]");
++  TEST (s10, "[a]b");
++  TEST (s11, "ab");
++  TEST (u03, u"a[b]");
++  TEST (u04, u"[a]b");
++  TEST (u05, u"ab");
++  TEST (u06, u"a[b]");
++  TEST (u07, u"[a]b");
++  TEST (u08, u"ab");
++  TEST (u09, u"a[b]");
++  TEST (u10, u"[a]b");
++  TEST (u11, u"ab");
++  TEST (U03, U"a[b]");
++  TEST (U04, U"[a]b");
++  TEST (U05, U"ab");
++  TEST (U06, U"a[b]");
++  TEST (U07, U"[a]b");
++  TEST (U08, U"ab");
++  TEST (U09, U"a[b]");
++  TEST (U10, U"[a]b");
++  TEST (U11, U"ab");
++  TEST (L03, L"a[b]");
++  TEST (L04, L"[a]b");
++  TEST (L05, L"ab");
++  TEST (L06, L"a[b]");
++  TEST (L07, L"[a]b");
++  TEST (L08, L"ab");
++  TEST (L09, L"a[b]");
++  TEST (L10, L"[a]b");
++  TEST (L11, L"ab");
++  return 0;
++}
+--- gcc/testsuite/gcc.dg/raw-string-3.c.jj	2008-09-12 13:27:09.000000000 +0200
++++ gcc/testsuite/gcc.dg/raw-string-3.c	2008-09-12 13:42:55.000000000 +0200
+@@ -0,0 +1,53 @@
++/* If not gnu99, the {,u,u8,U,L}R prefix should be parsed as separate
++   token. */
++/* { dg-do compile } */
++/* { dg-options "" } */
++
++const void	*s0	= R"[a]";	/* { dg-error "undeclared" } */
++		/* { dg-error "expected ',' or ';'" "" { target *-*-* } 6 } */
++const void	*s1	= uR"[a]";	/* { dg-error "undeclared" } */
++		/* { dg-error "expected ',' or ';'" "" { target *-*-* } 8 } */
++const void	*s2	= UR"[a]";	/* { dg-error "undeclared" } */
++		/* { dg-error "expected ',' or ';'" "" { target *-*-* } 10 } */
++const void	*s3	= u8R"[a]";	/* { dg-error "undeclared" } */
++		/* { dg-error "expected ',' or ';'" "" { target *-*-* } 12 } */
++const void	*s4	= LR"[a]";	/* { dg-error "undeclared" } */
++		/* { dg-error "expected ',' or ';'" "" { target *-*-* } 14 } */
++
++const int	i0	= R'a';		/* { dg-error "expected ',' or ';'" } */
++const int	i1	= uR'a';	/* { dg-error "expected ',' or ';'" } */
++const int	i2	= UR'a';	/* { dg-error "expected ',' or ';'" } */
++const int	i3	= u8R'a';	/* { dg-error "expected ',' or ';'" } */
++const int	i4	= LR'a';	/* { dg-error "expected ',' or ';'" } */
++
++#define R	"a"
++#define uR	"b"
++#define UR	"c"
++#define u8R	"d"
++#define LR	"e"
++
++const void	*s5	= R"[a]";
++const void	*s6	= uR"[a]";
++const void	*s7	= UR"[a]";
++const void	*s8	= u8R"[a]";
++const void	*s9	= LR"[a]";
++
++#undef R
++#undef uR
++#undef UR
++#undef u8R
++#undef LR
++
++#define R	1 +
++#define uR	2 +
++#define UR	3 +
++#define u8R	4 +
++#define LR	5 +
++
++const int	i5	= R'a';
++const int	i6	= uR'a';
++const int	i7	= UR'a';
++const int	i8	= u8R'a';
++const int	i9	= LR'a';
++
++int main () {}
+--- gcc/testsuite/gcc.dg/raw-string-4.c.jj	2008-09-12 13:27:09.000000000 +0200
++++ gcc/testsuite/gcc.dg/raw-string-4.c	2008-09-12 13:33:43.000000000 +0200
+@@ -0,0 +1,28 @@
++/* R is not applicable for character literals.  */
++/* { dg-do compile } */
++/* { dg-options "-std=gnu99" } */
++
++const int	i0	= R'a';	/* { dg-error "undeclared" } */
++		/* { dg-error "expected ',' or ';'" "" { target *-*-* } 5 } */
++const int	i1	= uR'a';	/* { dg-error "undeclared" } */
++		/* { dg-error "expected ',' or ';'" "" { target *-*-* } 7 } */
++const int	i2	= UR'a';	/* { dg-error "undeclared" } */
++		/* { dg-error "expected ',' or ';'" "" { target *-*-* } 9 } */
++const int	i3	= u8R'a';	/* { dg-error "undeclared" } */
++		/* { dg-error "expected ',' or ';'" "" { target *-*-* } 11 } */
++const int	i4	= LR'a';	/* { dg-error "undeclared" } */
++		/* { dg-error "expected ',' or ';'" "" { target *-*-* } 13 } */
++
++#define R	1 +
++#define uR	2 +
++#define UR	3 +
++#define u8R	4 +
++#define LR	5 +
++
++const int	i5	= R'a';
++const int	i6	= uR'a';
++const int	i7	= UR'a';
++const int	i8	= u8R'a';
++const int	i9	= LR'a';
++
++int main () {}
+--- gcc/testsuite/gcc.dg/raw-string-5.c.jj	2008-09-12 13:49:58.000000000 +0200
++++ gcc/testsuite/gcc.dg/raw-string-5.c	2008-09-12 13:59:14.000000000 +0200
+@@ -0,0 +1,23 @@
++/* { dg-do compile } */
++/* { dg-options "-std=gnu99" } */
++
++const void *s0 = R"0123456789abcdefg[]0123456789abcdefg";
++	/* { dg-error "raw string delimiter longer" "" { target *-*-* } 4 } */
++	/* { dg-error "stray" "" { target *-*-* } 4 } */
++const void *s1 = R" [] ";
++	/* { dg-error "invalid character" "" { target *-*-* } 7 } */
++	/* { dg-error "stray" "" { target *-*-* } 7 } */
++const void *s2 = R"	[]	";
++	/* { dg-error "invalid character" "" { target *-*-* } 10 } */
++	/* { dg-error "stray" "" { target *-*-* } 10 } */
++const void *s3 = R"][]]";
++	/* { dg-error "invalid character" "" { target *-*-* } 13 } */
++	/* { dg-error "stray" "" { target *-*-* } 13 } */
++const void *s4 = R"@[]@";
++	/* { dg-error "invalid character" "" { target *-*-* } 16 } */
++	/* { dg-error "stray" "" { target *-*-* } 16 } */
++const void *s5 = R"$[]$";
++	/* { dg-error "invalid character" "" { target *-*-* } 19 } */
++	/* { dg-error "stray" "" { target *-*-* } 19 } */
++
++int main () {}
+--- gcc/testsuite/gcc.dg/raw-string-6.c.jj	2008-09-12 13:59:33.000000000 +0200
++++ gcc/testsuite/gcc.dg/raw-string-6.c	2008-09-12 14:03:46.000000000 +0200
+@@ -0,0 +1,5 @@
++/* { dg-do compile } */
++/* { dg-options "-std=gnu99" } */
++
++const void *s0 = R"ouch[]ouCh";	/* { dg-error "expected expression at end of input" } */
++	/* { dg-error "unterminated raw string" "" { target *-*-* } 6 } */
+--- gcc/testsuite/gcc.dg/raw-string-7.c.jj	2008-09-12 14:27:39.000000000 +0200
++++ gcc/testsuite/gcc.dg/raw-string-7.c	2008-09-12 14:34:17.000000000 +0200
+@@ -0,0 +1,23 @@
++/* The trailing whitespace after \ and before newline extension
++   breaks full compliance for raw strings.  */
++/* { dg-do run { xfail *-*-* } } */
++/* { dg-options "-std=gnu99" } */
++
++/* Note, there is a single space after \ on the following line.  */
++const void *s0 = R"[\ 
++]";
++/* { dg-bogus "backslash and newline separated by space" "" { xfail *-*-* } 7 } */
++
++/* Note, there is a single tab after \ on the following line.  */
++const void *s1 = R"[\	
++]";
++/* { dg-bogus "backslash and newline separated by space" "" { xfail *-*-* } 12 } */
++
++int
++main (void)
++{
++  if (__builtin_strcmp (s0, "\\ \n") != 0
++      || __builtin_strcmp (s1, "\\\t\n") != 0)
++    __builtin_abort ();
++  return 0;
++}
+--- gcc/testsuite/gcc.dg/utf8-1.c.jj	2008-09-12 10:01:47.000000000 +0200
++++ gcc/testsuite/gcc.dg/utf8-1.c	2008-09-12 11:45:48.000000000 +0200
+@@ -0,0 +1,45 @@
++/* { dg-do run } */
++/* { dg-require-iconv "ISO-8859-2" } */
++/* { dg-options "-std=gnu99 -fexec-charset=ISO-8859-2" } */
++
++const char *str1 = "h\u00e1\U0000010Dky ";
++const char *str2 = "\u010d\u00E1rky\n";
++const char *str3 = u8"h\u00e1\U0000010Dky ";
++const char *str4 = u8"\u010d\u00E1rky\n";
++const char *str5 = "h\u00e1\U0000010Dky " "\u010d\u00E1rky\n";
++const char *str6 = u8"h\u00e1\U0000010Dky " "\u010d\u00E1rky\n";
++const char *str7 = "h\u00e1\U0000010Dky " u8"\u010d\u00E1rky\n";
++#define u8
++const char *str8 = u8"h\u00e1\U0000010Dky " u8"\u010d\u00E1rky\n";
++
++const char latin2_1[] = "\x68\xe1\xe8\x6b\x79\x20";
++const char latin2_2[] = "\xe8\xe1\x72\x6b\x79\n";
++const char utf8_1[] = "\x68\xc3\xa1\xc4\x8d\x6b\x79\x20";
++const char utf8_2[] = "\xc4\x8d\xc3\xa1\x72\x6b\x79\n";
++
++int
++main (void)
++{
++  if (__builtin_strcmp (str1, latin2_1) != 0
++      || __builtin_strcmp (str2, latin2_2) != 0
++      || __builtin_strcmp (str3, utf8_1) != 0
++      || __builtin_strcmp (str4, utf8_2) != 0
++      || __builtin_strncmp (str5, latin2_1, sizeof (latin2_1) - 1) != 0
++      || __builtin_strcmp (str5 + sizeof (latin2_1) - 1, latin2_2) != 0
++      || __builtin_strncmp (str6, utf8_1, sizeof (utf8_1) - 1) != 0
++      || __builtin_strcmp (str6 + sizeof (utf8_1) - 1, utf8_2) != 0
++      || __builtin_strncmp (str7, utf8_1, sizeof (utf8_1) - 1) != 0
++      || __builtin_strcmp (str7 + sizeof (utf8_1) - 1, utf8_2) != 0
++      || __builtin_strncmp (str8, utf8_1, sizeof (utf8_1) - 1) != 0
++      || __builtin_strcmp (str8 + sizeof (utf8_1) - 1, utf8_2) != 0)
++    __builtin_abort ();
++  if (sizeof ("a" u8"b"[0]) != 1
++      || sizeof (u8"a" "b"[0]) != 1
++      || sizeof (u8"a" u8"b"[0]) != 1
++      || sizeof ("a" "\u010d") != 3
++      || sizeof ("a" u8"\u010d") != 4
++      || sizeof (u8"a" "\u010d") != 4
++      || sizeof (u8"a" "\u010d") != 4)
++    __builtin_abort ();
++  return 0;
++}
+--- gcc/testsuite/gcc.dg/utf8-2.c.jj	2008-09-12 11:27:51.000000000 +0200
++++ gcc/testsuite/gcc.dg/utf8-2.c	2008-09-12 11:36:48.000000000 +0200
+@@ -0,0 +1,26 @@
++/* { dg-do compile } */
++/* { dg-options "-std=gnu99" } */
++
++#include <wchar.h>
++
++typedef __CHAR16_TYPE__	char16_t;
++typedef __CHAR32_TYPE__ char32_t;
++
++const char	s0[]	= u8"ab";
++const char16_t	s1[]	= u8"ab";	/* { dg-error "from non-wide" } */
++const char32_t  s2[]    = u8"ab";	/* { dg-error "from non-wide" } */
++const wchar_t   s3[]    = u8"ab";	/* { dg-error "from non-wide" } */
++
++const char      t0[0]   = u8"ab";	/* { dg-warning "chars is too long" } */
++const char      t1[1]   = u8"ab";	/* { dg-warning "chars is too long" } */
++const char      t2[2]   = u8"ab";
++const char      t3[3]   = u8"ab";
++const char      t4[4]   = u8"ab";
++
++const char      u0[0]   = u8"\u2160.";	/* { dg-warning "chars is too long" } */
++const char      u1[1]   = u8"\u2160.";	/* { dg-warning "chars is too long" } */
++const char      u2[2]   = u8"\u2160.";	/* { dg-warning "chars is too long" } */
++const char      u3[3]   = u8"\u2160.";	/* { dg-warning "chars is too long" } */
++const char      u4[4]   = u8"\u2160.";
++const char      u5[5]   = u8"\u2160.";
++const char      u6[6]   = u8"\u2160.";
+--- gcc/testsuite/gcc.dg/utf-badconcat2.c.jj	2008-09-12 11:28:26.000000000 +0200
++++ gcc/testsuite/gcc.dg/utf-badconcat2.c	2008-09-12 11:30:53.000000000 +0200
+@@ -0,0 +1,15 @@
++/* Test unsupported concatenation of UTF-8 string literals. */
++/* { dg-do compile } */
++/* { dg-options "-std=gnu99" } */
++
++void	*s0	= u8"a"   "b";
++void	*s1	=   "a" u8"b";
++void	*s2	= u8"a" u8"b";
++void	*s3	= u8"a"  u"b";	/* { dg-error "non-standard concatenation" } */
++void	*s4	=  u"a" u8"b";	/* { dg-error "non-standard concatenation" } */
++void	*s5	= u8"a"  U"b";	/* { dg-error "non-standard concatenation" } */
++void	*s6	=  U"a" u8"b";	/* { dg-error "non-standard concatenation" } */
++void	*s7	= u8"a"  L"b";	/* { dg-error "non-standard concatenation" } */
++void	*s8	=  L"a" u8"b";	/* { dg-error "non-standard concatenation" } */
++
++int main () {}
+--- gcc/testsuite/gcc.dg/utf-dflt2.c.jj	2008-09-12 11:32:03.000000000 +0200
++++ gcc/testsuite/gcc.dg/utf-dflt2.c	2008-09-12 13:24:39.000000000 +0200
+@@ -0,0 +1,12 @@
++/* If not gnu99, the u8 prefix should be parsed as separate tokens. */
++/* { dg-do compile } */
++/* { dg-options "" } */
++
++const void	*s0 = u8"a";		/* { dg-error "undeclared" } */
++		/* { dg-error "expected ',' or ';'" "" { target *-*-* } 5 } */
++
++#define u8	"a"
++
++const void	*s1 = u8"a";
++
++int main () {}
+--- gcc/testsuite/g++.dg/ext/raw-string-1.C.jj	2008-09-12 11:48:36.000000000 +0200
++++ gcc/testsuite/g++.dg/ext/raw-string-1.C	2008-09-12 14:18:07.000000000 +0200
+@@ -0,0 +1,96 @@
++// { dg-do run }
++// { dg-options "-std=c++0x" }
++
++const char s0[] = R"[a\
++\u010d\U0000010D\\\'\"\?\a\b\f\n\r\t\v\0\00\000\xa\xabb
++c]";
++const char s1[] = "a\U0000010d\u010d\\\\\\'\\\"\\?\\a\\b\\f\\n\\r\\t\\v\\0\\00\\000\\xa\\xabb\nc";
++const char s2[] = R"*|*[a\
++b
++c]"
++c]*|"
++c]*|*";
++const char s3[] = "ab\nc]\"\nc]*|\"\nc";
++
++const char t0[] = u8R"[a\
++\u010d\U0000010D\\\'\"\?\a\b\f\n\r\t\v\0\00\000\xa\xabb
++c]";
++const char t1[] = u8"a\U0000010d\u010d\\\\\\'\\\"\\?\\a\\b\\f\\n\\r\\t\\v\\0\\00\\000\\xa\\xabb\nc";
++const char t2[] = u8R"*|*[a\
++b
++c]"
++c]*|"
++c]*|*";
++const char t3[] = u8"ab\nc]\"\nc]*|\"\nc";
++
++const char16_t u0[] = uR"[a\
++\u010d\U0000010D\\\'\"\?\a\b\f\n\r\t\v\0\00\000\xa\xabb
++c]";
++const char16_t u1[] = u"a\U0000010d\u010d\\\\\\'\\\"\\?\\a\\b\\f\\n\\r\\t\\v\\0\\00\\000\\xa\\xabb\nc";
++const char16_t u2[] = uR"*|*[a\
++b
++c]"
++c]*|"
++c]*|*";
++const char16_t u3[] = u"ab\nc]\"\nc]*|\"\nc";
++
++const char32_t U0[] = UR"[a\
++\u010d\U0000010D\\\'\"\?\a\b\f\n\r\t\v\0\00\000\xa\xabb
++c]";
++const char32_t U1[] = U"a\U0000010d\u010d\\\\\\'\\\"\\?\\a\\b\\f\\n\\r\\t\\v\\0\\00\\000\\xa\\xabb\nc";
++const char32_t U2[] = UR"*|*[a\
++b
++c]"
++c]*|"
++c]*|*";
++const char32_t U3[] = U"ab\nc]\"\nc]*|\"\nc";
++
++const wchar_t L0[] = LR"[a\
++\u010d\U0000010D\\\'\"\?\a\b\f\n\r\t\v\0\00\000\xa\xabb
++c]";
++const wchar_t L1[] = L"a\U0000010d\u010d\\\\\\'\\\"\\?\\a\\b\\f\\n\\r\\t\\v\\0\\00\\000\\xa\\xabb\nc";
++const wchar_t L2[] = LR"*|*[a\
++b
++c]"
++c]*|"
++c]*|*";
++const wchar_t L3[] = L"ab\nc]\"\nc]*|\"\nc";
++
++int
++main (void)
++{
++  if (sizeof (s0) != sizeof (s1)
++      || __builtin_memcmp (s0, s1, sizeof (s0)) != 0)
++    __builtin_abort ();
++  if (sizeof (s2) != sizeof (s3)
++      || __builtin_memcmp (s2, s3, sizeof (s2)) != 0)
++    __builtin_abort ();
++  if (sizeof (t0) != sizeof (t1)
++      || __builtin_memcmp (t0, t1, sizeof (t0)) != 0)
++    __builtin_abort ();
++  if (sizeof (t2) != sizeof (t3)
++      || __builtin_memcmp (t2, t3, sizeof (t2)) != 0)
++    __builtin_abort ();
++  if (sizeof (u0) != sizeof (u1)
++      || __builtin_memcmp (u0, u1, sizeof (u0)) != 0)
++    __builtin_abort ();
++  if (sizeof (u2) != sizeof (u3)
++      || __builtin_memcmp (u2, u3, sizeof (u2)) != 0)
++    __builtin_abort ();
++  if (sizeof (U0) != sizeof (U1)
++      || __builtin_memcmp (U0, U1, sizeof (U0)) != 0)
++    __builtin_abort ();
++  if (sizeof (U2) != sizeof (U3)
++      || __builtin_memcmp (U2, U3, sizeof (U2)) != 0)
++    __builtin_abort ();
++  if (sizeof (L0) != sizeof (L1)
++      || __builtin_memcmp (L0, L1, sizeof (L0)) != 0)
++    __builtin_abort ();
++  if (sizeof (L2) != sizeof (L3)
++      || __builtin_memcmp (L2, L3, sizeof (L2)) != 0)
++    __builtin_abort ();
++  if (sizeof (R"*[]*") != 1
++      || __builtin_memcmp (R"*[]*", "", 1) != 0)
++    __builtin_abort ();
++  return 0;
++}
+--- gcc/testsuite/g++.dg/ext/raw-string-2.C.jj	2008-09-12 12:14:42.000000000 +0200
++++ gcc/testsuite/g++.dg/ext/raw-string-2.C	2008-09-12 14:18:14.000000000 +0200
+@@ -0,0 +1,104 @@
++// { dg-do run }
++// { dg-options "-std=c++0x" }
++
++#define R
++#define u
++#define uR
++#define U
++#define UR
++#define u8
++#define u8R
++#define L
++#define LR
++
++const char s00[] = R"[a]" "[b]";
++const char s01[] = "[a]" R"*[b]*";
++const char s02[] = R"[a]" R"[b]";
++const char s03[] = R"-[a]-" u8"[b]";
++const char s04[] = "[a]" u8R"MNOPQRSTUVWXYZ[b]MNOPQRSTUVWXYZ";
++const char s05[] = R"[a]" u8R"wxyzABCDEFGHIJKL[b]wxyzABCDEFGHIJKL";
++const char s06[] = u8R";([a];(" "[b]";
++const char s07[] = u8"[a]" R"[b]";
++const char s08[] = u8R"[a]" R"_{}#()<>%:;.?*+-[b]_{}#()<>%:;.?*+-";
++const char s09[] = u8R"/^&|~!=,"'\[a]/^&|~!=,"'\" u8"[b]";
++const char s10[] = u8"[a]" u8R"0123456789abcdef[b]0123456789abcdef";
++const char s11[] = u8R"ghijklmnopqrstuv[a]ghijklmnopqrstuv" u8R"w[b]w";
++
++const char16_t u03[] = R"-[a]-" u"[b]";
++const char16_t u04[] = "[a]" uR"MNOPQRSTUVWXYZ[b]MNOPQRSTUVWXYZ";
++const char16_t u05[] = R"[a]" uR"wxyzABCDEFGHIJKL[b]wxyzABCDEFGHIJKL";
++const char16_t u06[] = uR";([a];(" "[b]";
++const char16_t u07[] = u"[a]" R"[b]";
++const char16_t u08[] = uR"[a]" R"_{}#()<>%:;.?*+-[b]_{}#()<>%:;.?*+-";
++const char16_t u09[] = uR"/^&|~!=,"'\[a]/^&|~!=,"'\" u"[b]";
++const char16_t u10[] = u"[a]" uR"0123456789abcdef[b]0123456789abcdef";
++const char16_t u11[] = uR"ghijklmnopqrstuv[a]ghijklmnopqrstuv" uR"w[b]w";
++
++const char32_t U03[] = R"-[a]-" U"[b]";
++const char32_t U04[] = "[a]" UR"MNOPQRSTUVWXYZ[b]MNOPQRSTUVWXYZ";
++const char32_t U05[] = R"[a]" UR"wxyzABCDEFGHIJKL[b]wxyzABCDEFGHIJKL";
++const char32_t U06[] = UR";([a];(" "[b]";
++const char32_t U07[] = U"[a]" R"[b]";
++const char32_t U08[] = UR"[a]" R"_{}#()<>%:;.?*+-[b]_{}#()<>%:;.?*+-";
++const char32_t U09[] = UR"/^&|~!=,"'\[a]/^&|~!=,"'\" U"[b]";
++const char32_t U10[] = U"[a]" UR"0123456789abcdef[b]0123456789abcdef";
++const char32_t U11[] = UR"ghijklmnopqrstuv[a]ghijklmnopqrstuv" UR"w[b]w";
++
++const wchar_t L03[] = R"-[a]-" L"[b]";
++const wchar_t L04[] = "[a]" LR"MNOPQRSTUVWXYZ[b]MNOPQRSTUVWXYZ";
++const wchar_t L05[] = R"[a]" LR"wxyzABCDEFGHIJKL[b]wxyzABCDEFGHIJKL";
++const wchar_t L06[] = LR";([a];(" "[b]";
++const wchar_t L07[] = L"[a]" R"[b]";
++const wchar_t L08[] = LR"[a]" R"_{}#()<>%:;.?*+-[b]_{}#()<>%:;.?*+-";
++const wchar_t L09[] = LR"/^&|~!=,"'\[a]/^&|~!=,"'\" L"[b]";
++const wchar_t L10[] = L"[a]" LR"0123456789abcdef[b]0123456789abcdef";
++const wchar_t L11[] = LR"ghijklmnopqrstuv[a]ghijklmnopqrstuv" LR"w[b]w";
++
++int
++main (void)
++{
++#define TEST(str, val) \
++  if (sizeof (str) != sizeof (val) \
++      || __builtin_memcmp (str, val, sizeof (str)) != 0) \
++    __builtin_abort ()
++  TEST (s00, "a[b]");
++  TEST (s01, "[a]b");
++  TEST (s02, "ab");
++  TEST (s03, "a[b]");
++  TEST (s04, "[a]b");
++  TEST (s05, "ab");
++  TEST (s06, "a[b]");
++  TEST (s07, "[a]b");
++  TEST (s08, "ab");
++  TEST (s09, "a[b]");
++  TEST (s10, "[a]b");
++  TEST (s11, "ab");
++  TEST (u03, u"a[b]");
++  TEST (u04, u"[a]b");
++  TEST (u05, u"ab");
++  TEST (u06, u"a[b]");
++  TEST (u07, u"[a]b");
++  TEST (u08, u"ab");
++  TEST (u09, u"a[b]");
++  TEST (u10, u"[a]b");
++  TEST (u11, u"ab");
++  TEST (U03, U"a[b]");
++  TEST (U04, U"[a]b");
++  TEST (U05, U"ab");
++  TEST (U06, U"a[b]");
++  TEST (U07, U"[a]b");
++  TEST (U08, U"ab");
++  TEST (U09, U"a[b]");
++  TEST (U10, U"[a]b");
++  TEST (U11, U"ab");
++  TEST (L03, L"a[b]");
++  TEST (L04, L"[a]b");
++  TEST (L05, L"ab");
++  TEST (L06, L"a[b]");
++  TEST (L07, L"[a]b");
++  TEST (L08, L"ab");
++  TEST (L09, L"a[b]");
++  TEST (L10, L"[a]b");
++  TEST (L11, L"ab");
++  return 0;
++}
+--- gcc/testsuite/g++.dg/ext/raw-string-3.C.jj	2008-09-12 13:27:09.000000000 +0200
++++ gcc/testsuite/g++.dg/ext/raw-string-3.C	2008-09-12 14:17:57.000000000 +0200
+@@ -0,0 +1,58 @@
++// If c++98, the {,u,u8,U,L}R prefix should be parsed as separate
++// token.
++// { dg-do compile }
++// { dg-options "-std=c++98" }
++
++const void	*s0	= R"[a]";	// { dg-error "was not declared" }
++		// { dg-error "expected ',' or ';'" "" { target *-*-* } 6 }
++const void	*s1	= uR"[a]";	// { dg-error "was not declared" }
++		// { dg-error "expected ',' or ';'" "" { target *-*-* } 8 }
++const void	*s2	= UR"[a]";	// { dg-error "was not declared" }
++		// { dg-error "expected ',' or ';'" "" { target *-*-* } 10 }
++const void	*s3	= u8R"[a]";	// { dg-error "was not declared" }
++		// { dg-error "expected ',' or ';'" "" { target *-*-* } 12 }
++const void	*s4	= LR"[a]";	// { dg-error "was not declared" }
++		// { dg-error "expected ',' or ';'" "" { target *-*-* } 14 }
++
++const int	i0	= R'a';	// { dg-error "was not declared" }
++		// { dg-error "expected ',' or ';'" "" { target *-*-* } 17 }
++const int	i1	= uR'a';	// { dg-error "was not declared" }
++		// { dg-error "expected ',' or ';'" "" { target *-*-* } 19 }
++const int	i2	= UR'a';	// { dg-error "was not declared" }
++		// { dg-error "expected ',' or ';'" "" { target *-*-* } 21 }
++const int	i3	= u8R'a';	// { dg-error "was not declared" }
++		// { dg-error "expected ',' or ';'" "" { target *-*-* } 23 }
++const int	i4	= LR'a';	// { dg-error "was not declared" }
++		// { dg-error "expected ',' or ';'" "" { target *-*-* } 25 }
++
++#define R	"a"
++#define uR	"b"
++#define UR	"c"
++#define u8R	"d"
++#define LR	"e"
++
++const void	*s5	= R"[a]";
++const void	*s6	= uR"[a]";
++const void	*s7	= UR"[a]";
++const void	*s8	= u8R"[a]";
++const void	*s9	= LR"[a]";
++
++#undef R
++#undef uR
++#undef UR
++#undef u8R
++#undef LR
++
++#define R	1 +
++#define uR	2 +
++#define UR	3 +
++#define u8R	4 +
++#define LR	5 +
++
++const int	i5	= R'a';
++const int	i6	= uR'a';
++const int	i7	= UR'a';
++const int	i8	= u8R'a';
++const int	i9	= LR'a';
++
++int main () {}
+--- gcc/testsuite/g++.dg/ext/raw-string-4.C.jj	2008-09-12 13:27:09.000000000 +0200
++++ gcc/testsuite/g++.dg/ext/raw-string-4.C	2008-09-12 14:18:23.000000000 +0200
+@@ -0,0 +1,28 @@
++// R is not applicable for character literals.
++// { dg-do compile }
++// { dg-options "-std=c++0x" }
++
++const int	i0	= R'a';	// { dg-error "was not declared" }
++		// { dg-error "expected ',' or ';'" "" { target *-*-* } 5 }
++const int	i1	= uR'a';	// { dg-error "was not declared" }
++		// { dg-error "expected ',' or ';'" "" { target *-*-* } 7 }
++const int	i2	= UR'a';	// { dg-error "was not declared" }
++		// { dg-error "expected ',' or ';'" "" { target *-*-* } 9 }
++const int	i3	= u8R'a';	// { dg-error "was not declared" }
++		// { dg-error "expected ',' or ';'" "" { target *-*-* } 11 }
++const int	i4	= LR'a';	// { dg-error "was not declared" }
++		// { dg-error "expected ',' or ';'" "" { target *-*-* } 13 }
++
++#define R	1 +
++#define uR	2 +
++#define UR	3 +
++#define u8R	4 +
++#define LR	5 +
++
++const int	i5	= R'a';
++const int	i6	= uR'a';
++const int	i7	= UR'a';
++const int	i8	= u8R'a';
++const int	i9	= LR'a';
++
++int main () {}
+--- gcc/testsuite/g++.dg/ext/raw-string-5.C.jj	2008-09-12 13:49:58.000000000 +0200
++++ gcc/testsuite/g++.dg/ext/raw-string-5.C	2008-09-12 14:18:32.000000000 +0200
+@@ -0,0 +1,23 @@
++// { dg-do compile }
++// { dg-options "-std=c++0x" }
++
++const void *s0 = R"0123456789abcdefg[]0123456789abcdefg";
++	// { dg-error "raw string delimiter longer" "" { target *-*-* } 4 }
++	// { dg-error "stray" "" { target *-*-* } 4 }
++const void *s1 = R" [] ";
++	// { dg-error "invalid character" "" { target *-*-* } 7 }
++	// { dg-error "stray" "" { target *-*-* } 7 }
++const void *s2 = R"	[]	";
++	// { dg-error "invalid character" "" { target *-*-* } 10 }
++	// { dg-error "stray" "" { target *-*-* } 10 }
++const void *s3 = R"][]]";
++	// { dg-error "invalid character" "" { target *-*-* } 13 }
++	// { dg-error "stray" "" { target *-*-* } 13 }
++const void *s4 = R"@[]@";
++	// { dg-error "invalid character" "" { target *-*-* } 16 }
++	// { dg-error "stray" "" { target *-*-* } 16 }
++const void *s5 = R"$[]$";
++	// { dg-error "invalid character" "" { target *-*-* } 19 }
++	// { dg-error "stray" "" { target *-*-* } 19 }
++
++int main () {}
+--- gcc/testsuite/g++.dg/ext/raw-string-6.C.jj	2008-09-12 13:59:33.000000000 +0200
++++ gcc/testsuite/g++.dg/ext/raw-string-6.C	2008-09-12 14:20:21.000000000 +0200
+@@ -0,0 +1,5 @@
++// { dg-do compile }
++// { dg-options "-std=c++0x" }
++
++const void *s0 = R"ouch[]ouCh";	// { dg-error "at end of input" }
++	// { dg-error "unterminated raw string" "" { target *-*-* } 6 }
+--- gcc/testsuite/g++.dg/ext/raw-string-7.C.jj	2008-09-12 14:34:54.000000000 +0200
++++ gcc/testsuite/g++.dg/ext/raw-string-7.C	2008-09-12 14:36:40.000000000 +0200
+@@ -0,0 +1,23 @@
++// The trailing whitespace after \ and before newline extension
++// breaks full compliance for raw strings.
++// { dg-do run { xfail *-*-* } }
++// { dg-options "-std=c++0x" }
++
++// Note, there is a single space after \ on the following line.
++const char *s0 = R"[\ 
++]";
++// { dg-bogus "backslash and newline separated by space" "" { xfail *-*-* } 7 }
++
++// Note, there is a single tab after \ on the following line.
++const char *s1 = R"[\	
++]";
++// { dg-bogus "backslash and newline separated by space" "" { xfail *-*-* } 12 }
++
++int
++main (void)
++{
++  if (__builtin_strcmp (s0, "\\ \n") != 0
++      || __builtin_strcmp (s1, "\\\t\n") != 0)
++    __builtin_abort ();
++  return 0;
++}
+--- gcc/testsuite/g++.dg/ext/utf8-1.C.jj	2008-09-12 10:01:47.000000000 +0200
++++ gcc/testsuite/g++.dg/ext/utf8-1.C	2008-09-12 14:18:53.000000000 +0200
+@@ -0,0 +1,45 @@
++// { dg-do run }
++// { dg-require-iconv "ISO-8859-2" }
++// { dg-options "-std=c++0x -fexec-charset=ISO-8859-2" }
++
++const char *str1 = "h\u00e1\U0000010Dky ";
++const char *str2 = "\u010d\u00E1rky\n";
++const char *str3 = u8"h\u00e1\U0000010Dky ";
++const char *str4 = u8"\u010d\u00E1rky\n";
++const char *str5 = "h\u00e1\U0000010Dky " "\u010d\u00E1rky\n";
++const char *str6 = u8"h\u00e1\U0000010Dky " "\u010d\u00E1rky\n";
++const char *str7 = "h\u00e1\U0000010Dky " u8"\u010d\u00E1rky\n";
++#define u8
++const char *str8 = u8"h\u00e1\U0000010Dky " u8"\u010d\u00E1rky\n";
++
++const char latin2_1[] = "\x68\xe1\xe8\x6b\x79\x20";
++const char latin2_2[] = "\xe8\xe1\x72\x6b\x79\n";
++const char utf8_1[] = "\x68\xc3\xa1\xc4\x8d\x6b\x79\x20";
++const char utf8_2[] = "\xc4\x8d\xc3\xa1\x72\x6b\x79\n";
++
++int
++main (void)
++{
++  if (__builtin_strcmp (str1, latin2_1) != 0
++      || __builtin_strcmp (str2, latin2_2) != 0
++      || __builtin_strcmp (str3, utf8_1) != 0
++      || __builtin_strcmp (str4, utf8_2) != 0
++      || __builtin_strncmp (str5, latin2_1, sizeof (latin2_1) - 1) != 0
++      || __builtin_strcmp (str5 + sizeof (latin2_1) - 1, latin2_2) != 0
++      || __builtin_strncmp (str6, utf8_1, sizeof (utf8_1) - 1) != 0
++      || __builtin_strcmp (str6 + sizeof (utf8_1) - 1, utf8_2) != 0
++      || __builtin_strncmp (str7, utf8_1, sizeof (utf8_1) - 1) != 0
++      || __builtin_strcmp (str7 + sizeof (utf8_1) - 1, utf8_2) != 0
++      || __builtin_strncmp (str8, utf8_1, sizeof (utf8_1) - 1) != 0
++      || __builtin_strcmp (str8 + sizeof (utf8_1) - 1, utf8_2) != 0)
++    __builtin_abort ();
++  if (sizeof ("a" u8"b"[0]) != 1
++      || sizeof (u8"a" "b"[0]) != 1
++      || sizeof (u8"a" u8"b"[0]) != 1
++      || sizeof ("a" "\u010d") != 3
++      || sizeof ("a" u8"\u010d") != 4
++      || sizeof (u8"a" "\u010d") != 4
++      || sizeof (u8"a" "\u010d") != 4)
++    __builtin_abort ();
++  return 0;
++}
+--- gcc/testsuite/g++.dg/ext/utf8-2.C.jj	2008-09-12 11:27:51.000000000 +0200
++++ gcc/testsuite/g++.dg/ext/utf8-2.C	2008-09-12 14:19:01.000000000 +0200
+@@ -0,0 +1,21 @@
++// { dg-do compile }
++// { dg-options "-std=c++0x" }
++
++const char	s0[]	= u8"ab";
++const char16_t	s1[]	= u8"ab";	// { dg-error "from non-wide" }
++const char32_t  s2[]    = u8"ab";	// { dg-error "from non-wide" }
++const wchar_t   s3[]    = u8"ab";	// { dg-error "from non-wide" }
++
++const char      t0[0]   = u8"ab";	// { dg-error "chars is too long" }
++const char      t1[1]   = u8"ab";	// { dg-error "chars is too long" }
++const char      t2[2]   = u8"ab";	// { dg-error "chars is too long" }
++const char      t3[3]   = u8"ab";
++const char      t4[4]   = u8"ab";
++
++const char      u0[0]   = u8"\u2160.";	// { dg-error "chars is too long" }
++const char      u1[1]   = u8"\u2160.";	// { dg-error "chars is too long" }
++const char      u2[2]   = u8"\u2160.";	// { dg-error "chars is too long" }
++const char      u3[3]   = u8"\u2160.";	// { dg-error "chars is too long" }
++const char      u4[4]   = u8"\u2160.";	// { dg-error "chars is too long" }
++const char      u5[5]   = u8"\u2160.";
++const char      u6[6]   = u8"\u2160.";
+--- gcc/testsuite/g++.dg/ext/utf-badconcat2.C.jj	2008-09-12 11:28:26.000000000 +0200
++++ gcc/testsuite/g++.dg/ext/utf-badconcat2.C	2008-09-12 14:19:17.000000000 +0200
+@@ -0,0 +1,15 @@
++// Test unsupported concatenation of UTF-8 string literals.
++// { dg-do compile }
++// { dg-options "-std=c++0x" }
++
++const void *s0	= u8"a"   "b";
++const void *s1	=   "a" u8"b";
++const void *s2	= u8"a" u8"b";
++const void *s3	= u8"a"  u"b";	// { dg-error "non-standard concatenation" }
++const void *s4	=  u"a" u8"b";	// { dg-error "non-standard concatenation" }
++const void *s5	= u8"a"  U"b";	// { dg-error "non-standard concatenation" }
++const void *s6	=  U"a" u8"b";	// { dg-error "non-standard concatenation" }
++const void *s7	= u8"a"  L"b";	// { dg-error "non-standard concatenation" }
++const void *s8	=  L"a" u8"b";	// { dg-error "non-standard concatenation" }
++
++int main () {}
+--- gcc/testsuite/g++.dg/ext/utf-dflt2.C.jj	2008-09-12 11:32:03.000000000 +0200
++++ gcc/testsuite/g++.dg/ext/utf-dflt2.C	2008-09-12 14:19:28.000000000 +0200
+@@ -0,0 +1,12 @@
++// In C++0x, the u8 prefix should be parsed as separate tokens.
++// { dg-do compile }
++// { dg-options "-std=c++98" }
++
++const void	*s0 = u8"a";		// { dg-error "was not declared" }
++		// { dg-error "expected ',' or ';'" "" { target *-*-* } 5 }
++
++#define u8	"a"
++
++const void	*s1 = u8"a";
++
++int main () {}

diff --git a/sources b/sources
index 0f02384..9b154f4 100644
--- a/sources
+++ b/sources
@@ -1,3 +1,3 @@
 2659f09c2e43ef8b7d4406321753f1b2  fastjar-0.97.tar.gz
-8962fbd3c8007cd80f5d50de6a8001ba  gcc-4.4.0-20090203.tar.bz2
+b411d96f6b80d81145db27ee639b8e1d  gcc-4.4.0-20090204.tar.bz2
 716b7a0823f96c9d02c1703a9c47d387  cloog-ppl-0.15.tar.gz