2004-08-09 Paolo Carlini <pcarlini@suse.de>

	* include/bits/stl_bvector.h: Trivial formatting fixes.

2004-08-09  Paolo Carlini  <pcarlini@suse.de>

	* src/ios.cc (ios_base::_M_grow_words): Uglify the names.

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

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index bcca0d2..816c4e7 100644 (file)
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,11 @@
+2004-08-09  Paolo Carlini  <pcarlini@suse.de>
+
+       * include/bits/stl_bvector.h: Trivial formatting fixes.
+
+2004-08-09  Paolo Carlini  <pcarlini@suse.de>
+
+       * src/ios.cc (ios_base::_M_grow_words): Uglify the names.
+
 2004-08-07  Jonathan Wakely  <redi@gcc.gnu.org>
            Paolo Carlini  <pcarlini@suse.de>
        

diff --git a/libstdc++-v3/include/bits/stl_bvector.h b/libstdc++-v3/include/bits/stl_bvector.h
index 3185bd7..a8f1b69 100644 (file)
--- a/libstdc++-v3/include/bits/stl_bvector.h
+++ b/libstdc++-v3/include/bits/stl_bvector.h
@@ -76,7 +76,8 @@ namespace _GLIBCXX_STD
 
     _Bit_reference() : _M_p(0), _M_mask(0) { }
 
-    operator bool() const { return !!(*_M_p & _M_mask); }
+    operator bool() const
+    { return !!(*_M_p & _M_mask); }
 
     _Bit_reference&
     operator=(bool __x)
@@ -101,7 +102,8 @@ namespace _GLIBCXX_STD
     { return !bool(*this) && bool(__x); }
 
     void
-    flip() { *_M_p ^= _M_mask; }
+    flip()
+    { *_M_p ^= _M_mask; }
   };
 
   struct _Bit_iterator_base : public iterator<random_access_iterator_tag, bool>
@@ -188,11 +190,13 @@ namespace _GLIBCXX_STD
     typedef _Bit_iterator   iterator;
 
     _Bit_iterator() : _Bit_iterator_base(0, 0) { }
+
     _Bit_iterator(_Bit_type * __x, unsigned int __y)
     : _Bit_iterator_base(__x, __y) { }
 
     reference
-    operator*() const { return reference(_M_p, 1UL << _M_offset); }
+    operator*() const
+    { return reference(_M_p, 1UL << _M_offset); }
 
     iterator&
     operator++()
@@ -258,8 +262,8 @@ namespace _GLIBCXX_STD
   };
 
   inline _Bit_iterator
-  operator+(ptrdiff_t __n, const _Bit_iterator& __x) { return __x + __n; }
-
+  operator+(ptrdiff_t __n, const _Bit_iterator& __x)
+  { return __x + __n; }
 
   struct _Bit_const_iterator : public _Bit_iterator_base
   {
@@ -269,8 +273,10 @@ namespace _GLIBCXX_STD
     typedef _Bit_const_iterator  const_iterator;
 
     _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
+
     _Bit_const_iterator(_Bit_type * __x, unsigned int __y)
     : _Bit_iterator_base(__x, __y) { }
+
     _Bit_const_iterator(const _Bit_iterator& __x)
     : _Bit_iterator_base(__x._M_p, __x._M_offset) { }
 
@@ -370,7 +376,8 @@ namespace _GLIBCXX_STD
 
       _Bvector_base(const allocator_type& __a) : _M_impl(__a) { }
 
-      ~_Bvector_base() { this->_M_deallocate(); }
+      ~_Bvector_base()
+      { this->_M_deallocate(); }
 
     protected:
       _Bvector_impl _M_impl;
@@ -384,7 +391,7 @@ namespace _GLIBCXX_STD
       {
        if (_M_impl._M_start._M_p)
          _M_impl.deallocate(_M_impl._M_start._M_p,
-                           _M_impl._M_end_of_storage - _M_impl._M_start._M_p);
+                            _M_impl._M_end_of_storage - _M_impl._M_start._M_p);
       }
     };
 } // namespace std
@@ -440,16 +447,19 @@ template<typename _Alloc>
     using _Bvector_base<_Alloc>::_M_deallocate;
 
   protected:
