multiway_merge.h: Reformat to 80 columns; adjust some inline specifiers; other minor style fixes.

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

	* include/parallel/multiway_merge.h: Reformat to 80 columns;
	adjust some inline specifiers; other minor style fixes.
	* include/parallel/losertree.h: Likewise.
	* include/parallel/list_partition.h: Likewise.
	* include/parallel/multiseq_selection.h: Likewise.
	* include/parallel/workstealing.h: Likewise.
	* include/parallel/base.h: Likewise.
	* include/parallel/par_loop.h: Likewise.
	* include/parallel/numeric: Likewise.
	* include/parallel/quicksort.h: Likewise.
	* include/parallel/algorithmfwd.h: Likewise.
	* include/parallel/for_each_selectors.h: Likewise.
	* include/parallel/omp_loop_static.h: Likewise.
	* include/parallel/random_shuffle.h: Likewise.
	* include/parallel/balanced_quicksort.h: Likewise.
	* include/parallel/set_operations.h: Likewise.
	* include/parallel/tree.h: Likewise.
	* include/parallel/merge.h: Likewise.
	* include/parallel/unique_copy.h: Likewise.
	* include/parallel/settings.h: Likewise.
	* include/parallel/multiway_mergesort.h: Likewise.
	* include/parallel/numericfwd.h: Likewise.
	* include/parallel/search.h: Likewise.
	* include/parallel/partition.h: Likewise.
	* include/parallel/compatibility.h: Likewise.
	* include/parallel/partial_sum.h: Likewise.
	* include/parallel/find.h: Likewise.
	* include/parallel/algo.h: Likewise.
	* include/parallel/queue.h: Likewise.
	* include/parallel/omp_loop.h: Likewise.
	* include/parallel/sort.h: Likewise.
	* include/parallel/random_number.h: Likewise.

From-SVN: r131440

libstdc++-v3/ChangeLog

+2008-01-09  Paolo Carlini  <pcarlini@suse.de>
+
+	* include/parallel/multiway_merge.h: Reformat to 80 columns;
+	adjust some inline specifiers; other minor style fixes.
+	* include/parallel/losertree.h: Likewise.
+	* include/parallel/list_partition.h: Likewise.
+	* include/parallel/multiseq_selection.h: Likewise.
+	* include/parallel/workstealing.h: Likewise.
+	* include/parallel/base.h: Likewise.
+	* include/parallel/par_loop.h: Likewise.
+	* include/parallel/numeric: Likewise.
+	* include/parallel/quicksort.h: Likewise.
+	* include/parallel/algorithmfwd.h: Likewise.
+	* include/parallel/for_each_selectors.h: Likewise.
+	* include/parallel/omp_loop_static.h: Likewise.
+	* include/parallel/random_shuffle.h: Likewise.
+	* include/parallel/balanced_quicksort.h: Likewise.
+	* include/parallel/set_operations.h: Likewise.
+	* include/parallel/tree.h: Likewise.
+	* include/parallel/merge.h: Likewise.
+	* include/parallel/unique_copy.h: Likewise.
+	* include/parallel/settings.h: Likewise.
+	* include/parallel/multiway_mergesort.h: Likewise.
+	* include/parallel/numericfwd.h: Likewise.
+	* include/parallel/search.h: Likewise.
+	* include/parallel/partition.h: Likewise.
+	* include/parallel/compatibility.h: Likewise.
+	* include/parallel/partial_sum.h: Likewise.
+	* include/parallel/find.h: Likewise.
+	* include/parallel/algo.h: Likewise.
+	* include/parallel/queue.h: Likewise.
+	* include/parallel/omp_loop.h: Likewise.
+	* include/parallel/sort.h: Likewise.
+	* include/parallel/random_number.h: Likewise.
+
 2008-01-09  Benjamin Kosnik  <bkoz@redhat.com>
 
 	* docs/html/17_intro/api.html: Fix markup for rope.h.

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

@@ -455,7 +455,7 @@ namespace __parallel
     transform2_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter3, _BiOperation, 
 		      random_access_iterator_tag, random_access_iterator_tag, 
 		      random_access_iterator_tag,
-		      __gnu_parallel::parallelism parallelism_tag);
+		      __gnu_parallel::parallelism);
 
   template<typename _IIter1, typename _IIter2, typename _OIter,
 	   typename _BiOperation, typename _Tag1,
@@ -525,7 +525,7 @@ namespace __parallel
 
   template<typename _FIter>
     _FIter
-    max_element(_FIter, _FIter, __gnu_parallel::parallelism parallelism_tag);
+    max_element(_FIter, _FIter, __gnu_parallel::parallelism);
 
   template<typename _FIter, typename _Compare>
     _FIter

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

@@ -112,8 +112,9 @@ template<typename RandomAccessIterator, typename Comparator>
     typedef typename traits_type::value_type value_type;
     typedef typename traits_type::difference_type difference_type;
 
-    RandomAccessIterator pivot_pos = median_of_three_iterators(
-        begin, begin + (end - begin) / 2, end  - 1, comp);
+    RandomAccessIterator pivot_pos =
+      median_of_three_iterators(begin, begin + (end - begin) / 2,
+				end  - 1, comp);
 
 #if defined(_GLIBCXX_ASSERTIONS)
     // Must be in between somewhere.
@@ -146,9 +147,9 @@ template<typename RandomAccessIterator, typename Comparator>
 
 #if _GLIBCXX_ASSERTIONS
     RandomAccessIterator r;
-    for (r = begin; r != pivot_pos; r++)
+    for (r = begin; r != pivot_pos; ++r)
       _GLIBCXX_PARALLEL_ASSERT(comp(*r, *pivot_pos));
-    for (; r != end; r++)
+    for (; r != end; ++r)
       _GLIBCXX_PARALLEL_ASSERT(!comp(*r, *pivot_pos));
 #endif
 
@@ -308,12 +309,12 @@ template<typename RandomAccessIterator, typename Comparator>
                 __gnu_parallel::unary_negate<__gnu_parallel::binder1st
                     <Comparator, value_type, value_type, bool>, value_type>
                     pred(__gnu_parallel::binder1st
-                        <Comparator, value_type, value_type, bool>(
-                        comp, *pivot_pos));
+                        <Comparator, value_type, value_type, bool>(comp,
+								   *pivot_pos));
 
                 // Find other end of pivot-equal range.
-                split_pos2 = __gnu_sequential::partition(
-                    split_pos1 + 1, end, pred);
+                split_pos2 = __gnu_sequential::partition(split_pos1 + 1,
+							 end, pred);
               }
             else
               // Only skip the pivot.
@@ -339,8 +340,8 @@ template<typename RandomAccessIterator, typename Comparator>
               {
                 // Left side larger.
                 if (begin != split_pos1)
-                  tl.leftover_parts.push_front(
-                      std::make_pair(begin, split_pos1));
+                  tl.leftover_parts.push_front(std::make_pair(begin,
+							      split_pos1));
 
                 current.first = split_pos2;
                 //current.second = end;	//already set anyway
@@ -394,8 +395,8 @@ template<typename RandomAccessIterator, typename Comparator>
             if (omp_get_wtime() >= (search_start + 1.0))
               {
                 sleep(1);
-                _GLIBCXX_PARALLEL_ASSERT(
-                    omp_get_wtime() < (search_start + 1.0));
+                _GLIBCXX_PARALLEL_ASSERT(omp_get_wtime()
+					 < (search_start + 1.0));
               }
 #endif
             if (!successfully_stolen)
@@ -452,7 +453,7 @@ template<typename RandomAccessIterator, typename Comparator>
     // 2. The largest range has at most length n
     // 3. Each range is larger than half of the range remaining
     volatile difference_type elements_leftover = n;
-    for (int i = 0; i < num_threads; i++)
+    for (int i = 0; i < num_threads; ++i)
       {
         tls[i]->elements_leftover = &elements_leftover;
         tls[i]->num_threads = num_threads;
@@ -468,11 +469,11 @@ template<typename RandomAccessIterator, typename Comparator>
 #if _GLIBCXX_ASSERTIONS
     // All stack must be empty.
     Piece dummy;
-    for (int i = 1; i < num_threads; i++)
+    for (int i = 1; i < num_threads; ++i)
       _GLIBCXX_PARALLEL_ASSERT(!tls[i]->leftover_parts.pop_back(dummy));
 #endif
 
-    for (int i = 0; i < num_threads; i++)
+    for (int i = 0; i < num_threads; ++i)
       delete tls[i];
     delete[] tls;
   }

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

 // -*- 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
@@ -96,17 +96,13 @@ decode2(lcas_t x, int& a, int& b)
 template<typename T>
   const T&
   min(const T& a, const T& b)
-  {
-    return (a < b) ? a : b;
-  };
+  { return (a < b) ? a : b; }
 
 /** @brief Equivalent to std::max. */
 template<typename T>
   const T&
   max(const T& a, const T& b)
-  {
-    return (a > b) ? a : b;
-  };
+  { return (a > b) ? a : b; }
 
 /** @brief Constructs predicate for equality from strict weak
   *  ordering predicate
@@ -402,7 +398,7 @@ template<typename _ValueTp>
   *  @param comp Comparator.
   */
 template<typename RandomAccessIterator, typename Comparator>
-RandomAccessIterator
+  RandomAccessIterator
   median_of_three_iterators(RandomAccessIterator a, RandomAccessIterator b,
                             RandomAccessIterator c, Comparator& comp)
   {

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

 // -*- 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
@@ -105,7 +105,8 @@ namespace __gnu_parallel
 #elif defined(__ECC)	//IA-64 version
     return _InterlockedExchangeAdd((void*)ptr, addend);
 #elif defined(__ICL) || defined(_MSC_VER)
-    return _InterlockedExchangeAdd(reinterpret_cast<volatile long*>(ptr), addend);
+    return _InterlockedExchangeAdd(reinterpret_cast<volatile long*>(ptr),
+				   addend);
 #elif defined(__GNUC__)
     return __sync_fetch_and_add(ptr, addend);
 #elif defined(__SUNPRO_CC) && defined(__sparc)
@@ -114,7 +115,8 @@ namespace __gnu_parallel
       {
 	before = *ptr;
 	after = before + addend;
-      } while (atomic_cas_32((volatile unsigned int*)ptr, before, after) != before);
+      } while (atomic_cas_32((volatile unsigned int*)ptr, before,
+			     after) != before);
     return before;
 #else	//fallback, slow
 #pragma message("slow fetch_and_add_32")
@@ -159,7 +161,8 @@ namespace __gnu_parallel
       {
 	before = *ptr;
 	after = before + addend;
-      } while (atomic_cas_64((volatile unsigned long long*)ptr, before, after) != before);
+      } while (atomic_cas_64((volatile unsigned long long*)ptr, before,
+			     after) != before);
     return before;
 #else	//fallback, slow
 #if defined(__GNUC__) && defined(__i386)
