Index: gcc/doc/cpp.texi
===================================================================
--- gcc/doc/cpp.texi	(.../vendor/gcc-4.1.1)	(revision 425)
+++ gcc/doc/cpp.texi	(.../branches/variadic-templates)	(revision 425)
@@ -2128,6 +2128,9 @@ use.
 This macro is defined, with value 2, when @option{-fstack-protector-all} is
 in use.
 
+@item__VARIADIC_TEMPLATES
+This macro is defined if support is provided for the variadic templates
+extension to C++.
 @end table
 
 @node System-specific Predefined Macros
Index: gcc/doc/invoke.texi
===================================================================
--- gcc/doc/invoke.texi	(.../vendor/gcc-4.1.1)	(revision 425)
+++ gcc/doc/invoke.texi	(.../branches/variadic-templates)	(revision 425)
@@ -182,7 +182,7 @@ in the following sections.
 -fno-optional-diags  -fpermissive @gol
 -frepo  -fno-rtti  -fstats  -ftemplate-depth-@var{n} @gol
 -fno-threadsafe-statics -fuse-cxa-atexit  -fno-weak  -nostdinc++ @gol
--fno-default-inline  -fvisibility-inlines-hidden @gol
+-fno-default-inline -fno-variadic-templates -fvisibility-inlines-hidden @gol
 -Wabi  -Wctor-dtor-privacy @gol
 -Wnon-virtual-dtor  -Wreorder @gol
 -Weffc++  -Wno-deprecated  -Wstrict-null-sentinel @gol
@@ -1579,6 +1579,12 @@ This option is required for fully standa
 destructors, but will only work if your C library supports
 @code{__cxa_atexit}.
 
+@item -fno-variadic-templates 
+@opindex fno-variadic-templates
+Disable support for the "variadic templates" extension to GNU
+C++. Variadic templates provide the ability for a template to accept a
+variable-length argument list through the use of the ellipsis operator.
+
 @item -fvisibility-inlines-hidden
 @opindex fvisibility-inlines-hidden
 Causes all inlined methods to be marked with
Index: gcc/c-cppbuiltin.c
===================================================================
--- gcc/c-cppbuiltin.c	(.../vendor/gcc-4.1.1)	(revision 425)
+++ gcc/c-cppbuiltin.c	(.../branches/variadic-templates)	(revision 425)
@@ -334,6 +334,8 @@ c_cpp_builtins (cpp_reader *pfile)
 	cpp_define (pfile, "__GXX_WEAK__=0");
       if (warn_deprecated)
 	cpp_define (pfile, "__DEPRECATED");
+      if (flag_variadic_templates)
+        cpp_define (pfile, "__VARIADIC_TEMPLATES");
     }
   /* Note that we define this for C as well, so that we know if
      __attribute__((cleanup)) will interface with EH.  */