-    void _M_initialize(size_type __n)
+    void
+    _M_initialize(size_type __n)
     {
       _Bit_type* __q = this->_M_allocate(__n);
-      this->_M_impl._M_end_of_storage = __q 
-                                      + (__n + _S_word_bit - 1) / _S_word_bit;
+      this->_M_impl._M_end_of_storage = (__q
+                                        + ((__n + _S_word_bit - 1)
+                                           / _S_word_bit));
       this->_M_impl._M_start = iterator(__q, 0);
       this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
     }
 
-    void _M_insert_aux(iterator __position, bool __x)
+    void
+    _M_insert_aux(iterator __position, bool __x)
     {
       if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
        {
@@ -467,129 +477,154 @@ template<typename _Alloc>
          *__i++ = __x;
          this->_M_impl._M_finish = std::copy(__position, end(), __i);
          this->_M_deallocate();
-         this->_M_impl._M_end_of_storage = __q + (__len + _S_word_bit - 1)
-                                   / _S_word_bit;
+         this->_M_impl._M_end_of_storage = (__q + ((__len + _S_word_bit - 1)
+                                                   / _S_word_bit));
          this->_M_impl._M_start = iterator(__q, 0);
        }
     }
 
     template<class _InputIterator>
-    void _M_initialize_range(_InputIterator __first, _InputIterator __last,
-                             input_iterator_tag)
-    {
-      this->_M_impl._M_start = iterator();
-      this->_M_impl._M_finish = iterator();
-      this->_M_impl._M_end_of_storage = 0;
-      for ( ; __first != __last; ++__first)
-        push_back(*__first);
-    }
+      void
+      _M_initialize_range(_InputIterator __first, _InputIterator __last,
+                         input_iterator_tag)
+      {
+       this->_M_impl._M_start = iterator();
+       this->_M_impl._M_finish = iterator();
+       this->_M_impl._M_end_of_storage = 0;
+       for (; __first != __last; ++__first)
+         push_back(*__first);
+      }
 
     template<class _ForwardIterator>
-    void _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
-                             forward_iterator_tag)
-    {
-      const size_type __n = std::distance(__first, __last);
-      _M_initialize(__n);
-      std::copy(__first, __last, this->_M_impl._M_start);
-    }
+      void
+      _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
+                         forward_iterator_tag)
+      {
+       const size_type __n = std::distance(__first, __last);
+       _M_initialize(__n);
+       std::copy(__first, __last, this->_M_impl._M_start);
+      }
 
     template<class _InputIterator>
-    void _M_insert_range(iterator __pos, _InputIterator __first, 
-                        _InputIterator __last, input_iterator_tag)
-    {
-      for ( ; __first != __last; ++__first)
-       {
-         __pos = insert(__pos, *__first);
-         ++__pos;
-       }
-    }
+      void
+      _M_insert_range(iterator __pos, _InputIterator __first, 
+                     _InputIterator __last, input_iterator_tag)
+      {
+       for (; __first != __last; ++__first)
+         {
+           __pos = insert(__pos, *__first);
+           ++__pos;
+         }
+      }
 
     template<class _ForwardIterator>
