iterator.h: Reformat to 80 columns; adjust some inline specifiers.

2008-01-09  Paolo Carlini  <pcarlini@suse.de>

	* include/parallel/iterator.h: Reformat to 80 columns; adjust some
	inline specifiers.
	* include/parallel/find_selectors.h: Likewise.
	* include/parallel/losertree.h: Likewise.
	* include/parallel/list_partition.h: Likewise.
	* include/parallel/for_each.h: Likewise.
	* include/parallel/multiseq_selection.h: Likewise.
	* include/parallel/algorithmfwd.h: Likewise.
	* include/parallel/for_each_selectors.h: Likewise.
	* include/parallel/balanced_quicksort.h: Likewise.
	* include/parallel/merge.h: Likewise.
	* include/parallel/algobase.h: Likewise.
	* include/parallel/find.h: Likewise.
	* include/parallel/algo.h: Likewise.
	* include/parallel/checkers.h: Likewise.

From-SVN: r131431

libstdc++-v3/ChangeLog

@@ -1,3 +1,21 @@
+2008-01-09  Paolo Carlini  <pcarlini@suse.de>
+
+	* include/parallel/iterator.h: Reformat to 80 columns; adjust some
+	inline specifiers.
+	* include/parallel/find_selectors.h: Likewise.
+	* include/parallel/losertree.h: Likewise.
+	* include/parallel/list_partition.h: Likewise.
+	* include/parallel/for_each.h: Likewise.
+	* include/parallel/multiseq_selection.h: Likewise.
+	* include/parallel/algorithmfwd.h: Likewise.
+	* include/parallel/for_each_selectors.h: Likewise.
+	* include/parallel/balanced_quicksort.h: Likewise.
+	* include/parallel/merge.h: Likewise.
+	* include/parallel/algobase.h: Likewise.
+	* include/parallel/find.h: Likewise.
+	* include/parallel/algo.h: Likewise.
+	* include/parallel/checkers.h: Likewise.	
+
 2008-01-09  Francesco Biscani  <bluescarni@gmail.com>
 
 	* include/tr1_impl/hashtable (_Hashtable): Fix friend declaration

libstdc++-v3/include/parallel/algobase.h

@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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
@@ -63,14 +63,16 @@ namespace __parallel
     { return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2); }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2, typename Predicate>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate>
     inline pair<InputIterator1, InputIterator2>
     mismatch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, 
 	     Predicate pred, __gnu_parallel::sequential_tag)
     { return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2, pred); }
 
   // Sequential fallback for input iterator case
-  template<typename InputIterator1, typename InputIterator2, typename Predicate, typename IteratorTag1, typename IteratorTag2>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate, typename IteratorTag1, typename IteratorTag2>
     inline pair<InputIterator1, InputIterator2>
     mismatch_switch(InputIterator1 begin1, InputIterator1 end1, 
 		    InputIterator2 begin2, Predicate pred, IteratorTag1, 
@@ -78,7 +80,8 @@ namespace __parallel
     { return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2, pred); }
 
   // Parallel mismatch for random access iterators
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Predicate>
+  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	   typename Predicate>
     pair<RandomAccessIterator1, RandomAccessIterator2>
     mismatch_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, 
 		    RandomAccessIterator2 begin2, Predicate pred, 
@@ -86,7 +89,10 @@ namespace __parallel
     {
       if (_GLIBCXX_PARALLEL_CONDITION(true))
 	{
-	RandomAccessIterator1 res = __gnu_parallel::find_template(begin1, end1, begin2, pred, __gnu_parallel::mismatch_selector()).first;
+	  RandomAccessIterator1 res =
+	    __gnu_parallel::find_template(begin1, end1, begin2, pred,
+					  __gnu_parallel::
+					  mismatch_selector()).first;
 	  return make_pair(res , begin2 + (res - begin1));
 	}
       else
@@ -112,7 +118,8 @@ namespace __parallel
     }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2, typename Predicate>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate>
     inline pair<InputIterator1, InputIterator2>
     mismatch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
 	     Predicate pred)
@@ -134,7 +141,8 @@ namespace __parallel
     { return _GLIBCXX_STD_P::equal(begin1, end1, begin2); }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2, typename Predicate>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate>
     inline bool
     equal(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, 
 	  Predicate pred, __gnu_parallel::sequential_tag)
@@ -147,7 +155,8 @@ namespace __parallel
     { return mismatch(begin1, end1, begin2).first == end1; }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2, typename Predicate>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate>
     inline bool
     equal(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, 
 	  Predicate pred)
@@ -159,35 +168,33 @@ namespace __parallel
     lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, 
 			    InputIterator2 begin2, InputIterator2 end2, 
 			    __gnu_parallel::sequential_tag)
-  {
+    { return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1,
-    return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, begin2, end2);
+						     begin2, end2); }
-  }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2, typename Predicate>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate>
     inline bool
     lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, 
 			    InputIterator2 begin2, InputIterator2 end2, 
 			    Predicate pred, __gnu_parallel::sequential_tag)
-  {
+    { return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, 
-    return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, 
+						     begin2, end2, pred); }
-						   begin2, end2, pred);
-  }
 
   // Sequential fallback for input iterator case
-  template<typename InputIterator1, typename InputIterator2, typename Predicate, typename IteratorTag1, typename IteratorTag2>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate, typename IteratorTag1, typename IteratorTag2>
     inline bool
     lexicographical_compare_switch(InputIterator1 begin1, InputIterator1 end1, 
 				   InputIterator2 begin2, InputIterator2 end2, 
 				   Predicate pred, IteratorTag1, IteratorTag2)
-  {
+    { return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, 
-    return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, 
+						     begin2, end2, pred); }
-						   begin2, end2, pred);
-  }
 
   // Parallel lexicographical_compare for random access iterators
   // Limitation: Both valuetypes must be the same
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Predicate>
+  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	   typename Predicate>
     bool
     lexicographical_compare_switch(RandomAccessIterator1 begin1, 
 				   RandomAccessIterator1 end1, 
@@ -204,12 +211,14 @@ namespace __parallel
 	  typedef iterator_traits<RandomAccessIterator2> traits2_type;
 	  typedef typename traits2_type::value_type value2_type;
 
-	typedef __gnu_parallel::equal_from_less<Predicate, value1_type, value2_type> equal_type;
+	  typedef __gnu_parallel::equal_from_less<Predicate, value1_type,
+	                                          value2_type> equal_type;
 
 	  // Longer sequence in first place.
 	  if ((end1 - begin1) < (end2 - begin2))
 	    {
-	    typedef pair<RandomAccessIterator1, RandomAccessIterator2> pair_type;
+	      typedef pair<RandomAccessIterator1, RandomAccessIterator2>
+		pair_type;
 	      pair_type mm = mismatch_switch(begin1, end1, begin2, 
 					     equal_type(pred), 
 					     random_access_iterator_tag(), 
@@ -219,7 +228,8 @@ namespace __parallel
 	    }
 	  else
 	    {
-	    typedef pair<RandomAccessIterator2, RandomAccessIterator1> pair_type;
+	      typedef pair<RandomAccessIterator2, RandomAccessIterator1>
+		pair_type;
 	      pair_type mm = mismatch_switch(begin2, end2, begin1, 
 					     equal_type(pred), 
 					     random_access_iterator_tag(), 
@@ -229,13 +239,15 @@ namespace __parallel
 	    }
 	}
       else
-      return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, begin2, end2, pred);
+	return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1,
+						       begin2, end2, pred);
     }
 
   // Public interface
   template<typename InputIterator1, typename InputIterator2>
     inline bool
-  lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2)
+    lexicographical_compare(InputIterator1 begin1, InputIterator1 end1,
+			    InputIterator2 begin2, InputIterator2 end2)
     {
       typedef iterator_traits<InputIterator1> traits1_type;
       typedef typename traits1_type::value_type value1_type;
@@ -252,9 +264,12 @@ namespace __parallel
     }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2, typename Predicate>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate>
     inline bool
