[multiple changes]

2009-11-30  Paolo Carlini  <paolo.carlini@oracle.com>

	* include/tr1_impl/functional: Remove file, copy its contents,
	trivially adjusted...
	* include/std/functional: ... here, and...
	* include/tr1_impl/functional: ... here.
	* include/Makefile.am: Adjust.
	* include/Makefile.in: Regenerate.

2009-11-30  Jonathan Wakely  <jwakely.gcc@gmail.com>

        * include/tr1_impl/functional (function): Add rvalue support and
        tweak doxygen markup.
        * testsuite/20_util/function/assign/move.cc: New.
        * testsuite/20_util/function/cons/move.cc: New.
        * testsuite/20_util/function/invoke/move_only.cc: New.
        * testsuite/20_util/function/cmp/cmp_neg.cc: New.
        * testsuite/20_util/function/1.cc: Copy from testsuite/tr1/.
        * testsuite/20_util/function/2.cc: Likewise.
        * testsuite/20_util/function/3.cc: Likewise.
        * testsuite/20_util/function/4.cc: Likewise.
        * testsuite/20_util/function/5.cc: Likewise.
        * testsuite/20_util/function/6.cc: Likewise.
        * testsuite/20_util/function/7.cc: Likewise.
        * testsuite/20_util/function/8.cc: Likewise.
        * testsuite/20_util/function/9.cc: Likewise.

From-SVN: r154759

libstdc++-v3/ChangeLog

@@ -1,3 +1,30 @@
+2009-11-30  Paolo Carlini  <paolo.carlini@oracle.com>
+
+	* include/tr1_impl/functional: Remove file, copy its contents,
+	trivially adjusted...
+	* include/std/functional: ... here, and...
+	* include/tr1_impl/functional: ... here.
+	* include/Makefile.am: Adjust.
+	* include/Makefile.in: Regenerate.
+
+2009-11-30  Jonathan Wakely  <jwakely.gcc@gmail.com>
+
+        * include/tr1_impl/functional (function): Add rvalue support and
+        tweak doxygen markup.
+        * testsuite/20_util/function/assign/move.cc: New.
+        * testsuite/20_util/function/cons/move.cc: New.
+        * testsuite/20_util/function/invoke/move_only.cc: New.
+        * testsuite/20_util/function/cmp/cmp_neg.cc: New.
+        * testsuite/20_util/function/1.cc: Copy from testsuite/tr1/.
+        * testsuite/20_util/function/2.cc: Likewise.
+        * testsuite/20_util/function/3.cc: Likewise.
+        * testsuite/20_util/function/4.cc: Likewise.
+        * testsuite/20_util/function/5.cc: Likewise.
+        * testsuite/20_util/function/6.cc: Likewise.
+        * testsuite/20_util/function/7.cc: Likewise.
+        * testsuite/20_util/function/8.cc: Likewise.
+        * testsuite/20_util/function/9.cc: Likewise.
+
 2009-11-29  Jonathan Wakely  <jwakely.gcc@gmail.com>
 
 	* doc/doxygen/user.cfg.in: Add __GXX_RTTI to PREDEFINED macros.

libstdc++-v3/include/Makefile.am

@@ -609,7 +609,6 @@ tr1_impl_headers = \
 	${tr1_impl_srcdir}/cstdlib \
 	${tr1_impl_srcdir}/cwchar \
 	${tr1_impl_srcdir}/cwctype \
-	${tr1_impl_srcdir}/functional \
 	${tr1_impl_srcdir}/hashtable \
 	${tr1_impl_srcdir}/hashtable_policy.h \
 	${tr1_impl_srcdir}/regex \

libstdc++-v3/include/Makefile.in

@@ -849,7 +849,6 @@ tr1_impl_headers = \
 	${tr1_impl_srcdir}/cstdlib \
 	${tr1_impl_srcdir}/cwchar \
 	${tr1_impl_srcdir}/cwctype \
-	${tr1_impl_srcdir}/functional \
 	${tr1_impl_srcdir}/hashtable \
 	${tr1_impl_srcdir}/hashtable_policy.h \
 	${tr1_impl_srcdir}/regex \

libstdc++-v3/testsuite/20_util/function/1.cc