-    void _M_insert_range(iterator __position, _ForwardIterator __first, 
-                        _ForwardIterator __last, forward_iterator_tag)
-    {
-      if (__first != __last)
-       {
-         size_type __n = std::distance(__first, __last);
-         if (capacity() - size() >= __n)
-           {
-             std::copy_backward(__position, end(),
-                              this->_M_impl._M_finish + difference_type(__n));
-             std::copy(__first, __last, __position);
-             this->_M_impl._M_finish += difference_type(__n);
-           }
-         else
-           {
-             const size_type __len = size() + std::max(size(), __n);
-             _Bit_type * __q = this->_M_allocate(__len);
-             iterator __i = std::copy(begin(), __position, iterator(__q, 0));
-             __i = std::copy(__first, __last, __i);
-             this->_M_impl._M_finish = std::copy(__position, end(), __i);
-             this->_M_deallocate();
-             this->_M_impl._M_end_of_storage = __q + (__len + _S_word_bit - 1)
-                                               / _S_word_bit;
-             this->_M_impl._M_start = iterator(__q, 0);
-           }
-       }
-    }
+      void
+      _M_insert_range(iterator __position, _ForwardIterator __first, 
+                     _ForwardIterator __last, forward_iterator_tag)
+      {
+       if (__first != __last)
+         {
+           size_type __n = std::distance(__first, __last);
+           if (capacity() - size() >= __n)
+             {
+               std::copy_backward(__position, end(),
+                                  this->_M_impl._M_finish
+                                  + difference_type(__n));
+               std::copy(__first, __last, __position);
+               this->_M_impl._M_finish += difference_type(__n);
+             }
+           else
+             {
+               const size_type __len = size() + std::max(size(), __n);
+               _Bit_type * __q = this->_M_allocate(__len);
+               iterator __i = std::copy(begin(), __position,
+                                        iterator(__q, 0));
+               __i = std::copy(__first, __last, __i);
+               this->_M_impl._M_finish = std::copy(__position, end(), __i);
+               this->_M_deallocate();
+               this->_M_impl._M_end_of_storage = (__q
+                                                  + ((__len + _S_word_bit - 1)
+                                                     / _S_word_bit));
+               this->_M_impl._M_start = iterator(__q, 0);
+             }
+         }
+      }
 
   public:
-    iterator begin()
+    iterator
+    begin()
     { return this->_M_impl._M_start; }
 
-    const_iterator begin() const
+    const_iterator
+    begin() const
     { return this->_M_impl._M_start; }
 
-    iterator end()
+    iterator
+    end()
     { return this->_M_impl._M_finish; }
 
-    const_iterator end() const
+    const_iterator
+    end() const
     { return this->_M_impl._M_finish; }
 
-    reverse_iterator rbegin()
+    reverse_iterator
+    rbegin()
     { return reverse_iterator(end()); }
 
-    const_reverse_iterator rbegin() const
+    const_reverse_iterator
+    rbegin() const
     { return const_reverse_iterator(end()); }
 
-    reverse_iterator rend()
+    reverse_iterator
+    rend()
     { return reverse_iterator(begin()); }
 
-    const_reverse_iterator rend() const
+    const_reverse_iterator
+    rend() const
     { return const_reverse_iterator(begin()); }
 
-    size_type size() const
+    size_type
+    size() const
     { return size_type(end() - begin()); }
 
-    size_type max_size() const
+    size_type
+    max_size() const
     { return size_type(-1); }
 
-    size_type capacity() const
+    size_type
+    capacity() const
     { return size_type(const_iterator(this->_M_impl._M_end_of_storage, 0)
                       - begin()); }
-    bool empty() const
+    bool
+    empty() const
     { return begin() == end(); }
 
-    reference operator[](size_type __n)
+    reference
+    operator[](size_type __n)
     { return *(begin() + difference_type(__n)); }
 
-    const_reference operator[](size_type __n) const
+    const_reference
+    operator[](size_type __n) const
     { return *(begin() + difference_type(__n)); }
 
-    void _M_range_check(size_type __n) const
+    void
+    _M_range_check(size_type __n) const
     {
       if (__n >= this->size())
         __throw_out_of_range(__N("vector<bool>::_M_range_check"));
     }
 
-    reference at(size_type __n)
+    reference
+    at(size_type __n)
     { _M_range_check(__n); return (*this)[__n]; }
 
-    const_reference at(size_type __n) const
+    const_reference
+    at(size_type __n) const
     { _M_range_check(__n); return (*this)[__n]; }
 
-    explicit vector(const allocator_type& __a = allocator_type())
-      : _Bvector_base<_Alloc>(__a) { }
+    explicit
+    vector(const allocator_type& __a = allocator_type())
+    : _Bvector_base<_Alloc>(__a) { }
 
     vector(size_type __n, bool __value, 
           const allocator_type& __a = allocator_type())
@@ -600,7 +635,8 @@ template<typename _Alloc>
                __value ? ~0 : 0);
     }
 
-    explicit vector(size_type __n)
+    explicit
+    vector(size_type __n)
     : _Bvector_base<_Alloc>(allocator_type())
     {
       _M_initialize(__n);
@@ -608,7 +644,8 @@ template<typename _Alloc>
                this->_M_impl._M_end_of_storage, 0);
     }
 