@@ -238,15 +241,19 @@ namespace __gnu_parallel
   compare_and_swap_32(volatile int32* ptr, int32 comparand, int32 replacement)
   {
 #if defined(__ICC)	//x86 version
-    return _InterlockedCompareExchange((void*)ptr, replacement, comparand) == comparand;
+    return _InterlockedCompareExchange((void*)ptr, replacement,
+				       comparand) == comparand;
 #elif defined(__ECC)	//IA-64 version
-    return _InterlockedCompareExchange((void*)ptr, replacement, comparand) == comparand;
+    return _InterlockedCompareExchange((void*)ptr, replacement,
+				       comparand) == comparand;
 #elif defined(__ICL) || defined(_MSC_VER)
-    return _InterlockedCompareExchange(reinterpret_cast<volatile long*>(ptr), replacement, comparand) == comparand;
+    return _InterlockedCompareExchange(reinterpret_cast<volatile long*>(ptr),
+				       replacement, comparand) == comparand;
 #elif defined(__GNUC__)
     return __sync_bool_compare_and_swap(ptr, comparand, replacement);
 #elif defined(__SUNPRO_CC) && defined(__sparc)
-    return atomic_cas_32((volatile unsigned int*)ptr, comparand, replacement) == comparand;
+    return atomic_cas_32((volatile unsigned int*)ptr, comparand,
+			 replacement) == comparand;
 #else
 #pragma message("slow compare_and_swap_32")
     bool res = false;
@@ -276,13 +283,15 @@ namespace __gnu_parallel
 #if defined(__ICC) && defined(__x86_64)	//x86 version
     return cas64<int>(ptr, comparand, replacement) == comparand;
 #elif defined(__ECC)	//IA-64 version
-    return _InterlockedCompareExchange64((void*)ptr, replacement, comparand) == comparand;
+    return _InterlockedCompareExchange64((void*)ptr, replacement,
+					 comparand) == comparand;
 #elif defined(__ICL) || defined(_MSC_VER)
 #ifndef _WIN64
     _GLIBCXX_PARALLEL_ASSERT(false);	//not available in this case
     return 0;
 #else
-    return _InterlockedCompareExchange64(ptr, replacement, comparand) == comparand;
+    return _InterlockedCompareExchange64(ptr, replacement,
+					 comparand) == comparand;
 #endif
 
 #elif defined(__GNUC__) && defined(__x86_64)
@@ -291,7 +300,8 @@ namespace __gnu_parallel
   (defined(__i686) || defined(__pentium4) || defined(__athlon))
     return __sync_bool_compare_and_swap(ptr, comparand, replacement);
 #elif defined(__SUNPRO_CC) && defined(__sparc)
-    return atomic_cas_64((volatile unsigned long long*)ptr, comparand, replacement) == comparand;
+    return atomic_cas_64((volatile unsigned long long*)ptr,
+			 comparand, replacement) == comparand;
 #else
 #if defined(__GNUC__) && defined(__i386)
     // XXX -march=native
@@ -323,9 +333,11 @@ namespace __gnu_parallel
   compare_and_swap(volatile T* ptr, T comparand, T replacement)
   {
     if (sizeof(T) == sizeof(int32))
-      return compare_and_swap_32((volatile int32*) ptr, (int32)comparand, (int32)replacement);
+      return compare_and_swap_32((volatile int32*) ptr,
+				 (int32)comparand, (int32)replacement);
     else if (sizeof(T) == sizeof(int64))
-      return compare_and_swap_64((volatile int64*) ptr, (int64)comparand, (int64)replacement);
+      return compare_and_swap_64((volatile int64*) ptr,
+				 (int64)comparand, (int64)replacement);
     else
       _GLIBCXX_PARALLEL_ASSERT(false);
   }

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

@@ -62,7 +62,7 @@ template<typename RandomAccessIterator1,
 	 typename RandomAccessIterator2,
 	 typename Pred,
 	 typename Selector>
-  std::pair<RandomAccessIterator1, RandomAccessIterator2>
+  inline std::pair<RandomAccessIterator1, RandomAccessIterator2>
   find_template(RandomAccessIterator1 begin1, RandomAccessIterator1 end1,
                 RandomAccessIterator2 begin2, Pred pred, Selector selector)
   {
@@ -158,8 +158,9 @@ template<typename RandomAccessIterator1,
     omp_destroy_lock(&result_lock);
     delete[] borders;
 
-    return std::pair<RandomAccessIterator1, RandomAccessIterator2>(
-        begin1 + result, begin2 + result);
+    return
+      std::pair<RandomAccessIterator1, RandomAccessIterator2>(begin1 + result,
+							      begin2 + result);
   }
 
 #endif
@@ -205,8 +206,8 @@ template<typename RandomAccessIterator1,
 
     difference_type length = end1 - begin1;
 
-    difference_type sequential_search_size = std::min<difference_type>(
-        length, Settings::find_sequential_search_size);
+    difference_type sequential_search_size =
+      std::min<difference_type>(length, Settings::find_sequential_search_size);
 
     // Try it sequentially first.
     std::pair<RandomAccessIterator1, RandomAccessIterator2> find_seq_result =
@@ -267,23 +268,25 @@ template<typename RandomAccessIterator1,
                   omp_unset_lock(&result_lock);
               }
 
-            block_size = std::min<difference_type>(
-                block_size * Settings::find_increasing_factor,
+            block_size =
+	      std::min<difference_type>(block_size
+					* Settings::find_increasing_factor,
 					Settings::find_maximum_block_size);
 
             // Get new block, update pointer to next block.
             start =
 	      fetch_and_add<difference_type>(&next_block_start, block_size);
-            stop = (length < (start + block_size)) ?
-                        length : (start + block_size);
+            stop = ((length < (start + block_size))
+		    ? length : (start + block_size));
           }
       } //parallel
 
     omp_destroy_lock(&result_lock);
 
     // Return iterator on found element.
-    return std::pair<RandomAccessIterator1, RandomAccessIterator2>(
-        begin1 + result, begin2 + result);
+    return
+      std::pair<RandomAccessIterator1, RandomAccessIterator2>(begin1 + result,
+							      begin2 + result);
   }
 
 #endif
@@ -391,8 +394,9 @@ template<typename RandomAccessIterator1,
     omp_destroy_lock(&result_lock);
 
     // Return iterator on found element.
-    return std::pair<RandomAccessIterator1, RandomAccessIterator2>(
-        begin1 + result, begin2 + result);
+    return
+      std::pair<RandomAccessIterator1, RandomAccessIterator2>(begin1 + result,
+							      begin2 + result);
   }
 #endif
 } // end namespace

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

@@ -144,7 +144,8 @@ namespace __gnu_parallel
 
       /** @brief Constructor
        *  @param new_val Value to replace with. */
-    explicit replace_selector(const T &new_val) : new_val(new_val) {}
+      explicit
+      replace_selector(const T &new_val) : new_val(new_val) {}
 
       /** @brief Functor execution.
        *  @param v Current value.
@@ -167,7 +168,8 @@ namespace __gnu_parallel
 
       /** @brief Constructor.
        *  @param new_val Value to replace with. */