-  lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2, Predicate pred)
+    lexicographical_compare(InputIterator1 begin1, InputIterator1 end1,
+			    InputIterator2 begin2, InputIterator2 end2,
+			    Predicate pred)
     {
       typedef iterator_traits<InputIterator1> traits1_type;
       typedef typename traits1_type::iterator_category iterator1_category;

libstdc++-v3/include/parallel/algorithmfwd.h

@@ -1,6 +1,6 @@
 // <algorithm> parallel extensions -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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
@@ -84,43 +84,43 @@ namespace __parallel
     typename iterator_traits<_IIter>::difference_type
     count(_IIter, _IIter, const _Tp&);
 
-  template<typename _IIter, typename T>
+  template<typename _IIter, typename _Tp>
     typename iterator_traits<_IIter>::difference_type
-    count(_IIter, _IIter, const T&, __gnu_parallel::sequential_tag);
+    count(_IIter, _IIter, const _Tp&, __gnu_parallel::sequential_tag);
 
-  template<typename _IIter, typename T>
+  template<typename _IIter, typename _Tp>
     typename iterator_traits<_IIter>::difference_type
-    count(_IIter, _IIter, const T&, __gnu_parallel::parallelism);
+    count(_IIter, _IIter, const _Tp&, __gnu_parallel::parallelism);
 
-  template<typename _IIter, typename T, typename _IterTag>
+  template<typename _IIter, typename _Tp, typename _IterTag>
     typename iterator_traits<_IIter>::difference_type
-    count_switch(_IIter, _IIter, const T&, _IterTag);
+    count_switch(_IIter, _IIter, const _Tp&, _IterTag);
 
-  template<typename _RAIter, typename T>
+  template<typename _RAIter, typename _Tp>
     typename iterator_traits<_RAIter>::difference_type
-    count_switch(_RAIter, _RAIter, const T&, random_access_iterator_tag,
+    count_switch(_RAIter, _RAIter, const _Tp&, random_access_iterator_tag,
 		 __gnu_parallel::parallelism);
 
 
-  template<typename _IIter, typename Predicate>
+  template<typename _IIter, typename _Predicate>
     typename iterator_traits<_IIter>::difference_type
-    count_if(_IIter, _IIter, Predicate);
+    count_if(_IIter, _IIter, _Predicate);
 
-  template<typename _IIter, typename Predicate>
+  template<typename _IIter, typename _Predicate>
     typename iterator_traits<_IIter>::difference_type
-    count_if(_IIter, _IIter, Predicate, __gnu_parallel::sequential_tag);
+    count_if(_IIter, _IIter, _Predicate, __gnu_parallel::sequential_tag);
 
-  template<typename _IIter, typename Predicate>
+  template<typename _IIter, typename _Predicate>
     typename iterator_traits<_IIter>::difference_type
-    count_if(_IIter, _IIter, Predicate, __gnu_parallel::parallelism);
+    count_if(_IIter, _IIter, _Predicate, __gnu_parallel::parallelism);
 
-  template<typename _IIter, typename Predicate, typename _IterTag>
+  template<typename _IIter, typename _Predicate, typename _IterTag>
     typename iterator_traits<_IIter>::difference_type
-    count_if_switch(_IIter, _IIter, Predicate, _IterTag);
+    count_if_switch(_IIter, _IIter, _Predicate, _IterTag);
 
-  template<typename _RAIter, typename Predicate>
+  template<typename _RAIter, typename _Predicate>
     typename iterator_traits<_RAIter>::difference_type
-    count_if_switch(_RAIter, _RAIter, Predicate, random_access_iterator_tag, 
+    count_if_switch(_RAIter, _RAIter, _Predicate, random_access_iterator_tag,
 		    __gnu_parallel::parallelism);
 
   // algobase.h
@@ -130,7 +130,8 @@ namespace __parallel
 
   template<typename _IIter1, typename _IIter2, typename Predicate>
     bool
-  equal(_IIter1, _IIter1, _IIter2, Predicate, __gnu_parallel::sequential_tag);
+    equal(_IIter1, _IIter1, _IIter2, Predicate,
+	  __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2>
     bool
@@ -140,45 +141,47 @@ namespace __parallel
     bool
     equal(_IIter1, _IIter1, _IIter2, Predicate);
 
-  template<typename _IIter, typename T>
+  template<typename _IIter, typename _Tp>
     _IIter
-  find(_IIter, _IIter, const T&, __gnu_parallel::sequential_tag);
+    find(_IIter, _IIter, const _Tp&, __gnu_parallel::sequential_tag);
 
-  template<typename _IIter, typename T>
+  template<typename _IIter, typename _Tp>
     _IIter
-  find(_IIter, _IIter, const T& val);
+    find(_IIter, _IIter, const _Tp& val);
 
-  template<typename _IIter, typename T, typename _IterTag>
+  template<typename _IIter, typename _Tp, typename _IterTag>
     _IIter
-  find_switch(_IIter, _IIter, const T&, _IterTag);
+    find_switch(_IIter, _IIter, const _Tp&, _IterTag);
 
-  template<typename _RAIter, typename T>
+  template<typename _RAIter, typename _Tp>
     _RAIter
-  find_switch(_RAIter, _RAIter, const T&, random_access_iterator_tag);
+    find_switch(_RAIter, _RAIter, const _Tp&, random_access_iterator_tag);
 
-  template<typename _IIter, typename Predicate>
+  template<typename _IIter, typename _Predicate>
     _IIter
-  find_if(_IIter, _IIter, Predicate, __gnu_parallel::sequential_tag);
+    find_if(_IIter, _IIter, _Predicate, __gnu_parallel::sequential_tag);
 
-  template<typename _IIter, typename Predicate>
+  template<typename _IIter, typename _Predicate>
     _IIter
-  find_if(_IIter, _IIter, Predicate);
+    find_if(_IIter, _IIter, _Predicate);
 
-  template<typename _IIter, typename Predicate, typename _IterTag>
+  template<typename _IIter, typename _Predicate, typename _IterTag>
     _IIter
-  find_if_switch(_IIter, _IIter, Predicate, _IterTag);
+    find_if_switch(_IIter, _IIter, _Predicate, _IterTag);
 
-  template<typename _RAIter, typename Predicate>
+  template<typename _RAIter, typename _Predicate>
     _RAIter
-  find_if_switch(_RAIter, _RAIter, Predicate, random_access_iterator_tag);
+    find_if_switch(_RAIter, _RAIter, _Predicate, random_access_iterator_tag);
 
   template<typename _IIter, typename _FIter>
     _IIter
-  find_first_of(_IIter, _IIter, _FIter, _FIter, __gnu_parallel::sequential_tag);
+    find_first_of(_IIter, _IIter, _FIter, _FIter,
+		  __gnu_parallel::sequential_tag);
 
   template<typename _IIter, typename _FIter, typename _BiPredicate>
     _IIter
-  find_first_of(_IIter, _IIter, _FIter, _FIter, _BiPredicate, __gnu_parallel::sequential_tag);
+    find_first_of(_IIter, _IIter, _FIter, _FIter, _BiPredicate,
+		  __gnu_parallel::sequential_tag);
 
   template<typename _IIter, typename _FIter, typename _BiPredicate>
     _IIter
@@ -188,131 +191,147 @@ namespace __parallel
     _IIter
     find_first_of(_IIter, _IIter, _FIter, _FIter);
 
-  template<typename _IIter, typename _FIter, typename _IterTag1, typename _IterTag2>
+  template<typename _IIter, typename _FIter,
+	   typename _IterTag1, typename _IterTag2>
     _IIter
     find_first_of_switch(_IIter, _IIter, _FIter, _FIter, _IterTag1, _IterTag2);
 
-  template<typename _RAIter, typename _FIter, typename _BiPredicate, typename _IterTag>
+  template<typename _RAIter, typename _FIter, typename _BiPredicate,
+	   typename _IterTag>
     _RAIter
-  find_first_of_switch(_RAIter, _RAIter, _FIter, _FIter, _BiPredicate, random_access_iterator_tag, _IterTag);
+    find_first_of_switch(_RAIter, _RAIter, _FIter, _FIter, _BiPredicate,
+			 random_access_iterator_tag, _IterTag);
 
-  template<typename _IIter, typename _FIter, typename _BiPredicate, typename _IterTag1, typename _IterTag2>
+  template<typename _IIter, typename _FIter, typename _BiPredicate,
+	   typename _IterTag1, typename _IterTag2>
     _IIter
-  find_first_of_switch(_IIter, _IIter, _FIter, _FIter, _BiPredicate, _IterTag1, _IterTag2);
+    find_first_of_switch(_IIter, _IIter, _FIter, _FIter, _BiPredicate,
+			 _IterTag1, _IterTag2);
 
 
-  template<typename _IIter, typename Function>
+  template<typename _IIter, typename _Function>
-    Function
+    _Function
-    for_each(_IIter, _IIter, Function);
+    for_each(_IIter, _IIter, _Function);
 
-  template<typename _IIter, typename Function>
+  template<typename _IIter, typename _Function>
-    Function
+    _Function
-    for_each(_IIter, _IIter, Function, __gnu_parallel::sequential_tag);
+    for_each(_IIter, _IIter, _Function, __gnu_parallel::sequential_tag);
 
-  template<typename Iterator, typename Function>
+  template<typename _Iterator, typename _Function>
-    Function
+    _Function
-    for_each(Iterator, Iterator, Function, __gnu_parallel::parallelism);
+    for_each(_Iterator, _Iterator, _Function, __gnu_parallel::parallelism);
 
-  template<typename _IIter, typename Function, typename _IterTag>
+  template<typename _IIter, typename _Function, typename _IterTag>
-    Function
+    _Function
-    for_each_switch(_IIter, _IIter, Function, _IterTag);
+    for_each_switch(_IIter, _IIter, _Function, _IterTag);
 
-  template<typename _RAIter, typename Function>
+  template<typename _RAIter, typename _Function>
-    Function
+    _Function
-    for_each_switch(_RAIter, _RAIter, Function, random_access_iterator_tag, 
+    for_each_switch(_RAIter, _RAIter, _Function, random_access_iterator_tag, 
 		    __gnu_parallel::parallelism);
 
 
-  template<typename _FIter, typename Generator>
+  template<typename _FIter, typename _Generator>
     void
-    generate(_FIter, _FIter, Generator);
+    generate(_FIter, _FIter, _Generator);
 
-  template<typename _FIter, typename Generator>
+  template<typename _FIter, typename _Generator>
     void
-    generate(_FIter, _FIter, Generator, __gnu_parallel::sequential_tag);
+    generate(_FIter, _FIter, _Generator, __gnu_parallel::sequential_tag);
 
-  template<typename _FIter, typename Generator>
+  template<typename _FIter, typename _Generator>
     void
-    generate(_FIter, _FIter, Generator, __gnu_parallel::parallelism);
+    generate(_FIter, _FIter, _Generator, __gnu_parallel::parallelism);
 
-  template<typename _FIter, typename Generator, typename _IterTag>
+  template<typename _FIter, typename _Generator, typename _IterTag>
     void
-    generate_switch(_FIter, _FIter, Generator, _IterTag);
+    generate_switch(_FIter, _FIter, _Generator, _IterTag);
 
-  template<typename _RAIter, typename Generator>
+  template<typename _RAIter, typename _Generator>
     void
-    generate_switch(_RAIter, _RAIter, Generator, random_access_iterator_tag, 
+    generate_switch(_RAIter, _RAIter, _Generator, random_access_iterator_tag, 
 		    __gnu_parallel::parallelism);
 
-  template<typename _OIter, typename Size, typename Generator>
+  template<typename _OIter, typename _Size, typename _Generator>
     _OIter
-    generate_n(_OIter, Size, Generator);
+    generate_n(_OIter, _Size, _Generator);
 
-  template<typename _OIter, typename Size, typename Generator>
+  template<typename _OIter, typename _Size, typename _Generator>
     _OIter
-    generate_n(_OIter, Size, Generator, __gnu_parallel::sequential_tag);
+    generate_n(_OIter, _Size, _Generator, __gnu_parallel::sequential_tag);
 
-  template<typename _OIter, typename Size, typename Generator>
+  template<typename _OIter, typename _Size, typename _Generator>
     _OIter
-    generate_n(_OIter, Size, Generator, __gnu_parallel::parallelism);
+    generate_n(_OIter, _Size, _Generator, __gnu_parallel::parallelism);
 
-  template<typename _OIter, typename Size, typename Generator, typename _IterTag>
+  template<typename _OIter, typename _Size, typename _Generator,
+	   typename _IterTag>
     _OIter
-    generate_n_switch(_OIter, Size, Generator, _IterTag);
+    generate_n_switch(_OIter, _Size, _Generator, _IterTag);
 
-  template<typename _RAIter, typename Size, typename Generator>
+  template<typename _RAIter, typename _Size, typename _Generator>
     _RAIter
-    generate_n_switch(_RAIter, Size, Generator, random_access_iterator_tag, 
+    generate_n_switch(_RAIter, _Size, _Generator, random_access_iterator_tag, 
 		      __gnu_parallel::parallelism);
 
   template<typename _IIter1, typename _IIter2>
     bool
-  lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, __gnu_parallel::sequential_tag);
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2,
+			    __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
     bool
-  lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, Predicate, __gnu_parallel::sequential_tag);
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Predicate,
+			    __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2>
     bool
     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
     bool
-  lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, Predicate);
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Predicate);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate, typename _IterTag1, typename _IterTag2>
+  template<typename _IIter1, typename _IIter2,
+	   typename _Predicate, typename _IterTag1, typename _IterTag2>
     bool
-  lexicographical_compare_switch(_IIter1, _IIter1, _IIter2, _IIter2, Predicate, _IterTag1, _IterTag2);
+    lexicographical_compare_switch(_IIter1, _IIter1, _IIter2, _IIter2,
+				   _Predicate, _IterTag1, _IterTag2);
 
-  template<typename _RAIter1, typename _RAIter2, typename Predicate>
+  template<typename _RAIter1, typename _RAIter2, typename _Predicate>
     bool
-  lexicographical_compare_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, Predicate, random_access_iterator_tag, random_access_iterator_tag);
+    lexicographical_compare_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+				   _Predicate, random_access_iterator_tag,
+				   random_access_iterator_tag);
 
   // algo.h
   template<typename _IIter1, typename _IIter2>
     pair<_IIter1, _IIter2>
     mismatch(_IIter1, _IIter1, _IIter2, __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
     pair<_IIter1, _IIter2>
-  mismatch(_IIter1, _IIter1, _IIter2, Predicate, __gnu_parallel::sequential_tag);
+    mismatch(_IIter1, _IIter1, _IIter2, _Predicate,
+	     __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2>
     pair<_IIter1, _IIter2>
     mismatch(_IIter1, _IIter1, _IIter2);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
     pair<_IIter1, _IIter2>
-  mismatch(_IIter1, _IIter1, _IIter2, Predicate);
+    mismatch(_IIter1, _IIter1, _IIter2, _Predicate);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate, typename _IterTag1, typename _IterTag2>
+  template<typename _IIter1, typename _IIter2, typename _Predicate,
+	   typename _IterTag1, typename _IterTag2>
     pair<_IIter1, _IIter2>
-  mismatch_switch(_IIter1, _IIter1, _IIter2, Predicate, _IterTag1, _IterTag2);
+    mismatch_switch(_IIter1, _IIter1, _IIter2, _Predicate,
+		    _IterTag1, _IterTag2);
 
-  template<typename _RAIter1, typename _RAIter2, typename Predicate>
+  template<typename _RAIter1, typename _RAIter2, typename _Predicate>
     pair<_RAIter1, _RAIter2>
-  mismatch_switch(_RAIter1, _RAIter1, _RAIter2, Predicate, random_access_iterator_tag, random_access_iterator_tag);
+    mismatch_switch(_RAIter1, _RAIter1, _RAIter2, _Predicate,
+		    random_access_iterator_tag, random_access_iterator_tag);
 
   template<typename _FIter1, typename _FIter2>
     _FIter1
@@ -324,7 +343,8 @@ namespace __parallel
 
   template<typename _FIter1, typename _FIter2, typename _BiPredicate>
     _FIter1
-  search(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate, __gnu_parallel::sequential_tag);
+    search(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate,
+	   __gnu_parallel::sequential_tag);
 
   template<typename _FIter1, typename _FIter2, typename _BiPredicate>
     _FIter1
@@ -332,43 +352,56 @@ namespace __parallel
 
   template<typename _RAIter1, typename _RAIter2>
     _RAIter1
-  search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, random_access_iterator_tag, random_access_iterator_tag);
+    search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+		  random_access_iterator_tag, random_access_iterator_tag);
 
-  template<typename _FIter1, typename _FIter2, typename _IterTag1, typename _IterTag2>
+  template<typename _FIter1, typename _FIter2, typename _IterTag1,
+	   typename _IterTag2>
     _FIter1
     search_switch(_FIter1, _FIter1, _FIter2, _FIter2, _IterTag1, _IterTag2);
 
   template<typename _RAIter1, typename _RAIter2, typename _BiPredicate>
     _RAIter1
-  search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _BiPredicate , random_access_iterator_tag, random_access_iterator_tag);
+    search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _BiPredicate,
+		  random_access_iterator_tag, random_access_iterator_tag);
 