-    vector(const vector& __x) : _Bvector_base<_Alloc>(__x.get_allocator())
+    vector(const vector& __x)
+    : _Bvector_base<_Alloc>(__x.get_allocator())
     {
       _M_initialize(__x.size());
       std::copy(__x.begin(), __x.end(), this->_M_impl._M_start);
@@ -616,12 +653,13 @@ template<typename _Alloc>
 
     // Check whether it's an integral type.  If so, it's not an iterator.
     template<class _Integer>
-    void _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
-    {
-      _M_initialize(__n);
-      std::fill(this->_M_impl._M_start._M_p, 
-               this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
-    }
+      void
+      _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
+      {
+       _M_initialize(__n);
+       std::fill(this->_M_impl._M_start._M_p, 
+                 this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
+      }
 
     template<class _InputIterator>
       void 
@@ -633,15 +671,16 @@ template<typename _Alloc>
     template<class _InputIterator>
       vector(_InputIterator __first, _InputIterator __last,
             const allocator_type& __a = allocator_type())
-    : _Bvector_base<_Alloc>(__a)
-    {
-      typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
-      _M_initialize_dispatch(__first, __last, _Integral());
-    }
+      : _Bvector_base<_Alloc>(__a)
+      {
+       typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
+       _M_initialize_dispatch(__first, __last, _Integral());
+      }
 
     ~vector() { }
 
-    vector& operator=(const vector& __x)
+    vector&
+    operator=(const vector& __x)
     {
       if (&__x == this)
        return *this;
@@ -660,7 +699,8 @@ template<typename _Alloc>
     // The range version is a member template, so we dispatch on whether
     // or not the type is an integer.
 
-    void _M_fill_assign(size_t __n, bool __x)
+    void
+    _M_fill_assign(size_t __n, bool __x)
     {
       if (__n > size())
        {
@@ -676,55 +716,62 @@ template<typename _Alloc>
        }
     }
 
-    void assign(size_t __n, bool __x)
+    void
+    assign(size_t __n, bool __x)
     { _M_fill_assign(__n, __x); }
 
     template<class _InputIterator>
-    void assign(_InputIterator __first, _InputIterator __last)
-    {
-      typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
-      _M_assign_dispatch(__first, __last, _Integral());
-    }
+      void
+      assign(_InputIterator __first, _InputIterator __last)
+      {
+       typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
+       _M_assign_dispatch(__first, __last, _Integral());
+      }
 
     template<class _Integer>
-    void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
-    { _M_fill_assign((size_t) __n, (bool) __val); }
+      void
+      _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+      { _M_fill_assign((size_t) __n, (bool) __val); }
 
     template<class _InputIterator>
-    void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
-                           __false_type)
-    { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
+      void
+      _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+                        __false_type)
+      { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
 
     template<class _InputIterator>
-    void _M_assign_aux(_InputIterator __first, _InputIterator __last,
-                       input_iterator_tag)
-    {
-      iterator __cur = begin();
-      for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
-        *__cur = *__first;
-      if (__first == __last)
-        erase(__cur, end());
-      else
-        insert(end(), __first, __last);
-    }
-
+      void
+      _M_assign_aux(_InputIterator __first, _InputIterator __last,
+                   input_iterator_tag)
+      {
+       iterator __cur = begin();
+       for (; __first != __last && __cur != end(); ++__cur, ++__first)
+         *__cur = *__first;
+       if (__first == __last)
+         erase(__cur, end());
+       else
+         insert(end(), __first, __last);
+      }
+    
     template<class _ForwardIterator>
-    void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
-                       forward_iterator_tag)
-    {
-      const size_type __len = std::distance(__first, __last);
-      if (__len < size())
-        erase(std::copy(__first, __last, begin()), end());
-      else
-       {
-         _ForwardIterator __mid = __first;
-         std::advance(__mid, size());
-         std::copy(__first, __mid, begin());
-         insert(end(), __mid, __last);
-       }
-    }
+      void
+      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+                   forward_iterator_tag)
+      {
+       const size_type __len = std::distance(__first, __last);
+       if (__len < size())
+         erase(std::copy(__first, __last, begin()), end());
+       else
+         {
+           _ForwardIterator __mid = __first;
+           std::advance(__mid, size());
+           std::copy(__first, __mid, begin());
+           insert(end(), __mid, __last);
+         }
+      }
 
-    void reserve(size_type __n)
+    void
+    reserve(size_type __n)
     {
       if (__n > this->max_size())
        __throw_length_error(__N("vector::reserve"));
@@ -735,23 +782,29 @@ template<typename _Alloc>
                                              iterator(__q, 0));
          this->_M_deallocate();
          this->_M_impl._M_start = iterator(__q, 0);
-         this->_M_impl._M_end_of_storage = __q + (__n + _S_word_bit - 1) / _S_word_bit;
+         this->_M_impl._M_end_of_storage = (__q + (__n + _S_word_bit - 1)
+                                            / _S_word_bit);
        }
     }
 
