Remove trailing whitespace in C++ headers

2016-08-24  Aditya Kumar  <hiraditya@msn.com>

	* include/bits/algorithmfwd.h: Remove trailing whitespace.
	* include/bits/shared_ptr_base.h: Likewise.

From-SVN: r239731

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index 467cf3a0360af466ac1312860441d2f677b299e4..0d7e8bf7f594e7438e7a5dbfc10a9fa348981f40 100644 (file)
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,8 @@
+2016-08-24  Aditya Kumar  <hiraditya@msn.com>
+
+       * include/bits/algorithmfwd.h: Remove trailing whitespace.
+       * include/bits/shared_ptr_base.h: Likewise.
+
 2016-08-23  Jonathan Wakely  <jwakely@redhat.com>
 
        * include/debug/array (array): Add _GLIBCXX17_CONSTEXPR.

diff --git a/libstdc++-v3/include/bits/algorithmfwd.h b/libstdc++-v3/include/bits/algorithmfwd.h
index c6481691236b3681ceacb8c95bd7c8aec9be4b68..a61fea7243961e7ef11462a78948c5bdaa08401a 100644 (file)
--- a/libstdc++-v3/include/bits/algorithmfwd.h
+++ b/libstdc++-v3/include/bits/algorithmfwd.h
@@ -168,12 +168,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    *
    * These algorithms are variations of a classic binary search, and
    * all assume that the sequence being searched is already sorted.
-   * 
+   *
    * The number of comparisons will be logarithmic (and as few as
    * possible).  The number of steps through the sequence will be
    * logarithmic for random-access iterators (e.g., pointers), and
    * linear otherwise.
-   * 
+   *
    * The LWG has passed Defect Report 270, which notes: <em>The
    * proposed resolution reinterprets binary search. Instead of
    * thinking about searching for a value in a sorted range, we view
@@ -202,11 +202,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #endif
 
   template<typename _FIter, typename _Tp>
-    bool 
+    bool
     binary_search(_FIter, _FIter, const _Tp&);
 
   template<typename _FIter, typename _Tp, typename _Compare>
-    bool 
+    bool
     binary_search(_FIter, _FIter, const _Tp&, _Compare);
 
 #if __cplusplus > 201402L
@@ -222,7 +222,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #endif
 
   template<typename _IIter, typename _OIter>
-    _OIter 
+    _OIter
     copy(_IIter, _IIter, _OIter);
 
   template<typename _BIter1, typename _BIter2>
@@ -251,7 +251,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     equal_range(_FIter, _FIter, const _Tp&, _Compare);
 
   template<typename _FIter, typename _Tp>
-    void 
+    void
     fill(_FIter, _FIter, const _Tp&);
 
   template<typename _OIter, typename _Size, typename _Tp>
@@ -282,36 +282,36 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   // generate_n
 
   template<typename _IIter1, typename _IIter2>
-    bool 
+    bool
     includes(_IIter1, _IIter1, _IIter2, _IIter2);
 
   template<typename _IIter1, typename _IIter2, typename _Compare>
-    bool 
+    bool
     includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
 
   template<typename _BIter>
-    void 
+    void
     inplace_merge(_BIter, _BIter, _BIter);
 
   template<typename _BIter, typename _Compare>
-    void 
+    void
     inplace_merge(_BIter, _BIter, _BIter, _Compare);
 
 #if __cplusplus >= 201103L
   template<typename _RAIter>