-  template<typename _FIter1, typename _FIter2, typename _BiPredicate, typename _IterTag1, typename _IterTag2>
+  template<typename _FIter1, typename _FIter2, typename _BiPredicate,
+	   typename _IterTag1, typename _IterTag2>
     _FIter1
-  search_switch(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate, _IterTag1, _IterTag2);
+    search_switch(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate,
+		  _IterTag1, _IterTag2);
 
-  template<typename _FIter, typename Integer, typename T>
+  template<typename _FIter, typename _Integer, typename _Tp>
     _FIter
-  search_n(_FIter, _FIter, Integer, const T&, __gnu_parallel::sequential_tag);
+    search_n(_FIter, _FIter, _Integer, const _Tp&,
+	     __gnu_parallel::sequential_tag);
 
-  template<typename _FIter, typename Integer, typename T, typename _BiPredicate>
+  template<typename _FIter, typename _Integer, typename _Tp,
+	   typename _BiPredicate>
     _FIter
-  search_n(_FIter, _FIter, Integer, const T&, _BiPredicate, __gnu_parallel::sequential_tag);
+    search_n(_FIter, _FIter, _Integer, const _Tp&, _BiPredicate,
+	     __gnu_parallel::sequential_tag);
     
-  template<typename _FIter, typename Integer, typename T>
+  template<typename _FIter, typename _Integer, typename _Tp>
     _FIter
-  search_n(_FIter, _FIter, Integer, const T& val);
+    search_n(_FIter, _FIter, _Integer, const _Tp&);
 
-  template<typename _FIter, typename Integer, typename T, typename _BiPredicate>
+  template<typename _FIter, typename _Integer, typename _Tp,
+	   typename _BiPredicate>
     _FIter
-  search_n(_FIter, _FIter, Integer, const T&, _BiPredicate);
+    search_n(_FIter, _FIter, _Integer, const _Tp&, _BiPredicate);
 
-  template<typename _RAIter, typename Integer, typename T, typename _BiPredicate>
+  template<typename _RAIter, typename _Integer, typename _Tp,
+	   typename _BiPredicate>
     _RAIter
-  search_n_switch(_RAIter, _RAIter, Integer, const T&, _BiPredicate, random_access_iterator_tag);
+    search_n_switch(_RAIter, _RAIter, _Integer, const _Tp&,
+		    _BiPredicate, random_access_iterator_tag);
 
-  template<typename _FIter, typename Integer, typename T, typename _BiPredicate, typename _IterTag>
+  template<typename _FIter, typename _Integer, typename _Tp,
+	   typename _BiPredicate, typename _IterTag>
     _FIter
-  search_n_switch(_FIter, _FIter, Integer, const T&, _BiPredicate, _IterTag);
+    search_n_switch(_FIter, _FIter, _Integer, const _Tp&,
+		    _BiPredicate, _IterTag);
 
 
   template<typename _IIter, typename _OIter, typename UnaryOperation>
@@ -385,7 +418,8 @@ namespace __parallel
     transform(_IIter, _IIter, _OIter, UnaryOperation, 
 	      __gnu_parallel::parallelism);
 
-  template<typename _IIter, typename _OIter, typename UnaryOperation, typename _IterTag1, typename _IterTag2>
+  template<typename _IIter, typename _OIter, typename UnaryOperation,
+	   typename _IterTag1, typename _IterTag2>
     _OIter
     transform1_switch(_IIter, _IIter, _OIter, UnaryOperation, 
 		      _IterTag1, _IterTag2);
@@ -398,80 +432,89 @@ namespace __parallel
 		      __gnu_parallel::parallelism);
 
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename _BiOperation>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _BiOperation>
     _OIter
     transform(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename _BiOperation>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _BiOperation>
     _OIter
     transform(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation, 
 	      __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename _BiOperation>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _BiOperation>
     _OIter
     transform(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation, 
 	      __gnu_parallel::parallelism);
 
-  template<typename _RAIter1, typename _RAIter2, typename _RAIter3, typename _BiOperation>
+  template<typename _RAIter1, typename _RAIter2, typename _RAIter3,
+	   typename _BiOperation>
     _RAIter3
     transform2_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter3, _BiOperation, 
 		      random_access_iterator_tag, random_access_iterator_tag, 
 		      random_access_iterator_tag, 
 		      __gnu_parallel::parallelism parallelism_tag);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename _BiOperation, typename tag1, typename tag2, typename tag3>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _BiOperation, typename _Tag1,
+	   typename _Tag2, typename _Tag3>
     _OIter
     transform2_switch(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation, 
-		      tag1, tag2, tag3);
+		      _Tag1, _Tag2, _Tag3);
 
 
-  template<typename _FIter, typename T>
+  template<typename _FIter, typename _Tp>
     void
-    replace(_FIter, _FIter, const T&, const T&);
+    replace(_FIter, _FIter, const _Tp&, const _Tp&);
 
-  template<typename _FIter, typename T>
+  template<typename _FIter, typename _Tp>
     void
-    replace(_FIter, _FIter, const T&, const T&, 
+    replace(_FIter, _FIter, const _Tp&, const _Tp&, 
 	    __gnu_parallel::sequential_tag);
 
-  template<typename _FIter, typename T>
+  template<typename _FIter, typename _Tp>
     void
-    replace(_FIter, _FIter, const T&, const T&, __gnu_parallel::parallelism);
+    replace(_FIter, _FIter, const _Tp&, const _Tp&,
-
-  template<typename _FIter, typename T, typename _IterTag>
-    void
-    replace_switch(_FIter, _FIter, const T&, const T&, _IterTag);
-
-  template<typename _RAIter, typename T>
-    void
-    replace_switch(_RAIter, _RAIter, const T&, const T&, 
-		   random_access_iterator_tag, __gnu_parallel::parallelism);
-
-
-  template<typename _FIter, typename Predicate, typename T>
-    void
-    replace_if(_FIter, _FIter, Predicate, const T&);
-
-  template<typename _FIter, typename Predicate, typename T>
-    void
-    replace_if(_FIter, _FIter, Predicate, const T&, 
-	       __gnu_parallel::sequential_tag);
-
-  template<typename _FIter, typename Predicate, typename T>
-    void
-    replace_if(_FIter, _FIter, Predicate, const T&, 
 	    __gnu_parallel::parallelism);
 
-  template<typename _FIter, typename Predicate, typename T, typename _IterTag>
+  template<typename _FIter, typename _Tp, typename _IterTag>
     void
-    replace_if_switch(_FIter, _FIter, Predicate, const T&, _IterTag);
+    replace_switch(_FIter, _FIter, const _Tp&, const _Tp&, _IterTag);
 
-  template<typename _RAIter, typename Predicate, typename T>
+  template<typename _RAIter, typename _Tp>
     void
-    replace_if_switch(_RAIter, _RAIter, Predicate, const T&, 
+    replace_switch(_RAIter, _RAIter, const _Tp&, const _Tp&, 
 		   random_access_iterator_tag, __gnu_parallel::parallelism);
 
 
+  template<typename _FIter, typename _Predicate, typename _Tp>
+    void
+    replace_if(_FIter, _FIter, _Predicate, const _Tp&);
+
+  template<typename _FIter, typename _Predicate, typename _Tp>
+    void
+    replace_if(_FIter, _FIter, _Predicate, const _Tp&,
+	       __gnu_parallel::sequential_tag);
+
+  template<typename _FIter, typename _Predicate, typename _Tp>
+    void
+    replace_if(_FIter, _FIter, _Predicate, const _Tp&,
+	       __gnu_parallel::parallelism);
+
+  template<typename _FIter, typename _Predicate, typename _Tp,
+	   typename _IterTag>
+    void
+    replace_if_switch(_FIter, _FIter, _Predicate, const _Tp&, _IterTag);
+ 
+  template<typename _RAIter, typename _Predicate, typename _Tp>
+    void
+    replace_if_switch(_RAIter, _RAIter, _Predicate, const _Tp&,
+		      random_access_iterator_tag,
+		      __gnu_parallel::parallelism);
+
+
   template<typename _FIter>
     _FIter
     max_element(_FIter, _FIter);
@@ -511,12 +554,14 @@ namespace __parallel
     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, 
 	  __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename _Compare>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Compare>
     _OIter
     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, 
 	  __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename _Compare>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Compare>
     _OIter
     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 
@@ -524,12 +569,15 @@ namespace __parallel
     _OIter
     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename _Compare, typename _IterTag1, typename _IterTag2, typename _IterTag3>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Compare, typename _IterTag1, typename _IterTag2,
+	   typename _IterTag3>
     _OIter
     merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, 
 		 _IterTag1, _IterTag2, _IterTag3);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename _Compare>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Compare>
     _OIter
     merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, 
 		 random_access_iterator_tag, random_access_iterator_tag, 
@@ -575,7 +623,8 @@ namespace __parallel
 
   template<typename _RAIter, typename _Compare>
     void
-  nth_element(_RAIter, _RAIter, _RAIter, _Compare, __gnu_parallel::sequential_tag);
+    nth_element(_RAIter, _RAIter, _RAIter, _Compare,
+		__gnu_parallel::sequential_tag);
 
   template<typename _RAIter, typename _Compare>
     void
@@ -587,7 +636,8 @@ namespace __parallel
 
   template<typename _RAIter, typename _Compare>
     void
-  partial_sort(_RAIter, _RAIter, _RAIter, _Compare, __gnu_parallel::sequential_tag);
+    partial_sort(_RAIter, _RAIter, _RAIter, _Compare,
+		 __gnu_parallel::sequential_tag);
 
   template<typename _RAIter>
     void
@@ -621,114 +671,163 @@ namespace __parallel
     void
     random_shuffle(_RAIter, _RAIter, __gnu_parallel::sequential_tag);
 
-  template<typename _RAIter, typename RandomNumberGenerator>
+  template<typename _RAIter, typename _RandomNumberGenerator>
     void
-  random_shuffle(_RAIter, _RAIter, RandomNumberGenerator& rand, __gnu_parallel::sequential_tag);
+    random_shuffle(_RAIter, _RAIter, _RandomNumberGenerator&,
+		   __gnu_parallel::sequential_tag);
 
   template<typename _RAIter>
     void
     random_shuffle(_RAIter, _RAIter);
 
-  template<typename _RAIter, typename RandomNumberGenerator>
+  template<typename _RAIter, typename _RandomNumberGenerator>
     void
-  random_shuffle(_RAIter, _RAIter, RandomNumberGenerator& rand);
+    random_shuffle(_RAIter, _RAIter, _RandomNumberGenerator&);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _OIter
-  set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, __gnu_parallel::sequential_tag);
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+	    __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename Predicate>
     _OIter
-  set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, __gnu_parallel::sequential_tag);
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate,
+	      __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _OIter
     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Predicate>
     _OIter 