@@ -0,0 +1,94 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu>
+//
+// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.15 polymorphic function object wrapper
+#include <functional>
+#include <testsuite_hooks.h>
+
+using namespace __gnu_test;
+
+bool test __attribute__((unused)) = true;
+
+// Operations on empty function<> objects
+void test01()
+{
+  using std::function;
+  using std::bad_function_call;
+
+  // Default-construction
+  function<int(float)> f1;
+  VERIFY( ((bool)f1 == false) );
+  VERIFY( !f1 );
+  VERIFY( f1 == 0 );
+  VERIFY( 0 == f1 );
+  VERIFY( !(f1 != 0) );
+  VERIFY( !(0 != f1) );
+
+  // Copy-construction
+  function<int(float)> f2(f1);
+  VERIFY( !f2 );
+
+  // Construct with NULL pointer
+  function<int(float)> f3(0);
+  VERIFY( !f3 );
+
+  // Assignment
+  f1 = f2;
+  VERIFY( !f1);
+
+  // Assignment to NULL pointer
+  f1 = 0;
+  VERIFY( !f1 );
+
+  // Swap
+  swap(f1, f2);
+  VERIFY( !f1 );
+  VERIFY( !f2 );
+
+  // Invocation should throw bad_function_call
+  bool thrown = false;
+  try
+    {
+      f1(3.14159f);
+      VERIFY( false );
+    }
+  catch (bad_function_call)
+    {
+      thrown = true;
+    }
+  VERIFY( thrown );
+
+  // target_type returns typeid(void)
+  VERIFY( f1.target_type() == typeid(void) );
+
+  // target() always returns a NULL pointer
+  VERIFY( f1.target<int (*)(float)>() == 0);
+
+  // Check const version
+  const function<int(float)>& f1c = f1;
+  VERIFY( f1c.target<int (*)(float)>() == 0 );
+  VERIFY( !f1c );
+}
+
+int main()
+{
+  test01();
+  return 0;
+}

libstdc++-v3/testsuite/20_util/function/2.cc

@@ -0,0 +1,78 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu>
+//
+// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.15 polymorphic function object wrapper
+#include <functional>
+#include <testsuite_hooks.h>
+#include <testsuite_tr1.h>
+
+using namespace __gnu_test;
+
+bool test __attribute__((unused)) = true;
+
+// Put function pointers into function<> wrappers
+void test02()
+{
+  using std::function;
+
+  function<int(float)> f1(truncate_float);
+  VERIFY( f1 );
+  VERIFY( !!f1 );
+  VERIFY( !(f1 == 0) );
+  VERIFY( !(0 == f1) );
+  VERIFY( f1 != 0 );
+  VERIFY( 0 != f1 );
+
+  // Copy-construction
+  function<int(float)> f2(f1);
+  VERIFY( f2 );
+
+  // Invocation
+  VERIFY( f1(3.1f) == 3 );
+  VERIFY( f2(3.1f) == 3 );
+
+  // Assignment to zero
+  f1 = 0;
+  VERIFY( !f1 );
+
+  // Swap
+  f1.swap(f2);
+  VERIFY( f1 );
+  VERIFY( !f2 );
+  VERIFY( f1(3.1f) == 3 );
+
+  // Assignment from a function pointer
+  f2 = truncate_float;
+  VERIFY( f2(3.1f) == 3 );
+
+  // target_type and target() functions
+  const function<int(float)>& f1c = f1;
+  VERIFY( typeid(int(*)(float)) == f1.target_type() );
+  VERIFY( f2.target<int(*)(float)>() != 0 );
+  VERIFY( *f2.target<int(*)(float)>() == &truncate_float );
+  VERIFY( f1c.target<int(*)(float)>() != 0 );
+  VERIFY( *f1c.target<int(*)(float)>() == &truncate_float );
+}
+
+int main()
+{
+  test02();
+  return 0;
+}

libstdc++-v3/testsuite/20_util/function/3.cc