-    bool 
+    bool
     is_heap(_RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
-    bool 
+    bool
     is_heap(_RAIter, _RAIter, _Compare);
 
   template<typename _RAIter>
-    _RAIter 
+    _RAIter
     is_heap_until(_RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
-    _RAIter 
+    _RAIter
     is_heap_until(_RAIter, _RAIter, _Compare);
 
   template<typename _IIter, typename _Predicate>
@@ -328,63 +328,63 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);
 
   template<typename _FIter>
-    bool 
+    bool
     is_sorted(_FIter, _FIter);
 
   template<typename _FIter, typename _Compare>
-    bool 
+    bool
     is_sorted(_FIter, _FIter, _Compare);
 
   template<typename _FIter>
-    _FIter 
+    _FIter
     is_sorted_until(_FIter, _FIter);
 
   template<typename _FIter, typename _Compare>
-    _FIter 
+    _FIter
     is_sorted_until(_FIter, _FIter, _Compare);
 #endif
 
   template<typename _FIter1, typename _FIter2>
-    void 
+    void
     iter_swap(_FIter1, _FIter2);
 
   template<typename _FIter, typename _Tp>
-    _FIter 
+    _FIter
     lower_bound(_FIter, _FIter, const _Tp&);
 
   template<typename _FIter, typename _Tp, typename _Compare>
-    _FIter 
+    _FIter
     lower_bound(_FIter, _FIter, const _Tp&, _Compare);
 
   template<typename _RAIter>
-    void 
+    void
     make_heap(_RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
-    void 
+    void
     make_heap(_RAIter, _RAIter, _Compare);
 
-  template<typename _Tp> 
+  template<typename _Tp>
     _GLIBCXX14_CONSTEXPR
-    const _Tp& 
+    const _Tp&
     max(const _Tp&, const _Tp&);
 
   template<typename _Tp, typename _Compare>
     _GLIBCXX14_CONSTEXPR
-    const _Tp& 
+    const _Tp&
     max(const _Tp&, const _Tp&, _Compare);
 
   // max_element
   // merge
 
-  template<typename _Tp> 
+  template<typename _Tp>
     _GLIBCXX14_CONSTEXPR
-    const _Tp& 
+    const _Tp&
     min(const _Tp&, const _Tp&);
 
   template<typename _Tp, typename _Compare>
     _GLIBCXX14_CONSTEXPR
-    const _Tp& 
+    const _Tp&
     min(const _Tp&, const _Tp&, _Compare);
 
   // min_element
@@ -392,7 +392,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #if __cplusplus >= 201103L
   template<typename _Tp>
     _GLIBCXX14_CONSTEXPR
-    pair<const _Tp&, const _Tp&> 
+    pair<const _Tp&, const _Tp&>
     minmax(const _Tp&, const _Tp&);
 
   template<typename _Tp, typename _Compare>
@@ -444,11 +444,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   // mismatch
 
   template<typename _BIter>
-    bool 
+    bool
     next_permutation(_BIter, _BIter);
 
   template<typename _BIter, typename _Compare>
-    bool 
+    bool
     next_permutation(_BIter, _BIter, _Compare);
 
 #if __cplusplus >= 201103L
@@ -482,65 +482,65 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #endif
 
   template<typename _RAIter>
-    void 
+    void
     pop_heap(_RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
-    void 
+    void
     pop_heap(_RAIter, _RAIter, _Compare);
 
   template<typename _BIter>
-    bool 
+    bool
     prev_permutation(_BIter, _BIter);
 
   template<typename _BIter, typename _Compare>
-    bool 
+    bool
     prev_permutation(_BIter, _BIter, _Compare);
 
   template<typename _RAIter>
-    void 
+    void
     push_heap(_RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
-    void 
+    void
     push_heap(_RAIter, _RAIter, _Compare);
 
   // random_shuffle
 
   template<typename _FIter, typename _Tp>
-    _FIter 
+    _FIter
     remove(_FIter, _FIter, const _Tp&);
 
   template<typename _FIter, typename _Predicate>
-    _FIter 
+    _FIter
     remove_if(_FIter, _FIter, _Predicate);
 
   template<typename _IIter, typename _OIter, typename _Tp>
-    _OIter 
+    _OIter
     remove_copy(_IIter, _IIter, _OIter, const _Tp&);
 
   template<typename _IIter, typename _OIter, typename _Predicate>
-    _OIter 
+    _OIter
     remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
 
   // replace
 
   template<typename _IIter, typename _OIter, typename _Tp>
-    _OIter 
+    _OIter
     replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
 
   template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
-    _OIter 
+    _OIter
     replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
 
   // replace_if
 
   template<typename _BIter>
-    void 
+    void
     reverse(_BIter, _BIter);
 
   template<typename _BIter, typename _OIter>
-    _OIter 
+    _OIter
     reverse_copy(_BIter, _BIter, _OIter);
 
   inline namespace _V2
@@ -551,7 +551,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   }
 
   template<typename _FIter, typename _OIter>
-    _OIter 
+    _OIter
     rotate_copy(_FIter, _FIter, _FIter, _OIter);
 
   // search
@@ -568,15 +568,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #endif
 
   template<typename _RAIter>
-    void 
+    void
     sort_heap(_RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
-    void 
+    void
     sort_heap(_RAIter, _RAIter, _Compare);
 
   template<typename _BIter, typename _Predicate>
-    _BIter 
+    _BIter
     stable_partition(_BIter, _BIter, _Predicate);
 
 #if __cplusplus < 201103L
@@ -592,27 +592,27 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #endif
 
   template<typename _FIter1, typename _FIter2>
-    _FIter2 
+    _FIter2
     swap_ranges(_FIter1, _FIter1, _FIter2);
 
   // transform
 
   template<typename _FIter>
-    _FIter 
+    _FIter
     unique(_FIter, _FIter);
 
   template<typename _FIter, typename _BinaryPredicate>
-    _FIter 
+    _FIter
     unique(_FIter, _FIter, _BinaryPredicate);
 
   // unique_copy
 
   template<typename _FIter, typename _Tp>
-    _FIter 
+    _FIter
     upper_bound(_FIter, _FIter, const _Tp&);
 
   template<typename _FIter, typename _Tp, typename _Compare>
-    _FIter 
+    _FIter
     upper_bound(_FIter, _FIter, const _Tp&, _Compare);
 
 _GLIBCXX_END_NAMESPACE_VERSION
@@ -620,11 +620,11 @@ _GLIBCXX_END_NAMESPACE_VERSION
 _GLIBCXX_BEGIN_NAMESPACE_ALGO
 
   template<typename _FIter>
-    _FIter 
+    _FIter
     adjacent_find(_FIter, _FIter);
 
   template<typename _FIter, typename _BinaryPredicate>
-    _FIter 
+    _FIter
     adjacent_find(_FIter, _FIter, _BinaryPredicate);
 
   template<typename _IIter, typename _Tp>
@@ -636,15 +636,15 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
     count_if(_IIter, _IIter, _Predicate);
 
   template<typename _IIter1, typename _IIter2>
-    bool 
+    bool
     equal(_IIter1, _IIter1, _IIter2);
 
   template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
-    bool 
+    bool
     equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
 
   template<typename _IIter, typename _Tp>
-    _IIter 
+    _IIter
     find(_IIter, _IIter, const _Tp&);
 
   template<typename _FIter1, typename _FIter2>
@@ -660,11 +660,11 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
     find_if(_IIter, _IIter, _Predicate);
 
   template<typename _IIter, typename _Funct>
-    _Funct 
+    _Funct
     for_each(_IIter, _IIter, _Funct);
 
   template<typename _FIter, typename _Generator>
-    void 
+    void
     generate(_FIter, _FIter, _Generator);
 
   template<typename _OIter, typename _Size, typename _Generator>
@@ -672,40 +672,40 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
     generate_n(_OIter, _Size, _Generator);
 
   template<typename _IIter1, typename _IIter2>
-    bool 
+    bool
     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
 
   template<typename _IIter1, typename _IIter2, typename _Compare>
-    bool 
+    bool
     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
 
   template<typename _FIter>
     _GLIBCXX14_CONSTEXPR
-    _FIter 
+    _FIter
     max_element(_FIter, _FIter);
 
   template<typename _FIter, typename _Compare>
     _GLIBCXX14_CONSTEXPR
-    _FIter 
+    _FIter
     max_element(_FIter, _FIter, _Compare);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
-    _OIter 
+    _OIter
     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, 
+  template<typename _IIter1, typename _IIter2, typename _OIter,
           typename _Compare>
-    _OIter 
+    _OIter
     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 
   template<typename _FIter>
     _GLIBCXX14_CONSTEXPR
-    _FIter 
+    _FIter
     min_element(_FIter, _FIter);
 
   template<typename _FIter, typename _Compare>
     _GLIBCXX14_CONSTEXPR
-    _FIter 
+    _FIter
     min_element(_FIter, _FIter, _Compare);
 
   template<typename _IIter1, typename _IIter2>
@@ -717,31 +717,31 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
     mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
 
   template<typename _RAIter>
-    void 
+    void
     nth_element(_RAIter, _RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
-    void 
+    void
     nth_element(_RAIter, _RAIter, _RAIter, _Compare);
 
   template<typename _RAIter>
-    void 
+    void
     partial_sort(_RAIter, _RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
-    void 
+    void
     partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
 
   template<typename _BIter, typename _Predicate>
-    _BIter 
+    _BIter
     partition(_BIter, _BIter, _Predicate);
 
   template<typename _RAIter>
-    void 
+    void
     random_shuffle(_RAIter, _RAIter);
 
   template<typename _RAIter, typename _Generator>
-    void 
+    void
     random_shuffle(_RAIter, _RAIter,
 #if __cplusplus >= 201103L
                   _Generator&&);
@@ -750,98 +750,98 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
 #endif
 
   template<typename _FIter, typename _Tp>
-    void 
+    void
     replace(_FIter, _FIter, const _Tp&, const _Tp&);
 
   template<typename _FIter, typename _Predicate, typename _Tp>
-    void 
+    void
     replace_if(_FIter, _FIter, _Predicate, const _Tp&);
 
   template<typename _FIter1, typename _FIter2>
-    _FIter1 
+    _FIter1
     search(_FIter1, _FIter1, _FIter2, _FIter2);
 
   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
-    _FIter1 
+    _FIter1
     search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
 
   template<typename _FIter, typename _Size, typename _Tp>
-    _FIter 
+    _FIter
     search_n(_FIter, _FIter, _Size, const _Tp&);
 
-  template<typename _FIter, typename _Size, typename _Tp, 
+  template<typename _FIter, typename _Size, typename _Tp,
           typename _BinaryPredicate>
-    _FIter 
+    _FIter
     search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
-    _OIter 
+    _OIter
     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, 
+  template<typename _IIter1, typename _IIter2, typename _OIter,
           typename _Compare>
-    _OIter 
+    _OIter
     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
-    _OIter 
+    _OIter
     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
   template<typename _IIter1, typename _IIter2, typename _OIter,
           typename _Compare>
-    _OIter 
+    _OIter
     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _OIter
     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, 
+  template<typename _IIter1, typename _IIter2, typename _OIter,
           typename _Compare>
     _OIter
-    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, 
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
                             _OIter, _Compare);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
-    _OIter 
+    _OIter
     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
   template<typename _IIter1, typename _IIter2, typename _OIter,
           typename _Compare>
-    _OIter 
+    _OIter
     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 
   template<typename _RAIter>
-    void 
+    void
     sort(_RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
-    void 
+    void
     sort(_RAIter, _RAIter, _Compare);
 
   template<typename _RAIter>
-    void 
+    void
     stable_sort(_RAIter, _RAIter);
 
   template<typename _RAIter, typename _Compare>
-    void 
+    void
     stable_sort(_RAIter, _RAIter, _Compare);
 
   template<typename _IIter, typename _OIter, typename _UnaryOperation>
-    _OIter 
+    _OIter
     transform(_IIter, _IIter, _OIter, _UnaryOperation);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, 
+  template<typename _IIter1, typename _IIter2, typename _OIter,
           typename _BinaryOperation>
-    _OIter 
+    _OIter
     transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
 
   template<typename _IIter, typename _OIter>
-    _OIter 
+    _OIter
     unique_copy(_IIter, _IIter, _OIter);
 
   template<typename _IIter, typename _OIter, typename _BinaryPredicate>
-    _OIter 
+    _OIter
     unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
 
 _GLIBCXX_END_NAMESPACE_ALGO

diff --git a/libstdc++-v3/include/bits/shared_ptr_base.h b/libstdc++-v3/include/bits/shared_ptr_base.h
index 787dc9b865885045426be7238e4b4a6f5e370dab..60b825c541e7ef2e2e358c9691ff693fbc8cac0e 100644 (file)
--- a/libstdc++-v3/include/bits/shared_ptr_base.h
+++ b/libstdc++-v3/include/bits/shared_ptr_base.h
@@ -70,7 +70,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   public:
     virtual char const* what() const noexcept;
 
-    virtual ~bad_weak_ptr() noexcept;    
+    virtual ~bad_weak_ptr() noexcept;
   };
 
   // Substitute for bad_weak_ptr object in the case of -fno-exceptions.
@@ -108,31 +108,31 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     class _Sp_counted_base
     : public _Mutex_base<_Lp>
     {
-    public:  
+    public:
       _Sp_counted_base() noexcept
       : _M_use_count(1), _M_weak_count(1) { }
-      
+
       virtual
       ~_Sp_counted_base() noexcept
       { }
-  
+
       // Called when _M_use_count drops to zero, to release the resources
       // managed by *this.
       virtual void
       _M_dispose() noexcept = 0;
-      
+
       // Called when _M_weak_count drops to zero.
       virtual void
       _M_destroy() noexcept
       { delete this; }
-      
+
       virtual void*
       _M_get_deleter(const std::type_info&) noexcept = 0;
 
       void
       _M_add_ref_copy()
       { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }
-  
+
       void
       _M_add_ref_lock();
 
@@ -167,7 +167,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
               }
          }
       }
-  
+
       void
       _M_weak_add_ref() noexcept
       { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }
@@ -189,7 +189,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
            _M_destroy();
          }
       }
-  
+
       long
       _M_get_use_count() const noexcept
       {
@@ -198,7 +198,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
         return __atomic_load_n(&_M_use_count, __ATOMIC_RELAXED);
       }
 
-    private:  
+    private:
       _Sp_counted_base(_Sp_counted_base const&) = delete;
       _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;
 
@@ -229,7 +229,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        }
     }
 
-  template<> 
+  template<>
     inline void
     _Sp_counted_base<_S_atomic>::
     _M_add_ref_lock()
@@ -241,10 +241,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
          if (__count == 0)
            __throw_bad_weak_ptr();
          // Replace the current counter value with the old value + 1, as
-         // long as it's not changed meanwhile. 
+         // long as it's not changed meanwhile.
        }
       while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
-                                         true, __ATOMIC_ACQ_REL, 
+                                         true, __ATOMIC_ACQ_REL,
                                          __ATOMIC_RELAXED));
     }