-    explicit replace_if_selector(const T &new_val) : new_val(new_val) { }
+      explicit
+      replace_if_selector(const T &new_val) : new_val(new_val) { }
 
       /** @brief Functor execution.
        *  @param o Operator.
@@ -235,7 +237,8 @@ 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)
+      explicit
+      inner_product_selector(It b1, It2 b2)
       : begin1_iterator(b1), begin2_iterator(b2) { }
 
       /** @brief Functor execution.
@@ -312,8 +315,8 @@ namespace __gnu_parallel
     {
       Comp& comp;
 
-    explicit min_element_reduct(Comp &c) : comp(c)
-    { }
+      explicit
+      min_element_reduct(Comp &c) : comp(c) { }
 
       It
       operator()(It x, It y)
@@ -331,8 +334,8 @@ namespace __gnu_parallel
     {
       Comp& comp;
 
-    explicit max_element_reduct(Comp& c) : comp(c)
-    { }
+      explicit
+      max_element_reduct(Comp& c) : comp(c) { }
 
       It
       operator()(It x, It y)
@@ -350,7 +353,8 @@ namespace __gnu_parallel
     {
       BinOp& binop;
 
-    explicit accumulate_binop_reduct(BinOp& b) : binop(b) {}
+      explicit
+      accumulate_binop_reduct(BinOp& b) : binop(b) { }
 
       template<typename Result, typename Addend>
         Result

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

@@ -159,7 +159,7 @@ namespace __gnu_parallel
       // Smallest partitions.
       for (int i = 1; i < (num_parts + 1 - size_greater); ++i)
 	{
-	  lengths[i-1] =  size_part * range_length;
+	  lengths[i - 1] =  size_part * range_length;
 	  index += size_part;
 	  starts[i] = os_starts[index];
 	}
@@ -167,7 +167,7 @@ namespace __gnu_parallel
       // Biggest partitions.
       for (int i = num_parts + 1 - size_greater; i <= num_parts; ++i)
 	{
-	  lengths[i-1] =  (size_part+1) * range_length;
+	  lengths[i - 1] =  (size_part+1) * range_length;
 	  index += (size_part+1);
 	  starts[i] = os_starts[index];
 	}

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

@@ -82,7 +82,7 @@ template<typename T, typename Comparator = std::less<T> >
       size = _size;
       offset = size;
       losers = new Loser[size];
-      for (unsigned int l = 0; l < size; l++)
+      for (unsigned int l = 0; l < size; ++l)
         {
           //losers[l].key = ... 	stays unset
           losers[l].inf = true;
@@ -156,9 +156,10 @@ template<typename T, typename Comparator = std::less<T> >
       bool inf = false;
       for (unsigned int pos = (offset + source) / 2; pos > 0; pos /= 2)
         {
-          if ((!inf && !losers[pos].inf && !sup && !losers[pos].sup &&
-              ((comp(losers[pos].key, key)) ||
-                (!comp(key, losers[pos].key) && losers[pos].source < source)))
+          if ((!inf && !losers[pos].inf && !sup && !losers[pos].sup
+	       && ((comp(losers[pos].key, key))
+		   || (!comp(key, losers[pos].key)
+		       && losers[pos].source < source)))
               || losers[pos].inf || sup)
             {
               // Take next key.
@@ -186,8 +187,9 @@ template<typename T, typename Comparator = std::less<T> >
       for (unsigned int pos = (offset + source) / 2; pos > 0; pos /= 2)
         {
           if ((!inf && !losers[pos].inf && !sup && !losers[pos].sup
-              && ((comp(losers[pos].key, key)) ||
-                (!comp(key, losers[pos].key) && losers[pos].source < source)))
+              && ((comp(losers[pos].key, key))
+		  || (!comp(key, losers[pos].key)
+		      && losers[pos].source < source)))
               || losers[pos].inf || sup)
             {
               std::swap(losers[pos].key, key);
@@ -285,8 +287,8 @@ template<typename T, typename Comparator = std::less<T> >
         {
           unsigned int left = init_winner (2 * root);
           unsigned int right = init_winner (2 * root + 1);
-          if (losers[right].sup ||
-              (!losers[left].sup
+          if (losers[right].sup
+	      || (!losers[left].sup
 		  && !comp(losers[right].key, losers[left].key)))
             {
               // Left one is less or equal.
@@ -443,7 +445,7 @@ template<typename T, typename Comparator = std::less<T> >
 #ifndef COPY
       keys = new T[ik];
 #endif
-      for (unsigned int i = ik - 1; i < k; i++)
+      for (unsigned int i = ik - 1; i < k; ++i)
         losers[i + k].sup = true;
     }
 
@@ -569,10 +571,10 @@ template<typename T, typename Comparator = std::less<T> >
       for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2)
         {
           // The smaller one gets promoted, ties are broken by source.
-          if (	(sup && (!losers[pos].sup || losers[pos].source < source)) ||
-                (!sup && !losers[pos].sup &&
-                ((comp(KEY(pos), KEY_SOURCE(source))) ||
-                  (!comp(KEY_SOURCE(source), KEY(pos))
+          if ((sup && (!losers[pos].sup || losers[pos].source < source))
+	      || (!sup && !losers[pos].sup
+		  && ((comp(KEY(pos), KEY_SOURCE(source)))
+		      || (!comp(KEY_SOURCE(source), KEY(pos))
 			  && losers[pos].source < source))))
             {
               // The other one is smaller.
@@ -629,7 +631,7 @@ template<typename T, typename Comparator = std::less<T> >
       k = 1 << (log2(ik - 1) + 1);
       offset = k;
       losers = new Loser[k * 2];
-      for (unsigned int i = ik - 1; i < k; i++)
+      for (unsigned int i = ik - 1; i < k; ++i)
         losers[i + k].sup = true;
     }
 
@@ -746,10 +748,10 @@ template<typename T, typename Comparator = std::less<T> >
       for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2)
         {
           // The smaller one gets promoted, ties are broken by source.
-          if (	(sup && (!losers[pos].sup || losers[pos].source < source)) ||
-                (!sup && !losers[pos].sup &&
-                ((comp(*losers[pos].keyp, *keyp)) ||
-                  (!comp(*keyp, *losers[pos].keyp)
+          if (	(sup && (!losers[pos].sup || losers[pos].source < source))
+		|| (!sup && !losers[pos].sup &&
+		    ((comp(*losers[pos].keyp, *keyp))
+		     || (!comp(*keyp, *losers[pos].keyp)
 			 && losers[pos].source < source))))
             {
               // The other one is smaller.
@@ -995,8 +997,8 @@ template<typename T, typename Comparator = std::less<T> >
           // Next greater or equal power of 2.
           unsigned int division = 1 << (log2(end - begin - 1));
           unsigned int left = init_winner(2 * root, begin, begin + division);
-          unsigned int right
-                          = init_winner(2 * root + 1, begin + division, end);
+          unsigned int right = init_winner(2 * root + 1,
+					   begin + division, end);
           if (!comp(*losers[right].keyp, *losers[left].keyp))
             {
               // Left one is less or equal.

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

@@ -74,7 +74,7 @@ namespace __gnu_parallel
 	    *target++ = *begin2++;
 	  else
 	    *target++ = *begin1++;
-	  max_length--;
+	  --max_length;
 	}
 
       if (begin1 != end1)
@@ -143,8 +143,8 @@ namespace __gnu_parallel
 
 	  *target = element1;
 
-	  target++;
-	  max_length--;
+	  ++target;
+	  --max_length;
 	}
       if (begin1 != end1)
 	{

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

@@ -212,7 +212,7 @@ namespace __gnu_parallel
       difference_type localrank = rank * m / N ;
 
       int j;
-      for (j = 0; j < localrank && ((n + 1) <= ns[sample[j].second]); j++)
+      for (j = 0; j < localrank && ((n + 1) <= ns[sample[j].second]); ++j)
 	a[sample[j].second] += n + 1;
       for (; j < m; j++)
 	b[sample[j].second] -= n + 1;
@@ -279,7 +279,7 @@ namespace __gnu_parallel
 		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();
@@ -302,7 +302,7 @@ namespace __gnu_parallel
 		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();
@@ -416,7 +416,7 @@ namespace __gnu_parallel
 
       ns[0] = std::distance(begin_seqs[0].first, begin_seqs[0].second);
       nmax = ns[0];
-      for (int i = 0; i < m; i++)
+      for (int i = 0; i < m; ++i)
 	{
 	  ns[i] = std::distance(begin_seqs[i].first, begin_seqs[i].second);
 	  nmax = std::max(nmax, ns[i]);
@@ -431,7 +431,7 @@ namespace __gnu_parallel
       // From now on, including padding.
       N = l * m;
 
-      for (int i = 0; i < m; i++)
+      for (int i = 0; i < m; ++i)
 	{
 	  a[i] = 0;
 	  b[i] = l;
@@ -460,9 +460,9 @@ namespace __gnu_parallel
       difference_type localrank = rank * m / N ;
 
       int j;
-      for (j = 0; j < localrank && ((n + 1) <= ns[sample[j].second]); j++)
+      for (j = 0; j < localrank && ((n + 1) <= ns[sample[j].second]); ++j)
 	a[sample[j].second] += n + 1;
-      for (; j < m; j++)
+      for (; j < m; ++j)
 	b[sample[j].second] -= n + 1;
 
       // Further refinement.
@@ -471,7 +471,7 @@ namespace __gnu_parallel
 	  n /= 2;
 
 	  const T* lmax = NULL;
-	  for (int i = 0; i < m; i++)
+	  for (int i = 0; i < m; ++i)
 	    {
 	      if (a[i] > 0)
 		{
@@ -496,7 +496,7 @@ namespace __gnu_parallel
 	    }
 
 	  difference_type leftsize = 0, total = 0;
-	  for (int i = 0; i < m; i++)
+	  for (int i = 0; i < m; ++i)
 	    {
 	      leftsize += a[i] / (n + 1);
 	      total += l / (n + 1);
@@ -512,7 +512,7 @@ namespace __gnu_parallel
 		std::vector<std::pair<T, int> >,
 		lexicographic_reverse<T, int, Comparator> > pq(lrcomp);
 
-	      for (int i = 0; i < m; i++)
+	      for (int i = 0; i < m; ++i)
 		if (b[i] < ns[i])
 		  pq.push(std::make_pair(S(i)[b[i]], i));
 
@@ -535,7 +535,7 @@ namespace __gnu_parallel
 		std::vector<std::pair<T, int> >,
 		lexicographic<T, int, Comparator> > pq(lcomp);
 
-	      for (int i = 0; i < m; i++)
+	      for (int i = 0; i < m; ++i)
 		if (a[i] > 0)
 		  pq.push(std::make_pair(S(i)[a[i] - 1], i));
 
@@ -566,7 +566,7 @@ namespace __gnu_parallel
 
       // Impossible to avoid the warning?
       T maxleft, minright;
-      for (int i = 0; i < m; i++)
+      for (int i = 0; i < m; ++i)
 	{
 	  if (a[i] > 0)
 	    {
@@ -610,7 +610,7 @@ namespace __gnu_parallel
 	  // We have to calculate an offset.
 	  offset = 0;
 
-	  for (int i = 0; i < m; i++)
+	  for (int i = 0; i < m; ++i)
 	    {
 	      difference_type lb = std::lower_bound(S(i), S(i) + ns[i],
 						    minright,

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

@@ -120,7 +120,7 @@ template<typename RandomAccessIterator>
   *  @param num_samples Number of samples to select.
   */
 template<typename RandomAccessIterator, typename _DifferenceTp>
-  inline void 
+  void 
   determine_samples(PMWMSSortingData<RandomAccessIterator>* sd,
                     _DifferenceTp& num_samples)
   {
@@ -138,9 +138,9 @@ template<typename RandomAccessIterator, typename _DifferenceTp>
     equally_split(sd->starts[iam + 1] - sd->starts[iam], 
                   num_samples + 1, es);
 
-    for (difference_type i = 0; i < num_samples; i++)
-      ::new(&(sd->samples[iam * num_samples + i])) value_type(
-          sd->source[sd->starts[iam] + es[i + 1]]);
+    for (difference_type i = 0; i < num_samples; ++i)
+      ::new(&(sd->samples[iam * num_samples + i]))
+	  value_type(sd->source[sd->starts[iam] + es[i + 1]]);
 
     delete[] es;
   }
@@ -150,7 +150,7 @@ template<typename RandomAccessIterator, typename _DifferenceTp>
   *  @param comp Comparator.
   */
 template<typename RandomAccessIterator, typename Comparator>