@@ -0,0 +1,78 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu>
+//
+// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.15 polymorphic function object wrapper
+#include <functional>
+#include <testsuite_hooks.h>
+#include <testsuite_tr1.h>
+
+using namespace __gnu_test;
+
+bool test __attribute__((unused)) = true;
+
+// Put nearly-matching function pointers into function<> wrappers
+void test03()
+{
+  using std::function;
+
+  function<int(float)> f1(truncate_double);
+  VERIFY( f1 );
+  VERIFY( !!f1 );
+  VERIFY( !(f1 == 0) );
+  VERIFY( !(0 == f1) );
+  VERIFY( f1 != 0 );
+  VERIFY( 0 != f1 );
+
+  // Copy-construction
+  function<int(float)> f2(f1);
+  VERIFY( f2 );
+
+  // Invocation
+  VERIFY( f1(3.1f) == 3 );
+  VERIFY( f2(3.1f) == 3 );
+
+  // Assignment to zero
+  f1 = 0;
+  VERIFY( !f1 );
+
+  // Swap
+  f1.swap(f2);
+  VERIFY( f1 );
+  VERIFY( !f2 );
+  VERIFY( f1(3.1f) == 3 );
+
+  // Assignment from a function pointer
+  f2 = truncate_double;
+  VERIFY( f2(3.1f) == 3 );
+
+  // target_type and target() functions
+  const function<int(float)>& f1c = f1;
+  VERIFY( typeid(long(*)(double)) == f1.target_type() );
+  VERIFY( f2.target<long(*)(double)>() != 0 );
+  VERIFY( *f2.target<long(*)(double)>() == &truncate_double );
+  VERIFY( f1c.target<long(*)(double)>() != 0 );
+  VERIFY( *f1c.target<long(*)(double)>() == &truncate_double );
+}
+
+int main()
+{
+  test03();
+  return 0;
+}

libstdc++-v3/testsuite/20_util/function/4.cc

@@ -0,0 +1,82 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu>
+//
+// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.15 polymorphic function object wrapper
+#include <functional>
+#include <testsuite_hooks.h>
+#include <testsuite_tr1.h>
+
+using namespace __gnu_test;
+
+bool test __attribute__((unused)) = true;
+
+// Put function objects into function<> wrappers
+void test04()
+{
+  using std::function;
+
+  do_truncate_float_t truncate_float;
+
+  function<int(float)> f1(truncate_float);
+  VERIFY( f1 );
+  VERIFY( !!f1 );
+  VERIFY( !(f1 == 0) );
+  VERIFY( !(0 == f1) );
+  VERIFY( f1 != 0 );
+  VERIFY( 0 != f1 );
+
+  // Copy-construction
+  function<int(float)> f2(f1);
+  VERIFY( f2 );
+
+  // Invocation
+  VERIFY( f1(3.1f) == 3 );
+  VERIFY( f2(3.1f) == 3 );
+
+  // Assignment to zero
+  f1 = 0;
+  VERIFY( !f1 );
+
+  // Swap
+  f1.swap(f2);
+  VERIFY( f1 );
+  VERIFY( !f2 );
+  VERIFY( f1(3.1f) == 3 );
+
+  // Assignment from a function pointer
+  f2 = do_truncate_float_t();
+  VERIFY( f2(3.1f) == 3 );
+
+  // target_type and target() functions
+  const function<int(float)>& f1c = f1;
+  VERIFY( typeid(do_truncate_float_t) == f1.target_type() );
+  VERIFY( f2.target<do_truncate_float_t>() != 0 );
+  VERIFY( f1c.target<do_truncate_float_t>() != 0 );
+}
+
+int main()
+{
+  test04();
+
+  VERIFY( do_truncate_double_t::live_objects == 0 );
+  VERIFY( do_truncate_float_t::live_objects == 0 );
+
+  return 0;
+}

libstdc++-v3/testsuite/20_util/function/5.cc

