stl_bvector.h: Trivial formatting fixes.

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.

From-SVN: r85716

libstdc++-v3/ChangeLog

+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>
 	

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

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