2004-07-04 Paolo Carlini <pcarlini@suse.de>

	* include/bits/basic_string.h: Trivial formatting fixes and/or
	const-ification of some variables.
	* include/bits/deque.tcc: Likewise.
	* include/bits/stl_algobase.h: Likewise.
	* include/bits/stl_bvector.h: Likewise.
	* include/bits/stl_construct.h: Likewise.
	* include/bits/stl_deque.h: Likewise.
	* include/bits/stl_pair.h: Likewise.
	* include/bits/stl_vector.h: Likewise.
	* include/bits/vector.tcc: Likewise.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@84090 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index 5305c34..6dba489 100644 (file)
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,5 +1,18 @@
 2004-07-04  Paolo Carlini  <pcarlini@suse.de>
 
+       * include/bits/basic_string.h: Trivial formatting fixes and/or
+       const-ification of some variables.
+       * include/bits/deque.tcc: Likewise.
+       * include/bits/stl_algobase.h: Likewise.
+       * include/bits/stl_bvector.h: Likewise.
+       * include/bits/stl_construct.h: Likewise.
+       * include/bits/stl_deque.h: Likewise.
+       * include/bits/stl_pair.h: Likewise.
+       * include/bits/stl_vector.h: Likewise.
+       * include/bits/vector.tcc: Likewise.
+
+2004-07-04  Paolo Carlini  <pcarlini@suse.de>
+
        * testsuite/25_algorithms/copy/1.cc: Add instantiations for
        systems with no COMDAT or weak support.
        * testsuite/25_algorithms/copy/2.cc: Likewise.

diff --git a/libstdc++-v3/include/bits/basic_string.h b/libstdc++-v3/include/bits/basic_string.h
index 16fe5ac..a7290d7 100644 (file)
--- a/libstdc++-v3/include/bits/basic_string.h
+++ b/libstdc++-v3/include/bits/basic_string.h
@@ -1294,47 +1294,47 @@ namespace std
       // Specializations for the common case of pointer and iterator:
       // useful to avoid the overhead of temporary buffering in _M_replace.
       basic_string&
-        replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
-        {
-         _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
-                                  && __i2 <= _M_iend());
-         __glibcxx_requires_valid_range(__k1, __k2);
-         return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
-                              __k1, __k2 - __k1);
-       }
+      replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
+      {
+       _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
+                                && __i2 <= _M_iend());
+       __glibcxx_requires_valid_range(__k1, __k2);
+       return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+                            __k1, __k2 - __k1);
+      }
 
       basic_string&
-        replace(iterator __i1, iterator __i2,
-               const _CharT* __k1, const _CharT* __k2)
-        {
-         _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
-                                  && __i2 <= _M_iend());
-         __glibcxx_requires_valid_range(__k1, __k2);
-         return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
-                              __k1, __k2 - __k1);
-       }
+      replace(iterator __i1, iterator __i2,
+             const _CharT* __k1, const _CharT* __k2)
+      {
+       _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
+                                && __i2 <= _M_iend());
+       __glibcxx_requires_valid_range(__k1, __k2);
+       return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+                            __k1, __k2 - __k1);
+      }
 
       basic_string&
-        replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
-        {
-         _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
-                                  && __i2 <= _M_iend());
-         __glibcxx_requires_valid_range(__k1, __k2);
-         return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
-                              __k1.base(), __k2 - __k1);
-       }
+      replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
+      {
+       _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
+                                && __i2 <= _M_iend());
+       __glibcxx_requires_valid_range(__k1, __k2);
+       return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+                            __k1.base(), __k2 - __k1);
+      }
 
       basic_string&
-        replace(iterator __i1, iterator __i2,
-               const_iterator __k1, const_iterator __k2)
-        {
-         _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
-                                  && __i2 <= _M_iend());
-         __glibcxx_requires_valid_range(__k1, __k2);
-         return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
-                              __k1.base(), __k2 - __k1);
-       }
-
+      replace(iterator __i1, iterator __i2,
+             const_iterator __k1, const_iterator __k2)
+      {
+       _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
+                                && __i2 <= _M_iend());
+       __glibcxx_requires_valid_range(__k1, __k2);
+       return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+                            __k1.base(), __k2 - __k1);
+      }
+      
     private:
       template<class _Integer>
        basic_string&