@@ -0,0 +1,107 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu>
+//
+// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.15 polymorphic function object wrapper
+#include <functional>
+#include <testsuite_hooks.h>
+#include <testsuite_tr1.h>
+
+using namespace __gnu_test;
+
+bool test __attribute__((unused)) = true;
+
+// Put member pointers into function<> wrappers
+void test05()
+{
+  using std::function;
+
+  X x;
+  x.bar = 17;
+
+  function<int(X&)> frm(&X::bar);
+  VERIFY( frm );
+  VERIFY( frm(x) == 17 );
+  VERIFY( typeid(int X::*) == frm.target_type() );
+  VERIFY( *frm.target<int X::*>() == &X::bar );
+
+  function<int(X&)> fr(&X::foo);
+  VERIFY( fr );
+  VERIFY( fr(x) == 1 );
+  VERIFY( typeid(int (X::*)()) == fr.target_type() );
+  VERIFY( *fr.target<int (X::*)()>() == &X::foo );
+
+  function<int(const X&)> frc(&X::foo_c);
+  VERIFY( frc );
+  VERIFY( frc(x) == 2 );
+  VERIFY( typeid(int (X::*)() const) == frc.target_type() );
+  VERIFY( *frc.target<int (X::*)() const >() == &X::foo_c );
+
+  function<int(volatile X&)> frv(&X::foo_v);
+  VERIFY( frv );
+  VERIFY( frv(x) == 3 );
+  VERIFY( typeid(int (X::*)() volatile) == frv.target_type() );
+  VERIFY( *frv.target<int (X::*)() volatile >() == &X::foo_v );
+  VERIFY( frv.target<int (X::*)() const volatile>() == 0 );
+
+  function<int(const volatile X&)> frcv(&X::foo_cv);
+  VERIFY( frcv );
+  VERIFY( frcv(x) == 4 );
+  VERIFY( typeid(int (X::*)() const volatile) == frcv.target_type() );
+  VERIFY( *frcv.target<int (X::*)() const volatile >() == &X::foo_cv );
+  VERIFY( frcv.target<int (X::*)() const>() == 0 );
+
+  function<int(X*)> grm(&X::bar);
+  VERIFY( grm );
+  VERIFY( grm(&x) == 17 );
+  VERIFY( typeid(int X::*) == grm.target_type() );
+  VERIFY( *grm.target<int X::*>() == &X::bar );
+
+  function<int(X*)> gr(&X::foo);
+  VERIFY( gr );
+  VERIFY( gr(&x) == 1 );
+  VERIFY( typeid(int (X::*)()) == gr.target_type() );
+  VERIFY( *gr.target<int (X::*)()>() == &X::foo );
+
+  function<int(const X*)> grc(&X::foo_c);
+  VERIFY( grc );
+  VERIFY( grc(&x) == 2 );
+  VERIFY( typeid(int (X::*)() const) == grc.target_type() );
+  VERIFY( *grc.target<int (X::*)() const >() == &X::foo_c );
+
+  function<int(volatile X*)> grv(&X::foo_v);
+  VERIFY( grv );
+  VERIFY( grv(&x) == 3 );
+  VERIFY( typeid(int (X::*)() volatile) == grv.target_type() );
+  VERIFY( *grv.target<int (X::*)() volatile >() == &X::foo_v );
+  VERIFY( grv.target<int (X::*)() const volatile>() == 0 );
+
+  function<int(const volatile X*)> grcv(&X::foo_cv);
+  VERIFY( grcv );
+  VERIFY( grcv(&x) == 4 );
+  VERIFY( typeid(int (X::*)() const volatile) == grcv.target_type() );
+  VERIFY( *grcv.target<int (X::*)() const volatile >() == &X::foo_cv );
+  VERIFY( grcv.target<int (X::*)() const>() == 0 );
+}
+
+int main()
+{
+  test05();
+  return 0;
+}

libstdc++-v3/testsuite/20_util/function/6.cc

@@ -0,0 +1,82 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu>
+//
+// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.15 polymorphic function object wrapper
+#include <functional>
+#include <testsuite_hooks.h>
+
+using namespace __gnu_test;
+
+bool test __attribute__((unused)) = true;
+
+struct secret {};
+
+struct noncopyable_function_object_type
+{
+  noncopyable_function_object_type(secret) {}
+
+  int operator()() const { return 42; }
+  int operator()()       { return 17; }
+
+ private:
+  noncopyable_function_object_type();
+  noncopyable_function_object_type(const noncopyable_function_object_type&);
+  void operator=(const noncopyable_function_object_type&);
+};
+
+// Put reference_wrappers into function<> wrappers
+void test06()
+{
+  using std::function;
+  using std::ref;
+  using std::cref;
+
+  secret password;
+  noncopyable_function_object_type x(password);
+
+  function<int()> f(ref(x));
+  VERIFY( f );
+  VERIFY( f() == 17 );
+  VERIFY( f.target_type() == typeid(noncopyable_function_object_type) );
+  VERIFY( f.target<noncopyable_function_object_type>() == &x );
+
+  function<int()> g = f;
+  VERIFY( g );
+  VERIFY( g() == 17 );
+  VERIFY( g.target_type() == typeid(noncopyable_function_object_type) );
+  VERIFY( g.target<noncopyable_function_object_type>() == &x );
+
+  function<int()> h = cref(x);
+  VERIFY( h );
+  VERIFY( h() == 42 );
+  VERIFY( h.target_type() == typeid(noncopyable_function_object_type) );
+  VERIFY( h.target<const noncopyable_function_object_type>() == &x );
+  VERIFY( h.target<const noncopyable_function_object_type>() == &x );
+
+  const function<int()>& hc = h;
+  VERIFY( h.target<noncopyable_function_object_type>() == 0 );
+  VERIFY( hc.target<noncopyable_function_object_type>() == &x );
+}
+
+int main()
+{
+  test06();
+  return 0;
+}