-  set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate);
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate, typename _OIter, typename _IterTag1, typename _IterTag2, typename _IterTag3>
+  template<typename _IIter1, typename _IIter2, typename _Predicate,
+	   typename _OIter, typename _IterTag1, typename _IterTag2,
+	   typename _IterTag3>
     _OIter
-  set_union_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, _IterTag1, _IterTag2, _IterTag3);
+    set_union_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+		     _Predicate, _IterTag1, _IterTag2, _IterTag3);
 
-  template<typename _RAIter1, typename _RAIter2, typename Output_RAIter, typename Predicate>
+  template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
-  Output_RAIter 
+	   typename _Predicate>
-  set_union_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, Output_RAIter, Predicate, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag);
+    _Output_RAIter
+    set_union_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _Output_RAIter,
+		     _Predicate, random_access_iterator_tag,
+		     random_access_iterator_tag, random_access_iterator_tag);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _OIter
-  set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, __gnu_parallel::sequential_tag);
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+		     __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Predicate>
     _OIter
-  set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, __gnu_parallel::sequential_tag);
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate,
+		     __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _OIter
     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Predicate>
     _OIter 
-  set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate);
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate, typename _OIter, typename _IterTag1, typename _IterTag2, typename _IterTag3>
+  template<typename _IIter1, typename _IIter2, typename _Predicate,
+	   typename _OIter, typename _IterTag1, typename _IterTag2,
+	   typename _IterTag3>
     _OIter
-  set_intersection_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, _IterTag1, _IterTag2, _IterTag3);
+    set_intersection_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+			    _Predicate, _IterTag1, _IterTag2, _IterTag3);
 
-  template<typename _RAIter1, typename _RAIter2, typename Output_RAIter, typename Predicate>
+  template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
-  Output_RAIter 
+	   typename _Predicate>
-  set_intersection_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, Output_RAIter, Predicate, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag);
+    _Output_RAIter
+    set_intersection_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+			    _Output_RAIter, _Predicate,
+			    random_access_iterator_tag,
+			    random_access_iterator_tag,
+			    random_access_iterator_tag);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _OIter
-  set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, __gnu_parallel::sequential_tag);
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+			     __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Predicate>
     _OIter
-  set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, __gnu_parallel::sequential_tag);
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+			     _Predicate, __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _OIter 
     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Predicate>
     _OIter 
-  set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate);
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+			     _Predicate);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate, typename _OIter, typename _IterTag1, typename _IterTag2, typename _IterTag3>
+  template<typename _IIter1, typename _IIter2, typename _Predicate,
+	   typename _OIter, typename _IterTag1, typename _IterTag2,
+	   typename _IterTag3>
     _OIter
-  set_symmetric_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, _IterTag1, _IterTag2, _IterTag3);
+    set_symmetric_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2,
+				    _OIter, _Predicate, _IterTag1, _IterTag2,
+				    _IterTag3);
 
-  template<typename _RAIter1, typename _RAIter2, typename Output_RAIter, typename Predicate>
+  template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
-  Output_RAIter 
+	   typename _Predicate>
-  set_symmetric_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, Output_RAIter, Predicate, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag);
+    _Output_RAIter
+    set_symmetric_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+				    _Output_RAIter, _Predicate,
+				    random_access_iterator_tag,
+				    random_access_iterator_tag,
+				    random_access_iterator_tag);
 
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _OIter
-  set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, __gnu_parallel::sequential_tag);
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+		   __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Predicate>
     _OIter
-  set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, __gnu_parallel::sequential_tag);
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate,
+		   __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _OIter
     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Predicate>
     _OIter
-  set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate);
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate, typename _OIter, typename _IterTag1, typename _IterTag2, typename _IterTag3>
+  template<typename _IIter1, typename _IIter2, typename _Predicate,
+	   typename _OIter, typename _IterTag1, typename _IterTag2,
+	   typename _IterTag3>
     _OIter
-  set_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, _IterTag1, _IterTag2, _IterTag3);
+    set_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+			  _Predicate, _IterTag1, _IterTag2, _IterTag3);
 
-  template<typename _RAIter1, typename _RAIter2, typename Output_RAIter, typename Predicate>
+  template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
-  Output_RAIter
+	   typename _Predicate>
-  set_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, Output_RAIter, Predicate, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag);
+    _Output_RAIter
+    set_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+			  _Output_RAIter, _Predicate,
+			  random_access_iterator_tag,
+			  random_access_iterator_tag,
+			  random_access_iterator_tag);
 
 
   template<typename _RAIter>
@@ -767,25 +866,28 @@ namespace __parallel
     _OIter
     unique_copy(_IIter, _IIter, _OIter, __gnu_parallel::sequential_tag);
 
-  template<typename _IIter, typename _OIter, typename Predicate>
+  template<typename _IIter, typename _OIter, typename _Predicate>
     _OIter
-  unique_copy(_IIter, _IIter, _OIter, Predicate, __gnu_parallel::sequential_tag);
+    unique_copy(_IIter, _IIter, _OIter, _Predicate,
+		__gnu_parallel::sequential_tag);
 
   template<typename _IIter, typename _OIter>
     _OIter
     unique_copy(_IIter, _IIter, _OIter);
 
-  template<typename _IIter, typename _OIter, typename Predicate>
+  template<typename _IIter, typename _OIter, typename _Predicate>
     _OIter
-  unique_copy(_IIter, _IIter, _OIter, Predicate);
+    unique_copy(_IIter, _IIter, _OIter, _Predicate);
 
-  template<typename _IIter, typename _OIter, typename Predicate, typename _IterTag1, typename _IterTag2>
+  template<typename _IIter, typename _OIter, typename _Predicate,
+	   typename _IterTag1, typename _IterTag2>
     _OIter
-  unique_copy_switch(_IIter, _IIter, _OIter, Predicate, _IterTag1, _IterTag2);
+    unique_copy_switch(_IIter, _IIter, _OIter, _Predicate,
+		       _IterTag1, _IterTag2);
 
-  template<typename _RAIter, typename RandomAccess_OIter, typename Predicate>
+  template<typename _RAIter, typename _RandomAccess_OIter, typename _Predicate>
-  RandomAccess_OIter
+    _RandomAccess_OIter
-  unique_copy_switch(_RAIter, _RAIter, RandomAccess_OIter, Predicate, 
+    unique_copy_switch(_RAIter, _RAIter, _RandomAccess_OIter, _Predicate,
 		       random_access_iterator_tag, random_access_iterator_tag);
 } // end namespace __parallel
 } // end namespace std

libstdc++-v3/include/parallel/balanced_quicksort.h

@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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
@@ -102,7 +102,7 @@ template<typename RandomAccessIterator>
   *  this part.
   *  @pre @c (end-begin)>=1 */
 template<typename RandomAccessIterator, typename Comparator>