-  inline void 
+  void 
   parallel_sort_mwms_pu(PMWMSSortingData<RandomAccessIterator>* sd,
                         Comparator& comp)
   {
@@ -209,7 +209,7 @@ template<typename RandomAccessIterator, typename Comparator>
 
 #       pragma omp barrier
 
-        for (int s = 0; s < sd->num_threads; s++)
+        for (int s = 0; s < sd->num_threads; ++s)
           {
             // For each sequence.
               if (num_samples * iam > 0)
@@ -243,7 +243,7 @@ template<typename RandomAccessIterator, typename Comparator>
 
         std::vector<std::pair<SortingPlacesIterator, SortingPlacesIterator> >
             seqs(sd->num_threads);
-        for (int s = 0; s < sd->num_threads; s++)
+        for (int s = 0; s < sd->num_threads; ++s)
           seqs[s] = std::make_pair(sd->sorting_places[s],
                                    sd->sorting_places[s]
                                        + (sd->starts[s + 1] - sd->starts[s]));
@@ -255,20 +255,20 @@ template<typename RandomAccessIterator, typename Comparator>
           multiseq_partition(seqs.begin(), seqs.end(),
                              sd->starts[iam + 1], offsets.begin(), comp);
 
-        for (int seq = 0; seq < sd->num_threads; seq++)
+        for (int seq = 0; seq < sd->num_threads; ++seq)
           {
             // for each sequence
             if (iam < (sd->num_threads - 1))
               sd->pieces[iam][seq].end = offsets[seq] - seqs[seq].first;
             else
               // very end of this sequence
-              sd->pieces[iam][seq].end =
-                  sd->starts[seq + 1] - sd->starts[seq];
+              sd->pieces[iam][seq].end = (sd->starts[seq + 1]
+					  - sd->starts[seq]);
           }
 
 #       pragma omp barrier
 
-        for (int seq = 0; seq < sd->num_threads; seq++)
+        for (int seq = 0; seq < sd->num_threads; ++seq)
           {
             // For each sequence.
             if (iam > 0)
@@ -281,7 +281,7 @@ template<typename RandomAccessIterator, typename Comparator>
 
     // Offset from target begin, length after merging.
     difference_type offset = 0, length_am = 0;
-    for (int s = 0; s < sd->num_threads; s++)
+    for (int s = 0; s < sd->num_threads; ++s)
       {
         length_am += sd->pieces[iam][s].end - sd->pieces[iam][s].begin;
         offset += sd->pieces[iam][s].begin;
@@ -293,8 +293,8 @@ template<typename RandomAccessIterator, typename Comparator>
     // instead of the assignment operator.
     // XXX incorrect (de)construction
     sd->merging_places[iam] = sd->temporaries[iam] =
-        static_cast<value_type*>(
-        ::operator new(sizeof(value_type) * length_am));
+        static_cast<value_type*>(::operator new(sizeof(value_type)
+						* length_am));
 #else
     // Merge directly to target.
     sd->merging_places[iam] = sd->source + offset;
@@ -302,7 +302,7 @@ template<typename RandomAccessIterator, typename Comparator>
     std::vector<std::pair<SortingPlacesIterator, SortingPlacesIterator> >
         seqs(sd->num_threads);
 
-    for (int s = 0; s < sd->num_threads; s++)
+    for (int s = 0; s < sd->num_threads; ++s)
       {
         seqs[s] =
 	  std::make_pair(sd->sorting_places[s] + sd->pieces[iam][s].begin,
@@ -333,13 +333,11 @@ template<typename RandomAccessIterator, typename Comparator>
   *  @param stable Stable sorting.
   */
 template<typename RandomAccessIterator, typename Comparator>
-  inline void
+  void
   parallel_sort_mwms(RandomAccessIterator begin, RandomAccessIterator end,
-                     Comparator comp, 
-                     typename std::iterator_traits<RandomAccessIterator>
-                        ::difference_type n,
-                     int num_threads,
-                     bool stable)
+                     Comparator comp, typename
+		     std::iterator_traits<RandomAccessIterator>::
+		     difference_type n, int num_threads, bool stable)
   {
     _GLIBCXX_CALL(n)
 
@@ -389,7 +387,7 @@ template<typename RandomAccessIterator, typename Comparator>
 
             sd.offsets = new difference_type[num_threads - 1];
             sd.pieces = new std::vector<Piece<difference_type> >[num_threads];
-            for (int s = 0; s < num_threads; s++)
+            for (int s = 0; s < num_threads; ++s)
               sd.pieces[s].resize(num_threads);
             starts = sd.starts = new difference_type[num_threads + 1];
             sd.stable = stable;
@@ -397,7 +395,7 @@ template<typename RandomAccessIterator, typename Comparator>
             difference_type chunk_length = n / num_threads;
             difference_type split = n % num_threads;
             difference_type pos = 0;
-            for (int i = 0; i < num_threads; i++)
+            for (int i = 0; i < num_threads; ++i)
               {
                 starts[i] = pos;
                 pos += (i < split) ? (chunk_length + 1) : chunk_length;

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

 // <numeric> 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
@@ -44,74 +44,80 @@ namespace std
 {
 namespace __parallel
 {
-  template<typename _IIter, typename T>
-  inline T
-  accumulate(_IIter, _IIter, T);
+  template<typename _IIter, typename _Tp>
+    _Tp
+    accumulate(_IIter, _IIter, _Tp);
 
-  template<typename _IIter, typename T>
-  inline T
-  accumulate(_IIter, _IIter, T, __gnu_parallel::sequential_tag);
+  template<typename _IIter, typename _Tp>
+    _Tp
+    accumulate(_IIter, _IIter, _Tp, __gnu_parallel::sequential_tag);
 
-  template<typename _IIter, typename T>
-  inline T
-  accumulate(_IIter, _IIter, T, __gnu_parallel::parallelism parallelism_tag);
+  template<typename _IIter, typename _Tp>
+    _Tp
+    accumulate(_IIter, _IIter, _Tp, __gnu_parallel::parallelism);
 
-  template<typename _IIter, typename T, typename _Tag>
-  inline T
-  accumulate_switch(_IIter, _IIter, T, _Tag);
+  template<typename _IIter, typename _Tp, typename _Tag>
+    _Tp
+    accumulate_switch(_IIter, _IIter, _Tp, _Tag);
 
-  template<typename _IIter, typename T, typename _BinaryOper>
-  inline T
-  accumulate(_IIter, _IIter, T, _BinaryOper);
+  template<typename _IIter, typename _Tp, typename _BinaryOper>
+    _Tp
+    accumulate(_IIter, _IIter, _Tp, _BinaryOper);
 
-  template<typename _IIter, typename T, typename _BinaryOper>
-  inline T
-  accumulate(_IIter, _IIter, T, _BinaryOper, __gnu_parallel::sequential_tag);
-
-  template<typename _IIter, typename T, typename _BinaryOper>
-  inline T
-  accumulate(_IIter, _IIter, T, _BinaryOper, 
-	     __gnu_parallel::parallelism parallelism_tag);
+  template<typename _IIter, typename _Tp, typename _BinaryOper>
+    _Tp
+    accumulate(_IIter, _IIter, _Tp, _BinaryOper,
+	       __gnu_parallel::sequential_tag);
 
-  template<typename _IIter, typename T, typename _BinaryOper, typename _Tag>
-  T
-  accumulate_switch(_IIter, _IIter, T, _BinaryOper, _Tag);
+  template<typename _IIter, typename _Tp, typename _BinaryOper>
+    _Tp
+    accumulate(_IIter, _IIter, _Tp, _BinaryOper,
+	       __gnu_parallel::parallelism);
 
-  template<typename _RAIter, typename T, typename _BinaryOper>
-  T
-  accumulate_switch(_RAIter, _RAIter, T, _BinaryOper, 
-		    random_access_iterator_tag, __gnu_parallel::parallelism);
+  template<typename _IIter, typename _Tp, typename _BinaryOper,
+	   typename _Tag>
+    _Tp
+    accumulate_switch(_IIter, _IIter, _Tp, _BinaryOper, _Tag);
 
+  template<typename _RAIter, typename _Tp, typename _BinaryOper>
+    _Tp
+    accumulate_switch(_RAIter, _RAIter, _Tp, _BinaryOper,
+		      random_access_iterator_tag,
+		      __gnu_parallel::parallelism);
 
   template<typename _IIter, typename _OIter>
-  inline _OIter
+    _OIter
     adjacent_difference(_IIter, _IIter, _OIter);
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
-  inline _OIter
+    _OIter
     adjacent_difference(_IIter, _IIter, _OIter, _BinaryOper);
 
   template<typename _IIter, typename _OIter>
-  inline _OIter
-  adjacent_difference(_IIter, _IIter, _OIter, __gnu_parallel::sequential_tag);
+    _OIter
+    adjacent_difference(_IIter, _IIter, _OIter,
+			__gnu_parallel::sequential_tag);
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
-  inline _OIter
+    _OIter
     adjacent_difference(_IIter, _IIter, _OIter, _BinaryOper, 
 			__gnu_parallel::sequential_tag);
 
   template<typename _IIter, typename _OIter>
-  inline _OIter
-  adjacent_difference(_IIter, _IIter, _OIter, __gnu_parallel::parallelism);
+    _OIter
+    adjacent_difference(_IIter, _IIter, _OIter,
+			__gnu_parallel::parallelism);
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
-  inline _OIter
+    _OIter
     adjacent_difference(_IIter, _IIter, _OIter, _BinaryOper, 
 			__gnu_parallel::parallelism);
 
-  template<typename _IIter, typename _OIter, typename _BinaryOper, typename _Tag1, typename _Tag2>
-  inline _OIter
-  adjacent_difference_switch(_IIter, _IIter, _OIter, _BinaryOper, _Tag1, _Tag2);
+  template<typename _IIter, typename _OIter, typename _BinaryOper,
+	   typename _Tag1, typename _Tag2>
+    _OIter
+    adjacent_difference_switch(_IIter, _IIter, _OIter, _BinaryOper,
+			       _Tag1, _Tag2);
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
     _OIter
@@ -120,70 +126,80 @@ namespace __parallel
 			       random_access_iterator_tag, 
 			       __gnu_parallel::parallelism);
 
+  template<typename _IIter1, typename _IIter2, typename _Tp>
+    _Tp
+    inner_product(_IIter1, _IIter1, _IIter2, _Tp);
 
-  template<typename _IIter1, typename _IIter2, typename T>
-  inline T
-  inner_product(_IIter1, _IIter1, _IIter2, T);
-
-  template<typename _IIter1, typename _IIter2, typename T>
-  inline T
-  inner_product(_IIter1, _IIter1, _IIter2, T, __gnu_parallel::sequential_tag);
-
-  template<typename _IIter1, typename _IIter2, typename T>
-  inline T
-  inner_product(_IIter1, _IIter1, _IIter2, T, __gnu_parallel::parallelism);
-
-
-  template<typename _IIter1, typename _IIter2, typename T, typename BinaryFunction1, typename BinaryFunction2>
-  inline T
-  inner_product(_IIter1, _IIter1, _IIter2, T, BinaryFunction1, BinaryFunction2);
-
-  template<typename _IIter1, typename _IIter2, typename T, typename BinaryFunction1, typename BinaryFunction2>
-  inline T
-  inner_product(_IIter1, _IIter1, _IIter2, T, BinaryFunction1, BinaryFunction2,
+  template<typename _IIter1, typename _IIter2, typename _Tp>
+    _Tp
+    inner_product(_IIter1, _IIter1, _IIter2, _Tp,
 		  __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename T, typename BinaryFunction1, typename BinaryFunction2>
-  inline T
-  inner_product(_IIter1, _IIter1, _IIter2, T, BinaryFunction1, BinaryFunction2,
+  template<typename _IIter1, typename _IIter2, typename _Tp>
+    _Tp
+    inner_product(_IIter1, _IIter1, _IIter2, _Tp,
 		  __gnu_parallel::parallelism);
 
-  template<typename _RAIter1, typename _RAIter2, typename T, typename BinaryFunction1, typename BinaryFunction2>
-  T
-  inner_product_switch(_RAIter1, _RAIter1, _RAIter2, T, BinaryFunction1, 
+  template<typename _IIter1, typename _IIter2, typename _Tp,
+	   typename _BinaryFunction1, typename _BinaryFunction2>
+    _Tp
+    inner_product(_IIter1, _IIter1, _IIter2, _Tp,
+		  _BinaryFunction1, _BinaryFunction2);
+
+  template<typename _IIter1, typename _IIter2, typename _Tp,
+	   typename _BinaryFunction1, typename _BinaryFunction2>
+    _Tp
+    inner_product(_IIter1, _IIter1, _IIter2, _Tp, _BinaryFunction1,
+		  _BinaryFunction2, __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _Tp,
+	   typename BinaryFunction1, typename BinaryFunction2>
+    _Tp
+    inner_product(_IIter1, _IIter1, _IIter2, _Tp, BinaryFunction1,
+		  BinaryFunction2, __gnu_parallel::parallelism);
+
+  template<typename _RAIter1, typename _RAIter2, typename _Tp,
+	   typename BinaryFunction1, typename BinaryFunction2>
+    _Tp
+    inner_product_switch(_RAIter1, _RAIter1, _RAIter2, _Tp, BinaryFunction1, 
 			 BinaryFunction2, random_access_iterator_tag, 
 			 random_access_iterator_tag, 
 			 __gnu_parallel::parallelism);
 
-  template<typename _IIter1, typename _IIter2, typename T, typename BinaryFunction1, typename BinaryFunction2, typename _Tag1, typename _Tag2>
-  inline T
-  inner_product_switch(_IIter1, _IIter1, _IIter2, T, BinaryFunction1, 
-		       BinaryFunction2, _Tag1, _Tag2);
+  template<typename _IIter1, typename _IIter2, typename _Tp,
+	   typename _BinaryFunction1, typename _BinaryFunction2,
+	   typename _Tag1, typename _Tag2>
+    _Tp
+    inner_product_switch(_IIter1, _IIter1, _IIter2, _Tp, _BinaryFunction1, 
+			 _BinaryFunction2, _Tag1, _Tag2);
 
 
   template<typename _IIter, typename _OIter>
-  inline _OIter
+    _OIter
     partial_sum(_IIter, _IIter, _OIter, __gnu_parallel::sequential_tag);
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
-  inline _OIter
-  partial_sum(_IIter, _IIter, _OIter, _BinaryOper, __gnu_parallel::sequential_tag);
+    _OIter
+    partial_sum(_IIter, _IIter, _OIter, _BinaryOper,
+		__gnu_parallel::sequential_tag);
 
   template<typename _IIter, typename _OIter>
-  inline _OIter
+    _OIter
     partial_sum(_IIter, _IIter, _OIter result);
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
-  inline _OIter
+    _OIter
     partial_sum(_IIter, _IIter, _OIter, _BinaryOper);
 
-  template<typename _IIter, typename _OIter, typename _BinaryOper, typename _Tag1, typename _Tag2>
-  inline _OIter
+  template<typename _IIter, typename _OIter, typename _BinaryOper,
+	   typename _Tag1, typename _Tag2>
+    _OIter
     partial_sum_switch(_IIter, _IIter, _OIter, _BinaryOper, _Tag1, _Tag2);
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
     _OIter
-  partial_sum_switch(_IIter, _IIter, _OIter, _BinaryOper, random_access_iterator_tag, random_access_iterator_tag);
+    partial_sum_switch(_IIter, _IIter, _OIter, _BinaryOper,
+		       random_access_iterator_tag, random_access_iterator_tag);
 } // end namespace
 } // end namespace
 

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

 // -*- 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
@@ -70,11 +70,12 @@ template<typename RandomAccessIterator,
 	 typename Red,
 	 typename Result>
   Op
-  for_each_template_random_access_omp_loop(
-             RandomAccessIterator begin,
+  for_each_template_random_access_omp_loop(RandomAccessIterator begin,
 					   RandomAccessIterator end,
-             Op o, Fu& f, Red r, Result base, Result& output,
-             typename std::iterator_traits<RandomAccessIterator>::
+					   Op o, Fu& f, Red r, Result base,
+					   Result& output,
+					   typename std::iterator_traits
+					   <RandomAccessIterator>::
 					   difference_type bound)
   {
     typedef typename
@@ -94,19 +95,19 @@ template<typename RandomAccessIterator,
             num_threads = omp_get_num_threads();
             thread_results = new Result[num_threads];
 
-            for (thread_index_t i = 0; i < num_threads; i++)
+            for (thread_index_t i = 0; i < num_threads; ++i)
               thread_results[i] = Result();
           }
 
         thread_index_t iam = omp_get_thread_num();
 
 #       pragma omp for schedule(dynamic, Settings::workstealing_chunk_size)
-        for (difference_type pos = 0; pos < length; pos++)
+        for (difference_type pos = 0; pos < length; ++pos)
           thread_results[iam] =
               r(thread_results[iam], f(o, begin+pos));
       } //parallel
 
-    for (thread_index_t i = 0; i < num_threads; i++)
+    for (thread_index_t i = 0; i < num_threads; ++i)
         output = r(output, thread_results[i]);
 
     delete [] thread_results;

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

 // -*- 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
@@ -70,11 +70,12 @@ template<typename RandomAccessIterator,
 	 typename Red,
 	 typename Result>
   Op
-  for_each_template_random_access_omp_loop_static(
-              RandomAccessIterator begin,
+  for_each_template_random_access_omp_loop_static(RandomAccessIterator begin,
 						  RandomAccessIterator end,
-              Op o, Fu& f, Red r, Result base, Result& output,
-              typename std::iterator_traits<RandomAccessIterator>::
+						  Op o, Fu& f, Red r,
+						  Result base, Result& output,
+						  typename std::iterator_traits
+						  <RandomAccessIterator>::
 						  difference_type bound)
   {
     typedef typename
@@ -94,19 +95,18 @@ template<typename RandomAccessIterator,
             num_threads = omp_get_num_threads();
             thread_results = new Result[num_threads];
 
-            for (thread_index_t i = 0; i < num_threads; i++)
+            for (thread_index_t i = 0; i < num_threads; ++i)
               thread_results[i] = Result();
           }
 
         thread_index_t iam = omp_get_thread_num();
 
 #       pragma omp for schedule(static, Settings::workstealing_chunk_size)
-        for (difference_type pos = 0; pos < length; pos++)
-          thread_results[iam] =
-              r(thread_results[iam], f(o, begin+pos));
+        for (difference_type pos = 0; pos < length; ++pos)
+          thread_results[iam] = r(thread_results[iam], f(o, begin+pos));
       } //parallel
 
-    for (thread_index_t i = 0; i < num_threads; i++)
+    for (thread_index_t i = 0; i < num_threads; ++i)
       output = r(output, thread_results[i]);
 
     delete [] thread_results;

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

 // -*- 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
@@ -64,18 +64,18 @@ namespace __gnu_parallel
   *  std::count_n()).
   *  @return User-supplied functor (that may contain a part of the result).
   */
-template<
-    typename RandomAccessIterator,
+template<typename RandomAccessIterator,
 	 typename Op,
 	 typename Fu,
 	 typename Red,
 	 typename Result>
   Op
-  for_each_template_random_access_ed(
-              RandomAccessIterator begin,
+  for_each_template_random_access_ed(RandomAccessIterator begin,
 				     RandomAccessIterator end,
-              Op o, Fu& f, Red r, Result base, Result& output,
-              typename std::iterator_traits<RandomAccessIterator>::
+				     Op o, Fu& f, Red r, Result base,
+				     Result& output,
+				     typename std::iterator_traits
+				     <RandomAccessIterator>::
 				     difference_type bound)
   {
     typedef std::iterator_traits<RandomAccessIterator> traits_type;
@@ -116,7 +116,7 @@ template<
         thread_results[iam] = reduct;
       } //parallel
 
-    for (thread_index_t i = 0; i < num_threads; i++)
+    for (thread_index_t i = 0; i < num_threads; ++i)
       output = r(output, thread_results[i]);
 
     // Points to last element processed (needed as return value for

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

@@ -57,15 +57,14 @@ namespace __gnu_parallel
   *  @param value Start value. Must be passed since the neutral
   *  element is unknown in general.
   *  @return End iterator of output sequence. */
-template<
-    typename InputIterator,
+template<typename InputIterator,
 	 typename OutputIterator,
 	 typename BinaryOperation>
-  inline OutputIterator
-  parallel_partial_sum_basecase(
-            InputIterator begin, InputIterator end,
+  OutputIterator
+  parallel_partial_sum_basecase(InputIterator begin, InputIterator end,
 				OutputIterator result, BinaryOperation bin_op,
-            typename std::iterator_traits<InputIterator>::value_type value)
+				typename std::iterator_traits
+				<InputIterator>::value_type value)
   {
     if (begin == end)
       return result;
@@ -90,15 +89,14 @@ template<
     *  @param num_threads Number of threads to use.
     *  @return End iterator of output sequence.
     */
-template<
-    typename InputIterator,
+template<typename InputIterator,
 	 typename OutputIterator,
 	 typename BinaryOperation>
   OutputIterator
-  parallel_partial_sum_linear(
-            InputIterator begin, InputIterator end,
+  parallel_partial_sum_linear(InputIterator begin, InputIterator end,
 			      OutputIterator result, BinaryOperation bin_op,
-            typename std::iterator_traits<InputIterator>::difference_type n)
+			      typename std::iterator_traits
+			      <InputIterator>::difference_type n)
   {
     typedef std::iterator_traits<InputIterator> traits_type;
     typedef typename traits_type::value_type value_type;
@@ -133,8 +131,9 @@ template<
             else
               {
                 difference_type chunk_length =
-                    ((double)n /
-                    ((double)num_threads + Settings::partial_sum_dilatation)),
+                    ((double)n
+		     / ((double)num_threads
+			+ Settings::partial_sum_dilatation)),
 		  borderstart = n - num_threads * chunk_length;
                 borders[0] = 0;
                 for (int i = 1; i < (num_threads + 1); ++i)
@@ -145,8 +144,8 @@ template<
                 borders[num_threads + 1] = n;
               }
 
-            sums = static_cast<value_type*>(
-                ::operator new(sizeof(value_type) * num_threads));
+            sums = static_cast<value_type*>(::operator new(sizeof(value_type)
+							   * num_threads));
             OutputIterator target_end;
           } //single
 
@@ -160,11 +159,12 @@ template<
           }
         else
           {
-            ::new(&(sums[iam])) value_type(
-                                std::accumulate(begin + borders[iam] + 1,
+            ::new(&(sums[iam]))
+	      value_type(std::accumulate(begin + borders[iam] + 1,
 					 begin + borders[iam + 1],
 					 *(begin + borders[iam]),
-                                bin_op, __gnu_parallel::sequential_tag()));
+					 bin_op,
+					 __gnu_parallel::sequential_tag()));
           }
 
 #       pragma omp barrier
@@ -194,8 +194,7 @@ template<
   *  @param result Begin iterator of output sequence.
   *  @param bin_op Associative binary function.
   *  @return End iterator of output sequence. */
-template<
-    typename InputIterator,
+template<typename InputIterator,
 	 typename OutputIterator,
 	 typename BinaryOperation>
   OutputIterator

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

 // -*- 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
@@ -92,10 +92,11 @@ template<typename RandomAccessIterator, typename Predicate>
             reserved_right = new bool[num_threads];
 
             if (Settings::partition_chunk_share > 0.0)
-              chunk_size = std::max<difference_type>(
-                  Settings::partition_chunk_size,
-                  (double)n * Settings::partition_chunk_share /
-                        (double)num_threads);
+              chunk_size = std::max<difference_type>(Settings::
+						     partition_chunk_size,
+						     (double)n * Settings::
+						     partition_chunk_share
+						     / (double)num_threads);
             else
               chunk_size = Settings::partition_chunk_size;
           }
@@ -106,7 +107,7 @@ template<typename RandomAccessIterator, typename Predicate>
               {
                 difference_type num_chunks = (right - left + 1) / chunk_size;
 
-                for (int r = 0; r < num_threads; r++)
+                for (int r = 0; r < num_threads; ++r)
                   {
                     reserved_left[r] = false;
                     reserved_right[r] = false;
@@ -164,10 +165,10 @@ template<typename RandomAccessIterator, typename Predicate>
                   {
                     while (pred(begin[thread_left])
                             && thread_left <= thread_left_border)
-                      thread_left++;
+                      ++thread_left;
                     while (!pred(begin[thread_right])
                             && thread_right >= thread_right_border)
-                      thread_right--;
+                      --thread_right;
 
                     if (thread_left > thread_left_border
                         || thread_right < thread_right_border)
@@ -175,18 +176,18 @@ template<typename RandomAccessIterator, typename Predicate>
                       break;
 
                     std::swap(begin[thread_left], begin[thread_right]);
-                    thread_left++;
-                    thread_right--;
+                    ++thread_left;
+                    --thread_right;
                   }
               }
 
             // Now swap the leftover chunks to the right places.
             if (thread_left <= thread_left_border)
 #             pragma omp atomic
-              leftover_left++;
+              ++leftover_left;
             if (thread_right >= thread_right_border)
 #             pragma omp atomic
-              leftover_right++;
+              ++leftover_right;
 
 #           pragma omp barrier
 
@@ -212,9 +213,8 @@ template<typename RandomAccessIterator, typename Predicate>
                 && thread_right_border <= rightnew)
               {
                 // Chunk already in place, reserve spot.
-                reserved_right
-                    [((thread_right_border - 1) - right) / chunk_size]
-                    = true;
+                reserved_right[((thread_right_border - 1) - right)
+			       / chunk_size] = true;
               }
 
 #           pragma omp barrier
@@ -225,7 +225,7 @@ template<typename RandomAccessIterator, typename Predicate>
                 // Find spot and swap.
                 difference_type swapstart = -1;
                 omp_set_lock(&result_lock);
-                for (int r = 0; r < leftover_left; r++)
+                for (int r = 0; r < leftover_left; ++r)
                   if (!reserved_left[r])
                     {
                       reserved_left[r] = true;
@@ -238,8 +238,8 @@ template<typename RandomAccessIterator, typename Predicate>
                 _GLIBCXX_PARALLEL_ASSERT(swapstart != -1);
 #endif
 
-                std::swap_ranges(
-                    begin + thread_left_border - (chunk_size - 1),
+                std::swap_ranges(begin + thread_left_border
+				 - (chunk_size - 1),
 				 begin + thread_left_border + 1,
 				 begin + swapstart);
               }
@@ -250,7 +250,7 @@ template<typename RandomAccessIterator, typename Predicate>
                 // Find spot and swap
                 difference_type swapstart = -1;
                 omp_set_lock(&result_lock);
-                for (int r = 0; r < leftover_right; r++)
+                for (int r = 0; r < leftover_right; ++r)
                   if (!reserved_right[r])
                     {
                       reserved_right[r] = true;
@@ -272,9 +272,9 @@ template<typename RandomAccessIterator, typename Predicate>
 
 #             pragma omp single
                 {
-                  for (int r = 0; r < leftover_left; r++)
+                  for (int r = 0; r < leftover_left; ++r)
                     _GLIBCXX_PARALLEL_ASSERT(reserved_left[r]);
-                  for (int r = 0; r < leftover_right; r++)
+                  for (int r = 0; r < leftover_right; ++r)
                     _GLIBCXX_PARALLEL_ASSERT(reserved_right[r]);
                 }
 
@@ -295,17 +295,17 @@ template<typename RandomAccessIterator, typename Predicate>
       {
         // Go right until key is geq than pivot.
         while (pred(begin[final_left]) && final_left < final_right)
-          final_left++;
+          ++final_left;
 
         // Go left until key is less than pivot.
         while (!pred(begin[final_right]) && final_left < final_right)
-          final_right--;
+          --final_right;
 
         if (final_left == final_right)
           break;
         std::swap(begin[final_left], begin[final_right]);
-        final_left++;
-        final_right--;
+        ++final_left;
+        --final_right;
       }
 
     // All elements on the left side are < piv, all elements on the
@@ -345,7 +345,8 @@ template<typename RandomAccessIterator, typename Comparator>
     RandomAccessIterator split;
     random_number rng;
 
-    difference_type minimum_length = std::max<difference_type>(2, Settings::partition_minimal_n);
+    difference_type minimum_length =
+      std::max<difference_type>(2, Settings::partition_minimal_n);
 
     // Break if input range to small.
     while (static_cast<sequence_index_t>(end - begin) >= minimum_length)
@@ -359,15 +360,19 @@ template<typename RandomAccessIterator, typename Comparator>
           std::swap(*pivot_pos, *(end - 1));
         pivot_pos = end - 1;
 
-        // XXX Comparator must have first_value_type, second_value_type, result_type
-        // Comparator == __gnu_parallel::lexicographic<S, int, __gnu_parallel::less<S, S> >
+        // XXX Comparator must have first_value_type, second_value_type,
+	// result_type
+        // Comparator == __gnu_parallel::lexicographic<S, int,
+	// __gnu_parallel::less<S, S> >
         // pivot_pos == std::pair<S, int>*
         // XXX binder2nd only for RandomAccessIterators??
-        __gnu_parallel::binder2nd<Comparator, value_type, value_type, bool> pred(comp, *pivot_pos);
+        __gnu_parallel::binder2nd<Comparator, value_type, value_type, bool>
+	  pred(comp, *pivot_pos);
 
         // Divide, leave pivot unchanged in last place.
         RandomAccessIterator split_pos1, split_pos2;
-        split_pos1 = begin + parallel_partition(begin, end - 1, pred, get_max_threads());
+        split_pos1 = begin + parallel_partition(begin, end - 1, pred,
+						get_max_threads());
 
         // Left side: < pivot_pos; right side: >= pivot_pos
 
@@ -377,14 +382,19 @@ template<typename RandomAccessIterator, typename Comparator>
         pivot_pos = split_pos1;
 
         // In case all elements are equal, split_pos1 == 0
-        if ((split_pos1 + 1 - begin) < (n >> 7) || (end - split_pos1) < (n >> 7))
+        if ((split_pos1 + 1 - begin) < (n >> 7)
+	    || (end - split_pos1) < (n >> 7))
           {
             // Very unequal split, one part smaller than one 128th
             // elements not stricly larger than the pivot.
-            __gnu_parallel::unary_negate<__gnu_parallel::binder1st<Comparator, value_type, value_type, bool>, value_type> pred(__gnu_parallel::binder1st<Comparator, value_type, value_type, bool>(comp, *pivot_pos));
+            __gnu_parallel::unary_negate<__gnu_parallel::
+	      binder1st<Comparator, value_type, value_type, bool>, value_type>
+	      pred(__gnu_parallel::binder1st<Comparator, value_type,
+		   value_type, bool>(comp, *pivot_pos));
 
             // Find other end of pivot-equal range.
-            split_pos2 = __gnu_sequential::partition(split_pos1 + 1, end, pred);
+            split_pos2 = __gnu_sequential::partition(split_pos1 + 1,
+						     end, pred);
           }
         else
           // Only skip the pivot.
@@ -410,7 +420,9 @@ template<typename RandomAccessIterator, typename Comparator>
 *  @param comp Comparator. */
 template<typename RandomAccessIterator, typename Comparator>
   void
-  parallel_partial_sort(RandomAccessIterator begin, RandomAccessIterator middle, RandomAccessIterator end, Comparator comp)
+  parallel_partial_sort(RandomAccessIterator begin,
+			RandomAccessIterator middle,
+			RandomAccessIterator end, Comparator comp)
   {
     parallel_nth_element(begin, middle, end, comp);
     std::sort(begin, middle, comp);

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

 // -*- 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
@@ -81,13 +81,12 @@ namespace __gnu_parallel
 
       /** @brief Destructor. Not to be called concurrent, of course. */
       ~RestrictedBoundedConcurrentQueue()
-    {
-      delete[] base;
-    }
+      { delete[] base; }
 
       /** @brief Pushes one element into the queue at the front end.
        *  Must not be called concurrently with pop_front(). */
-    void push_front(const T& t)
+      void
+      push_front(const T& t)
       {
 	lcas_t former_borders = borders;
 	int former_front, former_back;
@@ -95,14 +94,16 @@ namespace __gnu_parallel
 	*(base + former_front % max_size) = t;
 #if _GLIBCXX_ASSERTIONS
 	// Otherwise: front - back > max_size eventually.
-      _GLIBCXX_PARALLEL_ASSERT(((former_front + 1) - former_back) <= max_size);
+	_GLIBCXX_PARALLEL_ASSERT(((former_front + 1) - former_back)
+				 <= max_size);
 #endif
 	fetch_and_add(&borders, encode2(1, 0));
       }
 
       /** @brief Pops one element from the queue at the front end.
        *  Must not be called concurrently with pop_front(). */
-    bool pop_front(T& t)
+      bool
+      pop_front(T& t)
       {
 	int former_front, former_back;
 #pragma omp flush
@@ -125,7 +126,8 @@ namespace __gnu_parallel
 
       /** @brief Pops one element from the queue at the front end.
        *  Must not be called concurrently with pop_front(). */
-    bool pop_back(T& t)	//queue behavior
+      bool
+      pop_back(T& t)	//queue behavior
       {
 	int former_front, former_back;
 #pragma omp flush

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

@@ -53,17 +53,14 @@ namespace __gnu_parallel
    *  this part.
    */
   template<typename RandomAccessIterator, typename Comparator>
-  inline
     typename std::iterator_traits<RandomAccessIterator>::difference_type
-  parallel_sort_qs_divide(
-      RandomAccessIterator begin,
+    parallel_sort_qs_divide(RandomAccessIterator begin,
 			    RandomAccessIterator end,
-      Comparator comp,
-      typename std::iterator_traits<RandomAccessIterator>::difference_type
-          pivot_rank,
-      typename std::iterator_traits<RandomAccessIterator>::difference_type
-          num_samples,
-      thread_index_t num_threads)
+			    Comparator comp, typename std::iterator_traits
+			    <RandomAccessIterator>::difference_type pivot_rank,
+			    typename std::iterator_traits
+			    <RandomAccessIterator>::difference_type
+			    num_samples, thread_index_t num_threads)
     {
       typedef std::iterator_traits<RandomAccessIterator> traits_type;
       typedef typename traits_type::value_type value_type;
@@ -73,8 +70,9 @@ namespace __gnu_parallel
       num_samples = std::min(num_samples, n);
 
       // Allocate uninitialized, to avoid default constructor.
-    value_type* samples = static_cast<value_type*>(
-      ::operator new(num_samples * sizeof(value_type)));
+      value_type* samples =
+	static_cast<value_type*>(::operator new(num_samples
+						* sizeof(value_type)));
 
       for (difference_type s = 0; s < num_samples; ++s)
 	{
@@ -104,7 +102,7 @@ namespace __gnu_parallel
    *  this part.
    */
   template<typename RandomAccessIterator, typename Comparator>
-  inline void
+    void
     parallel_sort_qs_conquer(RandomAccessIterator begin,
 			     RandomAccessIterator end,
 			     Comparator comp,
@@ -134,9 +132,10 @@ namespace __gnu_parallel
 
       pivot_rank = n * num_threads_left / num_threads;
 
-    difference_type split = parallel_sort_qs_divide(
-        begin, end, comp, pivot_rank,
-        Settings::sort_qs_num_samples_preset, num_threads);
+      difference_type split =
+	parallel_sort_qs_divide(begin, end, comp, pivot_rank,
+				Settings::sort_qs_num_samples_preset,
+				num_threads);
 
 #pragma omp parallel sections
       {
@@ -160,12 +159,11 @@ namespace __gnu_parallel
    *  this part.
    */
   template<typename RandomAccessIterator, typename Comparator>
-  inline void
-  parallel_sort_qs(
-      RandomAccessIterator begin,
+    void
+    parallel_sort_qs(RandomAccessIterator begin,
 		     RandomAccessIterator end,
-      Comparator comp,
-      typename std::iterator_traits<RandomAccessIterator>::difference_type n,
+		     Comparator comp, typename std::iterator_traits
+		     <RandomAccessIterator>::difference_type n,
 		     int num_threads)
     {
       _GLIBCXX_CALL(n)

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

@@ -124,7 +124,7 @@ template<typename RandomNumberGenerator>
 /** @brief Random shuffle code executed by each thread.
   *  @param pus Array of thread-local data records. */
 template<typename RandomAccessIterator, typename RandomNumberGenerator>
-  inline void 
+  void 
   parallel_random_shuffle_drs_pu(DRSSorterPU<RandomAccessIterator,
                                  RandomNumberGenerator>* pus)
   {
@@ -213,8 +213,8 @@ template<typename RandomAccessIterator, typename RandomNumberGenerator>
         thread_index_t target_p = bin_proc[target_bin];
 
         // Last column [d->num_threads] stays unchanged.
-        ::new(&(temporaries[target_p][dist[target_bin + 1]++])) value_type(
-              *(source + i + start));
+        ::new(&(temporaries[target_p][dist[target_bin + 1]++]))
+	    value_type(*(source + i + start));
       }
 
     delete[] oracles;
@@ -260,11 +260,11 @@ template<typename T>
   *  @param rng Random number generator to use.
   */
 template<typename RandomAccessIterator, typename RandomNumberGenerator>
-  inline void
-  parallel_random_shuffle_drs(
-      RandomAccessIterator begin,
+  void
+  parallel_random_shuffle_drs(RandomAccessIterator begin,
 			      RandomAccessIterator end,
-      typename std::iterator_traits<RandomAccessIterator>::difference_type n,
+			      typename std::iterator_traits
+			      <RandomAccessIterator>::difference_type n,
 			      thread_index_t num_threads,
 			      RandomNumberGenerator& rng)
   {
@@ -393,7 +393,7 @@ template<typename RandomAccessIterator, typename RandomNumberGenerator>
  *  @param rng Random number generator to use.
  */
 template<typename RandomAccessIterator, typename RandomNumberGenerator>
-  inline void
+  void
   sequential_random_shuffle(RandomAccessIterator begin, 
                             RandomAccessIterator end,
                             RandomNumberGenerator& rng)

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

 // -*- 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
@@ -81,8 +81,7 @@ template<typename RandomAccessIterator, typename _DifferenceTp>
    *  @param end2 End iterator of second sequence.
    *  @param pred Find predicate.
    *  @return Place of finding in first sequences. */
-template<
-    typename _RandomAccessIterator1,
+template<typename _RandomAccessIterator1,
 	 typename _RandomAccessIterator2,
 	 typename Pred>
   _RandomAccessIterator1

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

 // -*- 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
@@ -48,7 +48,7 @@
 namespace __gnu_parallel
 {
 template<typename InputIterator, typename OutputIterator>
-  inline OutputIterator
+  OutputIterator
   copy_tail(std::pair<InputIterator, InputIterator> b,
             std::pair<InputIterator, InputIterator> e, OutputIterator r)
   {
@@ -68,8 +68,7 @@ template<typename InputIterator, typename OutputIterator>
     return r;
   }
 
-template<
-    typename InputIterator,
+template<typename InputIterator,
 	 typename OutputIterator,
 	 typename Comparator>
   struct symmetric_difference_func
@@ -82,7 +81,8 @@ template<
 
     Comparator comp;
 
-    inline OutputIterator invoke(InputIterator a, InputIterator b,
+    OutputIterator
+    invoke(InputIterator a, InputIterator b,
 	   InputIterator c, InputIterator d,
 	   OutputIterator r) const
     {
@@ -109,9 +109,9 @@ template<
       return std::copy(c, d, std::copy(a, b, r));
     }
 
-    inline difference_type
-    count(InputIterator a, InputIterator b, InputIterator c, InputIterator d)
-        const
+    difference_type
+    count(InputIterator a, InputIterator b,
+	  InputIterator c, InputIterator d) const
     {
       difference_type counter = 0;
 
@@ -137,19 +137,17 @@ template<
       return counter + (b - a) + (d - c);
     }
 
-    inline OutputIterator
+    OutputIterator
     first_empty(InputIterator c, InputIterator d, OutputIterator out) const
     { return std::copy(c, d, out); }
 
-    inline OutputIterator
+    OutputIterator
     second_empty(InputIterator a, InputIterator b, OutputIterator out) const
     { return std::copy(a, b, out); }
-
   };
 
 
-template<
-    typename InputIterator,
+template<typename InputIterator,
 	 typename OutputIterator,
 	 typename Comparator>
   struct difference_func
@@ -162,7 +160,7 @@ template<
 
     Comparator comp;
 
-    inline OutputIterator
+    OutputIterator
     invoke(InputIterator a, InputIterator b, InputIterator c, InputIterator d,
           OutputIterator r) const
     {
@@ -185,9 +183,9 @@ template<
       return std::copy(a, b, r);
     }
 
-    inline difference_type
-    count(InputIterator a, InputIterator b, InputIterator c, InputIterator d)
-        const
+    difference_type
+    count(InputIterator a, InputIterator b,
+	  InputIterator c, InputIterator d) const
     {
       difference_type counter = 0;
 
@@ -217,8 +215,7 @@ template<
   };
 
 
-template<
-    typename InputIterator,
+template<typename InputIterator,
 	 typename OutputIterator,
 	 typename Comparator>
   struct intersection_func
@@ -231,7 +228,7 @@ template<
 
     Comparator comp;
 
-    inline OutputIterator
+    OutputIterator
     invoke(InputIterator a, InputIterator b, InputIterator c, InputIterator d,
           OutputIterator r) const
     {
@@ -253,9 +250,9 @@ template<
       return r;
     }
 
-    inline difference_type
-    count(InputIterator a, InputIterator b, InputIterator c, InputIterator d)
-        const
+    difference_type
+    count(InputIterator a, InputIterator b,
+	  InputIterator c, InputIterator d) const
     {
       difference_type counter = 0;
 
@@ -295,7 +292,7 @@ template<class InputIterator, class OutputIterator, class Comparator>
 
     Comparator comp;
 
-    inline OutputIterator
+    OutputIterator
     invoke(InputIterator a, const InputIterator b, InputIterator c,
           const InputIterator d, OutputIterator r) const
     {
@@ -322,9 +319,9 @@ template<class InputIterator, class OutputIterator, class Comparator>
       return std::copy(c, d, std::copy(a, b, r));
     }
 
-    inline difference_type
-    count(InputIterator a, InputIterator b, InputIterator c, InputIterator d)
-        const
+    difference_type
+    count(InputIterator a, InputIterator b,
+	  InputIterator c, InputIterator d) const
     {
       difference_type counter = 0;
 
@@ -356,8 +353,7 @@ template<class InputIterator, class OutputIterator, class Comparator>
     { return std::copy(a, b, out); }
   };
 
-template<
-    typename InputIterator,
+template<typename InputIterator,
 	 typename OutputIterator,
 	 typename Operation>
   OutputIterator
@@ -480,11 +476,10 @@ template<
   }
 
 
-template<
-    typename InputIterator,
+template<typename InputIterator,
 	 typename OutputIterator,
 	 typename Comparator>
-  OutputIterator
+  inline OutputIterator
   parallel_set_union(InputIterator begin1, InputIterator end1,
                      InputIterator begin2, InputIterator end2,
                      OutputIterator result, Comparator comp)
@@ -493,11 +488,10 @@ template<
         union_func< InputIterator, OutputIterator, Comparator>(comp));
   }
 
-template<
-    typename InputIterator,
+template<typename InputIterator,
 	 typename OutputIterator,
 	 typename Comparator>
-  OutputIterator
+  inline OutputIterator
   parallel_set_intersection(InputIterator begin1, InputIterator end1,
                             InputIterator begin2, InputIterator end2,
                             OutputIterator result, Comparator comp)
@@ -508,7 +502,7 @@ template<
 
 
 template<typename InputIterator, typename OutputIterator>
-  OutputIterator
+  inline OutputIterator
   set_intersection(InputIterator begin1, InputIterator end1,
                    InputIterator begin2, InputIterator end2,
                    OutputIterator result)
@@ -520,11 +514,10 @@ template<typename InputIterator, typename OutputIterator>
 			    std::less<value_type>());
   }
 
-template<
-    typename InputIterator,
+template<typename InputIterator,
 	 typename OutputIterator,
 	 typename Comparator>
-  OutputIterator
+  inline OutputIterator
   parallel_set_difference(InputIterator begin1, InputIterator end1,
                           InputIterator begin2, InputIterator end2,
                           OutputIterator result, Comparator comp)
@@ -533,11 +526,10 @@ template<
         difference_func<InputIterator, OutputIterator, Comparator>(comp));
   }
 
-template<
-    typename InputIterator,
+template<typename InputIterator,
 	 typename OutputIterator,
 	 typename Comparator>
-  OutputIterator
+  inline OutputIterator
   parallel_set_symmetric_difference(InputIterator begin1, InputIterator end1,
                                     InputIterator begin2, InputIterator end2,
                                     OutputIterator result, Comparator comp)

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

 // -*- 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
@@ -33,7 +33,8 @@
  *  whether to use parallelized algorithms.
  *  This file is a GNU parallel extension to the Standard C++ Library.
  *
- *  @section parallelization_decision  The decision whether to run an algorithm in parallel.
+ *  @section parallelization_decision  The decision whether to run
+ *                                     an algorithm in parallel.
  *
  *  There are several ways the user can switch on and off the 
  *  parallel execution of an algorithm, both at compile- and 
@@ -104,7 +105,10 @@
   * __gnu_parallel::Settings::force_parallel, i. e. usually a decision based on
   * the input size.
   */
-#define _GLIBCXX_PARALLEL_CONDITION(c) (!(__gnu_parallel::Settings::force_sequential) && ((__gnu_parallel::get_max_threads() > 1 && (c)) || __gnu_parallel::Settings::force_parallel))
+#define _GLIBCXX_PARALLEL_CONDITION(c) \
+(!(__gnu_parallel::Settings::force_sequential) \
+ && ((__gnu_parallel::get_max_threads() > 1 \
+      && (c)) || __gnu_parallel::Settings::force_parallel))
 
 namespace __gnu_parallel
 {
@@ -131,7 +135,8 @@ namespace
     /** @brief Different merging algorithms: bubblesort-alike,
 	loser-tree variants, enum sentinel */
     enum MultiwayMergeAlgorithm
-    { BUBBLE, LOSER_TREE_EXPLICIT, LOSER_TREE, LOSER_TREE_COMBINED, LOSER_TREE_SENTINEL, MWM_ALGORITHM_LAST };
+    { BUBBLE, LOSER_TREE_EXPLICIT, LOSER_TREE, LOSER_TREE_COMBINED,
+      LOSER_TREE_SENTINEL, MWM_ALGORITHM_LAST };
 
     /** @brief Different splitting strategies for sorting/merging:
 	by sampling, exact */
@@ -340,7 +345,8 @@ namespace
   volatile sequence_index_t Settings::partition_chunk_size = 1000;
   volatile double Settings::partition_chunk_share = 0.0;
   volatile unsigned int Settings::adjacent_difference_minimal_n = 1000;
-  volatile  Settings::PartialSumAlgorithm Settings::partial_sum_algorithm = Settings::LINEAR;
+  volatile  Settings::PartialSumAlgorithm Settings::
+  partial_sum_algorithm = Settings::LINEAR;
   volatile unsigned int Settings::partial_sum_minimal_n = 1000;
   volatile float Settings::partial_sum_dilatation = 1.0f;
   volatile unsigned int Settings::random_shuffle_minimal_n = 1000;
@@ -352,10 +358,13 @@ namespace
 
   // unique copy
   volatile sequence_index_t Settings::unique_copy_minimal_n = 10000;
-  volatile  Settings::MultiwayMergeAlgorithm Settings::multiway_merge_algorithm = Settings::LOSER_TREE;
-  volatile  Settings::Splitting Settings::multiway_merge_splitting = Settings::EXACT;
+  volatile  Settings::MultiwayMergeAlgorithm Settings::
+  multiway_merge_algorithm = Settings::LOSER_TREE;
+  volatile  Settings::Splitting Settings::multiway_merge_splitting =
+    Settings::EXACT;
   volatile unsigned int Settings::multiway_merge_oversampling = 10;
-  volatile  Settings::FindDistribution Settings::find_distribution = Settings::CONSTANT_SIZE_BLOCKS;
+  volatile  Settings::FindDistribution Settings::find_distribution =
+    Settings::CONSTANT_SIZE_BLOCKS;
   volatile sequence_index_t Settings::find_sequential_search_size = 256;
   volatile sequence_index_t Settings::find_initial_block_size = 256;
   volatile sequence_index_t Settings::find_maximum_block_size = 8192;
@@ -375,7 +384,8 @@ namespace
   volatile sequence_index_t Settings::set_union_minimal_n = 1000;
   volatile sequence_index_t Settings::set_intersection_minimal_n = 1000;
   volatile sequence_index_t Settings::set_difference_minimal_n = 1000;
-  volatile sequence_index_t Settings::set_symmetric_difference_minimal_n = 1000;
+  volatile sequence_index_t Settings::set_symmetric_difference_minimal_n =
+    1000;
   volatile unsigned long long Settings::L1_cache_size = 16 << 10;
   volatile unsigned long long Settings::L2_cache_size = 256 << 10;
   volatile unsigned int Settings::TLB_size = 128;

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

 // -*- 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
@@ -92,7 +92,8 @@ namespace __gnu_parallel
 	    parallel_sort_qs(begin, end, comp, n, get_max_threads());
 #endif
 #if _GLIBCXX_BAL_QUICKSORT
-	else if (Settings::sort_algorithm == Settings::QS_BALANCED && !stable)
+	  else if (Settings::sort_algorithm == Settings::QS_BALANCED
+		   && !stable)
 	    parallel_sort_qsb(begin, end, comp, n, get_max_threads());
 #endif
 	  else

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

 // -*- 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
@@ -50,11 +50,10 @@ namespace __gnu_parallel
   *  @param result Begin iterator of result sequence.
   *  @param binary_pred Equality predicate.
   *  @return End iterator of result sequence. */
-template<
-    typename InputIterator,
+template<typename InputIterator,
 	 class OutputIterator,
 	 class BinaryPredicate>
-  inline OutputIterator
+  OutputIterator
   parallel_unique_copy(InputIterator first, InputIterator last,
                        OutputIterator result, BinaryPredicate binary_pred)
   {
@@ -99,14 +98,14 @@ template<
           begin = borders[0] + 1;	// == 1
           end = borders[iam + 1];
 
-          i++;
+          ++i;
           *out++ = *first;
 
           for (InputIterator iter = first + begin; iter < first + end; ++iter)
             {
               if (!binary_pred(*iter, *(iter-1)))
                 {
-                  i++;
+                  ++i;
                   *out++ = *iter;
                 }
             }
@@ -118,10 +117,8 @@ template<
 
           for (InputIterator iter = first + begin; iter < first + end; ++iter)
             {
-              if (!binary_pred(*iter, *(iter-1)))
-                {
-                  i++;
-                }
+              if (!binary_pred(*iter, *(iter - 1)))
+		++i;
 	    }
         }
       counter[iam] = i;
@@ -136,7 +133,7 @@ template<
 
       if (iam == 0)
         {
-          for (int t = 0; t < num_threads; t++)
+          for (int t = 0; t < num_threads; ++t)
             begin_output += counter[t];
 
           i = 0;
@@ -148,9 +145,9 @@ template<
 
           for (InputIterator iter = first + begin; iter < first + end; ++iter)
             {
-              if (iter == first || !binary_pred(*iter, *(iter-1)))
+              if (iter == first || !binary_pred(*iter, *(iter - 1)))
                 {
-                  i++;
+                  ++i;
                   *iter_out++ = *iter;
                 }
             }
@@ -166,12 +163,10 @@ template<
           for (InputIterator iter = first + begin; iter < first + end; ++iter)
             {
               if (!binary_pred(*iter, *(iter-1)))
-                {
 		*iter_out++ = *iter;
 	    }
         }
     }
-    }
 
     difference_type end_output = 0;
     for (int t = 0; t < num_threads + 1; t++)
@@ -193,8 +188,8 @@ template<typename InputIterator, class OutputIterator>
                        OutputIterator result)
   {
     typedef typename std::iterator_traits<InputIterator>::value_type value_type;
-
-    return parallel_unique_copy(first, last, result, std::equal_to<value_type>());
+    return parallel_unique_copy(first, last, result,
+				std::equal_to<value_type>());
   }
 
 }//namespace __gnu_parallel

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

 // -*- 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
@@ -96,20 +96,19 @@ template<typename _DifferenceTp>
   *  std::count_n()).
   *  @return User-supplied functor (that may contain a part of the result).
   */
-template<
-    typename RandomAccessIterator,
+template<typename RandomAccessIterator,
 	 typename Op,
 	 typename Fu,
 	 typename Red,
 	 typename Result>
   Op
-  for_each_template_random_access_workstealing(
-      RandomAccessIterator begin,
+  for_each_template_random_access_workstealing(RandomAccessIterator begin,
 					       RandomAccessIterator end,
 					       Op op, Fu& f, Red r,
 					       Result base, Result& output,
-      typename std::iterator_traits<RandomAccessIterator>::difference_type
-          bound)
+					       typename std::iterator_traits
+					       <RandomAccessIterator>::
+					       difference_type bound)
   {
     _GLIBCXX_CALL(end - begin)
 
@@ -180,7 +179,7 @@ template<
 
         // This thread is currently working.
 #       pragma omp atomic
-          busy++;
+          ++busy;
 
         iam_working = true;
 
@@ -198,8 +197,8 @@ template<
             // Cannot use volatile variable directly.
             difference_type my_first = my_job.first;
             result = f(op, begin + my_first);
-            my_job.first++;
-            my_job.load--;
+            ++my_job.first;
+            --my_job.load;
           }
 
         RandomAccessIterator current;
@@ -226,11 +225,11 @@ template<
                 my_job.load = my_job.last - my_job.first + 1;
                 for (difference_type job_counter = 0;
                      job_counter < chunk_size && current_job <= my_job.last;
-                     job_counter++)
+                     ++job_counter)
                   {
                     // Yes: process it!
                     current = begin + current_job;
-                    current_job++;
+                    ++current_job;
 
                     // Do actual work.
                     result = r(result, f(op, current));
@@ -244,7 +243,7 @@ template<
               {
                 // This thread no longer has work.
 #               pragma omp atomic
-                busy--;
+                --busy;
 
                 iam_working = false;
               }
@@ -286,7 +285,7 @@ template<
 
                 // Has potential work again.
 #               pragma omp atomic
-                  busy++;
+                  ++busy;
                 iam_working = true;
 
 #               pragma omp flush(busy)