libstdc++-v3/testsuite/20_util/function/7.cc

@@ -0,0 +1,82 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu>
+//
+// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.15 polymorphic function object wrapper
+#include <functional>
+#include <testsuite_hooks.h>
+#include <testsuite_tr1.h>
+
+using namespace __gnu_test;
+
+bool test __attribute__((unused)) = true;
+
+// Put reference_wrappers to function pointers into function<> wrappers
+void test07()
+{
+  using std::function;
+  using std::ref;
+  using std::cref;
+
+  int (*fptr)(float) = truncate_float;
+
+  function<int(float)> f1(ref(fptr));
+  VERIFY( f1 );
+  VERIFY( !!f1 );
+  VERIFY( !(f1 == 0) );
+  VERIFY( !(0 == f1) );
+  VERIFY( f1 != 0 );
+  VERIFY( 0 != f1 );
+
+  // Invocation
+  VERIFY( f1(3.1f) == 3 );
+
+  // target_type and target() functions
+  const function<int(float)>& f1c = f1;
+  VERIFY( typeid(int(*)(float)) == f1.target_type() );
+  VERIFY( f1.target<int(*)(float)>() != 0 );
+  VERIFY( f1.target<int(*)(float)>() == &fptr );
+  VERIFY( f1c.target<int(*)(float)>() != 0 );
+  VERIFY( f1c.target<int(*)(float)>() == &fptr );
+
+  function<int(float)> f2(cref(fptr));
+  VERIFY( f2 );
+  VERIFY( !!f2 );
+  VERIFY( !(f2 == 0) );
+  VERIFY( !(0 == f2) );
+  VERIFY( f2 != 0 );
+  VERIFY( 0 != f2 );
+
+  // Invocation
+  VERIFY( f2(3.1f) == 3 );
+
+  // target_type and target() functions
+  const function<int(float)>& f2c = f2;
+  VERIFY( typeid(int(*)(float)) == f2.target_type() );
+  VERIFY( f2.target<int(*)(float)>() == 0 );
+  VERIFY( f2.target<int(* const)(float)>() == &fptr );
+  VERIFY( f2c.target<int(*)(float)>() != 0 );
+  VERIFY( f2c.target<int(*)(float)>() == &fptr );
+}
+
+int main()
+{
+  test07();
+  return 0;
+}

libstdc++-v3/testsuite/20_util/function/8.cc