-  inline typename std::iterator_traits<RandomAccessIterator>::difference_type
+  typename std::iterator_traits<RandomAccessIterator>::difference_type
   qsb_divide(RandomAccessIterator begin, RandomAccessIterator end,
              Comparator comp, thread_index_t num_threads)
   {
@@ -164,7 +164,7 @@ template<typename RandomAccessIterator, typename Comparator>
   *  @param num_threads
   *          Number of threads that are allowed to work on this part. */
 template<typename RandomAccessIterator, typename Comparator>
-  inline void
+  void
   qsb_conquer(QSBThreadLocal<RandomAccessIterator>** tls,
               RandomAccessIterator begin, RandomAccessIterator end,
               Comparator comp,
@@ -240,7 +240,7 @@ template<typename RandomAccessIterator, typename Comparator>
   *  @param iam Number of the thread processing this function.
   */
 template<typename RandomAccessIterator, typename Comparator>
-  inline void
+  void
   qsb_local_sort_with_helping(QSBThreadLocal<RandomAccessIterator>** tls,
                               Comparator& comp, int iam, bool wait)
   {
@@ -418,7 +418,7 @@ template<typename RandomAccessIterator, typename Comparator>
   *  this part.
   */
 template<typename RandomAccessIterator, typename Comparator>
-  inline void
+  void
   parallel_sort_qsb(RandomAccessIterator begin, RandomAccessIterator end,
                     Comparator comp,
                     typename std::iterator_traits<RandomAccessIterator>

libstdc++-v3/include/parallel/checkers.h

@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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
@@ -54,7 +54,10 @@ namespace __gnu_parallel
   // XXX Comparator default template argument
   template<typename InputIterator, typename Comparator>
     bool
-  is_sorted(InputIterator begin, InputIterator end, Comparator comp = std::less<typename std::iterator_traits<InputIterator>::value_type>())
+    is_sorted(InputIterator begin, InputIterator end,
+	      Comparator comp
+	      = std::less<typename std::iterator_traits<InputIterator>::
+	      value_type>())
     {
       if (begin == end)
 	return true;
@@ -66,7 +69,8 @@ namespace __gnu_parallel
 	{
 	  if (comp(*current, *recent))
 	    {
-	    printf("is_sorted: check failed before position %i.\n", position);
+	      printf("is_sorted: check failed before position %i.\n",
+		     position);
 	      return false;
 	    }
 	  recent = current;
@@ -88,7 +92,11 @@ namespace __gnu_parallel
   // XXX Comparator default template argument
   template<typename InputIterator, typename Comparator>
     bool
-  is_sorted_failure(InputIterator begin, InputIterator end, InputIterator& first_failure, Comparator comp = std::less<typename std::iterator_traits<InputIterator>::value_type>())
+    is_sorted_failure(InputIterator begin, InputIterator end,
+		      InputIterator& first_failure,
+		      Comparator comp
+		      = std::less<typename std::iterator_traits<InputIterator>::
+		      value_type>())
     {
       if (begin == end)
 	return true;
@@ -101,7 +109,8 @@ namespace __gnu_parallel
 	  if (comp(*current, *recent))
 	    {
 	      first_failure = current;
-	    printf("is_sorted: check failed before position %lld.\n", position);
+	      printf("is_sorted: check failed before position %lld.\n",
+		     position);
 	      return false;
 	    }
 	  recent = current;
@@ -123,7 +132,10 @@ namespace __gnu_parallel
   template<typename InputIterator, typename Comparator>
     bool
     // XXX Comparator default template argument
-  is_sorted_print_failures(InputIterator begin, InputIterator end, Comparator comp = std::less<typename std::iterator_traits<InputIterator>::value_type>())
+    is_sorted_print_failures(InputIterator begin, InputIterator end,
+			     Comparator comp
+			     = std::less<typename std::iterator_traits
+			     <InputIterator>::value_type>())
     {
       if (begin == end)
 	return true;

libstdc++-v3/include/parallel/find.h

@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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
@@ -58,8 +58,7 @@ namespace __gnu_parallel
  *  @param selector Functionality (e. g. std::find_if (), std::equal(),...)
  *  @return Place of finding in both sequences.
  */
-template<
+template<typename RandomAccessIterator1,
-    typename RandomAccessIterator1,
 	 typename RandomAccessIterator2,
 	 typename Pred,
 	 typename Selector>
@@ -96,8 +95,7 @@ template<
  *  @param selector Functionality (e. g. std::find_if (), std::equal(),...)
  *  @return Place of finding in both sequences.
  */
-template<
+template<typename RandomAccessIterator1,
-    typename RandomAccessIterator1,
 	 typename RandomAccessIterator2,
 	 typename Pred,
 	 typename Selector>
@@ -190,8 +188,7 @@ template<
  *     for CSB, the blocks are allocated in a predetermined manner,
  *     namely spacial round-robin.
  */
-template<
+template<typename RandomAccessIterator1,
-    typename RandomAccessIterator1,
 	 typename RandomAccessIterator2,
 	 typename Pred,
 	 typename Selector>
@@ -311,8 +308,7 @@ template<
  *  blocks are allocated in a predetermined manner, namely spacial
  *  round-robin.
  */
-template<
+template<typename RandomAccessIterator1,
-    typename RandomAccessIterator1,
 	 typename RandomAccessIterator2,
 	 typename Pred,
 	 typename Selector>

libstdc++-v3/include/parallel/find_selectors.h

@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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
@@ -60,8 +60,9 @@ namespace __gnu_parallel
      * @param i2 Iterator on second sequence (unused).
      * @param pred Find predicate.
      */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
+    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-    inline bool 
+	     typename Pred>
+      bool 
       operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred)
       { return pred(*i1); }
 
@@ -71,12 +72,14 @@ namespace __gnu_parallel
      *  @param begin2 Begin iterator of second sequence.
      *  @param pred Find predicate.
      */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
+    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-    inline std::pair<RandomAccessIterator1, RandomAccessIterator2> 
+	     typename Pred>
-    sequential_algorithm(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, Pred pred)
+      std::pair<RandomAccessIterator1, RandomAccessIterator2> 
-    {
+      sequential_algorithm(RandomAccessIterator1 begin1,
-      return std::make_pair(find_if(begin1, end1, pred, sequential_tag()), begin2);
+			   RandomAccessIterator1 end1,
-    }
+			   RandomAccessIterator2 begin2, Pred pred)
+      { return std::make_pair(find_if(begin1, end1, pred,
+				      sequential_tag()), begin2); }
   };
 
   /** @brief Test predicate on two adjacent elements. */
@@ -87,8 +90,9 @@ namespace __gnu_parallel
      *  @param i2 Iterator on second sequence (unused).
      *  @param pred Find predicate.
      */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
+    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-    inline bool 
+	     typename Pred>
+      bool 
       operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred)
       {
 	// Passed end iterator is one short.
@@ -101,12 +105,16 @@ namespace __gnu_parallel
      *  @param begin2 Begin iterator of second sequence.
      *  @param pred Find predicate.
      */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
+    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-    inline std::pair<RandomAccessIterator1, RandomAccessIterator2>
+	     typename Pred>
-    sequential_algorithm(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, Pred pred)
+      std::pair<RandomAccessIterator1, RandomAccessIterator2>
+      sequential_algorithm(RandomAccessIterator1 begin1,
+			   RandomAccessIterator1 end1,
+			   RandomAccessIterator2 begin2, Pred pred)
       {
 	// Passed end iterator is one short.
-      RandomAccessIterator1 spot = adjacent_find(begin1, end1 + 1, pred, sequential_tag());
+	RandomAccessIterator1 spot = adjacent_find(begin1, end1 + 1,
+						   pred, sequential_tag());
 	if (spot == (end1 + 1))
 	  spot = end1;
 	return std::make_pair(spot, begin2);
@@ -122,8 +130,9 @@ namespace __gnu_parallel
      *  @param i2 Iterator on second sequence (unused).
      *  @param pred Find predicate. 
      */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
+    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-    inline bool 
+	     typename Pred>
+      bool 
       operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred)
       { return !pred(*i1, *i2); }
 
@@ -134,12 +143,13 @@ namespace __gnu_parallel
      *  @param begin2 Begin iterator of second sequence.
      *  @param pred Find predicate. 
      */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
+    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-    inline std::pair<RandomAccessIterator1, RandomAccessIterator2>
+	     typename Pred>
-    sequential_algorithm(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, Pred pred)
+      std::pair<RandomAccessIterator1, RandomAccessIterator2>
-    { 
+      sequential_algorithm(RandomAccessIterator1 begin1,
-      return mismatch(begin1, end1, begin2, pred, sequential_tag()); 
+			   RandomAccessIterator1 end1,
-    }
+			   RandomAccessIterator2 begin2, Pred pred)
+      { return mismatch(begin1, end1, begin2, pred, sequential_tag()); }
   };
 
 
@@ -157,11 +167,13 @@ namespace __gnu_parallel
      *  @param i1 Iterator on first sequence.
      *  @param i2 Iterator on second sequence (unused).
      *  @param pred Find predicate. */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
+    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-    inline bool 
+	     typename Pred>
+      bool 
       operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred)
       {
-      for (ForwardIterator pos_in_candidates = begin; pos_in_candidates != end; pos_in_candidates++)
+	for (ForwardIterator pos_in_candidates = begin;
+	     pos_in_candidates != end; ++pos_in_candidates)
 	  if (pred(*i1, *pos_in_candidates))
 	    return true;
 	return false;
@@ -172,12 +184,14 @@ namespace __gnu_parallel
      *  @param end1 End iterator of first sequence.
      *  @param begin2 Begin iterator of second sequence.
      *  @param pred Find predicate. */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
+    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-    inline std::pair<RandomAccessIterator1, RandomAccessIterator2>
+	     typename Pred>
-    sequential_algorithm(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, Pred pred)
+      std::pair<RandomAccessIterator1, RandomAccessIterator2>
-    {
+      sequential_algorithm(RandomAccessIterator1 begin1,
-      return std::make_pair(find_first_of(begin1, end1, begin, end, pred, sequential_tag()), begin2);
+			   RandomAccessIterator1 end1,
-    }
+			   RandomAccessIterator2 begin2, Pred pred)
+      { return std::make_pair(find_first_of(begin1, end1, begin, end, pred,
+					    sequential_tag()), begin2); }
   };
 }
 

libstdc++-v3/include/parallel/for_each.h

@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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
@@ -61,22 +61,42 @@ namespace __gnu_parallel
    *  @param output Output iterator.
    *  @param bound Maximum number of elements processed.
    *  @param parallelism_tag Parallelization method */
-  template<typename InputIterator, typename UserOp, typename Functionality, typename Red, typename Result>
+  template<typename InputIterator, typename UserOp,
+	   typename Functionality, typename Red, typename Result>
     UserOp
     for_each_template_random_access(InputIterator begin, InputIterator end,
-				  UserOp user_op, Functionality& functionality,
+				    UserOp user_op,
+				    Functionality& functionality,
 				    Red reduction, Result reduction_start,
-				  Result& output,
+				    Result& output, typename
-				  typename std::iterator_traits<InputIterator>::difference_type bound, parallelism parallelism_tag)
+				    std::iterator_traits<InputIterator>::
+				    difference_type bound,
+				    parallelism parallelism_tag)
     {
       if (parallelism_tag == parallel_unbalanced)
-      return for_each_template_random_access_ed(begin, end, user_op, functionality, reduction, reduction_start, output, bound);
+	return for_each_template_random_access_ed(begin, end, user_op,
+						  functionality, reduction,
+						  reduction_start,
+						  output, bound);
       else if (parallelism_tag == parallel_omp_loop)
-      return for_each_template_random_access_omp_loop(begin, end, user_op, functionality, reduction, reduction_start, output, bound);
+	return for_each_template_random_access_omp_loop(begin, end, user_op,
+							functionality,
+							reduction,
+							reduction_start,
+							output, bound);
       else if (parallelism_tag == parallel_omp_loop_static)
-      return for_each_template_random_access_omp_loop(begin, end, user_op, functionality, reduction, reduction_start, output, bound);
+	return for_each_template_random_access_omp_loop(begin, end, user_op,
+							functionality,
+							reduction,
+							reduction_start,
+							output, bound);
       else	//e. g. parallel_balanced
-      return for_each_template_random_access_workstealing(begin, end, user_op, functionality, reduction, reduction_start, output, bound);
+	return for_each_template_random_access_workstealing(begin, end,
+							    user_op,
+							    functionality,
+							    reduction,
+							    reduction_start,
+							    output, bound);
   }
 }
 

libstdc++-v3/include/parallel/for_each_selectors.h

@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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
@@ -63,7 +63,8 @@ namespace __gnu_parallel
      *  @param o Operator.
      *  @param i Iterator referencing object. */
     template<typename Op>
-    inline bool operator()(Op& o, It i)
+      bool
+      operator()(Op& o, It i)
       {
 	o(*i);
 	return true;
@@ -78,7 +79,8 @@ namespace __gnu_parallel
      *  @param o Operator.
      *  @param i Iterator referencing object. */
     template<typename Op>
-    inline bool operator()(Op& o, It i)
+      bool
+      operator()(Op& o, It i)
       {
 	*i = o();
 	return true;
@@ -93,7 +95,8 @@ namespace __gnu_parallel
      *  @param v Current value.
      *  @param i Iterator referencing object. */
     template<typename Val>
-    inline bool operator()(Val& v, It i)
+      bool
+      operator()(Val& v, It i)
       {
 	*i = v;
 	return true;
@@ -108,7 +111,8 @@ namespace __gnu_parallel
      *  @param o Operator.
      *  @param i Iterator referencing object. */
     template<typename Op>
-    inline bool operator()(Op& o, It i)
+      bool
+      operator()(Op& o, It i)
       {
 	*i.second = o(*i.first);
 	return true;
@@ -123,7 +127,8 @@ namespace __gnu_parallel
      *  @param o Operator.
      *  @param i Iterator referencing object. */
     template<typename Op>
-    inline bool operator()(Op& o, It i)
+      bool
+      operator()(Op& o, It i)
       {
 	*i.third = o(*i.first, *i.second);
 	return true;
@@ -144,7 +149,8 @@ namespace __gnu_parallel
     /** @brief Functor execution.
      *  @param v Current value.
      *  @param i Iterator referencing object. */
-    inline bool operator()(T& v, It i)
+    bool
+    operator()(T& v, It i)
     {
       if (*i == v)
 	*i = new_val;
@@ -166,7 +172,8 @@ namespace __gnu_parallel
     /** @brief Functor execution.
      *  @param o Operator.
      *  @param i Iterator referencing object. */
-    inline bool operator()(Op& o, It i)
+    bool
+    operator()(Op& o, It i)
     {
       if (o(*i))
 	*i = new_val;
@@ -183,7 +190,8 @@ namespace __gnu_parallel
      *  @param i Iterator referencing object.
      *  @return 1 if count, 0 if does not count. */
     template<typename Val>
-    inline Diff operator()(Val& v, It i)
+      Diff
+      operator()(Val& v, It i)
       { return (v == *i) ? 1 : 0; }
   };
 
@@ -196,7 +204,8 @@ namespace __gnu_parallel
      *  @param i Iterator referencing object.
      *  @return 1 if count, 0 if does not count. */
     template<typename Op>
-    inline Diff operator()(Op& o, It i)
+      Diff
+      operator()(Op& o, It i)
       { return (o(*i)) ? 1 : 0; }
   };
 
@@ -209,7 +218,7 @@ namespace __gnu_parallel
      *  @param i Iterator referencing object.
      *  @return The current value. */
     template<typename Op>
-    inline typename std::iterator_traits<It>::value_type operator()(Op o, It i)
+      typename std::iterator_traits<It>::value_type operator()(Op o, It i)
       { return *i; }
   };
 
@@ -226,16 +235,19 @@ namespace __gnu_parallel
     /** @brief Constructor.
      *  @param b1 Begin iterator of first sequence.
      *  @param b2 Begin iterator of second sequence. */
-    explicit inner_product_selector(It b1, It2 b2) : begin1_iterator(b1), begin2_iterator(b2) { }
+    explicit inner_product_selector(It b1, It2 b2)
+    : begin1_iterator(b1), begin2_iterator(b2) { }
 
     /** @brief Functor execution.
      *  @param mult Multiplication functor.
      *  @param current Iterator referencing object.
      *  @return Inner product elemental result. */
     template<typename Op>
-    inline T operator()(Op mult, It current)
+      T
+      operator()(Op mult, It current)
       {
-      typename std::iterator_traits<It>::difference_type position = current - begin1_iterator;
+	typename std::iterator_traits<It>::difference_type position
+	  = current - begin1_iterator;
 	return mult(*current, *(begin2_iterator + position));
       }
   };
@@ -249,7 +261,8 @@ namespace __gnu_parallel
      *  @param i Iterator referencing object.
      *  @return Passed iterator. */
     template<typename Op>
-    inline It operator()(Op o, It i)
+      It
+      operator()(Op o, It i)
       { return i; }
   };
 
@@ -260,7 +273,8 @@ namespace __gnu_parallel
   struct adjacent_difference_selector : public generic_for_each_selector<It>
   {
     template<typename Op>
-    inline bool operator()(Op& o, It i)
+      bool
+      operator()(Op& o, It i)
       {
 	typename It::first_type go_back_one = i.first;
 	--go_back_one;
@@ -280,14 +294,15 @@ namespace __gnu_parallel
     /** @brief Functor execution.
      *  @param i Iterator referencing object. */
     template<typename It>
-    inline void operator()(It i)
+      void
-    { }
+      operator()(It i) { }
   };
 
   /** @brief Reduction function doing nothing. */
   struct dummy_reduct
   {
-    inline bool operator()(bool /*x*/, bool /*y*/) const
+    bool
+    operator()(bool /*x*/, bool /*y*/) const
     { return true; }
   };
 
@@ -300,7 +315,8 @@ namespace __gnu_parallel
     explicit min_element_reduct(Comp &c) : comp(c)
     { }
 
-    inline It operator()(It x, It y)
+    It
+    operator()(It x, It y)
     {
       if (comp(*x, *y))
 	return x;
@@ -318,7 +334,8 @@ namespace __gnu_parallel
     explicit max_element_reduct(Comp& c) : comp(c)
     { }
 
-    inline It operator()(It x, It y)
+    It
+    operator()(It x, It y)
     {
       if (comp(*x, *y))
 	return y;
@@ -336,7 +353,9 @@ namespace __gnu_parallel
     explicit accumulate_binop_reduct(BinOp& b) : binop(b) {}
 
     template<typename Result, typename Addend>
-    Result operator()(const Result& x, const Addend& y) { return binop(x, y); }
+      Result
+      operator()(const Result& x, const Addend& y)
+      { return binop(x, y); }
   };
 }
 

libstdc++-v3/include/parallel/iterator.h

@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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
@@ -120,11 +120,13 @@ namespace __gnu_parallel
   /** @brief A triple of iterators. The usual iterator operations are
       applied to all three child iterators.
    */
-  template<typename Iterator1, typename Iterator2, typename Iterator3, typename IteratorCategory>
+  template<typename Iterator1, typename Iterator2, typename Iterator3,
+	   typename IteratorCategory>
     class iterator_triple
     {
     private:
-    typedef iterator_triple<Iterator1, Iterator2, Iterator3, IteratorCategory> type;
+      typedef iterator_triple<Iterator1, Iterator2, Iterator3,
+			      IteratorCategory> type;
 
     public:
       typedef IteratorCategory iterator_category;

libstdc++-v3/include/parallel/list_partition.h

@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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
@@ -53,13 +53,13 @@ namespace __gnu_parallel
    */
   template<typename InputIterator>
     void
-  shrink_and_double(std::vector<InputIterator>& os_starts, size_t& count_to_two, size_t& range_length, const bool make_twice)
+    shrink_and_double(std::vector<InputIterator>& os_starts,
+		      size_t& count_to_two, size_t& range_length,
+		      const bool make_twice)
     {
       ++count_to_two;
       if (not make_twice or count_to_two < 2)
-      {
 	shrink(os_starts, count_to_two, range_length);
-      }
       else
 	{
 	  os_starts.resize((os_starts.size() - 1) * 2 + 1);
@@ -76,10 +76,9 @@ namespace __gnu_parallel
     shrink(std::vector<InputIterator>& os_starts, size_t& count_to_two,
 	   size_t& range_length)
     {
-    for (typename std::vector<InputIterator>::size_type i = 0; i <= (os_starts.size() / 2); ++i)
+      for (typename std::vector<InputIterator>::size_type i = 0;
-      {
+	   i <= (os_starts.size() / 2); ++i)
 	os_starts[i] = os_starts[i * 2];
-      }
       range_length *= 2;
     }
 
@@ -125,11 +124,13 @@ namespace __gnu_parallel
       size_t cur = 1, next = 1;
       size_t range_length = 1;
       size_t count_to_two = 0;
-    while (it != end){
+      while (it != end)
+	{
 	  cur = next;
 	  for (; cur < os_starts.size() and it != end; ++cur)
 	    {
-	  for (dist_limit += range_length; dist < dist_limit and it != end; ++dist)
+	      for (dist_limit += range_length;
+		   dist < dist_limit and it != end; ++dist)
 		{
 		  f(it);
 		  ++it;
@@ -143,7 +144,7 @@ namespace __gnu_parallel
 	    break;
 
 	  shrink_and_double(os_starts, count_to_two, range_length, make_twice);
-      next = os_starts.size()/2 + 1;
+	  next = os_starts.size() / 2 + 1;
 	}
 
       // Calculation of the parts (one must be extracted from current

libstdc++-v3/include/parallel/losertree.h

@@ -76,7 +76,6 @@ template<typename T, typename Comparator = std::less<T> >
     Comparator comp;
 
   public:
-    inline
     LoserTreeExplicit(unsigned int _size, Comparator _comp = std::less<T>())
     : comp(_comp)
     {
@@ -92,14 +91,14 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline ~LoserTreeExplicit()
+    ~LoserTreeExplicit()
     { delete[] losers; }
 
-    inline int
+    int
     get_min_source()
     { return losers[0].source; }
 
-    inline void
+    void
     insert_start(T key, int source, bool sup)
     {
       bool inf = false;
@@ -122,10 +121,10 @@ template<typename T, typename Comparator = std::less<T> >
       losers[0].source = source;
     }
 
-    inline void
+    void
     init() { }
 
-    inline void
+    void
     delete_min_insert(T key, bool sup)
     {
       bool inf = false;
@@ -151,7 +150,7 @@ template<typename T, typename Comparator = std::less<T> >
       losers[0].source = source;
     }
 
-    inline void
+    void
     insert_start_stable(T key, int source, bool sup)
     {
       bool inf = false;
@@ -176,10 +175,10 @@ template<typename T, typename Comparator = std::less<T> >
       losers[0].source = source;
     }
 
-    inline void
+    void
     init_stable() { }
 
-    inline void
+    void
     delete_min_insert_stable(T key, bool sup)
     {
       bool inf = false;
@@ -233,7 +232,7 @@ template<typename T, typename Comparator = std::less<T> >
     bool first_insert;
 
   public:
-    inline LoserTree(unsigned int _k, Comparator _comp = std::less<T>())
+    LoserTree(unsigned int _k, Comparator _comp = std::less<T>())
     : comp(_comp)
     {
       ik = _k;
@@ -249,14 +248,14 @@ template<typename T, typename Comparator = std::less<T> >
       first_insert = true;
     }
 
-    inline ~LoserTree()
+    ~LoserTree()
     { ::operator delete(losers); }
 
-    inline int
+    int
     get_min_source()
     { return losers[0].source; }
 
-    inline void
+    void
     insert_start(const T& key, int source, bool sup)
     {
       unsigned int pos = k + source;
@@ -303,12 +302,12 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline void
+    void
     init()
     { losers[0] = losers[init_winner(1)]; }
 
     // Do not pass const reference since key will be used as local variable.
-    inline void
+    void
     delete_min_insert(T key, bool sup)
     {
       int source = losers[0].source;
@@ -329,7 +328,7 @@ template<typename T, typename Comparator = std::less<T> >
       losers[0].key = key;
     }
 
-    inline void
+    void
     insert_start_stable(const T& key, int source, bool sup)
     { return insert_start(key, source, sup); }
 
@@ -361,12 +360,12 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline void
+    void
     init_stable()
     { losers[0] = losers[init_winner_stable(1)]; }
 
     // Do not pass const reference since key will be used as local variable.
-    inline void
+    void
     delete_min_insert_stable(T key, bool sup)
     {
       int source = losers[0].source;
@@ -432,7 +431,6 @@ template<typename T, typename Comparator = std::less<T> >
     Comparator comp;
 
   public:
-    inline
     LoserTreeReference(unsigned int _k, Comparator _comp = std::less<T>())
     : comp(_comp)
     {
@@ -449,7 +447,7 @@ template<typename T, typename Comparator = std::less<T> >
         losers[i + k].sup = true;
     }
 
-    inline ~LoserTreeReference()
+    ~LoserTreeReference()
     {
       delete[] losers;
 #ifndef COPY
@@ -457,11 +455,11 @@ template<typename T, typename Comparator = std::less<T> >
 #endif
     }
 
-    inline int
+    int
     get_min_source()
     { return losers[0].source; }
 
-    inline void
+    void
     insert_start(T key, int source, bool sup)
     {
       unsigned int pos = k + source;
@@ -498,13 +496,13 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline void
+    void
     init()
     {
       losers[0] = losers[init_winner(1)];
     }
 
-    inline void
+    void
     delete_min_insert(T key, bool sup)
     {
       int source = losers[0].source;
@@ -529,7 +527,7 @@ template<typename T, typename Comparator = std::less<T> >
 #endif
     }
 
-    inline void
+    void
     insert_start_stable(T key, int source, bool sup)
     { return insert_start(key, source, sup); }
 
@@ -560,11 +558,11 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline void
+    void
     init_stable()
     { losers[0] = losers[init_winner_stable(1)]; }
 
-    inline void
+    void
     delete_min_insert_stable(T key, bool sup)
     {
       int source = losers[0].source;
@@ -622,7 +620,6 @@ template<typename T, typename Comparator = std::less<T> >
     Comparator comp;
 
   public:
-    inline
     LoserTreePointer(unsigned int _k, Comparator _comp = std::less<T>())
       : comp(_comp)
     {
@@ -636,14 +633,14 @@ template<typename T, typename Comparator = std::less<T> >
         losers[i + k].sup = true;
     }
 
-    inline ~LoserTreePointer()
+    ~LoserTreePointer()
     { delete[] losers; }
 
-    inline int
+    int
     get_min_source()
     { return losers[0].source; }
 
-    inline void
+    void
     insert_start(const T& key, int source, bool sup)
     {
       unsigned int pos = k + source;
@@ -657,9 +654,7 @@ template<typename T, typename Comparator = std::less<T> >
     init_winner(unsigned int root)
     {
       if (root >= k)
-        {
 	return root;
-        }
       else
         {
           unsigned int left = init_winner (2 * root);
@@ -681,11 +676,11 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline void
+    void
     init()
     { losers[0] = losers[init_winner(1)]; }
 
-    inline void
+    void
     delete_min_insert(const T& key, bool sup)
     {
       const T* keyp = &key;
@@ -707,7 +702,7 @@ template<typename T, typename Comparator = std::less<T> >
       losers[0].keyp = keyp;
     }
 
-    inline void
+    void
     insert_start_stable(const T& key, int source, bool sup)
     { return insert_start(key, source, sup); }
 
@@ -739,11 +734,11 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline void
+    void
     init_stable()
     { losers[0] = losers[init_winner_stable(1)]; }
 
-    inline void
+    void
     delete_min_insert_stable(const T& key, bool sup)
     {
       const T* keyp = &key;
@@ -810,7 +805,6 @@ template<typename T, typename Comparator = std::less<T> >
     }
 
   public:
-    inline
     LoserTreeUnguarded(unsigned int _k, Comparator _comp = std::less<T>())
     : comp(_comp)
     {
@@ -823,17 +817,17 @@ template<typename T, typename Comparator = std::less<T> >
       map(1, 0, ik);
     }
 
-    inline ~LoserTreeUnguarded()
+    ~LoserTreeUnguarded()
     {
       delete[] losers;
       delete[] mapping;
     }
 
-    inline int
+    int
     get_min_source()
     { return losers[0].source; }
 
-    inline void
+    void
     insert_start(const T& key, int source, bool)
     {
       unsigned int pos = mapping[source];
@@ -868,12 +862,12 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline void
+    void
     init()
     { losers[0] = losers[init_winner(1, 0, ik)]; }
 
     // Do not pass const reference since key will be used as local variable.
-    inline void
+    void
     delete_min_insert(const T& key, bool)
     {
       losers[0].key = key;
@@ -891,15 +885,15 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline void
+    void
     insert_start_stable(const T& key, int source, bool)
     { return insert_start(key, source, false); }
 
-    inline void
+    void
     init_stable()
     { init(); }
 
-    inline void
+    void
     delete_min_insert_stable(const T& key, bool)
     {
       losers[0].key = key;
@@ -959,7 +953,6 @@ template<typename T, typename Comparator = std::less<T> >
     }
 
   public:
-    inline
     LoserTreePointerUnguarded(unsigned int _k,
                               Comparator _comp = std::less<T>())
     : comp(_comp)
@@ -974,17 +967,17 @@ template<typename T, typename Comparator = std::less<T> >
       map(1, 0, ik);
     }
 
-    inline ~LoserTreePointerUnguarded()
+    ~LoserTreePointerUnguarded()
     {
       delete[] losers;
       delete[] mapping;
     }
 
-    inline int
+    int
     get_min_source()
     { return losers[0].source; }
 
-    inline void
+    void
     insert_start(const T& key, int source, bool)
     {
       unsigned int pos = mapping[source];
@@ -1019,13 +1012,11 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline void
+    void
     init()
-    {
+    { losers[0] = losers[init_winner(1, 0, ik)]; }
-      losers[0] = losers[init_winner(1, 0, ik)];
-    }
 
-    inline void
+    void
     delete_min_insert(const T& key, bool)
     {
       const T* keyp = &key;
@@ -1044,15 +1035,15 @@ template<typename T, typename Comparator = std::less<T> >
       losers[0].keyp = keyp;
     }
 
-    inline void
+    void
     insert_start_stable(const T& key, int source, bool)
     { return insert_start(key, source, false); }
 
-    inline void
+    void
     init_stable()
     { init(); }
 
-    inline void
+    void
     delete_min_insert_stable(const T& key, bool)
     {
       int& source = losers[0].source;

libstdc++-v3/include/parallel/merge.h

@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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
@@ -56,9 +56,15 @@ namespace __gnu_parallel
    * @param max_length Maximum number of elements to merge.
    * @param comp Comparator.
    * @return Output end iterator. */
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename OutputIterator, typename _DifferenceTp, typename Comparator>
+  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	   typename OutputIterator, typename _DifferenceTp,
+	   typename Comparator>
     OutputIterator
-  merge_advance_usual(RandomAccessIterator1& begin1, RandomAccessIterator1 end1, RandomAccessIterator2& begin2, RandomAccessIterator2 end2, OutputIterator target, _DifferenceTp max_length, Comparator comp)
+    merge_advance_usual(RandomAccessIterator1& begin1,
+			RandomAccessIterator1 end1,
+			RandomAccessIterator2& begin2,
+			RandomAccessIterator2 end2, OutputIterator target,
+			_DifferenceTp max_length, Comparator comp)
     {
       typedef _DifferenceTp difference_type;
       while (begin1 != end1 && begin2 != end2 && max_length > 0)
@@ -99,13 +105,22 @@ namespace __gnu_parallel
    * @param max_length Maximum number of elements to merge.
    * @param comp Comparator.
    * @return Output end iterator. */
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename OutputIterator, typename _DifferenceTp, typename Comparator>
+  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	   typename OutputIterator, typename _DifferenceTp,
+	   typename Comparator>
     OutputIterator
-  merge_advance_movc(RandomAccessIterator1& begin1, RandomAccessIterator1 end1, RandomAccessIterator2& begin2, RandomAccessIterator2 end2, OutputIterator target, _DifferenceTp max_length, Comparator comp)
+    merge_advance_movc(RandomAccessIterator1& begin1,
+		       RandomAccessIterator1 end1,
+		       RandomAccessIterator2& begin2,
+		       RandomAccessIterator2 end2,
+		       OutputIterator target,
+		       _DifferenceTp max_length, Comparator comp)
     {
       typedef _DifferenceTp difference_type;
-    typedef typename std::iterator_traits<RandomAccessIterator1>::value_type value_type1;
+      typedef typename std::iterator_traits<RandomAccessIterator1>::value_type
-    typedef typename std::iterator_traits<RandomAccessIterator2>::value_type value_type2;
+	value_type1;
+      typedef typename std::iterator_traits<RandomAccessIterator2>::value_type
+	value_type2;
 
 #if _GLIBCXX_ASSERTIONS
       _GLIBCXX_PARALLEL_ASSERT(max_length >= 0);
@@ -124,9 +139,7 @@ namespace __gnu_parallel
 	      begin2 = next2;
 	    }
 	  else
-	  {
 	    begin1 = next1;
-	  }
 
 	  *target = element1;
 
@@ -160,13 +173,19 @@ namespace __gnu_parallel
    *  @param max_length Maximum number of elements to merge.
    *  @param comp Comparator.
    *  @return Output end iterator. */
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename OutputIterator, typename _DifferenceTp, typename Comparator>
+  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	   typename OutputIterator, typename _DifferenceTp,
+	   typename Comparator>
     inline OutputIterator
-  merge_advance(RandomAccessIterator1& begin1, RandomAccessIterator1 end1, RandomAccessIterator2& begin2, RandomAccessIterator2 end2, OutputIterator target, _DifferenceTp max_length, Comparator comp)
+    merge_advance(RandomAccessIterator1& begin1, RandomAccessIterator1 end1,
+		  RandomAccessIterator2& begin2, RandomAccessIterator2 end2,
+		  OutputIterator target, _DifferenceTp max_length,
+		  Comparator comp)
     {
       _GLIBCXX_CALL(max_length)
 
-      return merge_advance_movc(begin1, end1, begin2, end2, target, max_length, comp);
+      return merge_advance_movc(begin1, end1, begin2, end2, target,
+				max_length, comp);
     }
 
   /** @brief Merge routine fallback to sequential in case the
@@ -179,15 +198,20 @@ namespace __gnu_parallel
       *  @param max_length Maximum number of elements to merge.
       *  @param comp Comparator.
       *  @return Output end iterator. */
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename RandomAccessIterator3, typename Comparator>
+  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	   typename RandomAccessIterator3, typename Comparator>
     inline RandomAccessIterator3
-  parallel_merge_advance(RandomAccessIterator1& begin1, RandomAccessIterator1 end1,
+    parallel_merge_advance(RandomAccessIterator1& begin1,
-			 RandomAccessIterator2& begin2, RandomAccessIterator2 end2,	//different iterators, parallel implementation not available
+			   RandomAccessIterator1 end1,
-			 RandomAccessIterator3 target,
+			   RandomAccessIterator2& begin2,
-			 typename std::iterator_traits<RandomAccessIterator1>::difference_type max_length, Comparator comp)
+			   // different iterators, parallel implementation
-  {
+			   // not available			   
-    return merge_advance(begin1, end1, begin2, end2, target, max_length, comp);
+			   RandomAccessIterator2 end2,
-  }
+			   RandomAccessIterator3 target, typename
+			   std::iterator_traits<RandomAccessIterator1>::
+			   difference_type max_length, Comparator comp)
+    { return merge_advance(begin1, end1, begin2, end2, target,
+			   max_length, comp); }
 
   /** @brief Parallel merge routine being able to merge only the @c
    * max_length smallest elements.
@@ -204,19 +228,30 @@ namespace __gnu_parallel
    *  @param comp Comparator.
    *  @return Output end iterator.
    */
-  template<typename RandomAccessIterator1, typename RandomAccessIterator3, typename Comparator>
+  template<typename RandomAccessIterator1, typename RandomAccessIterator3,
+	   typename Comparator>
     inline RandomAccessIterator3
-  parallel_merge_advance(RandomAccessIterator1& begin1, RandomAccessIterator1 end1, RandomAccessIterator1& begin2, RandomAccessIterator1 end2, RandomAccessIterator3 target, typename std::iterator_traits<RandomAccessIterator1>::difference_type max_length, Comparator comp)
+    parallel_merge_advance(RandomAccessIterator1& begin1,
+			   RandomAccessIterator1 end1,
+			   RandomAccessIterator1& begin2,
+			   RandomAccessIterator1 end2,
+			   RandomAccessIterator3 target, typename
+			   std::iterator_traits<RandomAccessIterator1>::
+			   difference_type max_length, Comparator comp)
     {
       typedef typename std::iterator_traits<RandomAccessIterator1>::value_type
 	value_type;
-    typedef typename std::iterator_traits<RandomAccessIterator1>::difference_type
+      typedef typename std::iterator_traits<RandomAccessIterator1>::
-      difference_type1 /* == difference_type2 */;
+	difference_type difference_type1 /* == difference_type2 */;
-    typedef typename std::iterator_traits<RandomAccessIterator3>::difference_type
+      typedef typename std::iterator_traits<RandomAccessIterator3>::
-      difference_type3;
+	difference_type difference_type3;
 
-    std::pair<RandomAccessIterator1, RandomAccessIterator1> seqs[2] = { std::make_pair(begin1, end1), std::make_pair(begin2, end2) };
+      std::pair<RandomAccessIterator1, RandomAccessIterator1>
-    RandomAccessIterator3 target_end = parallel_multiway_merge(seqs, seqs + 2, target, comp, max_length, true, false);
+	seqs[2] = { std::make_pair(begin1, end1),
+		    std::make_pair(begin2, end2) };
+      RandomAccessIterator3 
+	target_end = parallel_multiway_merge(seqs, seqs + 2, target,
+					     comp, max_length, true, false);
 
       return target_end;
     }

libstdc++-v3/include/parallel/multiseq_selection.h

@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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
@@ -58,7 +58,8 @@ namespace __gnu_parallel
 {
   /** @brief Compare a pair of types lexicographically, ascending. */
   template<typename T1, typename T2, typename Comparator>
-  class lexicographic : public std::binary_function<std::pair<T1, T2>, std::pair<T1, T2>, bool>
+    class lexicographic
+    : public std::binary_function<std::pair<T1, T2>, std::pair<T1, T2>, bool>
     {
     private:
       Comparator& comp;
@@ -67,8 +68,9 @@ namespace __gnu_parallel
       lexicographic(Comparator& _comp) : comp(_comp) { }
 
       // XXX const
-    inline bool
+      bool
-    operator()(const std::pair<T1, T2>& p1, const std::pair<T1, T2>& p2) const
+      operator()(const std::pair<T1, T2>& p1,
+		 const std::pair<T1, T2>& p2) const
       {
 	if (comp(p1.first, p2.first))
 	  return true;
@@ -91,8 +93,9 @@ namespace __gnu_parallel
     public:
       lexicographic_reverse(Comparator& _comp) : comp(_comp) { }
 
-    inline bool
+      bool
-    operator()(const std::pair<T1, T2>& p1, const std::pair<T1, T2>& p2) const
+      operator()(const std::pair<T1, T2>& p1,
+		 const std::pair<T1, T2>& p2) const
       {
 	if (comp(p2.first, p1.first))
 	  return true;
@@ -121,17 +124,23 @@ namespace __gnu_parallel
    *  the respective sequence.
    *  @param comp The ordering functor, defaults to std::less<T>. 
    */
-  template<typename RanSeqs, typename RankType, typename RankIterator, typename Comparator>
+  template<typename RanSeqs, typename RankType, typename RankIterator,
+	   typename Comparator>
     void
-  multiseq_partition(RanSeqs begin_seqs, RanSeqs end_seqs, RankType rank,
+    multiseq_partition(RanSeqs begin_seqs, RanSeqs end_seqs,
+		       RankType rank,
 		       RankIterator begin_offsets,
 		       Comparator comp = std::less<
-		     typename std::iterator_traits<typename std::iterator_traits<RanSeqs>::value_type::first_type>::value_type>()) // std::less<T>
+		       typename std::iterator_traits<typename
+		       std::iterator_traits<RanSeqs>::value_type::
+		       first_type>::value_type>()) // std::less<T>
     {
       _GLIBCXX_CALL(end_seqs - begin_seqs)
 
-    typedef typename std::iterator_traits<RanSeqs>::value_type::first_type It;
+      typedef typename std::iterator_traits<RanSeqs>::value_type::first_type
-    typedef typename std::iterator_traits<It>::difference_type difference_type;
+	It;
+      typedef typename std::iterator_traits<It>::difference_type
+	difference_type;
       typedef typename std::iterator_traits<It>::value_type value_type;
 
       lexicographic<value_type, int, Comparator> lcomp(comp);
@@ -139,7 +148,8 @@ namespace __gnu_parallel
 
       // Number of sequences, number of elements in total (possibly
       // including padding).
-    difference_type m = std::distance(begin_seqs, end_seqs), N = 0, nmax, n, r;
+      difference_type m = std::distance(begin_seqs, end_seqs), N = 0,
+	nmax, n, r;
 
       for (int i = 0; i < m; i++)
 	N += std::distance(begin_seqs[i].first, begin_seqs[i].second);
@@ -240,7 +250,8 @@ namespace __gnu_parallel
 	    {
 	      difference_type middle = (b[i] + a[i]) / 2;
 	      if (lmax && middle < ns[i] &&
-		lcomp(std::make_pair(S(i)[middle], i), std::make_pair(*lmax, lmax_seq)))
+		  lcomp(std::make_pair(S(i)[middle], i),
+			std::make_pair(*lmax, lmax_seq)))
 		a[i] = std::min(a[i] + n + 1, ns[i]);
 	      else
 		b[i] -= n + 1;
@@ -253,12 +264,16 @@ namespace __gnu_parallel
 	      total += l / (n + 1);
 	    }
 	  
-	difference_type skew = static_cast<difference_type>(static_cast<uint64>(total) * rank / N - leftsize);
+	  difference_type skew = static_cast<difference_type>
+	    (static_cast<uint64>(total) * rank / N - leftsize);
 
 	  if (skew > 0)
 	    {
 	      // Move to the left, find smallest.
-	    std::priority_queue<std::pair<value_type, int>, std::vector<std::pair<value_type, int> >, lexicographic_reverse<value_type, int, Comparator> > pq(lrcomp);
+	      std::priority_queue<std::pair<value_type, int>,
+		std::vector<std::pair<value_type, int> >,
+		lexicographic_reverse<value_type, int, Comparator> >
+		pq(lrcomp);
 	      
 	      for (int i = 0; i < m; i++)
 		if (b[i] < ns[i])
@@ -279,7 +294,9 @@ namespace __gnu_parallel
 	  else if (skew < 0)
 	    {
 	      // Move to the right, find greatest.
-	    std::priority_queue<std::pair<value_type, int>, std::vector<std::pair<value_type, int> >, lexicographic<value_type, int, Comparator> > pq(lcomp);
+	      std::priority_queue<std::pair<value_type, int>,
+		std::vector<std::pair<value_type, int> >,
+		lexicographic<value_type, int, Comparator> > pq(lcomp);
 
 	      for (int i = 0; i < m; i++)
 		if (a[i] > 0)
@@ -360,15 +377,18 @@ namespace __gnu_parallel
    *  selected element is unique, this number is 0.
    *  @param comp The ordering functor, defaults to std::less. 
    */
-  template<typename T, typename RanSeqs, typename RankType, typename Comparator>
+  template<typename T, typename RanSeqs, typename RankType,
+	   typename Comparator>
     T
     multiseq_selection(RanSeqs begin_seqs, RanSeqs end_seqs, RankType rank,
 		       RankType& offset, Comparator comp = std::less<T>())
     {
       _GLIBCXX_CALL(end_seqs - begin_seqs)
 
-    typedef typename std::iterator_traits<RanSeqs>::value_type::first_type It;
+      typedef typename std::iterator_traits<RanSeqs>::value_type::first_type
-    typedef typename std::iterator_traits<It>::difference_type difference_type;
+	It;
+      typedef typename std::iterator_traits<It>::difference_type
+	difference_type;
 
       lexicographic<T, int, Comparator> lcomp(comp);
       lexicographic_reverse<T, int, Comparator> lrcomp(comp);
@@ -429,7 +449,8 @@ namespace __gnu_parallel
       for (int i = 0; i < m; i++)
 	if (n < ns[i])
 	  sample.push_back(std::make_pair(S(i)[n], i));
-    __gnu_sequential::sort(sample.begin(), sample.end(), lcomp, sequential_tag());
+      __gnu_sequential::sort(sample.begin(), sample.end(),
+			     lcomp, sequential_tag());
 
       // Conceptual infinity.
       for (int i = 0; i < m; i++)
@@ -455,9 +476,7 @@ namespace __gnu_parallel
 	      if (a[i] > 0)
 		{
 		  if (!lmax)
-		  {
 		    lmax = &(S(i)[a[i] - 1]);
-		  }
 		  else
 		    {
 		      if (comp(*lmax, S(i)[a[i] - 1]))	//max
@@ -483,18 +502,21 @@ namespace __gnu_parallel
 	      total += l / (n + 1);
 	    }
 
-	difference_type skew = (unsigned long long)total * rank / N - leftsize;
+	  difference_type skew = ((unsigned long long)total * rank / N
+				  - leftsize);
 
 	  if (skew > 0)
 	    {
 	      // Move to the left, find smallest.
-	    std::priority_queue<std::pair<T, int>, std::vector<std::pair<T, int> >, lexicographic_reverse<T, int, Comparator> > pq(lrcomp);
+	      std::priority_queue<std::pair<T, int>,
+		std::vector<std::pair<T, int> >,
+		lexicographic_reverse<T, int, Comparator> > pq(lrcomp);
 
 	      for (int i = 0; i < m; i++)
 		if (b[i] < ns[i])
 		  pq.push(std::make_pair(S(i)[b[i]], i));
 
-	    for (; skew != 0 && !pq.empty(); skew--)
+	      for (; skew != 0 && !pq.empty(); --skew)
 		{
 		  int source = pq.top().second;
 		  pq.pop();
@@ -509,13 +531,15 @@ namespace __gnu_parallel
 	  else if (skew < 0)
 	    {
 	      // Move to the right, find greatest.
-	    std::priority_queue<std::pair<T, int>, std::vector<std::pair<T, int> >, lexicographic<T, int, Comparator> > pq(lcomp);
+	      std::priority_queue<std::pair<T, int>,
+		std::vector<std::pair<T, int> >,
+		lexicographic<T, int, Comparator> > pq(lcomp);
 
 	      for (int i = 0; i < m; i++)
 		if (a[i] > 0)
 		  pq.push(std::make_pair(S(i)[a[i] - 1], i));
 
-	    for (; skew != 0; skew++)
+	      for (; skew != 0; ++skew)
 		{
 		  int source = pq.top().second;
 		  pq.pop();
@@ -588,7 +612,8 @@ namespace __gnu_parallel
 
 	  for (int i = 0; i < m; i++)
 	    {
-	    difference_type lb = std::lower_bound(S(i), S(i) + ns[i], minright,
+	      difference_type lb = std::lower_bound(S(i), S(i) + ns[i],
+						    minright,
 						    comp) - S(i);
 	      offset += a[i] - lb;
 	    }