diff --git a/libstdc++-v3/include/bits/deque.tcc b/libstdc++-v3/include/bits/deque.tcc
index 84191f5..dda81bf 100644 (file)
--- a/libstdc++-v3/include/bits/deque.tcc
+++ b/libstdc++-v3/include/bits/deque.tcc
@@ -86,7 +86,7 @@ namespace _GLIBCXX_STD
 
   template <typename _Tp, typename _Alloc>
     typename deque<_Tp,_Alloc>::iterator
-    deque<_Tp,_Alloc>::
+    deque<_Tp, _Alloc>::
     insert(iterator position, const value_type& __x)
     {
       if (position._M_cur == this->_M_impl._M_start._M_cur)
@@ -107,12 +107,12 @@ namespace _GLIBCXX_STD
 
   template <typename _Tp, typename _Alloc>
     typename deque<_Tp,_Alloc>::iterator
-    deque<_Tp,_Alloc>::
+    deque<_Tp, _Alloc>::
     erase(iterator __position)
     {
       iterator __next = __position;
       ++__next;
-      size_type __index = __position - this->_M_impl._M_start;
+      const size_type __index = __position - this->_M_impl._M_start;
       if (__index < (size() >> 1))
        {
          std::copy_backward(this->_M_impl._M_start, __position, __next);
@@ -128,7 +128,7 @@ namespace _GLIBCXX_STD
 
   template <typename _Tp, typename _Alloc>
     typename deque<_Tp,_Alloc>::iterator
-    deque<_Tp,_Alloc>::
+    deque<_Tp, _Alloc>::
     erase(iterator __first, iterator __last)
     {
       if (__first == this->_M_impl._M_start
@@ -166,7 +166,7 @@ namespace _GLIBCXX_STD
 
   template <typename _Tp, typename _Alloc>
     void
-    deque<_Tp,_Alloc>::
+    deque<_Tp, _Alloc>::
     clear()
     {
       for (_Map_pointer __node = this->_M_impl._M_start._M_node + 1;
@@ -195,12 +195,12 @@ namespace _GLIBCXX_STD
   template <typename _Tp, class _Alloc>
     template <typename _InputIterator>
       void
-      deque<_Tp,_Alloc>
+      deque<_Tp, _Alloc>
       ::_M_assign_aux(_InputIterator __first, _InputIterator __last,
                      input_iterator_tag)
       {
         iterator __cur = begin();
-        for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
+        for (; __first != __last && __cur != end(); ++__cur, ++__first)
           *__cur = *__first;
         if (__first == __last)
           erase(__cur, end());
@@ -210,7 +210,7 @@ namespace _GLIBCXX_STD
 
   template <typename _Tp, typename _Alloc>
     void
-    deque<_Tp,_Alloc>::
+    deque<_Tp, _Alloc>::
     _M_fill_insert(iterator __pos, size_type __n, const value_type& __x)
     {
       if (__pos._M_cur == this->_M_impl._M_start._M_cur)
@@ -250,7 +250,7 @@ namespace _GLIBCXX_STD
 
   template <typename _Tp, typename _Alloc>
     void
-    deque<_Tp,_Alloc>::
+    deque<_Tp, _Alloc>::
     _M_fill_initialize(const value_type& __value)
     {
       _Map_pointer __cur;
@@ -274,14 +274,14 @@ namespace _GLIBCXX_STD
   template <typename _Tp, typename _Alloc>
     template <typename _InputIterator>
       void
-      deque<_Tp,_Alloc>::
+      deque<_Tp, _Alloc>::
       _M_range_initialize(_InputIterator __first, _InputIterator __last,
                           input_iterator_tag)
       {
         this->_M_initialize_map(0);
         try
           {
-            for ( ; __first != __last; ++__first)
+            for (; __first != __last; ++__first)
               push_back(*__first);
           }
         catch(...)
@@ -294,7 +294,7 @@ namespace _GLIBCXX_STD
   template <typename _Tp, typename _Alloc>
     template <typename _ForwardIterator>
       void
-      deque<_Tp,_Alloc>::
+      deque<_Tp, _Alloc>::
       _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
                           forward_iterator_tag)
       {
@@ -327,7 +327,7 @@ namespace _GLIBCXX_STD
   // Called only if _M_impl._M_finish._M_cur == _M_impl._M_finish._M_last - 1.
   template <typename _Tp, typename _Alloc>
     void
-    deque<_Tp,_Alloc>::
+    deque<_Tp, _Alloc>::
     _M_push_back_aux(const value_type& __t)
     {
       value_type __t_copy = __t;
@@ -350,7 +350,7 @@ namespace _GLIBCXX_STD
   // Called only if _M_impl._M_start._M_cur == _M_impl._M_start._M_first.
   template <typename _Tp, typename _Alloc>
     void
-    deque<_Tp,_Alloc>::
+    deque<_Tp, _Alloc>::
     _M_push_front_aux(const value_type& __t)
     {
       value_type __t_copy = __t;
@@ -373,7 +373,7 @@ namespace _GLIBCXX_STD
 
   // Called only if _M_impl._M_finish._M_cur == _M_impl._M_finish._M_first.
   template <typename _Tp, typename _Alloc>
-    void deque<_Tp,_Alloc>::
+    void deque<_Tp, _Alloc>::
     _M_pop_back_aux()
     {
       _M_deallocate_node(this->_M_impl._M_finish._M_first);
@@ -388,7 +388,7 @@ namespace _GLIBCXX_STD
   //   _M_impl._M_start._M_cur == _M_impl._M_start._M_last,
   // then the deque must have at least two nodes.
   template <typename _Tp, typename _Alloc>
-    void deque<_Tp,_Alloc>::
+    void deque<_Tp, _Alloc>::
     _M_pop_front_aux()
     {
       std::_Destroy(this->_M_impl._M_start._M_cur);
@@ -400,7 +400,7 @@ namespace _GLIBCXX_STD
   template <typename _Tp, typename _Alloc>
     template <typename _InputIterator>
       void
-      deque<_Tp,_Alloc>::
+      deque<_Tp, _Alloc>::
       _M_range_insert_aux(iterator __pos,
                           _InputIterator __first, _InputIterator __last,
                           input_iterator_tag)
@@ -409,12 +409,12 @@ namespace _GLIBCXX_STD
   template <typename _Tp, typename _Alloc>
     template <typename _ForwardIterator>
       void
-      deque<_Tp,_Alloc>::
+      deque<_Tp, _Alloc>::
       _M_range_insert_aux(iterator __pos,
                           _ForwardIterator __first, _ForwardIterator __last,
                           forward_iterator_tag)
       {
-        size_type __n = std::distance(__first, __last);
+        const size_type __n = std::distance(__first, __last);
         if (__pos._M_cur == this->_M_impl._M_start._M_cur)
          {
            iterator __new_start = _M_reserve_elements_at_front(__n);
@@ -452,7 +452,7 @@ namespace _GLIBCXX_STD
 
   template <typename _Tp, typename _Alloc>
     typename deque<_Tp, _Alloc>::iterator
-    deque<_Tp,_Alloc>::
+    deque<_Tp, _Alloc>::
     _M_insert_aux(iterator __pos, const value_type& __x)
     {
       difference_type __index = __pos - this->_M_impl._M_start;
@@ -485,11 +485,11 @@ namespace _GLIBCXX_STD
 
   template <typename _Tp, typename _Alloc>
     void
-    deque<_Tp,_Alloc>::
+    deque<_Tp, _Alloc>::
     _M_insert_aux(iterator __pos, size_type __n, const value_type& __x)
     {
       const difference_type __elems_before = __pos - this->_M_impl._M_start;
-      size_type __length = this->size();
+      const size_type __length = this->size();
       value_type __x_copy = __x;
       if (__elems_before < difference_type(__length / 2))
        {
@@ -566,13 +566,13 @@ namespace _GLIBCXX_STD
   template <typename _Tp, typename _Alloc>
     template <typename _ForwardIterator>
       void
-      deque<_Tp,_Alloc>::
+      deque<_Tp, _Alloc>::
       _M_insert_aux(iterator __pos,
                     _ForwardIterator __first, _ForwardIterator __last,
                     size_type __n)
       {
         const difference_type __elemsbefore = __pos - this->_M_impl._M_start;
-        size_type __length = size();
+        const size_type __length = size();
         if (static_cast<size_type>(__elemsbefore) < __length / 2)
          {
            iterator __new_start = _M_reserve_elements_at_front(__n);
@@ -650,10 +650,10 @@ namespace _GLIBCXX_STD
 
   template <typename _Tp, typename _Alloc>
     void
-    deque<_Tp,_Alloc>::
+    deque<_Tp, _Alloc>::
     _M_new_elements_at_front(size_type __new_elems)
     {
-      size_type __new_nodes
+      const size_type __new_nodes
        = (__new_elems + _S_buffer_size() - 1) / _S_buffer_size();
       _M_reserve_map_at_front(__new_nodes);
       size_type __i;
@@ -672,11 +672,11 @@ namespace _GLIBCXX_STD
 
   template <typename _Tp, typename _Alloc>
     void
-    deque<_Tp,_Alloc>::
+    deque<_Tp, _Alloc>::
     _M_new_elements_at_back(size_type __new_elems)
     {
-      size_type __new_nodes
-          = (__new_elems + _S_buffer_size() - 1) / _S_buffer_size();
+      const size_type __new_nodes
+       = (__new_elems + _S_buffer_size() - 1) / _S_buffer_size();
       _M_reserve_map_at_back(__new_nodes);
       size_type __i;
       try
@@ -694,12 +694,12 @@ namespace _GLIBCXX_STD
 
   template <typename _Tp, typename _Alloc>
     void
-    deque<_Tp,_Alloc>::
+    deque<_Tp, _Alloc>::
     _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front)
     {
-      size_type __old_num_nodes
+      const size_type __old_num_nodes
        = this->_M_impl._M_finish._M_node - this->_M_impl._M_start._M_node + 1;
-      size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
+      const size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
 
       _Map_pointer __new_nstart;
       if (this->_M_impl._M_map_size > 2 * __new_num_nodes)

diff --git a/libstdc++-v3/include/bits/stl_algobase.h b/libstdc++-v3/include/bits/stl_algobase.h
index 39a52ca..b0502da 100644 (file)
--- a/libstdc++-v3/include/bits/stl_algobase.h
+++ b/libstdc++-v3/include/bits/stl_algobase.h
@@ -721,8 +721,8 @@ namespace std
            typename iterator_traits<_InputIterator1>::value_type,
            typename iterator_traits<_InputIterator2>::value_type>)
       __glibcxx_requires_valid_range(__first1, __last1);
-
-      for ( ; __first1 != __last1; ++__first1, ++__first2)
+      
+      for (; __first1 != __last1; ++__first1, ++__first2)
        if (!(*__first1 == *__first2))
          return false;
       return true;
@@ -753,7 +753,7 @@ namespace std
       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
       __glibcxx_requires_valid_range(__first1, __last1);
 
-      for ( ; __first1 != __last1; ++__first1, ++__first2)
+      for (; __first1 != __last1; ++__first1, ++__first2)
        if (!__binary_pred(*__first1, *__first2))
          return false;
       return true;
@@ -788,7 +788,8 @@ namespace std
       __glibcxx_requires_valid_range(__first1, __last1);
       __glibcxx_requires_valid_range(__first2, __last2);
 
-      for (;__first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)
+      for (; __first1 != __last1 && __first2 != __last2;
+          ++__first1, ++__first2)
        {
          if (*__first1 < *__first2)
            return true;
@@ -823,8 +824,8 @@ namespace std
       __glibcxx_requires_valid_range(__first1, __last1);
       __glibcxx_requires_valid_range(__first2, __last2);
 
-      for ( ; __first1 != __last1 && __first2 != __last2
-           ; ++__first1, ++__first2)
+      for (; __first1 != __last1 && __first2 != __last2;
+          ++__first1, ++__first2)
        {
          if (__comp(*__first1, *__first2))
            return true;

diff --git a/libstdc++-v3/include/bits/stl_bvector.h b/libstdc++-v3/include/bits/stl_bvector.h
index afae738..3185bd7 100644 (file)
--- a/libstdc++-v3/include/bits/stl_bvector.h
+++ b/libstdc++-v3/include/bits/stl_bvector.h
@@ -323,7 +323,8 @@ namespace _GLIBCXX_STD
     }
 
     const_iterator 
-    operator+(difference_type __i) const {
+    operator+(difference_type __i) const
+    {
       const_iterator __tmp = *this;
       return __tmp += __i;
     }

diff --git a/libstdc++-v3/include/bits/stl_construct.h b/libstdc++-v3/include/bits/stl_construct.h
index afb3387..cba3546 100644 (file)
--- a/libstdc++-v3/include/bits/stl_construct.h
+++ b/libstdc++-v3/include/bits/stl_construct.h
@@ -117,7 +117,10 @@ namespace std
     inline void
     __destroy_aux(_ForwardIterator __first, _ForwardIterator __last,
                  __false_type)
-    { for ( ; __first != __last; ++__first) std::_Destroy(&*__first); }
+    {
+      for (; __first != __last; ++__first)
+       std::_Destroy(&*__first);
+    }
 
   /**
    * @if maint

diff --git a/libstdc++-v3/include/bits/stl_deque.h b/libstdc++-v3/include/bits/stl_deque.h
index fc58581..9dc9efb 100644 (file)
--- a/libstdc++-v3/include/bits/stl_deque.h
+++ b/libstdc++-v3/include/bits/stl_deque.h
@@ -419,15 +419,16 @@ namespace _GLIBCXX_STD
     };
 
   template<typename _Tp, typename _Alloc>
-  _Deque_base<_Tp,_Alloc>::~_Deque_base()
-  {
-    if (this->_M_impl._M_map)
+    _Deque_base<_Tp, _Alloc>::
+    ~_Deque_base()
     {
-      _M_destroy_nodes(this->_M_impl._M_start._M_node,
-                      this->_M_impl._M_finish._M_node + 1);
-      _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
+      if (this->_M_impl._M_map)
+       {
+         _M_destroy_nodes(this->_M_impl._M_start._M_node,
+                          this->_M_impl._M_finish._M_node + 1);
+         _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
+       }
     }
-  }
 
   /**
    *  @if maint
@@ -441,12 +442,14 @@ namespace _GLIBCXX_STD
   */
   template<typename _Tp, typename _Alloc>
     void
-    _Deque_base<_Tp,_Alloc>::_M_initialize_map(size_t __num_elements)
+    _Deque_base<_Tp, _Alloc>::
+    _M_initialize_map(size_t __num_elements)
     {
-      size_t __num_nodes = __num_elements / __deque_buf_size(sizeof(_Tp)) + 1;
+      const size_t __num_nodes = (__num_elements / __deque_buf_size(sizeof(_Tp))
+                                 + 1);
 
       this->_M_impl._M_map_size = std::max((size_t) _S_initial_map_size,
-                                  size_t(__num_nodes + 2));
+                                          size_t(__num_nodes + 2));
       this->_M_impl._M_map = _M_allocate_map(this->_M_impl._M_map_size);
 
       // For "small" maps (needing less than _M_map_size nodes), allocation
@@ -478,7 +481,8 @@ namespace _GLIBCXX_STD
 
   template<typename _Tp, typename _Alloc>
     void
-    _Deque_base<_Tp,_Alloc>::_M_create_nodes(_Tp** __nstart, _Tp** __nfinish)
+    _Deque_base<_Tp, _Alloc>::
+    _M_create_nodes(_Tp** __nstart, _Tp** __nfinish)
     {
       _Tp** __cur;
       try
@@ -495,7 +499,8 @@ namespace _GLIBCXX_STD
 
   template<typename _Tp, typename _Alloc>
     void
-    _Deque_base<_Tp,_Alloc>::_M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish)
+    _Deque_base<_Tp, _Alloc>::
+    _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish)
     {
       for (_Tp** __n = __nstart; __n < __nfinish; ++__n)
        _M_deallocate_node(*__n);
@@ -923,7 +928,10 @@ namespace _GLIBCXX_STD
        */
       reference
       at(size_type __n)
-      { _M_range_check(__n); return (*this)[__n]; }
+      {
+       _M_range_check(__n);
+       return (*this)[__n];
+      }
 
       /**
        *  @brief  Provides access to the data contained in the %deque.

diff --git a/libstdc++-v3/include/bits/stl_pair.h b/libstdc++-v3/include/bits/stl_pair.h
index d5146bb..92a5bb0 100644 (file)
--- a/libstdc++-v3/include/bits/stl_pair.h
+++ b/libstdc++-v3/include/bits/stl_pair.h
@@ -141,7 +141,8 @@ namespace std
   // 181.  make_pair() unintended behavior
   template<class _T1, class _T2>
     inline pair<_T1, _T2>
-    make_pair(_T1 __x, _T2 __y) { return pair<_T1, _T2>(__x, __y); }
+    make_pair(_T1 __x, _T2 __y)
+    { return pair<_T1, _T2>(__x, __y); }
 } // namespace std
 
 #endif /* _PAIR_H */

diff --git a/libstdc++-v3/include/bits/stl_vector.h b/libstdc++-v3/include/bits/stl_vector.h
index f0ba332..1682986 100644 (file)
--- a/libstdc++-v3/include/bits/stl_vector.h
+++ b/libstdc++-v3/include/bits/stl_vector.h
@@ -81,7 +81,7 @@ namespace _GLIBCXX_STD
        _Tp*           _M_start;
        _Tp*           _M_finish;
        _Tp*           _M_end_of_storage;
-       _Vector_impl (_Alloc const& __a)
+       _Vector_impl(_Alloc const& __a)
        : _Alloc(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
        { }
       };
@@ -799,7 +799,7 @@ namespace _GLIBCXX_STD
         _M_range_initialize(_InputIterator __first,
                            _InputIterator __last, input_iterator_tag)
         {
-         for ( ; __first != __last; ++__first)
+         for (; __first != __last; ++__first)
            push_back(*__first);
        }
 
@@ -809,7 +809,7 @@ namespace _GLIBCXX_STD
         _M_range_initialize(_ForwardIterator __first,
                            _ForwardIterator __last, forward_iterator_tag)
         {
-         size_type __n = std::distance(__first, __last);
+         const size_type __n = std::distance(__first, __last);
          this->_M_impl._M_start = this->_M_allocate(__n);
          this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
          this->_M_impl._M_finish = std::uninitialized_copy(__first, __last,

diff --git a/libstdc++-v3/include/bits/vector.tcc b/libstdc++-v3/include/bits/vector.tcc
index 5e8b9a7..3840185 100644 (file)
--- a/libstdc++-v3/include/bits/vector.tcc
+++ b/libstdc++-v3/include/bits/vector.tcc
@@ -91,7 +91,7 @@ namespace _GLIBCXX_STD
     vector<_Tp, _Alloc>::
     insert(iterator __position, const value_type& __x)
     {
-      size_type __n = __position - begin();
+      const size_type __n = __position - begin();
       if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
          && __position == end())
        {
@@ -193,7 +193,7 @@ namespace _GLIBCXX_STD
                    input_iterator_tag)
       {
        iterator __cur(begin());
-       for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
+       for (; __first != __last && __cur != end(); ++__cur, ++__first)
          *__cur = *__first;
        if (__first == __last)
          erase(__cur, end());
@@ -204,11 +204,11 @@ namespace _GLIBCXX_STD
   template<typename _Tp, typename _Alloc>
     template<typename _ForwardIterator>
       void
-      vector<_Tp,_Alloc>::
+      vector<_Tp, _Alloc>::
       _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
                    forward_iterator_tag)
       {
-       size_type __len = std::distance(__first, __last);
+       const size_type __len = std::distance(__first, __last);
 
        if (__len > capacity())
          {
@@ -242,7 +242,7 @@ namespace _GLIBCXX_STD
 
   template<typename _Tp, typename _Alloc>
     void
-    vector<_Tp,_Alloc>::
+    vector<_Tp, _Alloc>::
     _M_insert_aux(iterator __position, const _Tp& __x)
     {
       if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
@@ -293,7 +293,7 @@ namespace _GLIBCXX_STD
 
   template<typename _Tp, typename _Alloc>
     void
-    vector<_Tp,_Alloc>::
+    vector<_Tp, _Alloc>::
     _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
     {
       if (__n != 0)
@@ -360,11 +360,11 @@ namespace _GLIBCXX_STD
 
   template<typename _Tp, typename _Alloc> template<typename _InputIterator>
     void
-    vector<_Tp,_Alloc>::
+    vector<_Tp, _Alloc>::
     _M_range_insert(iterator __pos, _InputIterator __first,
                    _InputIterator __last, input_iterator_tag)
     {
-      for ( ; __first != __last; ++__first)
+      for (; __first != __last; ++__first)
        {
          __pos = insert(__pos, *__first);
          ++__pos;
@@ -374,13 +374,13 @@ namespace _GLIBCXX_STD
   template<typename _Tp, typename _Alloc>
     template<typename _ForwardIterator>
       void
-      vector<_Tp,_Alloc>::
+      vector<_Tp, _Alloc>::
       _M_range_insert(iterator __position,_ForwardIterator __first,
                      _ForwardIterator __last, forward_iterator_tag)
       {
        if (__first != __last)
          {
-           size_type __n = std::distance(__first, __last);
+           const size_type __n = std::distance(__first, __last);
            if (size_type(this->_M_impl._M_end_of_storage
                          - this->_M_impl._M_finish) >= __n)
              {