@@ -0,0 +1,148 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu>
+//
+// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.15 polymorphic function object wrapper
+#include <functional>
+#include <testsuite_hooks.h>
+#include <testsuite_tr1.h>
+
+using namespace __gnu_test;
+
+bool test __attribute__((unused)) = true;
+
+// Put reference_wrappers to member pointers
+void test08()
+{
+  using std::function;
+  using std::ref;
+  using std::cref;
+
+  int X::* X_bar = &X::bar;
+  int (X::* X_foo)() = &X::foo;
+  int (X::* X_foo_c)() const = &X::foo_c;
+  int (X::* X_foo_v)() volatile = &X::foo_v;
+  int (X::* X_foo_cv)() const volatile = &X::foo_cv;
+
+  X x;
+  x.bar = 17;
+
+  function<int(X&)> frm(ref(X_bar));
+  VERIFY( frm );
+  VERIFY( frm(x) == 17 );
+  VERIFY( typeid(int X::*) == frm.target_type() );
+  VERIFY( frm.target<int X::*>() == &X_bar );
+
+  function<int(X&)> fr(ref(X_foo));
+  VERIFY( fr );
+  VERIFY( fr(x) == 1 );
+  VERIFY( typeid(int (X::*)()) == fr.target_type() );
+  VERIFY( fr.target<int (X::*)()>() == &X_foo );
+
+  function<int(const X&)> frc(ref(X_foo_c));
+  VERIFY( frc );
+  VERIFY( frc(x) == 2 );
+  VERIFY( typeid(int (X::*)() const) == frc.target_type() );
+  VERIFY( frc.target<int (X::*)() const >() == &X_foo_c );
+
+  function<int(volatile X&)> frv(ref(X_foo_v));
+  VERIFY( frv );
+  VERIFY( frv(x) == 3 );
+  VERIFY( typeid(int (X::*)() volatile) == frv.target_type() );
+  VERIFY( *frv.target<int (X::*)() volatile >() == X_foo_v );
+  VERIFY( frv.target<int (X::*)() const volatile>() == 0 );
+
+  function<int(const volatile X&)> frcv(ref(X_foo_cv));
+  VERIFY( frcv );
+  VERIFY( frcv(x) == 4 );
+  VERIFY( typeid(int (X::*)() const volatile) == frcv.target_type() );
+  VERIFY( *frcv.target<int (X::*)() const volatile >() == X_foo_cv );
+  VERIFY( frcv.target<int (X::*)() const>() == 0 );
+
+  function<int(X*)> grm(ref(X_bar));
+  VERIFY( grm );
+  VERIFY( grm(&x) == 17 );
+  VERIFY( typeid(int X::*) == grm.target_type() );
+  VERIFY( *grm.target<int X::*>() == X_bar );
+
+  function<int(X*)> gr(ref(X_foo));
+  VERIFY( gr );
+  VERIFY( gr(&x) == 1 );
+  VERIFY( typeid(int (X::*)()) == gr.target_type() );
+  VERIFY( *gr.target<int (X::*)()>() == X_foo );
+
+  function<int(const X*)> grc(ref(X_foo_c));
+  VERIFY( grc );
+  VERIFY( grc(&x) == 2 );
+  VERIFY( typeid(int (X::*)() const) == grc.target_type() );
+  VERIFY( *grc.target<int (X::*)() const >() == X_foo_c );
+
+  function<int(volatile X*)> grv(ref(X_foo_v));
+  VERIFY( grv );
+  VERIFY( grv(&x) == 3 );
+  VERIFY( typeid(int (X::*)() volatile) == grv.target_type() );
+  VERIFY( *grv.target<int (X::*)() volatile >() == X_foo_v );
+  VERIFY( grv.target<int (X::*)() const volatile>() == 0 );
+
+  function<int(const volatile X*)> grcv(ref(X_foo_cv));
+  VERIFY( grcv );
+  VERIFY( grcv(&x) == 4 );
+  VERIFY( typeid(int (X::*)() const volatile) == grcv.target_type() );
+  VERIFY( *grcv.target<int (X::*)() const volatile >() == X_foo_cv );
+  VERIFY( grcv.target<int (X::*)() const>() == 0 );
+
+  function<int(X&)> hrm(cref(X_bar));
+  VERIFY( hrm );
+  VERIFY( hrm(x) == 17 );
+  VERIFY( typeid(int X::*) == hrm.target_type() );
+  VERIFY( hrm.target<int X::*>() == 0 );
+  VERIFY( hrm.target<int X::* const>() == &X_bar );
+
+  function<int(X&)> hr(cref(X_foo));
+  VERIFY( hr );
+  VERIFY( hr(x) == 1 );
+  VERIFY( typeid(int (X::*)()) == hr.target_type() );
+  VERIFY( hr.target<int (X::* const)()>() == &X_foo );
+
+  function<int(const X&)> hrc(cref(X_foo_c));
+  VERIFY( hrc );
+  VERIFY( hrc(x) == 2 );
+  VERIFY( typeid(int (X::*)() const) == hrc.target_type() );
+  VERIFY( hrc.target<int (X::* const)() const >() == &X_foo_c );
+
+  function<int(volatile X&)> hrv(cref(X_foo_v));
+  VERIFY( hrv );
+  VERIFY( hrv(x) == 3 );
+  VERIFY( typeid(int (X::*)() volatile) == hrv.target_type() );
+  VERIFY( hrv.target<int (X::* const)() volatile >() == &X_foo_v );
+  VERIFY( hrv.target<int (X::* const)() const volatile>() == 0 );
+
+  function<int(const volatile X&)> hrcv(cref(X_foo_cv));
+  VERIFY( hrcv );
+  VERIFY( hrcv(x) == 4 );
+  VERIFY( typeid(int (X::*)() const volatile) == hrcv.target_type() );
+  VERIFY( hrcv.target<int (X::* const)() const volatile >() == &X_foo_cv );
+  VERIFY( hrcv.target<int (X::* const)() const>() == 0 );
+}
+
+int main()
+{
+  test08();
+  return 0;
+}