-    reference front()
+    reference
+    front()
     { return *begin(); }
 
-    const_reference front() const
+    const_reference
+    front() const
     { return *begin(); }
 
-    reference back()
+    reference
+    back()
     { return *(end() - 1); }
 
-    const_reference back() const
+    const_reference
+    back() const
     { return *(end() - 1); }
 
-    void push_back(bool __x)
+    void
+    push_back(bool __x)
     {
       if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
         *this->_M_impl._M_finish++ = __x;
@@ -759,7 +812,8 @@ template<typename _Alloc>
         _M_insert_aux(end(), __x);
     }
 
-    void swap(vector<bool, _Alloc>& __x)
+    void
+    swap(vector<bool, _Alloc>& __x)
     {
       std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
       std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
@@ -768,14 +822,16 @@ template<typename _Alloc>
     }
 
     // [23.2.5]/1, third-to-last entry in synopsis listing
-    static void swap(reference __x, reference __y)
+    static void
+    swap(reference __x, reference __y)
     {
       bool __tmp = __x;
       __x = __y;
       __y = __tmp;
     }
 
-    iterator insert(iterator __position, bool __x = bool())
+    iterator
+    insert(iterator __position, bool __x = bool())
     {
       const difference_type __n = __position - begin();
       if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage
@@ -789,26 +845,30 @@ template<typename _Alloc>
     // Check whether it's an integral type.  If so, it's not an iterator.
 
     template<class _Integer>
-    void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
-                            __true_type)
-    { _M_fill_insert(__pos, __n, __x); }
+      void
+      _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
+                        __true_type)
+      { _M_fill_insert(__pos, __n, __x); }
 
     template<class _InputIterator>
-    void _M_insert_dispatch(iterator __pos,
-                            _InputIterator __first, _InputIterator __last,
-                            __false_type)
-    { _M_insert_range(__pos, __first, __last,
-                     std::__iterator_category(__first)); }
+      void
+      _M_insert_dispatch(iterator __pos,
+                        _InputIterator __first, _InputIterator __last,
+                        __false_type)
+      { _M_insert_range(__pos, __first, __last,
+                       std::__iterator_category(__first)); }
 
     template<class _InputIterator>
-    void insert(iterator __position,
-                _InputIterator __first, _InputIterator __last)
-    {
-      typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
-      _M_insert_dispatch(__position, __first, __last, _Integral());
-    }
+      void
+      insert(iterator __position,
+            _InputIterator __first, _InputIterator __last)
+      {
+       typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
+       _M_insert_dispatch(__position, __first, __last, _Integral());
+      }
 
-    void _M_fill_insert(iterator __position, size_type __n, bool __x)
+    void
+    _M_fill_insert(iterator __position, size_type __n, bool __x)
     {
       if (__n == 0)
        return;
@@ -828,19 +888,22 @@ template<typename _Alloc>
          this->_M_impl._M_finish = std::copy(__position, end(),
                                              __i + difference_type(__n));
          this->_M_deallocate();
-         this->_M_impl._M_end_of_storage = __q + (__len + _S_word_bit - 1)
-                                           / _S_word_bit;
+         this->_M_impl._M_end_of_storage = (__q + ((__len + _S_word_bit - 1)
+                                                   / _S_word_bit));
          this->_M_impl._M_start = iterator(__q, 0);
        }
     }
 