Index: gcc/testsuite/g++.dg/template/variadic-function.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic-function.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic-function.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,95 @@
+// { dg-do "run" }
+// A basic implementation of TR1's function using variadic teplates
+// Contributed by Douglas Gregor <doug.gregor@gmail.com>
+#include <cassert>
+
+template<typename Signature>
+class function;
+
+template<typename R, typename... Args>
+class invoker_base
+{
+ public:
+  virtual ~invoker_base() { }
+  virtual R invoke(Args...) = 0;
+  virtual invoker_base* clone() = 0;
+};
+
+template<typename F, typename R, typename... Args>
+class functor_invoker : public invoker_base<R, Args...>
+{
+ public:
+  explicit functor_invoker(const F& f) : f(f) { }
+  R invoke(Args... args) { return f(args...); }
+  functor_invoker* clone() { return new functor_invoker(f); }
+
+ private:
+  F f;
+};
+
+template<typename R, typename... Args>
+class function<R (Args...)> {
+ public:
+  typedef R result_type;
+
+  function() : invoker (0) { }
+
+  function(const function& other) : invoker(0) {
+    if (other.invoker) 
+      invoker = other.invoker->clone();
+  }
+
+  template<typename F>
+  function(const F& f) : invoker(0) {
+    invoker = new functor_invoker<F, R, Args...>(f); 
+  }
+
+  ~function() {
+    if (invoker)
+      delete invoker;
+  }
+
+  function& operator=(const function& other) {
+    function(other).swap(*this);
+    return *this;
+  }
+
+  template<typename F>
+  function& operator=(const F& f) {
+    function(f).swap(*this);
+    return *this;
+  }
+
+  void swap(function& other) {
+    invoker_base<R, Args...>* tmp = invoker;
+    invoker = other.invoker;
+    other.invoker = tmp;
+  }
+
+  result_type operator()(Args... args) const {
+    assert(invoker);
+    return invoker->invoke(args...);
+  }
+
+ private:
+  invoker_base<R, Args...>* invoker;
+};
+
+struct plus {
+  template<typename T> T operator()(T x, T y) { return x + y; }
+};
+
+struct multiplies {
+  template<typename T> T operator()(T x, T y) { return x * y; }
+};
+
+int main()
+{
+  function<int(int, int)> f1 = plus();
+  assert(f1(3, 5) == 8);
+
+  f1 = multiplies();
+  assert(f1(3, 5) == 15);
+
+  return 0;
+}
Index: gcc/testsuite/g++.dg/template/variadic69.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic69.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic69.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,33 @@
+template<typename T>
+struct stored_value
+{
+  explicit stored_value() : value() { }
+
+  explicit stored_value(const T& value) : value(value) { }
+
+  stored_value(int, const T& value) : value(value) { }
+
+  T value;
+};
+
+template<typename... Values>
+struct myclass : public stored_value<Values>...
+{
+  myclass() { }
+
+  explicit myclass(const Values&... values)
+    : stored_value<Values>(values)... { }
+
+  explicit myclass(int x, const Values&... values)
+    : stored_value<Values>(x, values)... { }
+
+};
+
+void f()
+{
+  int i;
+  float f;
+  myclass<int*, float*> ifp1;
+  myclass<int*, float*> ifp2(&i, &f);
+  myclass<int*, float*> ifp3(1, &i, &f);
+}
Index: gcc/testsuite/g++.dg/template/variadic11.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic11.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic11.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,17 @@
+template<typename...> struct count;
+
+template<>
+struct count<> {
+  static const int value = 0;
+};
+
+template<typename T, typename... Args>
+struct count<T, Args...> {
+  static const int value = 1 + count<Args...>::value;
+};
+
+int a0[count<>::value == 0? 1 : -1];
+int a1[count<char>::value == 1? 1 : -1];
+int a2[count<char, short>::value == 2? 1 : -1];
+int a3[count<char, short, int>::value == 3? 1 : -1];
+int a4[count<char, short, int, long>::value == 4? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic20.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic20.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic20.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,44 @@
+template<typename T> struct add_pointer;
+template<typename T> struct add_reference;
+
+template<template<class T> class... Metafunctions>
+struct metatuple {
+  static const int value = 0;
+};
+
+template<>
+struct metatuple<add_pointer> {
+  static const int value = 1;
+};
+
+template<template<class T> class Meta>
+struct metatuple<Meta, Meta> {
+  static const int value = 2;
+};
+
+template<template<class T> class... Metafunctions>
+struct metatuple<add_pointer, Metafunctions...> {
+  static const int value = 3;
+};
+
+template<template<class T> class First,
+         template<class T> class... Metafunctions>
+struct metatuple<First, Metafunctions...> {
+  static const int value = 4;
+};
+
+template<template<class T> class First,
+         template<class T> class Second,
+         template<class T> class... Metafunctions>
+struct metatuple<First, Second, Metafunctions...> {
+  static const int value = 5;
+};
+
+int a0[metatuple<>::value == 0? 1 : -1];
+int a1[metatuple<add_pointer>::value == 1? 1 : -1];
+int a2a[metatuple<add_pointer, add_pointer>::value == 2? 1 : -1];
+int a2b[metatuple<add_reference, add_reference>::value == 2? 1 : -1];
+int a3[metatuple<add_pointer, add_reference>::value == 3? 1 : -1];
+int a4[metatuple<add_reference>::value == 4? 1 : -1];
+int a5[metatuple<add_reference, add_pointer>::value == 5? 1 : -1];
+
Index: gcc/testsuite/g++.dg/template/variadic12.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic12.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic12.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,41 @@
+// A tuple type
+template<typename... Args> struct tuple { };
+
+// Determine if two types are the same
+template<typename T, typename U>
+struct is_same {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+// Append 'T' to the end of Tuple
+template<typename T, typename Tuple>
+struct append_to_tuple;
+
+template<typename T, typename... Args>
+struct append_to_tuple<T, tuple<Args...> > {
+  typedef tuple<Args..., T> type;
+};
+
+// Reverse a sequence of arguments (and return the result as a tuple)
+template<typename... Args> struct reverse;
+
+template<typename T, typename... Args>
+struct reverse<T, Args...> {
+  typedef typename append_to_tuple<T, typename reverse<Args...>::type>::type
+    type;
+};
+
+template<>
+struct reverse<> {
+  typedef tuple<> type;
+};
+
+int a0[is_same<reverse<>::type, tuple<> >::value? 1 : -1];
+int a1[is_same<reverse<int>::type, tuple<int> >::value? 1 : -1];
+int a2[is_same<reverse<char, int>::type, tuple<int, char> >::value? 1 : -1];
+int a3[is_same<reverse<char, int, long>::type, tuple<long, int, char> >::value? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic21.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic21.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic21.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,6 @@
+template<typename T, int... Dims>
+struct array { };
+
+array<int> a0;
+array<int, 1> a1;
+array<int, 1, 2, 3, 4> a1234;
Index: gcc/testsuite/g++.dg/template/variadic30.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic30.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic30.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,10 @@
+template<typename... T>
+void eat(T...);
+
+void f()
+{
+  eat();
+  eat(1);
+  eat(1, 2);
+  eat(17, 3.14159, "Hello, World!");
+}
Index: gcc/testsuite/g++.dg/template/variadic13.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic13.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic13.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,18 @@
+template<typename... Args> struct tuple1 { };
+template<typename... Args> struct tuple2 { };
+
+template<typename T, typename U>
+struct same_tuple_args {
+  static const bool value = false;
+};
+
+template<typename... Args>
+struct same_tuple_args<tuple1<Args...>, tuple2<Args...> > {
+  static const bool value = true;
+};
+
+int same0[same_tuple_args<tuple1<>, tuple2<> >::value? 1 : -1];
+int same1[same_tuple_args<tuple1<int>, tuple2<int> >::value? 1 : -1];
+int same2[same_tuple_args<tuple1<float, int>, tuple2<float, int> >::value? 1 : -1];
+int diff0[!same_tuple_args<tuple1<>, tuple2<int> >::value? 1 : -1];
+int diff1[!same_tuple_args<tuple1<int, float>, tuple2<float, int> >::value? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic22.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic22.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic22.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,20 @@
+template<typename R, typename... ArgTypes>
+struct make_function_type
+{
+  typedef R type(ArgTypes... args);
+};
+
+template<typename T, typename U>
+struct is_same {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+int a0[is_same<make_function_type<int>::type, int()>::value? 1 : -1];
+int a1[is_same<make_function_type<int, float>::type, int(float)>::value? 1 : -1];
+int a2[is_same<make_function_type<int, float>::type, int(float)>::value? 1 : -1];
+int a3[is_same<make_function_type<int, float, double>::type, int(float, double const)>::value? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic31.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic31.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic31.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,10 @@
+template<typename... T>
+void eat(T...) { }
+
+void f()
+{
+  eat();
+  eat(1);
+  eat(1, 2);
+  eat(17, 3.14159, "Hello, World!");
+}
Index: gcc/testsuite/g++.dg/template/variadic14.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic14.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic14.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,20 @@
+template<typename R, typename... ArgTypes>
+struct make_function_type
+{
+  typedef R type(ArgTypes...);
+};
+
+template<typename T, typename U>
+struct is_same {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+int a0[is_same<make_function_type<int>::type, int()>::value? 1 : -1];
+int a1[is_same<make_function_type<int, float>::type, int(float)>::value? 1 : -1];
+int a2[is_same<make_function_type<int, float>::type, int(float)>::value? 1 : -1];
+int a3[is_same<make_function_type<int, float, double>::type, int(float, double)>::value? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic40.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic40.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic40.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,2 @@
+template<typename... Values, typename T>
+struct backward_tuple {}; // { dg-error "end" }
Index: gcc/testsuite/g++.dg/template/variadic23.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic23.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic23.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,24 @@
+template<typename T, int... Dims>
+struct array { 
+  static const int value = 0;
+};
+
+template<>
+struct array<int, 17> {
+  static const int value = 1;
+};
+
+template<int... Dims>
+struct array<float, 1, Dims...> {
+  static const int value = 2;
+};
+
+template<typename T, int... Dims>
+struct array<T, 1, Dims...> {
+  static const int value = 3;
+};
+
+int a0[array<int>::value == 0? 1 : -1];
+int a1[array<int, 17>::value == 1? 1 : -1];
+int a2[array<float, 1, 2, 3>::value == 2? 1 : -1];
+int a3[array<double, 1, 2, 3>::value == 3? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic32.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic32.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic32.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,10 @@
+template<typename... T>
+void eat(const T&...) { }
+
+void f()
+{
+  eat();
+  eat(1);
+  eat(1, 2);
+  eat(17, 3.14159, "Hello, World!");
+}
Index: gcc/testsuite/g++.dg/template/variadic15.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic15.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic15.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,20 @@
+template<typename R, typename... ArgTypes>
+struct make_function_type
+{
+  typedef R type(const ArgTypes&...);
+};
+
+template<typename T, typename U>
+struct is_same {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+int a0[is_same<make_function_type<int>::type, int()>::value? 1 : -1];
+int a1[is_same<make_function_type<int, float>::type, int(const float&)>::value? 1 : -1];
+int a2[is_same<make_function_type<int, float>::type, int(const float&)>::value? 1 : -1];
+int a3[is_same<make_function_type<int, float, double>::type, int(const float&, double const&)>::value? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic1.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic1.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic1.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,9 @@
+template<typename...>
+class tuple;
+
+template<typename... Args>
+class tuple { };
+
+template<typename T1, class... Args>
+class tuple1p { };
+
Index: gcc/testsuite/g++.dg/template/variadic41.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic41.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic41.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,2 @@
+template<typename... Args>
+void f(const Args&... args, int oops); // { dg-error "end" }
Index: gcc/testsuite/g++.dg/template/variadic24.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic24.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic24.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,5 @@
+template<typename T, T... Values>
+struct vector_c { };
+
+vector_c<int, 17, 42> intvec;
+vector_c<char, 'a', 'b', 'c'> charvec;
Index: gcc/testsuite/g++.dg/template/variadic50.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic50.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic50.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,8 @@
+int& f(int, double, ...);
+
+template<typename... Args>
+float& f(Args...);
+
+float& g() {
+  return f(17, 3.14159, 3);
+}
Index: gcc/testsuite/g++.dg/template/variadic33.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic33.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic33.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,15 @@
+void print_all() {}
+
+template<typename T, typename... Rest>
+void print_all(const T& t, const Rest&... rest)
+{
+  print_all(rest...);
+}
+
+void f()
+{
+  print_all();
+  print_all(1);
+  print_all(1, 3.14159);
+  print_all("Hello, World!", 17, 3.14159);
+}
Index: gcc/testsuite/g++.dg/template/variadic16.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic16.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic16.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,20 @@
+template<typename R, typename... ArgTypes>
+struct make_function_type
+{
+  typedef R type(const ArgTypes&... args);
+};
+
+template<typename T, typename U>
+struct is_same {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+int a0[is_same<make_function_type<int>::type, int()>::value? 1 : -1];
+int a1[is_same<make_function_type<int, float>::type, int(const float&)>::value? 1 : -1];
+int a2[is_same<make_function_type<int, float>::type, int(const float&)>::value? 1 : -1];
+int a3[is_same<make_function_type<int, float, double>::type, int(const float&, double const&)>::value? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic2.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic2.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic2.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,16 @@
+template<typename... Args = int> // { dg-error "default argument" }
+class tuple2;
+
+template<typename... = int> // { dg-error "default argument" }
+class tuple3;
+
+template<typename T1, typename T2, typename... Rest>
+struct two_or_more {}; // { dg-error "provided for" }
+
+typedef two_or_more<int> bad; // { dg-error "2 or more" }
+// { dg-error "invalid type" "" { target *-*-* } 10 }
+
+void f()
+{
+  two_or_more<int, float> z = 5; // { dg-error "two_or_more<int, float>" }
+}
Index: gcc/testsuite/g++.dg/template/variadic42.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic42.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic42.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,11 @@
+// { dg-do compile }
+template<typename... Args>
+void f(Args...) { }
+
+void g()
+{
+  f<int*, float*, double*>(0, 0, 0);
+  f<int*>(0,0,0);
+}
+// { dg-final { scan-assembler "_Z1fIPiPfPdEvU10__variadicT_" } }
+// { dg-final { scan-assembler "_Z1fIPiiiEvU10__variadicT_" } }
Index: gcc/testsuite/g++.dg/template/variadic25.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic25.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic25.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,15 @@
+template<int... Values>
+struct sum;
+
+template<>
+struct sum<> {
+  static const int value = 0;
+};
+
+template<int Value, int... Values>
+struct sum<Value, Values...> {
+  static const int value = Value + sum<Values...>::value;
+};
+
+int a0[sum<>::value == 0? 1 : -1];
+int a1[sum<1, 2, 3, 4, 5>::value == 15? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic51.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic51.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic51.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,9 @@
+template<typename T1, typename T2>
+float& f(T1, T2);
+
+template<typename... Args>
+int& f(Args...);
+
+float& g() { 
+  return f(17, 3.14159); 
+}
Index: gcc/testsuite/g++.dg/template/variadic34.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic34.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic34.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,10 @@
+template<int I, typename... Args>
+void get_ith(const Args&... args);
+
+void f()
+{
+  get_ith<1>(1, 2, 3);
+  get_ith<1, int>(1, 2.0, 'x');
+  get_ith<1, int, double>(1, 2.0, 'x');
+  get_ith<1, int, double, char>(1, 2.0, 'x');
+}
Index: gcc/testsuite/g++.dg/template/variadic17.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic17.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic17.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,20 @@
+template<typename R, typename... ArgTypes>
+struct make_function_type
+{
+  typedef R type(const ArgTypes&......);
+};
+
+template<typename T, typename U>
+struct is_same {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+int a0[is_same<make_function_type<int>::type, int(...)>::value? 1 : -1];
+int a1[is_same<make_function_type<int, float>::type, int(const float&...)>::value? 1 : -1];
+int a2[is_same<make_function_type<int, float>::type, int(const float&,...)>::value? 1 : -1];
+int a3[is_same<make_function_type<int, float, double>::type, int(const float&, double const&...)>::value? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic3.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic3.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic3.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,9 @@
+template<typename... Args>
+class tuple {};
+
+void f()
+{
+  tuple<> x;
+  tuple<int> y;
+  tuple<int, float> z;
+}
Index: gcc/testsuite/g++.dg/template/variadic60.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic60.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic60.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,18 @@
+template<int... Indexes>
+  struct _Index_tuple { };
+
+template<int _Num, typename _Tuple = _Index_tuple<> >
+struct _Build_index_tuple;
+
+template<int _Num, int... _Indexes> 
+struct _Build_index_tuple<_Num, _Index_tuple<_Indexes...> >
+  : _Build_index_tuple<_Num - 1, 
+                       _Index_tuple<_Indexes..., sizeof...(_Indexes)> >
+{
+};
+
+template<int... _Indexes>
+struct _Build_index_tuple<0, _Index_tuple<_Indexes...> >
+{
+  typedef _Index_tuple<_Indexes...> __type;
+};
Index: gcc/testsuite/g++.dg/template/variadic43.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic43.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic43.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,7 @@
+template<typename... Args>
+int f(const Args&...);
+
+void g()
+{
+  int (*fp)(const int&, const float&) = &f;
+}
Index: gcc/testsuite/g++.dg/template/variadic26.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic26.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic26.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,23 @@
+template<template<int, int> class Meta, int Initial, int... Values>
+struct accumulate {
+  static const int value = Initial;
+};
+
+template<template<int, int> class Meta, int Initial, int Value, int... Rest>
+struct accumulate<Meta, Initial, Value, Rest...> {
+  static const int value = 
+    Meta<Value, accumulate<Meta, Initial, Rest...>::value>::value;
+};
+
+template<int X, int Y>
+struct sum {
+  static const int value = X + Y;
+};
+
+template<int X, int Y>
+struct prod {
+  static const int value = X * Y;
+};
+
+int a0[accumulate<sum,0,1,2,3,4,5>::value == 15? 1 : -1];
+int a1[accumulate<prod,1,1,2,3,4,5>::value == 120? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic-bind.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic-bind.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic-bind.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,475 @@
+// { dg-do "run" }
+// A basic implementation of TR1's bind using variadic teplates
+// Contributed by Douglas Gregor <doug.gregor@gmail.com>
+#include <cassert>
+
+// Trivial reference_wrapper
+template<typename T>
+struct reference_wrapper
+{
+  reference_wrapper(T& x) : ptr(&x) { }
+
+  operator T&() const { return *ptr; }
+  
+  T& get() const { return *ptr; }
+
+  T* ptr;
+};
+
+template<typename T> reference_wrapper<T> ref(T& x) { return x; }
+template<typename T> reference_wrapper<const T> cref(const T& x) { return x; }
+
+// Simple type-traits we'll need
+template<typename T>
+struct add_reference
+{
+  typedef T& type;
+};
+
+template<typename T>
+struct add_reference<T&>
+{
+  typedef T& type;
+};
+
+template<typename T, typename U>
+struct is_same
+{
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T>
+{
+  static const bool value = true;
+};
+
+// For creating the constructor parameters of tuple<>
+template<typename T>
+struct add_const_reference
+{
+  typedef const T& type;
+};
+
+template<typename T>
+struct add_const_reference<T&>
+{
+  typedef T& type;
+};
+
+// 6.1.3 Class template tuple: Needed for bind() implementation
+template<typename... Values>
+class tuple;
+
+template<> class tuple<> { };
+
+template<typename Head, typename... Tail>
+class tuple<Head, Tail...> 
+  : private tuple<Tail...>
+{
+  typedef tuple<Tail...> inherited;
+
+ public:
+  tuple() { }
+
+  // implicit copy-constructor is okay
+
+  tuple(typename add_const_reference<Head>::type v, 
+        typename add_const_reference<Tail>::type... vtail)
+    : m_head(v), inherited(vtail...) { }
+
+  template<typename... VValues>
+  tuple(const tuple<VValues...>& other)
+    : m_head(other.head()), inherited(other.tail()) { }
+
+  template<typename... VValues>
+  tuple& operator=(const tuple<VValues...>& other)
+  {
+    m_head = other.head();
+    tail() = other.tail();
+    return *this;
+  }
+
+  typename add_reference<Head>::type       head()       { return m_head; }
+  typename add_reference<const Head>::type head() const { return m_head; }
+  inherited&                               tail()       { return *this; }
+  const inherited&                         tail() const { return *this; }
+
+ protected:
+  Head m_head;
+};
+
+template<typename T>
+struct make_tuple_result
+{
+  typedef T type;
+};
+
+template<typename T>
+struct make_tuple_result<reference_wrapper<T> >
+{
+  typedef T& type;
+};
+
+// 6.1.3.2 Tuple creation functions
+struct ignore_t { 
+  template<typename T> ignore_t& operator=(const T&) { return *this; }
+} ignore;
+
+template<typename... Values>
+tuple<typename make_tuple_result<Values>::type...> 
+make_tuple(const Values&... values)
+{
+  return tuple<typename make_tuple_result<Values>::type...>(values...);
+}
+
+template<typename... Values>
+tuple<Values&...> tie(Values&... values)
+{
+  return tuple<Values&...>(values...);
+}
+
+// 6.1.3.3 Tuple helper classes
+template<typename Tuple>
+struct tuple_size;
+
+template<>
+struct tuple_size<tuple<> >
+{
+  static const __SIZE_TYPE__ value = 0;
+};
+
+template<typename Head, typename... Tail>
+struct tuple_size<tuple<Head, Tail...> >
+{
+  static const __SIZE_TYPE__ value = 1 + tuple_size<tuple<Tail...> >::value;
+};
+
+template<int I, typename Tuple>
+struct tuple_element;
+
+template<int I, typename Head, typename... Tail>
+struct tuple_element<I, tuple<Head, Tail...> >
+{
+  typedef typename tuple_element<I-1, tuple<Tail...> >::type type;
+};
+
+template<typename Head, typename... Tail>
+struct tuple_element<0, tuple<Head, Tail...> >
+{
+  typedef Head type;
+};
+
+// 6.1.3.4 Element access
+template<int I, typename Tuple>
+class get_impl;
+
+template<int I, typename Head, typename... Values> 
+class get_impl<I, tuple<Head, Values...> >
+{
+  typedef typename tuple_element<I-1, tuple<Values...> >::type Element;
+  typedef typename add_reference<Element>::type RJ;
+  typedef typename add_const_reference<Element>::type PJ;
+  typedef get_impl<I-1, tuple<Values...> > Next;
+
+ public:
+  static RJ get(tuple<Head, Values...>& t)       
+  { return Next::get(t.tail()); }
+
+  static PJ get(const tuple<Head, Values...>& t) 
+  { return Next::get(t.tail()); }
+};
+
+template<typename Head, typename... Values> 
+class get_impl<0, tuple<Head, Values...> >
+{
+  typedef typename add_reference<Head>::type RJ;
+  typedef typename add_const_reference<Head>::type PJ;
+
+ public:
+  static RJ get(tuple<Head, Values...>& t)       { return t.head(); }
+  static PJ get(const tuple<Head, Values...>& t) { return t.head(); }
+};
+
+template<int I, typename... Values>
+typename add_reference<
+           typename tuple_element<I, tuple<Values...> >::type
+         >::type
+get(tuple<Values...>& t)
+{
+  return get_impl<I, tuple<Values...> >::get(t);
+}
+
+template<int I, typename... Values>
+typename add_const_reference<
+           typename tuple_element<I, tuple<Values...> >::type
+         >::type
+get(const tuple<Values...>& t)
+{
+  return get_impl<I, tuple<Values...> >::get(t);
+}
+
+// 6.1.3.5 Relational operators
+inline bool operator==(const tuple<>&, const tuple<>&) { return true; }
+
+template<typename T, typename... TTail, typename U, typename... UTail>
+bool operator==(const tuple<T, TTail...>& t, const tuple<U, UTail...>& u)
+{
+  return t.head() == u.head() && t.tail() == u.tail();
+}
+
+template<typename... TValues, typename... UValues>
+bool operator!=(const tuple<TValues...>& t, const tuple<UValues...>& u)
+{
+  return !(t == u);
+}
+
+inline bool operator<(const tuple<>&, const tuple<>&) { return false; }
+
+template<typename T, typename... TTail, typename U, typename... UTail>
+bool operator<(const tuple<T, TTail...>& t, const tuple<U, UTail...>& u)
+{
+  return (t.head() < u.head() || 
+          (!(t.head() < u.head()) && t.tail() < u.tail()));
+}
+
+template<typename... TValues, typename... UValues>
+bool operator>(const tuple<TValues...>& t, const tuple<UValues...>& u)
+{
+  return u < t;
+}
+
+template<typename... TValues, typename... UValues>
+bool operator<=(const tuple<TValues...>& t, const tuple<UValues...>& u)
+{
+  return !(u < t);
+}
+
+template<typename... TValues, typename... UValues>
+bool operator>=(const tuple<TValues...>& t, const tuple<UValues...>& u)
+{
+  return !(t < u);
+}
+
+// enable_if, the breakfast of champions
+template<bool Cond, typename Type = void>
+struct enable_if {
+  typedef Type type;
+};
+
+template<typename Type>
+struct enable_if<false, Type> { };
+
+// 3.6 Function object binders
+
+// 3.6.1 Class template is_bind_expression
+template<typename T> 
+struct is_bind_expression {
+  static const bool value = false;
+};
+
+// 3.6.2 Class template is_placeholder
+template<typename T>
+struct is_placeholder {
+  static const int value = 0;
+};
+
+// 3.6.3 Function template bind
+template<int I> struct placeholder {} ;
+
+template<int N> struct int_c { };
+
+// A tuple of integer values
+template<int...> struct int_tuple {};
+
+// make_indexes_impl is a helper for make_indexes
+template<int I, typename IntTuple, typename... Types>
+struct make_indexes_impl;
+
+
+template<int I, int... Indexes, typename T, typename... Types>
+struct make_indexes_impl<I, int_tuple<Indexes...>, T, Types...>
+{
+  typedef typename make_indexes_impl<I+1,
+                                     int_tuple<Indexes..., I>,
+                                     Types...>::type type;
+};
+
+template<int I, int... Indexes>
+struct make_indexes_impl<I, int_tuple<Indexes...> > {
+  typedef int_tuple<Indexes...> type;
+};
+
+// make_indexes takes a variable-length number of N types and
+// generates an int_tuple that contains <0, 1, 2, ..., N-1>. These can
+// be used as indexes for tuple's get or tuple_element operation.
+template<typename... Types> 
+struct make_indexes : make_indexes_impl<0, int_tuple<>, Types...> { };
+
+// Get the Ith tuple element, but only if I is in bounds.
+template<int I, typename Tuple, typename = void> 
+struct safe_tuple_element{ };
+
+template<int I, typename... Values>
+struct safe_tuple_element<I, tuple<Values...>, 
+         typename enable_if<(I >= 0 && 
+                             I < tuple_size<tuple<Values...> >::value)
+                            >::type>
+{
+  typedef typename tuple_element<I, tuple<Values...> >::type type;
+};
+
+// mu maps a bound argument to an actual argument, given a tuple of
+// the arguments passed to the function object returned by bind().
+
+// Return the stored reference from reference_wrapper
+template<typename T, typename... Args>
+inline T& mu(reference_wrapper<T>& bound_arg, const tuple<Args&...>&)
+{
+  return bound_arg.get();
+}
+
+// Unwrap a tuple into separate arguments and forward to the function
+// object f.
+template<typename F, int... Indexes, typename... Args>
+inline typename F::result_type
+unwrap_and_forward(F& f, int_tuple<Indexes...>, const tuple<Args&...>& args)
+{
+  return f(get<Indexes>(args)...);
+}
+
+// Evaluate the inner bind expression
+template<typename Bound, typename... Args>
+inline typename enable_if<is_bind_expression<Bound>::value,
+                          typename Bound::result_type>::type
+mu(Bound& bound_arg, const tuple<Args&...>& args)
+{
+  typedef typename make_indexes<Args...>::type Indexes;
+  return unwrap_and_forward(bound_arg, Indexes(), args);
+}
+
+// Retrieve the Ith argument from args
+template<typename Bound, typename... Args>
+inline typename safe_tuple_element<is_placeholder<Bound>::value - 1,
+                                   tuple<Args...> >::type
+mu(Bound& bound_arg, const tuple<Args&...>& args)
+{
+  return get<is_placeholder<Bound>::value-1>(args);
+}
+
+// Return the stored value.
+template<typename T>
+struct is_reference_wrapper {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_reference_wrapper<reference_wrapper<T> > {
+  static const bool value = true;
+};
+
+template<typename Bound, typename... Args>
+inline typename enable_if<(!is_bind_expression<Bound>::value
+                           && !is_placeholder<Bound>::value
+                           && !is_reference_wrapper<Bound>::value),
+                          Bound&>::type
+mu(Bound& bound_arg, const tuple<Args&...>&) 
+{
+  return bound_arg;
+}
+
+// 
+template<typename F, typename... BoundArgs, int... Indexes, typename... Args>
+typename F::result_type
+apply_functor(F& f, tuple<BoundArgs...>& bound_args, int_tuple<Indexes...>,
+              const tuple<Args&...>& args)
+{
+  return f(mu(get<Indexes>(bound_args), args)...);
+}
+
+template<typename F, typename... BoundArgs>
+class bound_functor
+{
+  typedef typename make_indexes<BoundArgs...>::type indexes;
+
+ public:
+  typedef typename F::result_type result_type;
+
+  explicit bound_functor(const F& f, const BoundArgs&... bound_args)
+    : f(f), bound_args(bound_args...) { }
+
+  template<typename... Args>
+  typename F::result_type operator()(Args&... args) {
+    return apply_functor(f, bound_args, indexes(), tie(args...));
+  }
+
+ private:
+  F f;
+  tuple<BoundArgs...> bound_args;
+};
+
+template<typename F, typename... BoundArgs>
+struct is_bind_expression<bound_functor<F, BoundArgs...> > {
+  static const bool value = true;
+};
+
+template<typename F, typename... BoundArgs>
+inline bound_functor<F, BoundArgs...>
+bind(const F& f, const BoundArgs&... bound_args) 
+{
+  return bound_functor<F, BoundArgs...>(f, bound_args...);
+}
+
+
+// 3.6.4 Placeholders
+template<int I> 
+struct is_placeholder<placeholder<I> > {
+  static const int value = I;
+};
+
+placeholder<1> _1;
+placeholder<2> _2;
+placeholder<3> _3;
+placeholder<4> _4;
+placeholder<5> _5;
+placeholder<6> _6;
+placeholder<7> _7;
+placeholder<8> _8;
+placeholder<9> _9;
+
+// Test code
+template<typename T>
+struct plus {
+  typedef T result_type;
+  
+  T operator()(T x, T y) { return x + y; }
+};
+
+template<typename T>
+struct multiplies {
+  typedef T result_type;
+  
+  T operator()(T x, T y) { return x * y; }
+};
+
+template<typename T>
+struct negate {
+  typedef T result_type;
+  
+  T operator()(T x) { return -x; }
+};
+
+int main()
+{
+  int seventeen = 17;
+  int forty_two = 42;
+
+  assert(bind(plus<int>(), _1, _2)(seventeen, forty_two) == 59);
+  assert(bind(plus<int>(), _1, _1)(seventeen, forty_two) == 34);
+  assert(bind(plus<int>(), _2, _1)(seventeen, forty_two) == 59);
+  assert(bind(plus<int>(), 5, _1)(seventeen, forty_two) == 22);
+  assert(bind(plus<int>(), ref(seventeen), _2)(seventeen, forty_two) == 59);
+  assert(bind(plus<int>(), bind(multiplies<int>(), 3, _1), _2)(seventeen, forty_two) 
+         == 93);
+  return 0;
+}
Index: gcc/testsuite/g++.dg/template/variadic52.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic52.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic52.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,6 @@
+template<typename T, T... Values>
+struct vector_c { };
+
+vector_c<int, 1, 2, 3> v1;
+vector_c<char, 'a', 'b', 'c'> v2;
+vector_c<long, 1u, 2, 3l> v3;
Index: gcc/testsuite/g++.dg/template/variadic35.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic35.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic35.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,8 @@
+template<int I, typename... Args>
+void get_ith(const Args&... args);
+
+void f()
+{
+  get_ith<1, float>(1, 2.0, 'x');
+  get_ith<1, int, double, char, int>(1, 2.0, 'x'); // { dg-error "no matching function" }
+}
Index: gcc/testsuite/g++.dg/template/variadic18.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic18.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic18.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,46 @@
+template<typename...> class tuple { };
+
+template<typename T, template<typename T> class... Metafunctions>
+struct apply_all
+{
+  typedef tuple<typename Metafunctions<T>::type...> type;
+};
+
+template<typename T, typename U>
+struct is_same {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+template<typename T>
+struct add_pointer {
+  typedef T* type;
+};
+
+template<typename T>
+struct add_pointer<T&>
+{
+  typedef T& type;
+};
+
+template<typename T>
+struct add_reference {
+  typedef T& type;
+};
+
+template<typename T>
+struct add_reference<T&>
+{
+  typedef T& type;
+};
+
+int a0[is_same<apply_all<int>::type,tuple<> >::value? 1 : -1];
+int a1[is_same<apply_all<int, add_pointer>::type,tuple<int*> >::value? 1 : -1];
+int a2[is_same<apply_all<int, add_pointer, add_reference>::type,tuple<int*, int&> >::value? 1 : -1];
+int a3[is_same<apply_all<int&, add_pointer, add_reference>::type,tuple<int&, int&> >::value? 1 : -1];
+
+
Index: gcc/testsuite/g++.dg/template/variadic4.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic4.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic4.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,14 @@
+// { dg-do compile }
+template<typename... Args>
+class tuple {};
+
+void f_none(tuple<>) {}
+void f_one(tuple<int>) {}
+void f_two(tuple<int, float>) {}
+void f_nested(tuple<int, tuple<double, char>, float>) { }
+
+
+// { dg-final { scan-assembler "_Z6f_none5tupleIE" } }
+// { dg-final { scan-assembler "_Z5f_one5tupleIiE" } }
+// { dg-final { scan-assembler "_Z5f_two5tupleIifE" } }
+// { dg-final { scan-assembler "_Z8f_nested5tupleIiS_IdcEfE" } }
Index: gcc/testsuite/g++.dg/template/variadic61.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic61.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic61.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,7 @@
+struct unused;
+template<typename T1 = unused, typename T2 = unused, typename T3 = unused,
+         typename T4 = unused, typename T5 = unused, typename T6 = unused>
+struct tuple {};
+
+template<typename... Args>
+void foo(tuple<Args...>) { } // { dg-error "cannot unpack" }
Index: gcc/testsuite/g++.dg/template/variadic44.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic44.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic44.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,12 @@
+// { dg-do compile }
+template<typename... Args>
+int f(const Args&...);
+
+template<typename T> void g(T) { }
+
+void h()
+{
+  g(&f<int, float>);
+}
+
+// { dg-final { scan-assembler "_Z1gIPFiRKiRKfEEvT_"} }
Index: gcc/testsuite/g++.dg/template/variadic27.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic27.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic27.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,21 @@
+template<typename Signature>
+struct function_traits;
+
+template<typename R, typename... ArgTypes>
+struct function_traits<R(ArgTypes...)> {
+  typedef R result_type;
+};
+
+template<typename T, typename U>
+struct same_type {
+  static const bool value = false;
+};
+
+template<typename T>
+struct same_type<T, T> {
+  static const bool value = true;
+};
+
+int a0[same_type<function_traits<int()>::result_type, int>::value? 1 : -1];
+int a1[same_type<function_traits<int(float)>::result_type, int>::value? 1 : -1];
+int a2[same_type<function_traits<int(double, char)>::result_type, int>::value? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic53.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic53.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic53.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,16 @@
+template<typename F, typename... BoundArgs>
+class bound_functor
+{
+ public:
+  typedef typename F::result_type result_type;
+
+  template<typename... Args>
+  typename F::result_type operator()(Args&... args);
+};
+
+template<typename F, typename... BoundArgs>
+template<typename... Args>
+typename F::result_type 
+bound_functor<F, BoundArgs...>::operator()(Args&... args)
+{
+}
Index: gcc/testsuite/g++.dg/template/variadic36.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic36.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic36.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,14 @@
+template<typename T, typename... Args>
+void f(const T&, const Args&... args)
+{
+  f(args); // { dg-error "packs not unpacked" }
+}
+
+template<typename... Values>
+struct tuple_base { };
+
+template<typename... Values>
+struct tuple : tuple_base<Values> { }; // { dg-error "packs not unpacked" }
+
+// { dg-error "args" "" { target *-*-* } 4 }
+// { dg-error "Values" "" { target *-*-* } 11 }
Index: gcc/testsuite/g++.dg/template/variadic19.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic19.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic19.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,18 @@
+template<typename... Args>
+struct tuple {
+  static const int value = 0;
+};
+
+template<typename T, template<class T> class... Metafunctions>
+struct tuple<Metafunctions<T>...> {
+  static const int value = 1;
+};
+
+template<typename T> struct add_pointer;
+template<typename T> struct add_reference;
+
+int a0[tuple<int, float>::value == 0? 1 : -1];
+int a1[tuple<add_pointer<int>, add_pointer<float> >::value == 0? 1 : -1];
+int a2[tuple<>::value == 0? 1 : -1];
+int a3[tuple<add_pointer<int> >::value == 1? 1 : -1];
+int a4[tuple<add_pointer<int>, add_reference<int> >::value == 1? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic5.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic5.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic5.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,37 @@
+template<typename... Args>
+struct tuple {
+  static const int value = 0;
+};
+
+template<>
+struct tuple<> {
+  static const int value = 1;
+};
+
+template<>
+struct tuple<int> {
+  static const int value = 2;
+};
+
+
+template<>
+struct tuple<int, float> {
+  static const int value = 3;
+};
+
+template<typename T>
+struct tuple<T, T> {
+  static const int value = 4;
+};
+
+template<>
+struct tuple<float, float> {
+  static const int value = 5;
+};
+
+int a0[tuple<float>::value == 0? 1 : -1];
+int a1[tuple<>::value == 1? 1 : -1];
+int a2[tuple<int>::value == 2? 1 : -1];
+int a3[tuple<int, float>::value == 3? 1 : -1];
+int a4[tuple<int, int>::value == 4? 1 : -1];
+int a5[tuple<float, float>::value == 5? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic-tuple.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic-tuple.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic-tuple.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,293 @@
+// { dg-do "run" }
+// An implementation of TR1's <tuple> using variadic teplates
+// Contributed by Douglas Gregor <doug.gregor@gmail.com>
+
+#include <string>
+#include <cassert>
+#include <cstring>
+
+// Trivial reference_wrapper
+template<typename T>
+struct reference_wrapper
+{
+  reference_wrapper(T& x) : ptr(&x) { }
+
+  operator T&() const { return *ptr; }
+
+  T* ptr;
+};
+
+template<typename T> reference_wrapper<T> ref(T& x) { return x; }
+template<typename T> reference_wrapper<const T> cref(const T& x) { return x; }
+
+// Simple type-traits we'll need
+template<typename T>
+struct add_reference
+{
+  typedef T& type;
+};
+
+template<typename T>
+struct add_reference<T&>
+{
+  typedef T& type;
+};
+
+template<typename T, typename U>
+struct is_same
+{
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T>
+{
+  static const bool value = true;
+};
+
+// For creating the constructor parameters of tuple<>
+template<typename T>
+struct add_const_reference
+{
+  typedef const T& type;
+};
+
+template<typename T>
+struct add_const_reference<T&>
+{
+  typedef T& type;
+};
+
+// 6.1.3 Class template tuple 
+template<typename... Values>
+class tuple;
+
+template<> class tuple<> { };
+
+template<typename Head, typename... Tail>
+class tuple<Head, Tail...> 
+  : private tuple<Tail...>
+{
+  typedef tuple<Tail...> inherited;
+
+ public:
+  tuple() { }
+
+  // implicit copy-constructor is okay
+
+  tuple(typename add_const_reference<Head>::type v, 
+        typename add_const_reference<Tail>::type... vtail)
+    : m_head(v), inherited(vtail...) { }
+
+  template<typename... VValues>
+  tuple(const tuple<VValues...>& other)
+    : m_head(other.head()), inherited(other.tail()) { }
+
+  template<typename... VValues>
+  tuple& operator=(const tuple<VValues...>& other)
+  {
+    m_head = other.head();
+    tail() = other.tail();
+    return *this;
+  }
+
+  typename add_reference<Head>::type       head()       { return m_head; }
+  typename add_reference<const Head>::type head() const { return m_head; }
+  inherited&                               tail()       { return *this; }
+  const inherited&                         tail() const { return *this; }
+
+ protected:
+  Head m_head;
+};
+
+template<typename T>
+struct make_tuple_result
+{
+  typedef T type;
+};
+
+template<typename T>
+struct make_tuple_result<reference_wrapper<T> >
+{
+  typedef T& type;
+};
+
+// 6.1.3.2 Tuple creation functions
+struct ignore_t { 
+  template<typename T> ignore_t& operator=(const T&) { return *this; }
+} ignore;
+
+template<typename... Values>
+tuple<typename make_tuple_result<Values>::type...> 
+make_tuple(const Values&... values)
+{
+  return tuple<typename make_tuple_result<Values>::type...>(values...);
+}
+
+template<typename... Values>
+tuple<Values&...> tie(Values&... values)
+{
+  return tuple<Values&...>(values...);
+}
+
+// 6.1.3.3 Tuple helper classes
+template<typename Tuple>
+struct tuple_size;
+
+template<>
+struct tuple_size<tuple<> >
+{
+  static const std::size_t value = 0;
+};
+
+template<typename Head, typename... Tail>
+struct tuple_size<tuple<Head, Tail...> >
+{
+  static const std::size_t value = 1 + tuple_size<tuple<Tail...> >::value;
+};
+
+template<int I, typename Tuple>
+struct tuple_element;
+
+template<int I, typename Head, typename... Tail>
+struct tuple_element<I, tuple<Head, Tail...> >
+{
+  typedef typename tuple_element<I-1, tuple<Tail...> >::type type;
+};
+
+template<typename Head, typename... Tail>
+struct tuple_element<0, tuple<Head, Tail...> >
+{
+  typedef Head type;
+};
+
+// 6.1.3.4 Element access
+template<int I, typename Tuple>
+class get_impl;
+
+template<int I, typename Head, typename... Values> 
+class get_impl<I, tuple<Head, Values...> >
+{
+  typedef typename tuple_element<I-1, tuple<Values...> >::type Element;
+  typedef typename add_reference<Element>::type RJ;
+  typedef typename add_const_reference<Element>::type PJ;
+  typedef get_impl<I-1, tuple<Values...> > Next;
+
+ public:
+  static RJ get(tuple<Head, Values...>& t)       
+  { return Next::get(t.tail()); }
+
+  static PJ get(const tuple<Head, Values...>& t) 
+  { return Next::get(t.tail()); }
+};
+
+template<typename Head, typename... Values> 
+class get_impl<0, tuple<Head, Values...> >
+{
+  typedef typename add_reference<Head>::type RJ;
+  typedef typename add_const_reference<Head>::type PJ;
+
+ public:
+  static RJ get(tuple<Head, Values...>& t)       { return t.head(); }
+  static PJ get(const tuple<Head, Values...>& t) { return t.head(); }
+};
+
+template<int I, typename... Values>
+typename add_reference<
+           typename tuple_element<I, tuple<Values...> >::type
+         >::type
+get(tuple<Values...>& t)
+{
+  return get_impl<I, tuple<Values...> >::get(t);
+}
+
+template<int I, typename... Values>
+typename add_const_reference<
+           typename tuple_element<I, tuple<Values...> >::type
+         >::type
+get(const tuple<Values...>& t)
+{
+  return get_impl<I, tuple<Values...> >::get(t);
+}
+
+// 6.1.3.5 Relational operators
+inline bool operator==(const tuple<>&, const tuple<>&) { return true; }
+
+template<typename T, typename... TTail, typename U, typename... UTail>
+bool operator==(const tuple<T, TTail...>& t, const tuple<U, UTail...>& u)
+{
+  return t.head() == u.head() && t.tail() == u.tail();
+}
+
+template<typename... TValues, typename... UValues>
+bool operator!=(const tuple<TValues...>& t, const tuple<UValues...>& u)
+{
+  return !(t == u);
+}
+
+inline bool operator<(const tuple<>&, const tuple<>&) { return false; }
+
+template<typename T, typename... TTail, typename U, typename... UTail>
+bool operator<(const tuple<T, TTail...>& t, const tuple<U, UTail...>& u)
+{
+  return (t.head() < u.head() || 
+          (!(t.head() < u.head()) && t.tail() < u.tail()));
+}
+
+template<typename... TValues, typename... UValues>
+bool operator>(const tuple<TValues...>& t, const tuple<UValues...>& u)
+{
+  return u < t;
+}
+
+template<typename... TValues, typename... UValues>
+bool operator<=(const tuple<TValues...>& t, const tuple<UValues...>& u)
+{
+  return !(u < t);
+}
+
+template<typename... TValues, typename... UValues>
+bool operator>=(const tuple<TValues...>& t, const tuple<UValues...>& u)
+{
+  return !(t < u);
+}
+
+int a0[tuple_size<tuple<> >::value == 0? 1 : -1];
+int a1[tuple_size<tuple<int, float, double> >::value == 3? 1 : -1];
+int a2a[is_same<tuple_element<0, tuple<int, float, double> >::type, int>
+         ::value? 1 : -1];
+int a2b[is_same<tuple_element<1, tuple<int, float, double> >::type, float>
+         ::value? 1 : -1];
+int a2c[is_same<tuple_element<2, tuple<int, float, double> >::type, double>
+         ::value? 1 : -1];
+
+int main()
+{
+  tuple<> t0;
+  tuple<int> t1(1);
+  tuple<int, float> t2(1, 3.14159f);
+  tuple<int, float, const char*> t3a(1, 3.14159f, "Hello, world!");
+  tuple<long, double, std::string> t3b(t3a);
+  t3b = t3a;
+  //  t3a = t3b; DPG: triggers an error, as it should.
+
+  tuple<int, float, std::string> t3c = 
+    make_tuple(17, 2.718281828, std::string("Fun"));
+
+  int seventeen = 17;
+  double pi = 3.14159;
+  tuple<int&, double&> seventeen_pi = make_tuple(ref(seventeen), ref(pi));
+  tuple<int&, const double&> seventeen_pi2 = 
+    make_tuple(ref(seventeen), cref(pi));
+  tuple<int&, double&> seventeen_pi_tied = tie(seventeen, pi);
+  assert(get<0>(t3a) == 1);
+  assert(get<1>(t3a) == 3.14159f);
+  assert(std::strcmp(get<2>(t3a), "Hello, world!") == 0);
+
+  assert(t3a == t3b);
+  assert(!(t3a != t3b));
+  assert(!(t3a < t3b));
+  assert(!(t3a > t3b));
+  assert(t3a <= t3b && t3b <= t3a);
+  assert(t3a >= t3b && t3b >= t3a);
+}
Index: gcc/testsuite/g++.dg/template/variadic62.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic62.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic62.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,7 @@
+template<typename Result, typename Functor, typename... ArgTypes>
+Result bind(Functor, ArgTypes...) { }
+
+void f()
+{
+  bind<int>(17, 20, 22);
+}
Index: gcc/testsuite/g++.dg/template/variadic45.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic45.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic45.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,9 @@
+template<typename... Args>
+int& f(Args...);
+
+template<typename T1, typename T2>
+float& f(T1, T2);
+
+float& g() { 
+  return f(17, 3.14159); 
+}
Index: gcc/testsuite/g++.dg/template/variadic28.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic28.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic28.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,24 @@
+template<typename Signature>
+struct function_traits;
+
+template<typename R, typename... ArgTypes>
+struct function_traits<R(ArgTypes......)> {
+  typedef R result_type;
+};
+
+template<typename T, typename U>
+struct same_type {
+  static const bool value = false;
+};
+
+template<typename T>
+struct same_type<T, T> {
+  static const bool value = true;
+};
+
+int a0[same_type<function_traits<int(double, char...)>::result_type, int>::value? 1 : -1];
+int a1[same_type<function_traits<int(double, char,...)>::result_type, int>::value? 1 : -1];
+int a2[same_type<function_traits<int(char,...)>::result_type, int>::value? 1 : -1];
+int a3[same_type<function_traits<int(...)>::result_type, int>::value? 1 : -1];
+int a4[same_type<function_traits<int(double x, char...)>::result_type, int>::value? 1 : -1];
+int a5[same_type<function_traits<int(double, char y...)>::result_type, int>::value? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic54.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic54.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic54.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,11 @@
+template<typename F, typename... BoundArgs>
+class bound_functor
+{
+ public:
+  bound_functor();
+};
+
+template<typename F, typename... BoundArgs>
+bound_functor<F, BoundArgs...>::bound_functor()
+{
+}
Index: gcc/testsuite/g++.dg/template/variadic37.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic37.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic37.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,9 @@
+template<typename... Values>
+struct tuple
+{
+  static const __SIZE_TYPE__ length = sizeof...(Values);
+};
+
+int a0[tuple<>::length == 0? 1 : -1];
+int a1[tuple<int>::length == 1? 1 : -1];
+int a2[tuple<int, float>::length == 2? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic6.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic6.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic6.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,11 @@
+template<typename ... Args>
+struct tuple_base {};
+
+template<typename ... Args>
+struct tuple : public tuple_base<Args...>
+{ 
+};
+
+tuple<> zero;
+tuple<int> one;
+tuple<float, int> two;
Index: gcc/testsuite/g++.dg/template/variadic63.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic63.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic63.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,23 @@
+template<typename... Elements> struct tuple {};
+
+template<typename... Args>
+struct nested
+{
+  typedef tuple<tuple<Args, Args...>...> type;
+};
+
+template<typename T, typename U>
+struct is_same
+{
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T>
+{
+  static const bool value = true;
+};
+
+int a0[is_same<nested<int, float>::type, 
+                      tuple<tuple<int, int, float>, 
+                            tuple<float, int, float> > >::value? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic46.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic46.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic46.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,10 @@
+template<typename... Args>
+int& f(Args&...);
+
+template<typename... Args>
+float& f(const Args&...);
+
+int& g(int x, float y)
+{
+  return f(x, y);
+}
Index: gcc/testsuite/g++.dg/template/variadic29.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic29.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic29.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,34 @@
+template<typename Signature>
+struct function_traits;
+
+template<typename R, typename... ArgTypes>
+struct function_traits<R(ArgTypes...)> {
+  typedef R result_type;
+};
+
+template<typename R, typename Class, typename... ArgTypes>
+struct function_traits<R (Class::*)(ArgTypes...)> {
+  typedef R result_type;
+};
+
+template<typename R, typename Class, typename... ArgTypes>
+struct function_traits<R (Class::*)(ArgTypes...) const> {
+  typedef R result_type;
+};
+
+template<typename T, typename U>
+struct same_type {
+  static const bool value = false;
+};
+
+template<typename T>
+struct same_type<T, T> {
+  static const bool value = true;
+};
+
+struct X {};
+
+int a0[same_type<function_traits<int (X::*)()>::result_type, int>::value? 1 : -1];
+int a1[same_type<function_traits<int (X::*)(float)>::result_type, int>::value? 1 : -1];
+int a2[same_type<function_traits<int (X::*)(double, char)>::result_type, int>::value? 1 : -1];
+int a3[same_type<function_traits<int (X::*)(double, char) const>::result_type, int>::value? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic55.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic55.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic55.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,11 @@
+template<typename F, typename... BoundArgs>
+class bound_functor
+{
+ public:
+  bound_functor(const BoundArgs&... bound_args);
+};
+
+template<typename F, typename... BoundArgs>
+bound_functor<F, BoundArgs...>::bound_functor(const BoundArgs&...)
+{
+}
Index: gcc/testsuite/g++.dg/template/variadic38.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic38.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic38.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,5 @@
+template<int... Values>
+struct int_vec {};
+
+template<int... Values>
+struct int_vec<0, (Values+1)...> {}; // { dg-error "involves template parameter" }
Index: gcc/testsuite/g++.dg/template/variadic7.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic7.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic7.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,32 @@
+template<typename... Args>
+struct tuple_base {
+  static const int value = 0;
+};
+
+template<>
+struct tuple_base<int> {
+  static const int value = 1;
+};
+
+template<>
+struct tuple_base<int, float> {
+  static const int value = 2;
+};
+
+template<>
+struct tuple_base<float, int> {
+  static const int value = 3;
+};
+
+template<typename... Args>
+struct int_tuple : tuple_base<int, Args...> { };
+
+template<typename... Args>
+struct tuple_int : tuple_base<Args..., int> { };
+
+int a0a[int_tuple<int>::value == 0? 1 : -1];
+int a0b[int_tuple<int>::value == 0? 1 : -1];
+int a1a[int_tuple<>::value == 1? 1 : -1];
+int a1b[tuple_int<>::value == 1? 1 : -1];
+int a2[int_tuple<float>::value == 2? 1 : -1];
+int a3[tuple_int<float>::value == 3? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic64.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic64.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic64.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,21 @@
+// { dg-do "run" }
+template <typename T, T... Args> struct bomb;
+
+template <typename T>
+struct bomb<T> {
+ static const T value = 0;
+};
+
+template <typename T, T v, T... Args>
+struct bomb<T, v, Args...> {
+ static const T value = v + bomb<T, Args...>::value;
+};
+
+extern "C" void abort();
+
+int main() {
+  bomb<int, 1, 2, 3, 4> b;
+  if (b.value != 10)
+    abort();
+  return 0;
+}
Index: gcc/testsuite/g++.dg/template/variadic47.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic47.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic47.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,17 @@
+template<typename T> struct wrap { };
+
+template<typename... Args>
+int& f(const Args&...);
+
+template<typename... Args>
+float& f(const wrap<Args>&...);
+
+int& g(int x, float y, double z)
+{
+  return f(x, y, z);
+}
+
+float& h(wrap<int> x, wrap<float> y, wrap<double> z)
+{
+  return f(x, y, z);
+}
Index: gcc/testsuite/g++.dg/template/variadic56.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic56.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic56.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,18 @@
+template<typename... Elements>
+struct tuple { };
+
+template<typename T, typename... Elements>
+struct tuple<T, Elements...> {
+  int foo();
+};
+
+template<typename T, typename... Elements>
+struct tuple<T*, Elements...> {
+  int bar();
+};
+
+template<typename T, typename... Elements>
+int tuple<T, Elements...>::foo() { return 0; }
+
+template<typename T, typename... Elements>
+int tuple<T*, Elements...>::bar() { return 0; }
Index: gcc/testsuite/g++.dg/template/variadic39.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic39.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic39.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,12 @@
+template<typename... Args>
+struct tuple {};
+
+template<typename T, typename... Args>
+struct tuple<Args..., T> { }; // { dg-error "end" }
+
+
+template<int... Values>
+struct int_vec { };
+
+template<int I, int... Values>
+struct int_vec<Values..., I> { }; // { dg-error "end" }
Index: gcc/testsuite/g++.dg/template/variadic8.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic8.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic8.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,22 @@
+template<typename... Args>
+struct tuple_base {
+  static const int value = 0;
+};
+
+template<>
+struct tuple_base<int*>
+{
+  static const int value = 1;
+};
+
+template<typename T>
+struct tuple_base<T*>
+{
+  static const int value = 2;
+};
+
+template<typename... Args>
+struct tuple_of_pointers : tuple_base<Args*...> { };
+
+int a1[tuple_of_pointers<int>::value == 1? 1 : -1];
+int a2[tuple_of_pointers<float>::value == 2? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic65.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic65.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic65.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,11 @@
+template<typename...> struct list {};
+
+template<typename Sequence, typename Head>
+struct push_front;
+
+template<typename... Elements, typename Head>
+struct push_front<list<Elements...>, Head> {
+  typedef list<Head, Elements> type; // { dg-error "parameter packs not unpacked" }
+};
+
+// { dg-error "Elements" "" { target *-*-* } 8 }
Index: gcc/testsuite/g++.dg/template/variadic48.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic48.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic48.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,9 @@
+template<typename T, typename... Args>
+int& f(const T&, Args...);
+
+template<typename T>
+float& f(const T&);
+
+float& g() {
+  return f(17);
+}
Index: gcc/testsuite/g++.dg/template/variadic-mem_fn.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic-mem_fn.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic-mem_fn.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,49 @@
+// { dg-do "run" }
+// A basic implementation of TR1's mem_fn using variadic teplates
+// Contributed by Douglas Gregor <doug.gregor@gmail.com>
+#include <cassert>
+
+template<typename R, typename Class, typename... Args>
+class Mem_fn
+{
+ public:
+  explicit Mem_fn(R (Class::*pmf)(Args...)) : pmf(pmf) { }
+
+  R operator()(Class& object, Args... args)
+  {
+    return (object.*pmf)(args...);
+  }
+
+  R operator()(Class* object, Args... args)
+  {
+    return (object->*pmf)(args...);
+  }
+
+  R (Class::*pmf)(Args...);
+};
+
+template<typename R, typename Class, typename... Args>  
+inline Mem_fn<R, Class, Args...>
+mem_fn(R (Class::* pmf)(Args...))
+{
+  return Mem_fn<R, Class, Args...>(pmf);
+}
+
+class X {
+ public:
+  int negate(int x) { return -x; }
+  int plus(int x, int y) { return x + y; }
+};
+
+int main()
+{
+  X x;
+  X* xp = &x;
+
+  assert(mem_fn(&X::negate)(x, 17) == -17);
+  assert(mem_fn(&X::negate)(xp, 17) == -17);
+  assert(mem_fn(&X::plus)(x, 17, 25) == 42);
+  assert(mem_fn(&X::plus)(xp, 17, 25) == 42);
+
+  return 0;
+}
Index: gcc/testsuite/g++.dg/template/variadic57.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic57.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic57.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,15 @@
+template<typename T, int... Dims>
+struct array { 
+  int foo();
+};
+
+template<typename T>
+struct array<T, 0> {
+  int bar();
+};
+
+template<typename T, int... Dims>
+int array<T, Dims...>::foo() { }
+
+template<typename T>
+int array<T, 0>::bar() { }
Index: gcc/testsuite/g++.dg/template/variadic9.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic9.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic9.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,37 @@
+template<typename T1, typename T2>
+struct pair {};
+
+template<typename... Args>
+struct tuple {
+  static const int value = 0;
+};
+
+template<>
+struct tuple<pair<int, float> > {
+  static const int value = 1;
+};
+
+template<typename U>
+struct tuple<pair<int, U> > {
+  static const int value = 2;
+};
+
+template<typename T, typename U>
+struct tuple<pair<T, U>, pair<T, U> > {
+  static const int value = 3;
+};
+
+
+template<typename... Outer>
+struct X {
+  template<typename... Inner>
+  struct Y
+  {
+    typedef tuple<pair<Outer, Inner>...> type;
+  };
+};
+
+int a0[X<int, double>::Y<short, char>::type::value == 0? 1 : -1];
+int a1[X<int>::Y<float>::type::value == 1? 1 : -1];
+int a2[X<int>::Y<double>::type::value == 2? 1 : -1];
+int a3[X<int, int>::Y<double, double>::type::value == 3? 1 : -1];
Index: gcc/testsuite/g++.dg/template/variadic66.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic66.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic66.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,20 @@
+struct A {};
+struct B {};
+struct C {};
+
+template<typename... Mixins>
+struct mixed_up : public Mixins...
+{
+};
+
+void fA(A);
+void fB(B);
+void fC(C);
+
+void g()
+{
+  mixed_up<A, B, C> m;
+  fA(m);
+  fB(m);
+  fC(m);
+}
Index: gcc/testsuite/g++.dg/template/variadic49.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic49.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic49.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,8 @@
+int& f(...);
+
+template<typename... Args>
+float& f(Args...);
+
+float& g() {
+  return f(17, 3.14159);
+}
Index: gcc/testsuite/g++.dg/template/variadic58.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic58.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic58.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,15 @@
+#include <typeinfo>
+
+template<typename... Args>
+void foo(Args...) { }
+
+template<typename... Args>
+void bar(Args... args) {
+  foo(Args()...);
+  foo(args = args...);
+  foo(reinterpret_cast<void*>(&args)...);
+  foo(const_cast<const Args>(args)...);
+  foo(static_cast<void*>(&args)...);
+  foo(dynamic_cast<void*>(&args)...);
+  foo(typeid(Args)...);
+}
Index: gcc/testsuite/g++.dg/template/variadic67.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic67.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic67.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,32 @@
+// { dg-do "run" }
+struct A {};
+struct B {};
+struct C {};
+
+template<typename... Exceptions> void f(int idx) throw(Exceptions...) {
+  if (idx == 0) throw A();
+  else if (idx == 1) throw B();
+  else if (idx == 2) throw C();
+}
+
+extern "C" void abort();
+
+int main()
+{
+  try {
+    f<A, B, C>(0);
+    abort();
+  } catch (A) {
+  }
+  try {
+    f<A, B, C>(1);
+    abort();
+  } catch (B) {
+  }
+  try {
+    f<A, B, C>(2);
+    abort();
+  } catch (C) {
+  }
+  return 0;
+}
Index: gcc/testsuite/g++.dg/template/variadic59.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic59.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic59.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,3 @@
+template<class T, typename... VarArgs>
+void print(T t, VarArgs args); // { dg-error "packs not unpacked" }
+// { dg-error "VarArgs" "" { target *-*-* } 2 }
Index: gcc/testsuite/g++.dg/template/variadic68.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic68.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic68.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,23 @@
+// { dg-do "run" }
+
+extern "C" void abort();
+
+template<typename T, T... Values>
+void f(T* expected_values, int n)
+{
+  if (sizeof...(Values) != n)
+    abort ();
+
+  T values[] = { Values... };
+  for (int i = 0; i < n; ++i)
+    if (values[i] != expected_values[i])
+      abort();
+}
+
+int main()
+{
+  int test_arr1[3] = { 1, 2, 3 };
+  f<int, 1, 2, 3>(test_arr1, 3);
+
+  return 0;
+}
Index: gcc/testsuite/g++.dg/template/variadic10.C
===================================================================
--- gcc/testsuite/g++.dg/template/variadic10.C	(.../vendor/gcc-4.1.1)	(revision 0)
+++ gcc/testsuite/g++.dg/template/variadic10.C	(.../branches/variadic-templates)	(revision 425)
@@ -0,0 +1,21 @@
+template<typename T1, typename T2>
+struct pair {};
+
+template<typename... Args>
+struct tuple {
+  static const int value = 0;
+};
+
+template<>
+struct tuple<pair<int, float> > { };
+
+template<typename... Outer>
+struct X {
+  template<typename... Inner>
+  struct Y
+  {
+    typedef tuple<pair<Outer, Inner>...> type; // { dg-error "mismatched argument pack lengths" }
+  };
+};
+
+X<int, double>::Y<short, char, double>::type honk; 
Index: gcc/cp/typeck.c
===================================================================
--- gcc/cp/typeck.c	(.../vendor/gcc-4.1.1)	(revision 425)
+++ gcc/cp/typeck.c	(.../branches/variadic-templates)	(revision 425)
@@ -997,7 +997,9 @@ comptypes (tree t1, tree t2, int strict)
     case TEMPLATE_TEMPLATE_PARM:
     case BOUND_TEMPLATE_TEMPLATE_PARM:
       if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2)
-	  || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2))
+	  || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2)
+          || (TEMPLATE_TYPE_PARAMETER_PACK (t1) 
+              != TEMPLATE_TYPE_PARAMETER_PACK (t2)))
 	return false;
       if (!comp_template_parms
 	  (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1)),
@@ -1056,7 +1058,9 @@ comptypes (tree t1, tree t2, int strict)
 
     case TEMPLATE_TYPE_PARM:
       if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2)
-	  || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2))
+	  || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2)
+          || (TEMPLATE_TYPE_PARAMETER_PACK (t1) 
+              != TEMPLATE_TYPE_PARAMETER_PACK (t2)))
 	return false;
       break;
 
@@ -1086,6 +1090,9 @@ comptypes (tree t1, tree t2, int strict)
 	return false;
       break;
 
+    case PACK_UNPACK_TYPE:
+      return same_type_p (PACK_UNPACK_PATTERN (t1), PACK_UNPACK_PATTERN (t2));
+
     default:
       return false;
     }
Index: gcc/cp/decl.c
===================================================================
--- gcc/cp/decl.c	(.../vendor/gcc-4.1.1)	(revision 425)
+++ gcc/cp/decl.c	(.../branches/variadic-templates)	(revision 425)
@@ -6682,6 +6682,7 @@ grokdeclarator (const cp_declarator *dec
   cp_storage_class storage_class;
   bool unsigned_p, signed_p, short_p, long_p, thread_p;
   bool type_was_error_mark_node = false;
+  bool pack_unpack_p = declarator? declarator->pack_unpack_p : false;
 
   signed_p = declspecs->specs[(int)ds_signed];
   unsigned_p = declspecs->specs[(int)ds_unsigned];
@@ -7636,6 +7637,16 @@ grokdeclarator (const cp_declarator *dec
 	attrlist = &returned_attrs;
     }
 
+  /* Handle parameter packs. */
+  if (pack_unpack_p)
+    {
+      if (decl_context == PARM)
+        /* Turn the type into a pack/unpack type.*/
+        type = make_argument_pack_unpack (type);
+      else
+        error ("non-parameter %qs cannot be a parameter pack", name);
+    }
+
   /* Did array size calculations overflow?  */
 
   if (TREE_CODE (type) == ARRAY_TYPE
@@ -8632,6 +8643,13 @@ grokparms (cp_parameter_declarator *firs
 	    init = check_default_argument (decl, init);
 	}
 
+      if (TREE_CODE (decl) == PARM_DECL
+          && FUNCTION_PARAMETER_PACK_P (decl)
+          && parm->next)
+        /* Function parameter packs must be last in the parameter
+           list. */
+        error ("parameter packs must be at the end of the parameter list");
+
       TREE_CHAIN (decl) = decls;
       decls = decl;
       result = tree_cons (init, type, result);
@@ -9599,6 +9617,8 @@ xref_basetypes (tree ref, tree base_list
       if (access == access_default_node)
 	access = default_access;
 
+      if (PACK_UNPACK_P (basetype))
+        basetype = PACK_UNPACK_PATTERN (basetype);
       if (TREE_CODE (basetype) == TYPE_DECL)
 	basetype = TREE_TYPE (basetype);
       if (TREE_CODE (basetype) != RECORD_TYPE
@@ -9644,6 +9664,11 @@ xref_basetypes (tree ref, tree base_list
 	    error ("duplicate base type %qT invalid", basetype);
 	  continue;
 	}
+
+      if (PACK_UNPACK_P (TREE_VALUE (base_list)))
+        /* Regenerate the pack/unpack type for the bases. */
+        basetype = make_argument_pack_unpack (basetype);
+
       TYPE_MARKED_P (basetype) = 1;
 
       base_binfo = copy_binfo (base_binfo, basetype, ref,
Index: gcc/cp/cp-tree.def
===================================================================
--- gcc/cp/cp-tree.def	(.../vendor/gcc-4.1.1)	(revision 425)
+++ gcc/cp/cp-tree.def	(.../branches/variadic-templates)	(revision 425)
@@ -342,6 +342,65 @@ DEFTREECODE (STMT_EXPR, "stmt_expr", tcc
    is applied.  */
 DEFTREECODE (UNARY_PLUS_EXPR, "unary_plus_expr", tcc_unary, 1)
 
+/* Represents an argument pack of types (or templates). An argument
+   pack stores zero or more arguments that will be used to instantiate
+   a parameter pack. 
+
+   ARGUMENT_PACK_ARGS retrieves the arguments stored in the argument
+   pack.
+
+   Example:
+     template<typename... Values>
+     class tuple { ... };
+
+     tuple<int, float, double> t;
+
+   Values is a (template) parameter pack. When tuple<int, float,
+   double> is instantiated, the Values parameter pack is instantiated
+   with the argment pack <int, float, double>. ARGUMENT_PACK_ARGS will
+   be a TREE_VEC containing int, float, and double.  */
+DEFTREECODE (TYPE_ARGUMENT_PACK, "type_argument_pack", tcc_type, 0)
+
+/* Represents an argument pack of values, which can be used either for
+   non-type template arguments or function call arguments. 
+
+   NONTYPE_ARGUMENT_PACK plays precisely the same role as
+   TYPE_ARGUMENT_PACK, but will be used for packing non-type template
+   arguments (e.g., "int... Dimensions") or function arguments ("const
+   Args&... args").
+*/
+DEFTREECODE (NONTYPE_ARGUMENT_PACK, "nontype_argument_pack", tcc_expression, 1)
+
+/* Represents a type expression that will be packed into or unpacked
+   from an argument pack. 
+
+   PACK_UNPACK_PATTERN retrieves the packing/unpacked pattern. This is
+   the type or expression that we will substitute into with each
+   argument in an argument pack.
+
+   SET_PACK_UNPACK_PATTERN sets the packing/unpacking pattern.
+
+   PACK_UNPACK_PARAMETER_PACKS contains a TREE_LIST of the parameter
+   packs that are used in this pack/unpack expression.
+
+   Example:
+     template<typename... Values>
+     struct tied : tuple<Values&...> { 
+       // ...
+     };
+
+   The derivation from tuple contains a PACK_UNPACK_TYPE for the
+   template arguments. Its PACK_UNPACK_EXPR is "Values&" and its
+   PACK_UNPACK_PARAMETER_PACKS will contain "Values". */
+DEFTREECODE (PACK_UNPACK_TYPE, "pack_unpack_type", tcc_type, 0)
+
+/* Represents an expression that will be packed into or unpacked
+   from an argument pack. 
+
+   PACK_UNPACK_EXPR plays precisely the same role as PACK_UNPACK_TYPE,
+   but will be used for packing/unpacking expressions. */
+DEFTREECODE (PACK_UNPACK_EXPR, "pack_unpack_expr", tcc_expression, 1)
+
 /*
 Local variables:
 mode:c
Index: gcc/cp/cp-objcp-common.c
===================================================================
--- gcc/cp/cp-objcp-common.c	(.../vendor/gcc-4.1.1)	(revision 425)
+++ gcc/cp/cp-objcp-common.c	(.../branches/variadic-templates)	(revision 425)
@@ -123,6 +123,15 @@ cp_tree_size (enum tree_code code)
     case TEMPLATE_PARM_INDEX:	return sizeof (template_parm_index);
     case DEFAULT_ARG:		return sizeof (struct tree_default_arg);
     case OVERLOAD:		return sizeof (struct tree_overload);
+
+    case TYPE_ARGUMENT_PACK:
+    case PACK_UNPACK_TYPE:
+      return sizeof (struct tree_common);
+
+    case NONTYPE_ARGUMENT_PACK:
+    case PACK_UNPACK_EXPR:
+      return sizeof (struct tree_exp);
+
     default:
       gcc_unreachable ();
     }
Index: gcc/cp/error.c
===================================================================
--- gcc/cp/error.c	(.../vendor/gcc-4.1.1)	(revision 425)
+++ gcc/cp/error.c	(.../branches/variadic-templates)	(revision 425)
@@ -136,7 +136,9 @@ dump_scope (tree scope, int flags)
 static void
 dump_template_argument (tree arg, int flags)
 {
-  if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
+  if (ARGUMENT_PACK_P (arg))
+    dump_template_argument_list (ARGUMENT_PACK_ARGS (arg), flags);
+  else if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
     dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
   else
     dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
@@ -154,9 +156,17 @@ dump_template_argument_list (tree args, 
 
   for (i = 0; i< n; ++i)
     {
-      if (need_comma)
+      tree arg = TREE_VEC_ELT (args, i);
+
+      /* Only print a comma if we know there is an argument coming. In
+         the case of an empty template argument pack, no actual
+         argument will be printed. */
+      if (need_comma
+          && (!ARGUMENT_PACK_P (arg)
+              || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
 	pp_separate_with_comma (cxx_pp);
-      dump_template_argument (TREE_VEC_ELT (args, i), flags);
+
+      dump_template_argument (arg, flags);
       need_comma = 1;
     }
 }
@@ -174,6 +184,8 @@ dump_template_parameter (tree parm, int 
       if (flags & TFF_DECL_SPECIFIERS)
 	{
 	  pp_cxx_identifier (cxx_pp, "class");
+          if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p)))
+            pp_cxx_identifier (cxx_pp, "...");
 	  if (DECL_NAME (p))
 	    pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
 	}
@@ -370,6 +382,11 @@ dump_type (tree t, int flags)
       pp_cxx_right_paren (cxx_pp);
       break;
 
+    case PACK_UNPACK_TYPE:
+      dump_type (PACK_UNPACK_PATTERN (t), flags);
+      pp_cxx_identifier (cxx_pp, "...");
+      break;
+
     default:
       pp_unsupported_tree (cxx_pp, t);
       /* Fall through to error.  */
@@ -1216,14 +1233,19 @@ dump_template_parms (tree info, int prim
 	{
 	  tree arg = TREE_VEC_ELT (args, ix);
 
-	  if (ix)
-	    pp_separate_with_comma (cxx_pp);
-
-	  if (!arg)
-	    pp_identifier (cxx_pp, "<template parameter error>");
-	  else
-	    dump_template_argument (arg, flags);
-	}
+          /* Only print a comma if we know there is an argument coming. In
+             the case of an empty template argument pack, no actual
+             argument will be printed. */
+          if (ix
+              && (!ARGUMENT_PACK_P (arg)
+                  || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
+            pp_separate_with_comma (cxx_pp);
+          
+          if (!arg)
+            pp_identifier (cxx_pp, "<template parameter error>");
+          else
+            dump_template_argument (arg, flags);
+        }
     }
   else if (primary)
     {
@@ -1879,6 +1901,11 @@ dump_expr (tree t, int flags)
       dump_expr (TREE_OPERAND (t, 0), flags);
       break;
 
+    case PACK_UNPACK_EXPR:
+      dump_expr (PACK_UNPACK_PATTERN (t), flags);
+      pp_cxx_identifier (cxx_pp, "...");
+      break;
+
       /*  This list is incomplete, but should suffice for now.
 	  It is very important that `sorry' does not call
 	  `report_error_function'.  That could cause an infinite loop.  */
Index: gcc/cp/operators.def
===================================================================
--- gcc/cp/operators.def	(.../vendor/gcc-4.1.1)	(revision 425)
+++ gcc/cp/operators.def	(.../branches/variadic-templates)	(revision 425)
@@ -156,3 +156,6 @@ DEF_SIMPLE_OPERATOR ("?:", COND_EXPR, "q
 
 /* Miscellaneous.  */
 DEF_SIMPLE_OPERATOR ("()", CALL_EXPR, "cl", -1)
+
+/* Variadic templates extension. */
+DEF_SIMPLE_OPERATOR ("...", PACK_UNPACK_EXPR, "pu", 1)
Index: gcc/cp/mangle.c
===================================================================
--- gcc/cp/mangle.c	(.../vendor/gcc-4.1.1)	(revision 425)
+++ gcc/cp/mangle.c	(.../branches/variadic-templates)	(revision 425)
@@ -1647,6 +1647,11 @@ write_type (tree type)
 	  write_type (TREE_TYPE (type));
 	  break;
 
+        case PACK_UNPACK_TYPE:
+          write_string ("U10__variadic");
+          write_type (PACK_UNPACK_PATTERN (type));
+          break;
+
 	default:
 	  gcc_unreachable ();
 	}
@@ -2280,7 +2285,15 @@ write_template_arg (tree node)
 	G.need_abi_warning = 1;
     }
 
-  if (TYPE_P (node))
+  if (ARGUMENT_PACK_P (node))
+    {
+      /* Expand the template argument pack. */
+      tree args = ARGUMENT_PACK_ARGS (node);
+      int i, length = TREE_VEC_LENGTH (args);
+      for (i = 0; i < length; ++i)
+        write_template_arg (TREE_VEC_ELT (args, i));
+    }
+  else if (TYPE_P (node))
     write_type (node);
   else if (code == TEMPLATE_DECL)
     /* A template appearing as a template arg is a template template arg.  */
Index: gcc/cp/cp-tree.h
===================================================================
--- gcc/cp/cp-tree.h	(.../vendor/gcc-4.1.1)	(revision 425)
+++ gcc/cp/cp-tree.h	(.../branches/variadic-templates)	(revision 425)
@@ -100,6 +100,7 @@ struct diagnostic_context;
    1: C_TYPEDEF_EXPLICITLY_SIGNED (in TYPE_DECL).
       DECL_TEMPLATE_INSTANTIATED (in a VAR_DECL or a FUNCTION_DECL)
       DECL_MEMBER_TEMPLATE_P (in TEMPLATE_DECL)
+      FUNCTION_PARAMETER_PACK_P (in PARM_DECL)
    2: DECL_THIS_EXTERN (in VAR_DECL or FUNCTION_DECL).
       DECL_IMPLICIT_TYPEDEF_P (in a TYPE_DECL)
    3: DECL_IN_AGGR_P.
@@ -219,6 +220,10 @@ struct template_parm_index_s GTY(())
   HOST_WIDE_INT level;
   HOST_WIDE_INT orig_level;
   tree decl;
+
+  /* When true, indicates that this parameter is actually a parameter
+     pack, for variadic templates. */
+  BOOL_BITFIELD parameter_pack;
 };
 typedef struct template_parm_index_s template_parm_index;
 
@@ -2151,7 +2156,7 @@ extern void decl_shadowed_for_var_insert
 /* Nonzero if the template arguments is actually a vector of vectors,
    rather than just a vector.  */
 #define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE)		\
-  (NODE && TREE_VEC_ELT (NODE, 0)			\
+  (NODE && TREE_VEC_ELT (NODE, 0)                       \
    && TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC)
 
 /* The depth of a template argument vector.  When called directly by
@@ -2248,6 +2253,63 @@ extern void decl_shadowed_for_var_insert
    the class definition is complete.  */
 #define TEMPLATE_PARMS_FOR_INLINE(NODE) TREE_LANG_FLAG_1 (NODE)
 
+/* Determine if a parameter is a function parameter pack. */
+#define FUNCTION_PARAMETER_PACK_P(NODE) \
+  (DECL_LANG_FLAG_1 (PARM_DECL_CHECK (NODE)))
+
+/* Determines if NODE is a PACK_UNPACK_TYPE or PACK_UNPACK_EXPR. */
+#define PACK_UNPACK_P(NODE)                     \
+  (TREE_CODE (NODE) == PACK_UNPACK_TYPE         \
+   || TREE_CODE (NODE) == PACK_UNPACK_EXPR)
+
+/* Extracts the type or expression pattern from a PACK_UNPACK_TYPE or
+   PACK_UNPACK_EXPR. */
+#define PACK_UNPACK_PATTERN(NODE)                               \
+  (TREE_CODE (NODE) == PACK_UNPACK_TYPE? TREE_TYPE (NODE)       \
+   : TREE_OPERAND (NODE, 0))
+
+/* Sets the type or expression pattern for a PACK_UNPACK_TYPE or
+   PACK_UNPACK_EXPR. */
+#define SET_PACK_UNPACK_PATTERN(NODE,VALUE)     \
+  if (TREE_CODE (NODE) == PACK_UNPACK_TYPE)     \
+    TREE_TYPE (NODE) = VALUE;                   \
+  else                                          \
+    TREE_OPERAND (NODE, 0) = VALUE
+
+/* The list of parameter packs used in the PACK_UNPACK_* node. */
+#define PACK_UNPACK_PARAMETER_PACKS(NODE) TREE_CHAIN (NODE)
+
+/* Determine if this is an argument pack. */
+#define ARGUMENT_PACK_P(NODE)                          \
+  (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK              \
+   || TREE_CODE (NODE) == NONTYPE_ARGUMENT_PACK)
+
+/* The arguments stored in an argument pack. */
+#define ARGUMENT_PACK_ARGS(NODE)                               \
+  (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK? TREE_TYPE (NODE)    \
+   : TREE_OPERAND (NODE, 0))
+
+/* Set the arguments stored in an argument pack. */
+#define SET_ARGUMENT_PACK_ARGS(NODE,VALUE)     \
+  if (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK)  \
+    TREE_TYPE (NODE) = VALUE;                           \
+  else                                                  \
+    TREE_OPERAND (NODE, 0) = VALUE
+
+/* Whether the argument pack is "incomplete", meaning that more
+   arguments can still be deduced. Incomplete argument packs are only
+   used when the user has provided an explicit template argument list
+   for a variadic function template. Some of the explicit template
+   arguments will be placed into the beginning of the argument pack,
+   but additional arguments might still be deduced. */
+#define ARGUMENT_PACK_INCOMPLETE_P(NODE)        \
+  TREE_LANG_FLAG_0 (ARGUMENT_PACK_ARGS (NODE))
+
+/* When ARGUMENT_PACK_INCOMPLETE_P, stores the explicit template
+   arguments used to fill this pack. */
+#define ARGUMENT_PACK_EXPLICIT_ARGS(NODE)       \
+  TREE_TYPE (ARGUMENT_PACK_ARGS (NODE))
+
 /* In a FUNCTION_DECL, the saved language-specific per-function data.  */
 #define DECL_SAVED_FUNCTION_DATA(NODE)			\
   (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (NODE))	\
@@ -3422,6 +3484,7 @@ enum overload_flags { NO_SPECIAL = 0, DT
 #define TEMPLATE_PARM_DESCENDANTS(NODE) (TREE_CHAIN (NODE))
 #define TEMPLATE_PARM_ORIG_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->orig_level)
 #define TEMPLATE_PARM_DECL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->decl)
+#define TEMPLATE_PARM_PARAMETER_PACK(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->parameter_pack)
 
 /* These macros are for accessing the fields of TEMPLATE_TYPE_PARM,
    TEMPLATE_TEMPLATE_PARM and BOUND_TEMPLATE_TEMPLATE_PARM nodes.  */
@@ -3436,6 +3499,8 @@ enum overload_flags { NO_SPECIAL = 0, DT
   (TEMPLATE_PARM_ORIG_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE)))
 #define TEMPLATE_TYPE_DECL(NODE) \
   (TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (NODE)))
+#define TEMPLATE_TYPE_PARAMETER_PACK(NODE) \
+  (TEMPLATE_PARM_PARAMETER_PACK (TEMPLATE_TYPE_PARM_INDEX (NODE)))
 
 /* These constants can used as bit flags in the process of tree formatting.
 
@@ -3618,6 +3683,9 @@ struct cp_declarator {
      cdk_id and cdk_error, guaranteed to be NULL.  */
   cp_declarator *declarator;
   location_t id_loc; /* Currently only set for cdk_id. */
+  /* Whether we parsed an ellipsis (`...') just before the declarator,
+     to indicate this is a pack/unpack parameter. */
+  bool pack_unpack_p;
   union {
     /* For identifiers.  */
     struct {
@@ -4012,7 +4080,7 @@ extern void end_specialization			(void);
 extern void begin_explicit_instantiation	(void);
 extern void end_explicit_instantiation		(void);
 extern tree check_explicit_specialization	(tree, tree, int, int);
-extern tree process_template_parm		(tree, tree, bool);
+extern tree process_template_parm		(tree, tree, bool, bool);
 extern tree end_template_parm_list		(tree);
 extern void end_template_decl			(void);
 extern tree current_template_args		(void);
@@ -4038,6 +4106,10 @@ extern int push_tinst_level			(tree);
 extern void pop_tinst_level			(void);
 extern int more_specialized_class		(tree, tree);
 extern int comp_template_parms			(tree, tree);
+extern bool uses_parameter_packs                (tree);
+extern bool template_parms_variadic_p           (tree);
+extern tree make_argument_pack_unpack           (tree);
+extern void check_for_bare_parameter_packs      (tree);
 extern int template_class_depth			(tree);
 extern int is_specialization_of			(tree, tree);
 extern bool is_specialization_of_friend		(tree, tree);
Index: gcc/cp/pt.c
===================================================================
--- gcc/cp/pt.c	(.../vendor/gcc-4.1.1)	(revision 425)
+++ gcc/cp/pt.c	(.../branches/variadic-templates)	(revision 425)
@@ -117,6 +117,7 @@ static tree convert_template_argument (t
 				       tsubst_flags_t, int, tree);
 static int for_each_template_parm (tree, tree_fn_t, void*,
 				   struct pointer_set_t*);
+static tree expand_template_argument_pack (tree);
 static tree build_template_parm_index (int, int, int, tree, tree);
 static int inline_needs_template_parms (tree);
 static void push_inline_template_parms_recursive (tree, int);
@@ -131,6 +132,8 @@ static int can_complete_type_without_cir
 static tree get_bindings (tree, tree, tree, bool);
 static int template_decl_level (tree);
 static int check_cv_quals_for_unify (int, tree, tree);
+static void template_parm_level_and_index (tree, int*, int*);
+static int unify_with_pack_expr (tree, tree, tree, tree, int, bool, bool);
 static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
 static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
 static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
@@ -158,10 +161,13 @@ static tree copy_default_args_to_explici
 static void copy_default_args_to_explicit_spec (tree);
 static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
 static int eq_local_specializations (const void *, const void *);
+static bool dependent_template_arg_p (tree);
 static bool dependent_type_p_r (tree);
 static tree tsubst (tree, tree, tsubst_flags_t, tree);
 static tree tsubst_expr	(tree, tree, tsubst_flags_t, tree);
 static tree tsubst_copy	(tree, tree, tsubst_flags_t, tree);
+static tree tsubst_argument_pack (tree, tree, tsubst_flags_t, tree);
+static tree make_ith_pack_parameter_name (tree, int);
 
 /* Make the current scope suitable for access checking when we are
    processing T.  T can be FUNCTION_DECL for instantiated function
@@ -2201,7 +2207,9 @@ comp_template_parms (tree parms1, tree p
 	  if (TREE_CODE (parm1) != TREE_CODE (parm2))
 	    return 0;
 
-	  if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM)
+	  if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM
+              && (TEMPLATE_TYPE_PARAMETER_PACK (parm1)
+                  == TEMPLATE_TYPE_PARAMETER_PACK (parm2)))
 	    continue;
 	  else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
 	    return 0;
@@ -2216,6 +2224,395 @@ comp_template_parms (tree parms1, tree p
   return 1;
 }
 
+/* Determine whether PARMS describes a variadic template parameter
+   list, i.e., one that is terminated by a template parameter pack. */
+bool 
+template_parms_variadic_p (tree parms)
+{
+  int nparms = TREE_VEC_LENGTH (parms);
+  tree last_parm = TREE_VALUE (TREE_VEC_ELT (parms, nparms - 1));
+
+  /* Determine if we have a non-type template parameter pack. */
+  if (TREE_CODE (last_parm) == PARM_DECL)
+    return (DECL_TEMPLATE_PARM_P (last_parm) 
+            && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (last_parm)));
+
+  return ((TREE_CODE (last_parm) == TYPE_DECL
+           || TREE_CODE (last_parm) == TEMPLATE_DECL)
+          && (TREE_CODE (TREE_TYPE (last_parm)) == TEMPLATE_TYPE_PARM
+              || TREE_CODE (TREE_TYPE (last_parm)) == TEMPLATE_TEMPLATE_PARM)
+          && TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (last_parm)));
+}
+
+/* Determine whether ARGS describes a variadic template args list,
+   i.e., one that is terminated by a template argument pack. */
+static bool 
+template_args_variadic_p (tree args)
+{
+  int nargs;
+  tree last_parm;
+
+  if (args == NULL_TREE)
+    return false;
+
+  args = INNERMOST_TEMPLATE_ARGS (args);
+  nargs = TREE_VEC_LENGTH (args);
+
+  if (nargs == 0)
+    return false;
+
+  last_parm = TREE_VEC_ELT (args, nargs - 1);
+
+  return ARGUMENT_PACK_P (last_parm);
+}
+
+/* Generate a new name for the parameter pack name NAME (an
+   IDENTIFIER_NODE) that incorporates its */
+tree
+make_ith_pack_parameter_name (tree name, int i)
+{
+  /* Munge the name to include the parameter index. */
+  char numbuf[128];
+  char* newname;
+  
+  sprintf(numbuf, "%i", i);
+  newname = (char*)alloca (IDENTIFIER_LENGTH (name) + strlen(numbuf) + 2);
+  sprintf(newname, "%s#%i", IDENTIFIER_POINTER (name), i);
+  return get_identifier (newname);
+}
+
+/* Structure used to track the progress of find_parameter_pack_r. */
+struct find_parameter_pack_data 
+{
+  tree* parameter_packs;
+  struct pointer_set_t *visited;
+};
+
+/* Identifiers all of the argument packs that occur in a template
+   argument and appends them to the TREE_LIST inside DATA, which is a
+   find_parameter_pack_Data structure. This is a subroutine of
+   make_argument_pack_unpack and uses_parameter_packs. */
+static tree
+find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data)
+{
+  tree t = *tp;
+  struct find_parameter_pack_data* ppd = 
+    (struct find_parameter_pack_data*)data;
+
+  if (TYPE_P (t))
+    {
+      tree context = TYPE_CONTEXT (t);
+      walk_tree (&context, &find_parameter_packs_r, ppd, ppd->visited);
+    }
+
+  /* We only want to deal with the underlying TEMPLATE_TEMPLATE_PARM. */
+  if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
+    {
+      t = TYPE_TI_TEMPLATE (t);
+      if (DECL_P (t) && TREE_TYPE (t))
+        t = TREE_TYPE (t);
+    }
+
+  /* This switch statement will return immediately if we don't find a
+     parameter pack. */
+  switch (TREE_CODE (t)) 
+    {
+    case TEMPLATE_PARM_INDEX:
+      if (TEMPLATE_PARM_PARAMETER_PACK (t))
+        break;
+      return NULL_TREE;
+
+    case TEMPLATE_TYPE_PARM:
+    case TEMPLATE_TEMPLATE_PARM:
+      if (TEMPLATE_TYPE_PARAMETER_PACK (t))
+        break;
+      return NULL_TREE;
+
+    case PARM_DECL:
+      if (FUNCTION_PARAMETER_PACK_P (t))
+        {
+          /* We don't want to walk into the type of a PARM_DECL,
+             because we don't want to see the type parameter pack.*/
+          *walk_subtrees = 0;
+          break;
+        }
+      return NULL_TREE;
+
+    case RECORD_TYPE:
+      if (TYPE_PTRMEMFUNC_P (t))
+	return NULL_TREE;
+      /* Fall through.  */
+
+    case UNION_TYPE:
+    case ENUMERAL_TYPE:
+      if (TYPE_TEMPLATE_INFO (t))
+        {
+          tree args = TREE_VALUE (TYPE_TEMPLATE_INFO (t));
+          walk_tree (&args, &find_parameter_packs_r, ppd, ppd->visited);
+        }
+      else
+	*walk_subtrees = 0;
+      return NULL_TREE;
+
+    case TEMPLATE_DECL:
+      if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
+        {
+          tree type = TREE_TYPE (t);
+          walk_tree (&type, &find_parameter_packs_r, ppd, ppd->visited);
+        }
+      else
+        *walk_subtrees = 0;
+      return NULL_TREE;
+      
+    case BASELINK:
+      /* If we do not handle this case specially, we end up walking
+	 the BINFO hierarchy, which is circular, and therefore
+	 confuses walk_tree.  */
+      *walk_subtrees = 0;
+      t = BASELINK_FUNCTIONS (t);
+      walk_tree (&t, &find_parameter_packs_r, ppd, ppd->visited);
+      return NULL_TREE;
+      
+    case TYPE_ARGUMENT_PACK:
+    case NONTYPE_ARGUMENT_PACK:
+      {
+        tree args = ARGUMENT_PACK_ARGS (t);
+        int i, len = TREE_VEC_LENGTH (args);
+        for (i = 0; i < len; i++) 
+          walk_tree (&TREE_VEC_ELT (args, i), &find_parameter_packs_r, 
+                     ppd, ppd->visited);
+      }
+      *walk_subtrees = 0;
+      return NULL_TREE;
+
+    case PACK_UNPACK_TYPE:
+    case PACK_UNPACK_EXPR:
+      *walk_subtrees = 0;
+      return NULL_TREE;
+
+    case CAST_EXPR:
+      if (TREE_TYPE (t))
+        walk_tree (&TREE_TYPE (t), &find_parameter_packs_r, ppd, ppd->visited);
+
+      {
+        int i;
+        for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (t)); ++i)
+          walk_tree (&TREE_OPERAND (t, i), &find_parameter_packs_r, 
+                     ppd, ppd->visited);
+      }
+      *walk_subtrees = 0;
+      return NULL_TREE;
+
+    default:
+      return NULL_TREE;
+    }
+  
+  /* Add this parameter pack to the list. */
+  *ppd->parameter_packs = tree_cons (NULL_TREE, t, *ppd->parameter_packs);
+
+  return NULL_TREE;
+}
+
+/* Determines if the expression or type T uses any parameter packs. */
+bool
+uses_parameter_packs (tree t)
+{
+  tree parameter_packs = NULL_TREE;
+  struct find_parameter_pack_data ppd;
+  ppd.parameter_packs = &parameter_packs;
+  ppd.visited = pointer_set_create ();
+  walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
+  return parameter_packs != NULL_TREE;
+}
+
+/* Turn ARG into the template argument unpacking expression
+   (PACK_UNPACK_EXPR) or type (PACK_UNPACK_TYPE). Returns the
+   unpacking expression or type. */
+tree 
+make_argument_pack_unpack (tree arg)
+{
+  tree result;
+  tree parameter_packs = NULL_TREE;
+  bool for_types = false;
+  struct find_parameter_pack_data ppd;
+
+  if (!arg || arg == error_mark_node)
+    return arg;
+
+  if (TREE_CODE (arg) == TREE_LIST)
+    {
+      /* The only time we will see a TREE_LIST here is for a base
+         class initializer. In this case, the TREE_PURPOSE will be a
+         _TYPE node (representing the base class expansion we're
+         initializing) and the TREE_VALUE will be a TREE_LIST
+         containing the initialization arguments. */
+      tree purpose;
+      tree value;
+      tree parameter_packs = NULL_TREE;
+
+      /* Determine which parameter packs will be used by the base
+         class expansion. */
+      ppd.visited = pointer_set_create ();
+      ppd.parameter_packs = &parameter_packs;
+      walk_tree (&TREE_PURPOSE (arg), &find_parameter_packs_r, 
+                 &ppd, ppd.visited);
+
+      if (parameter_packs == NULL_TREE)
+        {
+          error ("base initializer expansion %<%T%> contains no parameter packs", arg);
+          return error_mark_node;
+        }
+
+      /* Collect the sets of parameter packs used in each of the
+         initialization arguments. */
+      for (value = TREE_VALUE (arg); value; value = TREE_CHAIN (value))
+        {
+          /* Determine which parameter packs will be expanded in this
+             argument. */
+          walk_tree (&TREE_VALUE (value), &find_parameter_packs_r, 
+                     &ppd, ppd.visited);
+        }
+
+      /* Create the pack/unpack type for the base type. */
+      purpose = make_node (PACK_UNPACK_TYPE);
+      SET_PACK_UNPACK_PATTERN (purpose, TREE_PURPOSE (arg));
+      PACK_UNPACK_PARAMETER_PACKS (purpose) = parameter_packs;
+      
+      return tree_cons (purpose, TREE_VALUE (arg), NULL_TREE);
+    }
+
+  if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
+    for_types = true;
+
+  /* Build the PACK_UNPACK_* node. */
+  result = make_node (for_types? PACK_UNPACK_TYPE : PACK_UNPACK_EXPR);
+  SET_PACK_UNPACK_PATTERN (result, arg);
+  if (TREE_CODE (result) == PACK_UNPACK_EXPR)
+    {
+      TREE_TYPE (result) = TREE_TYPE (arg);
+      TREE_CONSTANT (result) = TREE_CONSTANT (arg);
+    }
+
+  /* Determine which parameter packs will be expanded. */
+  ppd.parameter_packs = &parameter_packs;
+  ppd.visited = pointer_set_create ();
+  walk_tree (&arg, &find_parameter_packs_r, &ppd, ppd.visited);
+
+  /* Make sure we found some parameter packs. */
+  if (parameter_packs == NULL_TREE)
+    {
+      if (TYPE_P (arg))
+        error ("unpacking pattern %<%T%> contains no argument packs", arg);
+      else
+        error ("unpacking pattern %<%E%> contains no argument packs", arg);
+      return error_mark_node;
+    }
+  PACK_UNPACK_PARAMETER_PACKS (result) = parameter_packs;
+
+  return result;
+}
+
+/* Checks T for any "bare" parameter packs, which have not yet been
+   unpacked, and issues an error if any are found. This operation can
+   only be done at a very coarse granularity (e.g., an expression
+   statement, "if" condition, etc.), because we could have expressions like:
+
+     foo(f(g(h(args)))...)
+
+   where "args" is a parameter pack. check_for_bare_parameter_packs
+   should not be called for the subexpressions args, h(args),
+   g(h(args)), or f(g(h(args))), because we would produce erroneous
+   error messages. */
+void 
+check_for_bare_parameter_packs (tree t)
+{
+  tree parameter_packs = NULL_TREE;
+  struct find_parameter_pack_data ppd;
+
+  if (!processing_template_decl || !t || t == error_mark_node)
+    return;
+
+  if (TREE_CODE (t) == TYPE_DECL)
+    t = TREE_TYPE (t);
+
+  ppd.parameter_packs = &parameter_packs;
+  ppd.visited = pointer_set_create ();
+  walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
+
+  if (parameter_packs) {
+    error ("parameter packs not unpacked with `...':");
+    while (parameter_packs)
+      {
+        tree pack = TREE_VALUE (parameter_packs);
+        tree name = NULL_TREE;
+
+        if (TREE_CODE (pack) == TEMPLATE_TYPE_PARM
+            || TREE_CODE (pack) == TEMPLATE_TEMPLATE_PARM)
+          name = TYPE_NAME (pack);
+        else
+          name = DECL_NAME (pack);
+        inform ("        %qD", name);
+
+        parameter_packs = TREE_CHAIN (parameter_packs);
+      }
+  }
+}
+
+/* Expand any parameter packs that occur in the template arguments in
+   ARGS. */
+tree
+expand_template_argument_pack (tree args)
+{
+  tree result_args = NULL_TREE;
+  int in_arg, out_arg = 0, nargs = args? TREE_VEC_LENGTH (args) : 0;
+  int num_result_args = -1;
+
+  /* First, determine if we need to expand anything, and the number of
+     slots we'll need. */
+  for (in_arg = 0; in_arg < nargs; ++in_arg)
+    {
+      tree arg = TREE_VEC_ELT (args, in_arg);
+      if (ARGUMENT_PACK_P (arg))
+        {
+          int num_packed = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg));
+          if (num_result_args < 0)
+            num_result_args = in_arg + num_packed;
+          else
+            num_result_args += num_packed;
+        }
+      else
+        {
+          if (num_result_args >= 0)
+            num_result_args++;
+        }
+    }
+
+  /* If no expansion is necessary, we're done. */
+  if (num_result_args < 0)
+    return args;
+
+  /* Expand arguments. */
+  result_args = make_tree_vec (num_result_args);
+  for (in_arg = 0; in_arg < nargs; ++in_arg)
+    {
+      tree arg = TREE_VEC_ELT (args, in_arg);
+      if (ARGUMENT_PACK_P (arg))
+        {
+          tree packed = ARGUMENT_PACK_ARGS (arg);
+          int i, num_packed = TREE_VEC_LENGTH (packed);
+          for (i = 0; i < num_packed; ++i, ++out_arg)
+            TREE_VEC_ELT (result_args, out_arg) = TREE_VEC_ELT(packed, i);
+        }
+      else
+        {
+          TREE_VEC_ELT (result_args, out_arg) = arg;
+          ++out_arg;
+        }
+    }
+
+  return result_args;
+}
+
 /* Complain if DECL shadows a template parameter.
 
    [temp.local]: A template-parameter shall not be redeclared within its
@@ -2309,6 +2706,7 @@ reduce_template_parm_level (tree index, 
 				     TEMPLATE_PARM_ORIG_LEVEL (index),
 				     decl, type);
       TEMPLATE_PARM_DESCENDANTS (index) = t;
+      TEMPLATE_PARM_PARAMETER_PACK (t) = TEMPLATE_PARM_PARAMETER_PACK (index);
 
 	/* Template template parameters need this.  */
       if (TREE_CODE (decl) != CONST_DECL)
@@ -2319,12 +2717,14 @@ reduce_template_parm_level (tree index, 
   return TEMPLATE_PARM_DESCENDANTS (index);
 }
 
-/* Process information from new template parameter NEXT and append it to the
-   LIST being built.  This new parameter is a non-type parameter iff
-   IS_NON_TYPE is true.  */
+/* Process information from new template parameter NEXT and append it
+   to the LIST being built.  This new parameter is a non-type
+   parameter iff IS_NON_TYPE is true. This new parameter is a parameter
+   pack iff IS_PARAMETER_PACK is true. */
 
 tree
-process_template_parm (tree list, tree next, bool is_non_type)
+process_template_parm (tree list, tree next, bool is_non_type, 
+                       bool is_parameter_pack)
 {
   tree parm;
   tree decl = 0;
@@ -2374,6 +2774,8 @@ process_template_parm (tree list, tree n
 	= build_template_parm_index (idx, processing_template_decl,
 				     processing_template_decl,
 				     decl, TREE_TYPE (parm));
+
+      TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)) = is_parameter_pack;
     }
   else
     {
@@ -2403,6 +2805,7 @@ process_template_parm (tree list, tree n
 	= build_template_parm_index (idx, processing_template_decl,
 				     processing_template_decl,
 				     decl, TREE_TYPE (parm));
+      TEMPLATE_TYPE_PARAMETER_PACK (t) = is_parameter_pack;
     }
   DECL_ARTIFICIAL (decl) = 1;
   SET_DECL_TEMPLATE_PARM_P (decl);
@@ -2492,10 +2895,38 @@ current_template_args (void)
 
 	      if (TREE_CODE (t) == TYPE_DECL
 		  || TREE_CODE (t) == TEMPLATE_DECL)
-		t = TREE_TYPE (t);
-	      else
-		t = DECL_INITIAL (t);
-	      TREE_VEC_ELT (a, i) = t;
+                {
+                  t = TREE_TYPE (t);
+
+                  if (TEMPLATE_TYPE_PARAMETER_PACK (t))
+                    {
+                      /* Turn this argument into a TYPE_ARGUMENT_PACK
+                         with a single element, which unpacks T. */
+                      tree vec = make_tree_vec (1);
+                      TREE_VEC_ELT (vec, 0) = make_argument_pack_unpack (t);
+
+                      t = make_node (TYPE_ARGUMENT_PACK);
+                      SET_ARGUMENT_PACK_ARGS (t, vec);
+                    }
+                }
+              else
+                {
+                  t = DECL_INITIAL (t);
+
+                  if (TEMPLATE_PARM_PARAMETER_PACK (t))
+                    {
+                      /* Turn this argument into a NONTYPE_ARGUMENT_PACK
+                         with a single element, which unpacks T. */
+                      tree vec = make_tree_vec (1);
+                      tree type = TREE_TYPE (TEMPLATE_PARM_DECL (t));
+                      TREE_VEC_ELT (vec, 0) = make_argument_pack_unpack (t);
+                      
+                      t  = make_node (NONTYPE_ARGUMENT_PACK);
+                      SET_ARGUMENT_PACK_ARGS (t, vec);
+                      TREE_TYPE (t) = type;
+                    }
+                }
+              TREE_VEC_ELT (a, i) = t;
 	    }
 	}
 
@@ -2684,74 +3115,114 @@ process_partial_specialization (tree dec
 
      The type of a template parameter corresponding to a specialized
      non-type argument shall not be dependent on a parameter of the
-     specialization.  */
+     specialization.  
+
+     Also, we verify that pack/unpack expressions only occur at the
+     end of the argument list. */
   gcc_assert (nargs == DECL_NTPARMS (maintmpl));
   tpd2.parms = 0;
   for (i = 0; i < nargs; ++i)
     {
+      tree parm = TREE_VALUE (TREE_VEC_ELT (main_inner_parms, i));
       tree arg = TREE_VEC_ELT (inner_args, i);
-      if (/* These first two lines are the `non-type' bit.  */
-	  !TYPE_P (arg)
-	  && TREE_CODE (arg) != TEMPLATE_DECL
-	  /* This next line is the `argument expression is not just a
-	     simple identifier' condition and also the `specialized
-	     non-type argument' bit.  */
-	  && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
-	{
-	  if (tpd.arg_uses_template_parms[i])
-	    error ("template argument %qE involves template parameter(s)", arg);
-	  else
-	    {
-	      /* Look at the corresponding template parameter,
-		 marking which template parameters its type depends
-		 upon.  */
-	      tree type =
-		TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms,
-						     i)));
-
-	      if (!tpd2.parms)
-		{
-		  /* We haven't yet initialized TPD2.  Do so now.  */
-		  tpd2.arg_uses_template_parms
-		    = alloca (sizeof (int) * nargs);
-		  /* The number of parameters here is the number in the
-		     main template, which, as checked in the assertion
-		     above, is NARGS.  */
-		  tpd2.parms = alloca (sizeof (int) * nargs);
-		  tpd2.level =
-		    TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
-		}
+      tree packed_args = NULL_TREE;
+      int j, len = 1;
 
-	      /* Mark the template parameters.  But this time, we're
-		 looking for the template parameters of the main
-		 template, not in the specialization.  */
-	      tpd2.current_arg = i;
-	      tpd2.arg_uses_template_parms[i] = 0;
-	      memset (tpd2.parms, 0, sizeof (int) * nargs);
-	      for_each_template_parm (type,
-				      &mark_template_parm,
-				      &tpd2,
-				      NULL);
-
-	      if (tpd2.arg_uses_template_parms [i])
-		{
-		  /* The type depended on some template parameters.
-		     If they are fully specialized in the
-		     specialization, that's OK.  */
-		  int j;
-		  for (j = 0; j < nargs; ++j)
-		    if (tpd2.parms[j] != 0
-			&& tpd.arg_uses_template_parms [j])
-		      {
-			error ("type %qT of template argument %qE depends "
-			       "on template parameter(s)",
-			       type,
-			       arg);
-			break;
-		      }
-		}
-	    }
-	}
+      if (ARGUMENT_PACK_P (arg))
+        {
+          /* Extract the arguments from the argument pack. We'll be
+             iterating over these in the following loop. */
+          packed_args = ARGUMENT_PACK_ARGS (arg);
+          len = TREE_VEC_LENGTH (packed_args);
+        }
+
+      for (j = 0; j < len; j++)
+        {
+          if (packed_args)
+            /* Get the Jth argument in the parameter pack. */
+            arg = TREE_VEC_ELT (packed_args, j);
+
+          if (PACK_UNPACK_P (arg))
+            {
+              /* Pack/unpack expressions must come at the end of the
+                 argument list. */
+              if ((packed_args && j < len - 1)
+                  || (!packed_args && i < nargs - 1))
+                {
+                  if (TREE_CODE (arg) == PACK_UNPACK_EXPR)
+                    error ("parameter pack argument %qE must be at the end of the template argument list", arg);
+                  else
+                    error ("parameter pack argument %qT must be at the end of the template argument list", arg);                   
+                }
+            }
+
+          if (TREE_CODE (arg) == PACK_UNPACK_EXPR)
+            /* We only care about the pattern. */
+            arg = PACK_UNPACK_PATTERN (arg);
+
+          if (/* These first two lines are the `non-type' bit.  */
+              !TYPE_P (arg)
+              && TREE_CODE (arg) != TEMPLATE_DECL
+              /* This next line is the `argument expression is not just a
+                 simple identifier' condition and also the `specialized
+                 non-type argument' bit.  */
+              && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
+            {
+              if ((!packed_args && tpd.arg_uses_template_parms[i])
+                  || (packed_args && uses_template_parms (arg)))
+                error ("template argument %qE involves template parameter(s)",
+                       arg);
+              else 
+                {
+                  /* Look at the corresponding template parameter,
+                     marking which template parameters its type depends
+                     upon.  */
+                  tree type = TREE_TYPE (parm);
+
+                  if (!tpd2.parms)
+                    {
+                      /* We haven't yet initialized TPD2.  Do so now.  */
+                      tpd2.arg_uses_template_parms 
+                        = alloca (sizeof (int) * nargs);
+                      /* The number of parameters here is the number in the
+                         main template, which, as checked in the assertion
+                         above, is NARGS.  */
+                      tpd2.parms = alloca (sizeof (int) * nargs);
+                      tpd2.level = 
+                        TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
+                    }
+
+                  /* Mark the template parameters.  But this time, we're
+                     looking for the template parameters of the main
+                     template, not in the specialization.  */
+                  tpd2.current_arg = i;
+                  tpd2.arg_uses_template_parms[i] = 0;
+                  memset (tpd2.parms, 0, sizeof (int) * nargs);
+                  for_each_template_parm (type,
+                                          &mark_template_parm,
+                                          &tpd2,
+                                          NULL);
+
+                  if (tpd2.arg_uses_template_parms [i])
+                    {
+                      /* The type depended on some template parameters.
+                         If they are fully specialized in the
+                         specialization, that's OK.  */
+                      int j;
+                      for (j = 0; j < nargs; ++j)
+                        if (tpd2.parms[j] != 0
+                            && tpd.arg_uses_template_parms [j])
+                          {
+                            error ("type %qT of template argument %qE depends "
+                                   "on template parameter(s)", 
+                                   type,
+                                   arg);
+                            break;
+                          }
+                    }
+                }
+            }
+        }
     }
 
   if (retrieve_specialization (maintmpl, specargs,
@@ -3031,9 +3502,37 @@ push_template_decl_real (tree decl, bool
   check_default_tmpl_args (decl, current_template_parms,
 			   primary, is_partial);
 
+  /* Ensure that there are no parameter packs in the type of this
+     declaration that have not been unpacked. */
+  check_for_bare_parameter_packs (TREE_TYPE (decl));
+
   if (is_partial)
     return process_partial_specialization (decl);
 
+  /* A primary class template can only have one parameter pack, at the
+     end of the template parameter list. */
+  if (primary && TREE_CODE (decl) == TYPE_DECL)
+    {
+      tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
+      int i, len = TREE_VEC_LENGTH (inner_parms);
+      for (i = 0; i < len - 1; i++)
+        {
+          tree parm = TREE_VALUE (TREE_VEC_ELT (inner_parms, i));
+
+          if (TREE_CODE (parm) == TYPE_DECL)
+            parm = TREE_TYPE (parm);
+
+          if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
+               || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
+              && TEMPLATE_TYPE_PARAMETER_PACK (parm))
+            error ("parameter pack %qT must be at the end of the template parameter list", parm);
+          else if (TREE_CODE (parm) == PARM_DECL
+                   && DECL_TEMPLATE_PARM_P (parm)
+                   && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
+            error ("parameter pack %qE must be at the end of the template parameter list", parm);
+        }
+    }
+
   args = current_template_args ();
 
   if (!ctx
@@ -3829,6 +4328,7 @@ convert_template_argument (tree parm,
   tree val;
   tree inner_args;
   int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
+  tree check_arg = arg;
 
   inner_args = INNERMOST_TEMPLATE_ARGS (args);
 
@@ -3848,10 +4348,16 @@ convert_template_argument (tree parm,
   requires_type = (TREE_CODE (parm) == TYPE_DECL
 		   || requires_tmpl_type);
 
-  is_tmpl_type = ((TREE_CODE (arg) == TEMPLATE_DECL
-		   && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
-		  || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
-		  || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
+  /* When determining whether a argument pack/unpack is a template,
+     look at the pattern. */
+  if (TREE_CODE (check_arg) == PACK_UNPACK_TYPE)
+    check_arg = PACK_UNPACK_PATTERN (check_arg);
+
+  is_tmpl_type = 
+    ((TREE_CODE (check_arg) == TEMPLATE_DECL
+      && TREE_CODE (DECL_TEMPLATE_RESULT (check_arg)) == TYPE_DECL)
+     || TREE_CODE (check_arg) == TEMPLATE_TEMPLATE_PARM
+     || TREE_CODE (check_arg) == UNBOUND_CLASS_TEMPLATE);
 
   if (is_tmpl_type
       && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
@@ -3919,7 +4425,15 @@ convert_template_argument (tree parm,
 	  else
 	    {
 	      tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
-	      tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
+	      tree argparm;
+
+              check_arg = arg;
+              /* When determining whether a argument pack/unpack is a template,
+                 look at the pattern. */
+              if (TREE_CODE (check_arg) == PACK_UNPACK_TYPE)
+                check_arg = PACK_UNPACK_PATTERN (check_arg);
+
+              argparm = DECL_INNERMOST_TEMPLATE_PARMS (check_arg);
 
 	      if (coerce_template_template_parms (parmparm, argparm,
 						  complain, in_decl,
@@ -3929,9 +4443,17 @@ convert_template_argument (tree parm,
 
 		  /* TEMPLATE_TEMPLATE_PARM node is preferred over
 		     TEMPLATE_DECL.  */
-		  if (val != error_mark_node
-		      && DECL_TEMPLATE_TEMPLATE_PARM_P (val))
-		    val = TREE_TYPE (val);
+		  if (val != error_mark_node)
+                    {
+                      if (DECL_TEMPLATE_TEMPLATE_PARM_P (val))
+                        val = TREE_TYPE (val);
+                      else if (TREE_CODE (val) == PACK_UNPACK_TYPE
+                               && DECL_TEMPLATE_TEMPLATE_PARM_P (check_arg))
+                        {
+                          val = TREE_TYPE (check_arg);
+                          val = make_argument_pack_unpack (val);
+                        }
+                    }
 		}
 	      else
 		{
@@ -4011,20 +4533,33 @@ coerce_template_parms (tree parms,
   tree new_args;
   tree new_inner_args;
 
-  inner_args = INNERMOST_TEMPLATE_ARGS (args);
+  /* When used as a boolean value, indicates whether this is a
+     variadic template parameter list. Since it's an int, we can also
+     subtract it from nparms to get the number of non-variadic
+     parameters. */
+  int variadic_p = template_parms_variadic_p (parms)? 1 : 0;
+
+  inner_args = expand_template_argument_pack (INNERMOST_TEMPLATE_ARGS (args));
   nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
   nparms = TREE_VEC_LENGTH (parms);
 
-  if (nargs > nparms
-      || (nargs < nparms
+  if ((nargs > nparms - variadic_p && !variadic_p)
+      || (nargs < nparms - variadic_p
 	  && require_all_arguments
 	  && TREE_PURPOSE (TREE_VEC_ELT (parms, nargs)) == NULL_TREE))
     {
       if (complain & tf_error)
 	{
-	  error ("wrong number of template arguments (%d, should be %d)",
-		 nargs, nparms);
+          const char *or_more = "";
+          if (variadic_p)
+            {
+              or_more = " or more";
+              --nparms;
+            }
 
+	  error ("wrong number of template arguments (%d, should be %d%s)",
+                 nargs, nparms, or_more);
+	  
 	  if (in_decl)
 	    error ("provided for %q+D", in_decl);
 	}
@@ -4034,7 +4569,7 @@ coerce_template_parms (tree parms,
 
   new_inner_args = make_tree_vec (nparms);
   new_args = add_outermost_template_args (args, new_inner_args);
-  for (i = 0; i < nparms; i++)
+  for (i = 0; i < nparms - variadic_p; i++)
     {
       tree arg;
       tree parm;
@@ -4044,7 +4579,33 @@ coerce_template_parms (tree parms,
 
       /* Calculate the Ith argument.  */
       if (i < nargs)
-	arg = TREE_VEC_ELT (inner_args, i);
+        {
+          arg = TREE_VEC_ELT (inner_args, i);
+
+          if (PACK_UNPACK_P (arg))
+            {
+              /* If ARG is a pack/unpack expression, then PARM must be
+                 a template parameter pack. We can't unpack into a
+                 fixed-length argument list. */
+              tree actual_parm = TREE_VALUE (parm);
+              bool parm_is_parameter_pack =
+                ((TREE_CODE (actual_parm) == TYPE_DECL
+                  && TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (actual_parm)))
+                 || (TREE_CODE (actual_parm) != TYPE_DECL
+                     && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (actual_parm)
+)));
+
+              if (!parm_is_parameter_pack)
+                {
+                  if (TREE_CODE (arg) == PACK_UNPACK_EXPR)
+                    error ("cannot unpack %<%E%> into a fixed-length "
+                           "argument list", arg);
+                  else
+                    error ("cannot unpack %<%T%> into a fixed-length "
+                           "argument list", arg);
+                }
+            }
+        }
       else if (require_all_arguments)
 	/* There must be a default arg in this case.  */
 	arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
@@ -4068,6 +4629,42 @@ coerce_template_parms (tree parms,
       TREE_VEC_ELT (new_inner_args, i) = arg;
     }
 
+  if (variadic_p)
+    {
+      int expected_len = nargs - nparms + 1;
+      tree parm = TREE_VEC_ELT (parms, nparms - 1);
+      tree packed_args;
+      tree argument_pack;
+
+      packed_args = make_tree_vec (expected_len >= 0? expected_len : 0);
+
+      /* Convert the remaining arguments, which will be a part of the
+         parameter pack "parm". */
+      for (; i < nargs; ++i)
+        {
+          tree arg = TREE_VEC_ELT (inner_args, i);
+          arg = convert_template_argument (TREE_VALUE (parm), 
+                                           arg, new_args, complain, i,
+                                           in_decl);
+          if (arg == error_mark_node)
+            lost++;
+          TREE_VEC_ELT (packed_args, i - nparms + 1) = arg; 
+        }
+
+      if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL
+          || TREE_CODE (TREE_VALUE (parm)) == TEMPLATE_DECL)
+          argument_pack = make_node (TYPE_ARGUMENT_PACK);
+      else
+        {
+          argument_pack = make_node (NONTYPE_ARGUMENT_PACK);
+          TREE_TYPE (argument_pack) = TREE_TYPE (TREE_VALUE (parm));
+          TREE_CONSTANT (argument_pack) = 1;
+        }
+
+      SET_ARGUMENT_PACK_ARGS (argument_pack, packed_args);
+      TREE_VEC_ELT (new_inner_args, nparms - 1) = argument_pack;
+    }
+
   if (lost)
     return error_mark_node;
 
@@ -4085,6 +4682,10 @@ template_args_equal (tree ot, tree nt)
   if (TREE_CODE (nt) == TREE_VEC)
     /* For member templates */
     return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
+  else if (PACK_UNPACK_P (ot))
+    return PACK_UNPACK_P (nt) 
+      && template_args_equal (PACK_UNPACK_PATTERN (ot),
+                              PACK_UNPACK_PATTERN (nt));
   else if (TYPE_P (nt))
     return TYPE_P (ot) && same_type_p (ot, nt);
   else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
@@ -4101,6 +4702,9 @@ comp_template_args (tree oldargs, tree n
 {
   int i;
 
+  oldargs = expand_template_argument_pack (oldargs);
+  newargs = expand_template_argument_pack (newargs);
+
   if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
     return 0;
 
@@ -4143,45 +4747,70 @@ mangle_class_name_for_template (const ch
     {
       tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
       tree arg = TREE_VEC_ELT (arglist, i);
+      tree args = NULL_TREE;
+      int argidx, len = 1;
 
-      if (i)
+      if (ARGUMENT_PACK_P (arg))
+        {
+          args = ARGUMENT_PACK_ARGS (arg);
+          len = TREE_VEC_LENGTH (args);
+        }
+        
+      /* Suppress printing the `,' when we have a template argument
+         pack, because the template argument pack might be empty. */
+      if (i && !args)
 	ccat (',');
 
-      if (TREE_CODE (parm) == TYPE_DECL)
-	{
-	  cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
-	  continue;
-	}
-      else if (TREE_CODE (parm) == TEMPLATE_DECL)
-	{
-	  if (TREE_CODE (arg) == TEMPLATE_DECL)
-	    {
-	      /* Already substituted with real template.  Just output
-		 the template name here */
-	      tree context = DECL_CONTEXT (arg);
-	      if (context)
-		{
-		  /* The template may be defined in a namespace, or
-		     may be a member template.  */
-		  gcc_assert (TREE_CODE (context) == NAMESPACE_DECL
-			      || CLASS_TYPE_P (context));
-		  cat (decl_as_string (DECL_CONTEXT (arg),
-				      TFF_PLAIN_IDENTIFIER));
-		  cat ("::");
-		}
-	      cat (IDENTIFIER_POINTER (DECL_NAME (arg)));