libstdc++-v3/testsuite/20_util/function/9.cc

@@ -0,0 +1,55 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu>
+//
+// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.15 polymorphic function object wrapper
+#include <functional>
+#include <testsuite_hooks.h>
+#include <testsuite_tr1.h>
+
+using namespace __gnu_test;
+
+bool test __attribute__((unused)) = true;
+
+// Put function objects into a void-returning function<> wrapper
+void test09()
+{
+  using std::function;
+  using std::ref;
+  using std::cref;
+
+  int (X::*X_foo_c)() const = &X::foo_c;
+  function<void(X&)> f(&X::bar);
+  f = &X::foo;
+  f = ref(X_foo_c);
+  f = cref(X_foo_c);
+
+  function<void(float)> g = &truncate_float;
+  g = do_truncate_float_t();
+}
+
+int main()
+{
+  test09();
+
+  VERIFY( do_truncate_double_t::live_objects == 0 );
+  VERIFY( do_truncate_float_t::live_objects == 0 );
+
+  return 0;
+}

libstdc++-v3/testsuite/20_util/function/assign/move.cc

@@ -0,0 +1,50 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <functional>
+#include <testsuite_hooks.h>
+
+int f1() { return 1; }
+struct { int operator()() { return 2; } } f2;
+
+void test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  typedef std::function<int()> function;
+
+  function fo(f1);
+  function fo1;
+  fo1 = (std::move(fo));
+  VERIFY( static_cast<bool>(fo1) );
+  VERIFY( fo1() == 1 );
+
+  fo = function(f2);
+  function fo2;
+  fo2 = (std::move(fo));
+  VERIFY( static_cast<bool>(fo2) );
+  VERIFY( fo2() == 2 );
+}
+
+int main()
+{
+  test01();
+
+  return 0;
+}

libstdc++-v3/testsuite/20_util/function/cmp/cmp_neg.cc

@@ -0,0 +1,37 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <functional>
+
+void test01()
+{
+  std::function<void()> f1;
+  std::function<void()> f2;
+  f1 == f2;  // { dg-error "here" }
+  f1 != f2;  // { dg-error "here" }
+  // { dg-excess-errors "" }
+}
+
+int main()
+{
+  test01();
+
+  return 0;
+}

libstdc++-v3/testsuite/20_util/function/cons/move.cc

@@ -0,0 +1,48 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <functional>
+#include <testsuite_hooks.h>
+
+int f1() { return 1; }
+struct { int operator()() { return 2; } } f2;
+
+void test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  typedef std::function<int()> function;
+
+  function fo(f1);
+  function fo1(std::move(fo));
+  VERIFY( static_cast<bool>(fo1) );
+  VERIFY( fo1() == 1 );
+
+  fo = function(f2);
+  function fo2(std::move(fo));
+  VERIFY( static_cast<bool>(fo2) );
+  VERIFY( fo2() == 2 );
+}
+
+int main()
+{
+  test01();
+
+  return 0;
+}

libstdc++-v3/testsuite/20_util/function/invoke/move_only.cc

@@ -0,0 +1,61 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <functional>
+
+struct moveable
+{
+  moveable() = default;
+  ~moveable() = default;
+  moveable(const moveable& c) = delete;
+  moveable& operator=(const moveable&) = delete;
+  moveable(moveable&&) { }
+};
+
+void f1(moveable) { }
+void f2(moveable&&) { }
+struct { void operator()(moveable&&) { } } f3;
+
+void test01()
+{
+  std::function<void (moveable)> fo1a(f1);
+  fo1a(moveable());
+
+  std::function<void (moveable)> fo2a(f2);
+  fo2a(moveable());
+
+  std::function<void (moveable)> fo3a(f3);
+  fo3a(moveable());
+
+  std::function<void (moveable&&)> fo1b(f1);
+  fo1b(moveable());
+
+  std::function<void (moveable&&)> fo2b(f2);
+  fo2b(moveable());
+
+  std::function<void (moveable&&)> fo3b(f3);
+  fo3b(moveable());
+}
+
+int main()
+{
+  test01();
+
+  return 0;
+}