-    void insert(iterator __position, size_type __n, bool __x)
+    void
+    insert(iterator __position, size_type __n, bool __x)
     { _M_fill_insert(__position, __n, __x); }
 
-    void pop_back()
+    void
+    pop_back()
     { --this->_M_impl._M_finish; }
 
-    iterator erase(iterator __position)
+    iterator
+    erase(iterator __position)
     {
       if (__position + 1 != end())
         std::copy(__position + 1, end(), __position);
@@ -848,13 +911,15 @@ template<typename _Alloc>
       return __position;
     }
 
-    iterator erase(iterator __first, iterator __last)
+    iterator
+    erase(iterator __first, iterator __last)
     {
       this->_M_impl._M_finish = std::copy(__last, end(), __first);
       return __first;
     }
 
-    void resize(size_type __new_size, bool __x = bool())
+    void
+    resize(size_type __new_size, bool __x = bool())
     {
       if (__new_size < size())
         erase(begin() + difference_type(__new_size), end());
@@ -862,14 +927,16 @@ template<typename _Alloc>
         insert(end(), __new_size - size(), __x);
     }
 
-    void flip()
+    void
+    flip()
     {
       for (_Bit_type * __p = this->_M_impl._M_start._M_p;
           __p != this->_M_impl._M_end_of_storage; ++__p)
         *__p = ~*__p;
     }
 
-    void clear()
+    void
+    clear()
     { erase(begin(), end()); }
   };
 } // namespace std

diff --git a/libstdc++-v3/src/ios.cc b/libstdc++-v3/src/ios.cc
index 12ffe2f..09b2929 100644 (file)
--- a/libstdc++-v3/src/ios.cc
+++ b/libstdc++-v3/src/ios.cc
@@ -149,32 +149,32 @@ namespace std
 
   // 27.4.2.5  iword/pword storage
   ios_base::_Words&
-  ios_base::_M_grow_words(int ix, bool iword)
+  ios_base::_M_grow_words(int __ix, bool __iword)
   {
-    // Precondition: _M_word_size <= ix
-    int newsize = _S_local_word_size;
-    _Words* words = _M_local_word;
-    if (ix > _S_local_word_size - 1)
+    // Precondition: _M_word_size <= __ix
+    int __newsize = _S_local_word_size;
+    _Words* __words = _M_local_word;
+    if (__ix > _S_local_word_size - 1)
       {
-       if (ix < numeric_limits<int>::max())
+       if (__ix < numeric_limits<int>::max())
          {
-           newsize = ix + 1;
+           __newsize = __ix + 1;
            try
-             { words = new _Words[newsize]; }
+             { __words = new _Words[__newsize]; }
            catch (...)
              {
                _M_streambuf_state |= badbit;
                if (_M_streambuf_state & _M_exception)
                  __throw_ios_failure(__N("ios_base::_M_grow_words "
                                      "allocation failed"));
-               if (iword)
+               if (__iword)
                  _M_word_zero._M_iword = 0;
                else
                  _M_word_zero._M_pword = 0;
                return _M_word_zero;
              }
-           for (int i = 0; i < _M_word_size; i++) 
-             words[i] = _M_word[i];
+           for (int __i = 0; __i < _M_word_size; __i++) 
+             __words[__i] = _M_word[__i];
            if (_M_word && _M_word != _M_local_word) 
              {
                delete [] _M_word;
@@ -186,16 +186,16 @@ namespace std
            _M_streambuf_state |= badbit;
            if (_M_streambuf_state & _M_exception)
              __throw_ios_failure(__N("ios_base::_M_grow_words is not valid"));
-           if (iword)
+           if (__iword)
              _M_word_zero._M_iword = 0;
            else
              _M_word_zero._M_pword = 0;
            return _M_word_zero;
          }
       }
-    _M_word = words;
-    _M_word_size = newsize;
-    return _M_word[ix];
+    _M_word = __words;
+    _M_word_size = __newsize;
+    return _M_word[__ix];
   }
 
   void