OSDN Git Service

Remove trailing whitespace (see ChangeLog for longwinded description).
authorbernie <bernie@138bc75d-0d04-0410-961f-82ee72b054a4>
Sun, 8 Feb 2004 04:46:42 +0000 (04:46 +0000)
committerbernie <bernie@138bc75d-0d04-0410-961f-82ee72b054a4>
Sun, 8 Feb 2004 04:46:42 +0000 (04:46 +0000)
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@77479 138bc75d-0d04-0410-961f-82ee72b054a4

65 files changed:
libstdc++-v3/ChangeLog
libstdc++-v3/include/bits/allocator.h
libstdc++-v3/include/bits/basic_ios.h
libstdc++-v3/include/bits/basic_ios.tcc
libstdc++-v3/include/bits/basic_string.h
libstdc++-v3/include/bits/basic_string.tcc
libstdc++-v3/include/bits/boost_concept_check.h
libstdc++-v3/include/bits/char_traits.h
libstdc++-v3/include/bits/codecvt.h
libstdc++-v3/include/bits/concurrence.h
libstdc++-v3/include/bits/cpp_type_traits.h
libstdc++-v3/include/bits/demangle.h
libstdc++-v3/include/bits/deque.tcc
libstdc++-v3/include/bits/fstream.tcc
libstdc++-v3/include/bits/functexcept.h
libstdc++-v3/include/bits/gslice.h
libstdc++-v3/include/bits/gslice_array.h
libstdc++-v3/include/bits/indirect_array.h
libstdc++-v3/include/bits/ios_base.h
libstdc++-v3/include/bits/istream.tcc
libstdc++-v3/include/bits/list.tcc
libstdc++-v3/include/bits/locale_classes.h
libstdc++-v3/include/bits/locale_facets.h
libstdc++-v3/include/bits/locale_facets.tcc
libstdc++-v3/include/bits/localefwd.h
libstdc++-v3/include/bits/mask_array.h
libstdc++-v3/include/bits/ostream.tcc
libstdc++-v3/include/bits/postypes.h
libstdc++-v3/include/bits/slice_array.h
libstdc++-v3/include/bits/sstream.tcc
libstdc++-v3/include/bits/stl_algo.h
libstdc++-v3/include/bits/stl_algobase.h
libstdc++-v3/include/bits/stl_bvector.h
libstdc++-v3/include/bits/stl_construct.h
libstdc++-v3/include/bits/stl_deque.h
libstdc++-v3/include/bits/stl_function.h
libstdc++-v3/include/bits/stl_heap.h
libstdc++-v3/include/bits/stl_iterator.h
libstdc++-v3/include/bits/stl_iterator_base_funcs.h
libstdc++-v3/include/bits/stl_list.h
libstdc++-v3/include/bits/stl_map.h
libstdc++-v3/include/bits/stl_multimap.h
libstdc++-v3/include/bits/stl_multiset.h
libstdc++-v3/include/bits/stl_numeric.h
libstdc++-v3/include/bits/stl_pair.h
libstdc++-v3/include/bits/stl_queue.h
libstdc++-v3/include/bits/stl_raw_storage_iter.h
libstdc++-v3/include/bits/stl_relops.h
libstdc++-v3/include/bits/stl_set.h
libstdc++-v3/include/bits/stl_stack.h
libstdc++-v3/include/bits/stl_tempbuf.h
libstdc++-v3/include/bits/stl_threads.h
libstdc++-v3/include/bits/stl_tree.h
libstdc++-v3/include/bits/stl_uninitialized.h
libstdc++-v3/include/bits/stl_vector.h
libstdc++-v3/include/bits/stream_iterator.h
libstdc++-v3/include/bits/streambuf.tcc
libstdc++-v3/include/bits/streambuf_iterator.h
libstdc++-v3/include/bits/stringfwd.h
libstdc++-v3/include/bits/type_traits.h
libstdc++-v3/include/bits/valarray_after.h
libstdc++-v3/include/bits/valarray_array.h
libstdc++-v3/include/bits/valarray_array.tcc
libstdc++-v3/include/bits/valarray_before.h
libstdc++-v3/include/bits/vector.tcc

index 7818cf2..97126b3 100644 (file)
@@ -1,3 +1,39 @@
+2004-02-08  Bernardo Innocenti  <bernie@develer.com>
+
+       * include/bits/allocator.h, include/bits/basic_ios.h,
+       include/bits/basic_ios.tcc, include/bits/basic_string.h,
+       include/bits/basic_string.tcc, include/bits/boost_concept_check.h,
+       include/bits/char_traits.h, include/bits/codecvt.h,
+       include/bits/concurrence.h, include/bits/cpp_type_traits.h,
+       include/bits/demangle.h, include/bits/deque.tcc,
+       include/bits/fstream.tcc, include/bits/functexcept.h,
+       include/bits/gslice.h, include/bits/gslice_array.h,
+       include/bits/indirect_array.h, include/bits/ios_base.h,
+       include/bits/istream.tcc, include/bits/list.tcc,
+       include/bits/locale_classes.h, include/bits/locale_facets.h,
+       include/bits/locale_facets.tcc, include/bits/localefwd.h,
+       include/bits/mask_array.h, include/bits/ostream.tcc,
+       include/bits/postypes.h, include/bits/slice_array.h,
+       include/bits/sstream.tcc, include/bits/stl_algo.h,
+       include/bits/stl_algobase.h, include/bits/stl_bvector.h,
+       include/bits/stl_construct.h, include/bits/stl_deque.h,
+       include/bits/stl_function.h, include/bits/stl_heap.h,
+       include/bits/stl_iterator.h, include/bits/stl_iterator_base_funcs.h,
+       include/bits/stl_list.h, include/bits/stl_map.h,
+       include/bits/stl_multimap.h, include/bits/stl_multiset.h,
+       include/bits/stl_numeric.h, include/bits/stl_pair.h,
+       include/bits/stl_queue.h, include/bits/stl_raw_storage_iter.h,
+       include/bits/stl_relops.h, include/bits/stl_set.h,
+       include/bits/stl_stack.h, include/bits/stl_tempbuf.h,
+       include/bits/stl_threads.h, include/bits/stl_tree.h,
+       include/bits/stl_uninitialized.h, include/bits/stl_vector.h,
+       include/bits/stream_iterator.h, include/bits/streambuf.tcc,
+       include/bits/streambuf_iterator.h,include/bits/stringfwd.h,
+       include/bits/type_traits.h, include/bits/valarray_after.h,
+       include/bits/valarray_array.h, include/bits/valarray_array.tcc,
+       include/bits/valarray_before.h, include/bits/vector.tcc: Remove
+       trailing whitespace.
+
 2004-02-06  Paolo Carlini  <pcarlini@suse.de>
 
        * include/bits/basic_string.h: Fix comment.
index 9c7b3ee..a1b04b4 100644 (file)
@@ -84,7 +84,7 @@ namespace std
    *  (See @link Allocators allocators info @endlink for more.)
    */
   template<typename _Tp>
-    class allocator: public __glibcxx_default_allocator<_Tp>  
+    class allocator: public __glibcxx_default_allocator<_Tp>
     {
    public:
       typedef size_t     size_type;
@@ -101,7 +101,7 @@ namespace std
 
       allocator() throw() { }
 
-      allocator(const allocator& a) throw() 
+      allocator(const allocator& a) throw()
       : __glibcxx_default_allocator<_Tp>(a) { }
 
       template<typename _Tp1>
index a9cb8d2..8e0b31e 100644 (file)
@@ -1,6 +1,6 @@
 // Iostreams base classes -*- C++ -*-
 
-// Copyright (C) 1997, 1998, 1999, 2001, 2002, 2003 
+// Copyright (C) 1997, 1998, 1999, 2001, 2002, 2003
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -43,7 +43,7 @@
 #include <bits/locale_classes.h>
 #include <bits/locale_facets.h>
 
-namespace std 
+namespace std
 {
   // 27.4.5  Template class basic_ios
   /**
@@ -76,12 +76,12 @@ namespace std
        *  @endif
       */
       typedef ctype<_CharT>                          __ctype_type;
-      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >     
+      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
                                                     __num_put_type;
-      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >     
-                                                    __num_get_type;
+      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
+                                                    __num_get_type;
       //@}
-      
+
       // Data members:
     protected:
       basic_ostream<_CharT, _Traits>*                _M_tie;
@@ -90,7 +90,7 @@ namespace std
       basic_streambuf<_CharT, _Traits>*              _M_streambuf;
 
       // Cached use_facet<ctype>, which is based on the current locale info.
-      const __ctype_type*                            _M_ctype;      
+      const __ctype_type*                            _M_ctype;
       // For ostream.
       const __num_put_type*                          _M_num_put;
       // For istream.
@@ -104,11 +104,11 @@ namespace std
        *  This allows you to write constructs such as
        *  "if (!a_stream) ..." and "while (a_stream) ..."
       */
-      operator void*() const 
+      operator void*() const
       { return this->fail() ? 0 : const_cast<basic_ios*>(this); }
 
-      bool 
-      operator!() const 
+      bool
+      operator!() const
       { return this->fail(); }
       //@}
 
@@ -119,8 +119,8 @@ namespace std
        *  See std::ios_base::iostate for the possible bit values.  Most
        *  users will call one of the interpreting wrappers, e.g., good().
       */
-      iostate 
-      rdstate() const 
+      iostate
+      rdstate() const
       { return _M_streambuf_state; }
 
       /**
@@ -130,7 +130,7 @@ namespace std
        *  See std::ios_base::iostate for the possible bit values.  Most
        *  users will not need to pass an argument.
       */
-      void 
+      void
       clear(iostate __state = goodbit);
 
       /**
@@ -139,19 +139,19 @@ namespace std
        *
        *  See std::ios_base::iostate for the possible bit values.
       */
-      void 
-      setstate(iostate __state) 
+      void
+      setstate(iostate __state)
       { this->clear(this->rdstate() | __state); }
 
       // Flip the internal state on for the proper state bits, then re
       // throws the propagated exception if bit also set in
       // exceptions().
       void
-      _M_setstate(iostate __state) 
-      { 
+      _M_setstate(iostate __state)
+      {
        // 27.6.1.2.1 Common requirements.
        // Turn this on without causing an ios::failure to be thrown.
-       _M_streambuf_state |= __state; 
+       _M_streambuf_state |= __state;
        if (this->exceptions() & __state)
          __throw_exception_again;
       }
@@ -162,8 +162,8 @@ namespace std
        *
        *  A wrapper around rdstate.
       */
-      bool 
-      good() const 
+      bool
+      good() const
       { return this->rdstate() == 0; }
 
       /**
@@ -172,8 +172,8 @@ namespace std
        *
        *  Note that other iostate flags may also be set.
       */
-      bool 
-      eof() const 
+      bool
+      eof() const
       { return (this->rdstate() & eofbit) != 0; }
 
       /**
@@ -183,8 +183,8 @@ namespace std
        *  Checking the badbit in fail() is historical practice.
        *  Note that other iostate flags may also be set.
       */
-      bool 
-      fail() const 
+      bool
+      fail() const
       { return (this->rdstate() & (badbit | failbit)) != 0; }
 
       /**
@@ -193,8 +193,8 @@ namespace std
        *
        *  Note that other iostate flags may also be set.
       */
-      bool 
-      bad() const 
+      bool
+      bad() const
       { return (this->rdstate() & badbit) != 0; }
 
       /**
@@ -204,8 +204,8 @@ namespace std
        *  This changes nothing in the stream.  See the one-argument version
        *  of exceptions(iostate) for the meaning of the return value.
       */
-      iostate 
-      exceptions() const 
+      iostate
+      exceptions() const
       { return _M_exception; }
 
       /**
@@ -224,26 +224,26 @@ namespace std
        *  #include <iostream>
        *  #include <fstream>
        *  #include <exception>
-       *  
+       *
        *  int main()
        *  {
        *      std::set_terminate (__gnu_cxx::__verbose_terminate_handler);
-       *  
+       *
        *      std::ifstream f ("/etc/motd");
-       *  
+       *
        *      std::cerr << "Setting badbit\n";
        *      f.setstate (std::ios_base::badbit);
-       *  
+       *
        *      std::cerr << "Setting exception mask\n";
        *      f.exceptions (std::ios_base::badbit);
        *  }
        *  @endcode
       */
-      void 
-      exceptions(iostate __except) 
-      { 
-        _M_exception = __except; 
-        this->clear(_M_streambuf_state); 
+      void
+      exceptions(iostate __except)
+      {
+        _M_exception = __except;
+        this->clear(_M_streambuf_state);
       }
 
       // Constructor/destructor:
@@ -252,8 +252,8 @@ namespace std
        *
        *  The parameter is passed by derived streams.
       */
-      explicit 
-      basic_ios(basic_streambuf<_CharT, _Traits>* __sb) 
+      explicit
+      basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
       : ios_base(), _M_ctype(0), _M_num_put(0), _M_num_get(0)
       { this->init(__sb); }
 
@@ -263,9 +263,9 @@ namespace std
        *  The destructor does nothing.  More specifically, it does not
        *  destroy the streambuf held by rdbuf().
       */
-      virtual 
+      virtual
       ~basic_ios() { }
-      
+
       // Members:
       /**
        *  @brief  Fetches the current @e tied stream.
@@ -277,7 +277,7 @@ namespace std
        *  first flushed.  For example, @c std::cin is tied to @c std::cout.
       */
       basic_ostream<_CharT, _Traits>*
-      tie() const      
+      tie() const
       { return _M_tie; }
 
       /**
@@ -303,7 +303,7 @@ namespace std
        *  This does not change the state of the stream.
       */
       basic_streambuf<_CharT, _Traits>*
-      rdbuf() const    
+      rdbuf() const
       { return _M_streambuf; }
 
       /**
@@ -328,7 +328,7 @@ namespace std
        *  foo.ios::rdbuf(p);            // ios == basic_ios<char>
        *  @endcode
       */
-      basic_streambuf<_CharT, _Traits>* 
+      basic_streambuf<_CharT, _Traits>*
       rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
 
       /**
@@ -351,15 +351,15 @@ namespace std
        *
        *  It defaults to a space (' ') in the current locale.
       */
-      char_type 
-      fill() const 
+      char_type
+      fill() const
       {
        if (!_M_fill_init)
          {
            _M_fill = this->widen(' ');
            _M_fill_init = true;
          }
-       return _M_fill; 
+       return _M_fill;
       }
 
       /**
@@ -371,7 +371,7 @@ namespace std
        *  have been requested (e.g., via setw), Q characters are actually
        *  used, and Q<P.  It defaults to a space (' ') in the current locale.
       */
-      char_type 
+      char_type
       fill(char_type __ch)
       {
        char_type __old = this->fill();
@@ -391,7 +391,7 @@ namespace std
        *  Additional l10n notes are at
        *  http://gcc.gnu.org/onlinedocs/libstdc++/22_locale/howto.html
       */
-      locale 
+      locale
       imbue(const locale& __loc);
 
       /**
@@ -411,7 +411,7 @@ namespace std
        *  Additional l10n notes are at
        *  http://gcc.gnu.org/onlinedocs/libstdc++/22_locale/howto.html
       */
-      char 
+      char
       narrow(char_type __c, char __dfault) const;
 
       /**
@@ -429,9 +429,9 @@ namespace std
        *  Additional l10n notes are at
        *  http://gcc.gnu.org/onlinedocs/libstdc++/22_locale/howto.html
       */
-      char_type 
+      char_type
       widen(char __c) const;
-     
+
     protected:
       // 27.4.5.1  basic_ios constructors
       /**
@@ -449,7 +449,7 @@ namespace std
        *  This is called from the public constructor.  It is not virtual and
        *  cannot be redefined.
       */
-      void 
+      void
       init(basic_streambuf<_CharT, _Traits>* __sb);
 
       void
index ce7af0d..cc73067 100644 (file)
@@ -37,7 +37,7 @@ namespace std
   template<typename _CharT, typename _Traits>
     void
     basic_ios<_CharT, _Traits>::clear(iostate __state)
-    { 
+    {
       if (this->rdbuf())
        _M_streambuf_state = __state;
       else
@@ -45,9 +45,9 @@ namespace std
       if (this->exceptions() & this->rdstate())
        __throw_ios_failure(__N("basic_ios::clear"));
     }
-  
+
   template<typename _CharT, typename _Traits>
-    basic_streambuf<_CharT, _Traits>* 
+    basic_streambuf<_CharT, _Traits>*
     basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
     {
       basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
@@ -66,17 +66,17 @@ namespace std
        {
          // Per 27.1.1, do not call imbue, yet must trash all caches
          // associated with imbue()
-         
+
          // Alloc any new word array first, so if it fails we have "rollback".
          _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
                             _M_local_word : new _Words[__rhs._M_word_size];
 
          // Bump refs before doing callbacks, for safety.
          _Callback_list* __cb = __rhs._M_callbacks;
-         if (__cb) 
+         if (__cb)
            __cb->_M_add_reference();
          _M_call_callbacks(erase_event);
-         if (_M_word != _M_local_word) 
+         if (_M_word != _M_local_word)
            {
              delete [] _M_word;
              _M_word = 0;
@@ -84,17 +84,17 @@ namespace std
          _M_dispose_callbacks();
 
          // NB: Don't want any added during above.
-         _M_callbacks = __cb;  
+         _M_callbacks = __cb;
          for (int __i = 0; __i < __rhs._M_word_size; ++__i)
            __words[__i] = __rhs._M_word[__i];
-         if (_M_word != _M_local_word) 
+         if (_M_word != _M_local_word)
            {
              delete [] _M_word;
              _M_word = 0;
            }
          _M_word = __words;
          _M_word_size = __rhs._M_word_size;
-         
+
          this->flags(__rhs.flags());
          this->width(__rhs.width());
          this->precision(__rhs.precision());
@@ -102,9 +102,9 @@ namespace std
          this->fill(__rhs.fill());
          _M_ios_locale = __rhs.getloc();
          _M_cache_locale(_M_ios_locale);
-         
+
          _M_call_callbacks(copyfmt_event);
-         
+
          // The next is required to be the last assignment.
          this->exceptions(__rhs.exceptions());
        }
@@ -172,13 +172,13 @@ namespace std
       if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
        _M_ctype = &use_facet<__ctype_type>(__loc);
       if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
-       _M_num_put = &use_facet<__num_put_type>(__loc); 
+       _M_num_put = &use_facet<__num_put_type>(__loc);
       if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
-       _M_num_get = &use_facet<__num_get_type>(__loc); 
+       _M_num_get = &use_facet<__num_get_type>(__loc);
     }
 
   // Inhibit implicit instantiations for required instantiations,
-  // which are defined via explicit instantiations elsewhere.  
+  // which are defined via explicit instantiations elsewhere.
   // NB:  This syntax is a GNU extension.
 #if _GLIBCXX_EXTERN_TEMPLATE
   extern template class basic_ios<char>;
@@ -189,4 +189,4 @@ namespace std
 #endif
 } // namespace std
 
-#endif 
+#endif
index 2103f63..26c3342 100644 (file)
@@ -111,20 +111,20 @@ namespace std
     {
       // Types:
     public:
-      typedef _Traits                                      traits_type;
-      typedef typename _Traits::char_type                  value_type;
-      typedef _Alloc                                       allocator_type;
-      typedef typename _Alloc::size_type                   size_type;
-      typedef typename _Alloc::difference_type                     difference_type;
-      typedef typename _Alloc::reference                   reference;
-      typedef typename _Alloc::const_reference                     const_reference;
-      typedef typename _Alloc::pointer                             pointer;
-      typedef typename _Alloc::const_pointer               const_pointer;
+      typedef _Traits                                      traits_type;
+      typedef typename _Traits::char_type                  value_type;
+      typedef _Alloc                                       allocator_type;
+      typedef typename _Alloc::size_type                   size_type;
+      typedef typename _Alloc::difference_type             difference_type;
+      typedef typename _Alloc::reference                   reference;
+      typedef typename _Alloc::const_reference             const_reference;
+      typedef typename _Alloc::pointer                     pointer;
+      typedef typename _Alloc::const_pointer               const_pointer;
       typedef __gnu_cxx::__normal_iterator<pointer, basic_string>  iterator;
       typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
                                                             const_iterator;
-      typedef std::reverse_iterator<const_iterator>    const_reverse_iterator;
-      typedef std::reverse_iterator<iterator>              reverse_iterator;
+      typedef std::reverse_iterator<const_iterator>    const_reverse_iterator;
+      typedef std::reverse_iterator<iterator>              reverse_iterator;
 
     private:
       // _Rep: string representation
@@ -143,8 +143,8 @@ namespace std
 
       struct _Rep_base
       {
-       size_type               _M_length;
-       size_type               _M_capacity;
+       size_type               _M_length;
+       size_type               _M_capacity;
        _Atomic_word            _M_refcount;
       };
 
@@ -166,17 +166,17 @@ namespace std
        // Solving for m:
        // m = ((npos - sizeof(_Rep))/sizeof(CharT)) - 1
        // In addition, this implementation quarters this amount.
-       static const size_type  _S_max_size;
-       static const _CharT     _S_terminal;
+       static const size_type  _S_max_size;
+       static const _CharT     _S_terminal;
 
        // The following storage is init'd to 0 by the linker, resulting
         // (carefully) in an empty string with one reference.
         static size_type _S_empty_rep_storage[];
 
-        static _Rep& 
+        static _Rep&
         _S_empty_rep()
         { return *reinterpret_cast<_Rep*>(&_S_empty_rep_storage); }
+
         bool
        _M_is_leaked() const
         { return this->_M_refcount < 0; }
@@ -246,11 +246,11 @@ namespace std
       // size that the allocator can hold.
       /// @var
       /// Value returned by various member functions when they fail.
-      static const size_type   npos = static_cast<size_type>(-1);
+      static const size_type   npos = static_cast<size_type>(-1);
 
     private:
       // Data Members (private):
-      mutable _Alloc_hider     _M_dataplus;
+      mutable _Alloc_hider     _M_dataplus;
 
       _CharT*
       _M_data() const
@@ -377,7 +377,7 @@ namespace std
        *  @param  s  Source character array.
        *  @param  n  Number of characters to copy.
        *  @param  a  Allocator to use (default is default allocator).
-       *  
+       *
        *  NB: s must have at least n characters, '\0' has no special
        *  meaning.
        */
@@ -606,9 +606,9 @@ namespace std
        */
       const_reference
       operator[] (size_type __pos) const
-      { 
+      {
        _GLIBCXX_DEBUG_ASSERT(__pos <= size());
-       return _M_data()[__pos]; 
+       return _M_data()[__pos];
       }
 
       /**
@@ -731,9 +731,9 @@ namespace std
        */
       basic_string&
       append(const _CharT* __s)
-      { 
+      {
        __glibcxx_requires_string(__s);
-       return this->append(__s, traits_type::length(__s)); 
+       return this->append(__s, traits_type::length(__s));
       }
 
       /**
@@ -819,9 +819,9 @@ namespace std
        */
       basic_string&
       assign(const _CharT* __s)
-      { 
+      {
        __glibcxx_requires_string(__s);
-       return this->assign(__s, traits_type::length(__s)); 
+       return this->assign(__s, traits_type::length(__s));
       }
 
       /**
@@ -870,7 +870,7 @@ namespace std
        *  @brief  Insert a range of characters.
        *  @param p  Iterator referencing location in string to insert at.
        *  @param beg  Start of range.
-       *  @param end  End of range. 
+       *  @param end  End of range.
        *  @throw  std::length_error  If new length exceeds @c max_size().
        *
        *  Inserts characters in range [beg,end).  If adding characters causes
@@ -929,7 +929,7 @@ namespace std
        *  @return  Reference to this string.
        *  @throw  std::length_error  If new length exceeds @c max_size().
        *  @throw  std::out_of_range  If @a pos is beyond the end of this
-       *  string. 
+       *  string.
        *
        *  Inserts the first @a n characters of @a s starting at @a pos.  If
        *  adding characters causes the length to exceed max_size(),
@@ -957,9 +957,9 @@ namespace std
       */
       basic_string&
       insert(size_type __pos, const _CharT* __s)
-      { 
+      {
        __glibcxx_requires_string(__s);
-       return this->insert(__pos, __s, traits_type::length(__s)); 
+       return this->insert(__pos, __s, traits_type::length(__s));
       }
 
       /**
@@ -1002,7 +1002,7 @@ namespace std
        const size_type __pos = __p - _M_ibegin();
        _M_replace_aux(__pos, size_type(0), size_type(1), __c);
        _M_rep()->_M_set_leaked();
-       return this->_M_ibegin() + __pos;
+       return this->_M_ibegin() + __pos;
       }
 
       /**
@@ -1035,7 +1035,7 @@ namespace std
       iterator
       erase(iterator __position)
       {
-       _GLIBCXX_DEBUG_PEDASSERT(__position >= _M_ibegin() 
+       _GLIBCXX_DEBUG_PEDASSERT(__position >= _M_ibegin()
                                 && __position < _M_iend());
        const size_type __pos = __position - _M_ibegin();
        _M_replace_safe(__pos, size_type(1), NULL, size_type(0));
@@ -1070,7 +1070,7 @@ namespace std
        *  @param str  String to insert.
        *  @return  Reference to this string.
        *  @throw  std::out_of_range  If @a pos is beyond the end of this
-       *  string. 
+       *  string.
        *  @throw  std::length_error  If new length exceeds @c max_size().
        *
        *  Removes the characters in the range [pos,pos+n) from this string.
@@ -1092,7 +1092,7 @@ namespace std
        *  @param n2  Number of characters from str to use.
        *  @return  Reference to this string.
        *  @throw  std::out_of_range  If @a pos1 > size() or @a pos2 >
-       *  str.size(). 
+       *  str.size().
        *  @throw  std::length_error  If new length exceeds @c max_size().
        *
        *  Removes the characters in the range [pos1,pos1 + n) from this
@@ -1146,9 +1146,9 @@ namespace std
       */
       basic_string&
       replace(size_type __pos, size_type __n1, const _CharT* __s)
-      { 
+      {
        __glibcxx_requires_string(__s);
-       return this->replace(__pos, __n1, __s, traits_type::length(__s)); 
+       return this->replace(__pos, __n1, __s, traits_type::length(__s));
       }
 
       /**
@@ -1207,7 +1207,7 @@ namespace std
       replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
       {
        _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
-                                && __i2 <= _M_iend()); 
+                                && __i2 <= _M_iend());
        return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
       }
 
@@ -1226,9 +1226,9 @@ namespace std
       */
       basic_string&
       replace(iterator __i1, iterator __i2, const _CharT* __s)
-      { 
+      {
        __glibcxx_requires_string(__s);
-       return this->replace(__i1, __i2, __s, traits_type::length(__s)); 
+       return this->replace(__i1, __i2, __s, traits_type::length(__s));
       }
 
       /**
@@ -1247,10 +1247,10 @@ namespace std
       */
       basic_string&
       replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
-      { 
+      {
        _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
                                 && __i2 <= _M_iend());
-       return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c); 
+       return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
       }
 
       /**
@@ -1271,40 +1271,40 @@ namespace std
         basic_string&
         replace(iterator __i1, iterator __i2,
                _InputIterator __k1, _InputIterator __k2)
-        { 
+        {
          _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
                                   && __i2 <= _M_iend());
          __glibcxx_requires_valid_range(__k1, __k2);
          typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
-         return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral()); 
+         return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
        }
 
       // 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); 
+                              __k1, __k2 - __k1);
        }
 
       basic_string&
-        replace(iterator __i1, iterator __i2, 
+        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); 
+                              __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);
@@ -1313,9 +1313,9 @@ namespace std
        }
 
       basic_string&
-        replace(iterator __i1, iterator __i2, 
+        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);
@@ -1326,7 +1326,7 @@ namespace std
     private:
       template<class _Integer>
        basic_string&
-       _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n, 
+       _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
                            _Integer __val, __true_type)
         { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }
 
@@ -1344,7 +1344,7 @@ namespace std
        _M_mutate(__pos1, __n1, __n2);
        if (__n2)
          traits_type::assign(_M_data() + __pos1, __n2, __c);
-       return *this;   
+       return *this;
       }
 
       basic_string&
@@ -1354,7 +1354,7 @@ namespace std
        _M_mutate(__pos1, __n1, __n2);
        if (__n2)
          traits_type::copy(_M_data() + __pos1, __s, __n2);
-       return *this;   
+       return *this;
       }
 
       // _S_construct_aux is used to implement the 21.3.1 para 15 which
@@ -1490,9 +1490,9 @@ namespace std
       */
       size_type
       find(const _CharT* __s, size_type __pos = 0) const
-      { 
+      {
        __glibcxx_requires_string(__s);
-       return this->find(__s, __pos, traits_type::length(__s)); 
+       return this->find(__s, __pos, traits_type::length(__s));
       }
 
       /**
@@ -1548,9 +1548,9 @@ namespace std
       */
       size_type
       rfind(const _CharT* __s, size_type __pos = npos) const
-      { 
+      {
        __glibcxx_requires_string(__s);
-       return this->rfind(__s, __pos, traits_type::length(__s)); 
+       return this->rfind(__s, __pos, traits_type::length(__s));
       }
 
       /**
@@ -1606,9 +1606,9 @@ namespace std
       */
       size_type
       find_first_of(const _CharT* __s, size_type __pos = 0) const
-      { 
+      {
        __glibcxx_requires_string(__s);
-       return this->find_first_of(__s, __pos, traits_type::length(__s)); 
+       return this->find_first_of(__s, __pos, traits_type::length(__s));
       }
 
       /**
@@ -1667,9 +1667,9 @@ namespace std
       */
       size_type
       find_last_of(const _CharT* __s, size_type __pos = npos) const
-      { 
+      {
        __glibcxx_requires_string(__s);
-       return this->find_last_of(__s, __pos, traits_type::length(__s)); 
+       return this->find_last_of(__s, __pos, traits_type::length(__s));
       }
 
       /**
@@ -1729,9 +1729,9 @@ namespace std
       */
       size_type
       find_first_not_of(const _CharT* __s, size_type __pos = 0) const
-      { 
+      {
        __glibcxx_requires_string(__s);
-       return this->find_first_not_of(__s, __pos, traits_type::length(__s)); 
+       return this->find_first_not_of(__s, __pos, traits_type::length(__s));
       }
 
       /**
@@ -1788,9 +1788,9 @@ namespace std
       */
       size_type
       find_last_not_of(const _CharT* __s, size_type __pos = npos) const
-      { 
+      {
        __glibcxx_requires_string(__s);
-       return this->find_last_not_of(__s, __pos, traits_type::length(__s)); 
+       return this->find_last_not_of(__s, __pos, traits_type::length(__s));
       }
 
       /**
@@ -1935,7 +1935,7 @@ namespace std
        *  Returns an integer < 0 if this substring is ordered before the string
        *  from @a s, 0 if their values are equivalent, or > 0 if this substring
        *  is ordered after the string from @a s. If the lengths of this
-       *  substring and @a n2 are different, the shorter one is ordered first. 
+       *  substring and @a n2 are different, the shorter one is ordered first.
        *  If they are the same, returns the result of
        *  traits::compare(substring.data(),s,size());
        *
@@ -1959,7 +1959,7 @@ namespace std
    *  @param lhs  First string.
    *  @param rhs  Last string.
    *  @return  New string with value of @a lhs followed by @a rhs.
-   */ 
+   */
  template<typename _CharT, typename _Traits, typename _Alloc>
     basic_string<_CharT, _Traits, _Alloc>
     operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
@@ -1975,7 +1975,7 @@ namespace std
    *  @param lhs  First string.
    *  @param rhs  Last string.
    *  @return  New string with value of @a lhs followed by @a rhs.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     basic_string<_CharT,_Traits,_Alloc>
     operator+(const _CharT* __lhs,
@@ -1986,7 +1986,7 @@ namespace std
    *  @param lhs  First string.
    *  @param rhs  Last string.
    *  @return  New string with @a lhs followed by @a rhs.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     basic_string<_CharT,_Traits,_Alloc>
     operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
@@ -1996,7 +1996,7 @@ namespace std
    *  @param lhs  First string.
    *  @param rhs  Last string.
    *  @return  New string with @a lhs followed by @a rhs.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline basic_string<_CharT, _Traits, _Alloc>
     operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
@@ -2012,12 +2012,12 @@ namespace std
    *  @param lhs  First string.
    *  @param rhs  Last string.
    *  @return  New string with @a lhs followed by @a rhs.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline basic_string<_CharT, _Traits, _Alloc>
     operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
     {
-      typedef basic_string<_CharT, _Traits, _Alloc>    __string_type;
+      typedef basic_string<_CharT, _Traits, _Alloc>    __string_type;
       typedef typename __string_type::size_type                __size_type;
       __string_type __str(__lhs);
       __str.append(__size_type(1), __rhs);
@@ -2030,7 +2030,7 @@ namespace std
    *  @param lhs  First string.
    *  @param rhs  Second string.
    *  @return  True if @a lhs.compare(@a rhs) == 0.  False otherwise.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline bool
     operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
@@ -2042,7 +2042,7 @@ namespace std
    *  @param lhs  C string.
    *  @param rhs  String.
    *  @return  True if @a rhs.compare(@a lhs) == 0.  False otherwise.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline bool
     operator==(const _CharT* __lhs,
@@ -2054,7 +2054,7 @@ namespace std
    *  @param lhs  String.
    *  @param rhs  C string.
    *  @return  True if @a lhs.compare(@a rhs) == 0.  False otherwise.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline bool
     operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
@@ -2067,7 +2067,7 @@ namespace std
    *  @param lhs  First string.
    *  @param rhs  Second string.
    *  @return  True if @a lhs.compare(@a rhs) != 0.  False otherwise.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline bool
     operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
@@ -2079,7 +2079,7 @@ namespace std
    *  @param lhs  C string.
    *  @param rhs  String.
    *  @return  True if @a rhs.compare(@a lhs) != 0.  False otherwise.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline bool
     operator!=(const _CharT* __lhs,
@@ -2091,7 +2091,7 @@ namespace std
    *  @param lhs  String.
    *  @param rhs  C string.
    *  @return  True if @a lhs.compare(@a rhs) != 0.  False otherwise.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline bool
     operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
@@ -2104,7 +2104,7 @@ namespace std
    *  @param lhs  First string.
    *  @param rhs  Second string.
    *  @return  True if @a lhs precedes @a rhs.  False otherwise.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline bool
     operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
@@ -2116,7 +2116,7 @@ namespace std
    *  @param lhs  String.
    *  @param rhs  C string.
    *  @return  True if @a lhs precedes @a rhs.  False otherwise.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline bool
     operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
@@ -2128,7 +2128,7 @@ namespace std
    *  @param lhs  C string.
    *  @param rhs  String.
    *  @return  True if @a lhs precedes @a rhs.  False otherwise.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline bool
     operator<(const _CharT* __lhs,
@@ -2141,7 +2141,7 @@ namespace std
    *  @param lhs  First string.
    *  @param rhs  Second string.
    *  @return  True if @a lhs follows @a rhs.  False otherwise.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline bool
     operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
@@ -2153,7 +2153,7 @@ namespace std
    *  @param lhs  String.
    *  @param rhs  C string.
    *  @return  True if @a lhs follows @a rhs.  False otherwise.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline bool
     operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
@@ -2165,7 +2165,7 @@ namespace std
    *  @param lhs  C string.
    *  @param rhs  String.
    *  @return  True if @a lhs follows @a rhs.  False otherwise.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline bool
     operator>(const _CharT* __lhs,
@@ -2178,7 +2178,7 @@ namespace std
    *  @param lhs  First string.
    *  @param rhs  Second string.
    *  @return  True if @a lhs doesn't follow @a rhs.  False otherwise.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline bool
     operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
@@ -2190,7 +2190,7 @@ namespace std
    *  @param lhs  String.
    *  @param rhs  C string.
    *  @return  True if @a lhs doesn't follow @a rhs.  False otherwise.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline bool
     operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
@@ -2202,7 +2202,7 @@ namespace std
    *  @param lhs  C string.
    *  @param rhs  String.
    *  @return  True if @a lhs doesn't follow @a rhs.  False otherwise.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline bool
     operator<=(const _CharT* __lhs,
@@ -2215,7 +2215,7 @@ namespace std
    *  @param lhs  First string.
    *  @param rhs  Second string.
    *  @return  True if @a lhs doesn't precede @a rhs.  False otherwise.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline bool
     operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
@@ -2227,7 +2227,7 @@ namespace std
    *  @param lhs  String.
    *  @param rhs  C string.
    *  @return  True if @a lhs doesn't precede @a rhs.  False otherwise.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline bool
     operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
@@ -2239,7 +2239,7 @@ namespace std
    *  @param lhs  C string.
    *  @param rhs  String.
    *  @return  True if @a lhs doesn't precede @a rhs.  False otherwise.
-   */ 
+   */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline bool
     operator>=(const _CharT* __lhs,
@@ -2251,7 +2251,7 @@ namespace std
    *  @param lhs  First string.
    *  @param rhs  Second string.
    *
-   *  Exchanges the contents of @a lhs and @a rhs in constant time. 
+   *  Exchanges the contents of @a lhs and @a rhs in constant time.
    */
   template<typename _CharT, typename _Traits, typename _Alloc>
     inline void
index 0e80f59..729b86c 100644 (file)
@@ -56,12 +56,12 @@ namespace std
     { return false; }
 
   template<typename _CharT, typename _Traits, typename _Alloc>
-    const typename basic_string<_CharT, _Traits, _Alloc>::size_type 
+    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
     basic_string<_CharT, _Traits, _Alloc>::
     _Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;
 
   template<typename _CharT, typename _Traits, typename _Alloc>
-    const _CharT 
+    const _CharT
     basic_string<_CharT, _Traits, _Alloc>::
     _Rep::_S_terminal = _CharT();
 
@@ -94,13 +94,13 @@ namespace std
        _CharT __buf[100];
        size_type __len = 0;
        while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT))
-         { 
-           __buf[__len++] = *__beg; 
+         {
+           __buf[__len++] = *__beg;
            ++__beg;
          }
        _Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
        traits_type::copy(__r->_M_refdata(), __buf, __len);
-       try 
+       try
          {
            while (__beg != __end)
              {
@@ -108,36 +108,36 @@ namespace std
                  {
                    // Allocate more space.
                    _Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
-                   traits_type::copy(__another->_M_refdata(), 
+                   traits_type::copy(__another->_M_refdata(),
                                      __r->_M_refdata(), __len);
                    __r->_M_destroy(__a);
                    __r = __another;
                  }
-               __r->_M_refdata()[__len++] = *__beg; 
+               __r->_M_refdata()[__len++] = *__beg;
                ++__beg;
              }
          }
-       catch(...) 
+       catch(...)
          {
-           __r->_M_destroy(__a); 
+           __r->_M_destroy(__a);
            __throw_exception_again;
          }
        __r->_M_length = __len;
        __r->_M_refdata()[__len] = _Rep::_S_terminal;       // grrr.
        return __r->_M_refdata();
       }
-  
+
   template<typename _CharT, typename _Traits, typename _Alloc>
     template <typename _InIterator>
       _CharT*
       basic_string<_CharT, _Traits, _Alloc>::
-      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a, 
+      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
                   forward_iterator_tag)
       {
        if (__beg == __end && __a == _Alloc())
          return _S_empty_rep()._M_refdata();
 
-       // NB: Not required, but considered best practice. 
+       // NB: Not required, but considered best practice.
        if (__builtin_expect(__is_null_pointer(__beg), 0))
          __throw_logic_error(__N("basic_string::_S_construct NULL not valid"));
 
@@ -145,11 +145,11 @@ namespace std
                                                                      __end));
        // Check for out_of_range and length_error exceptions.
        _Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a);
-       try 
+       try
          { _S_copy_chars(__r->_M_refdata(), __beg, __end); }
-       catch(...) 
-         { 
-           __r->_M_destroy(__a); 
+       catch(...)
+         {
+           __r->_M_destroy(__a);
            __throw_exception_again;
          }
        __r->_M_length = __dnew;
@@ -167,8 +167,8 @@ namespace std
 
       // Check for out_of_range and length_error exceptions.
       _Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
-      if (__n) 
-       traits_type::assign(__r->_M_refdata(), __n, __c); 
+      if (__n)
+       traits_type::assign(__r->_M_refdata(), __n, __c);
 
       __r->_M_length = __n;
       __r->_M_refdata()[__n] = _Rep::_S_terminal;  // grrr
@@ -187,7 +187,7 @@ namespace std
     basic_string(const _Alloc& __a)
     : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
     { }
+
   template<typename _CharT, typename _Traits, typename _Alloc>
     basic_string<_CharT, _Traits, _Alloc>::
     basic_string(const basic_string& __str, size_type __pos, size_type __n)
@@ -230,7 +230,7 @@ namespace std
     : _M_dataplus(_S_construct(__n, __c, __a), __a)
     { }
 
-  // TBD: DPG annotate 
+  // TBD: DPG annotate
   template<typename _CharT, typename _Traits, typename _Alloc>
     template<typename _InputIterator>
     basic_string<_CharT, _Traits, _Alloc>::
@@ -313,7 +313,7 @@ namespace std
            return *this;
          }
      }
+
    template<typename _CharT, typename _Traits, typename _Alloc>
      basic_string<_CharT, _Traits, _Alloc>&
      basic_string<_CharT, _Traits, _Alloc>::
@@ -350,7 +350,7 @@ namespace std
           return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2);
         }
      }
-  
+
   template<typename _CharT, typename _Traits, typename _Alloc>
     void
     basic_string<_CharT, _Traits, _Alloc>::_Rep::
@@ -369,7 +369,7 @@ namespace std
     {
       if (_M_rep() == &_S_empty_rep())
         return;
-      if (_M_rep()->_M_is_shared()) 
+      if (_M_rep()->_M_is_shared())
        _M_mutate(0, 0, 0);
       _M_rep()->_M_set_leaked();
     }
@@ -383,7 +383,7 @@ namespace std
       const size_type __new_size = __old_size + __len2 - __len1;
       const _CharT*        __src = _M_data()  + __pos + __len1;
       const size_type __how_much = __old_size - __pos - __len1;
-      
+
       if (_M_rep() == &_S_empty_rep()
          || _M_rep()->_M_is_shared() || __new_size > capacity())
        {
@@ -410,7 +410,7 @@ namespace std
       _M_data()[__new_size] = _Rep::_S_terminal; // grrr. (per 21.3.4)
       // You cannot leave those LWG people alone for a second.
     }
-  
+
   template<typename _CharT, typename _Traits, typename _Alloc>
     void
     basic_string<_CharT, _Traits, _Alloc>::reserve(size_type __res)
@@ -428,13 +428,13 @@ namespace std
          _M_data(__tmp);
         }
     }
-  
+
   template<typename _CharT, typename _Traits, typename _Alloc>
     void basic_string<_CharT, _Traits, _Alloc>::swap(basic_string& __s)
     {
-      if (_M_rep()->_M_is_leaked()) 
+      if (_M_rep()->_M_is_leaked())
        _M_rep()->_M_set_sharable();
-      if (__s._M_rep()->_M_is_leaked()) 
+      if (__s._M_rep()->_M_is_leaked())
        __s._M_rep()->_M_set_sharable();
       if (this->get_allocator() == __s.get_allocator())
        {
@@ -443,11 +443,11 @@ namespace std
          __s._M_data(__tmp);
        }
       // The code below can usually be optimized away.
-      else 
+      else
        {
          const basic_string __tmp1(_M_ibegin(), _M_iend(),
                                    __s.get_allocator());
-         const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(), 
+         const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
                                    this->get_allocator());
          *this = __tmp2;
          __s = __tmp1;
@@ -504,7 +504,7 @@ namespace std
       const size_type __page_capacity = ((__pagesize - __malloc_header_size
                                          - sizeof(_Rep) - sizeof(_CharT))
                                         / sizeof(_CharT));
-      
+
       if (__capacity > __old_capacity && __capacity < 2 * __old_capacity
          && __capacity > __page_capacity)
        __capacity = 2 * __old_capacity;
@@ -558,7 +558,7 @@ namespace std
       __r->_M_refdata()[this->_M_length] = _Rep::_S_terminal;
       return __r->_M_refdata();
     }
-  
+
   template<typename _CharT, typename _Traits, typename _Alloc>
     void
     basic_string<_CharT, _Traits, _Alloc>::resize(size_type __n, _CharT __c)
@@ -577,7 +577,7 @@ namespace std
     template<typename _InputIterator>
       basic_string<_CharT, _Traits, _Alloc>&
       basic_string<_CharT, _Traits, _Alloc>::
-      _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1, 
+      _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
                          _InputIterator __k2, __false_type)
       {
        const basic_string __s(__k1, __k2);
@@ -720,16 +720,16 @@ namespace std
        {
          __pos = std::min(size_type(__size - __n), __pos);
          const _CharT* __data = _M_data();
-         do 
+         do
            {
              if (traits_type::compare(__data + __pos, __s, __n) == 0)
                return __pos;
-           } 
+           }
          while (__pos-- > 0);
        }
       return npos;
     }
-  
+
   template<typename _CharT, typename _Traits, typename _Alloc>
     typename basic_string<_CharT, _Traits, _Alloc>::size_type
     basic_string<_CharT, _Traits, _Alloc>::
@@ -746,7 +746,7 @@ namespace std
        }
       return npos;
     }
-  
+
   template<typename _CharT, typename _Traits, typename _Alloc>
     typename basic_string<_CharT, _Traits, _Alloc>::size_type
     basic_string<_CharT, _Traits, _Alloc>::
@@ -761,7 +761,7 @@ namespace std
        }
       return npos;
     }
+
   template<typename _CharT, typename _Traits, typename _Alloc>
     typename basic_string<_CharT, _Traits, _Alloc>::size_type
     basic_string<_CharT, _Traits, _Alloc>::
@@ -770,19 +770,19 @@ namespace std
       __glibcxx_requires_string_len(__s, __n);
       size_type __size = this->size();
       if (__size && __n)
-       { 
-         if (--__size > __pos) 
+       {
+         if (--__size > __pos)
            __size = __pos;
          do
            {
              if (traits_type::find(__s, __n, _M_data()[__size]))
                return __size;
-           } 
+           }
          while (__size-- != 0);
        }
       return npos;
     }
-  
+
   template<typename _CharT, typename _Traits, typename _Alloc>
     typename basic_string<_CharT, _Traits, _Alloc>::size_type
     basic_string<_CharT, _Traits, _Alloc>::
@@ -817,11 +817,11 @@ namespace std
        {
          if (--__size > __pos)
            __size = __pos;
-         do
+         do
            {
              if (!traits_type::find(__s, __n, _M_data()[__size]))
                return __size;
-           } 
+           }
          while (__size--);
        }
       return npos;
@@ -836,17 +836,17 @@ namespace std
       if (__size)
        {
          if (--__size > __pos)
-           __size = __pos;       
+           __size = __pos;
          do
            {
              if (!traits_type::eq(_M_data()[__size], __c))
                return __size;
-           } 
+           }
          while (__size--);
        }
       return npos;
     }
-  
+
   template<typename _CharT, typename _Traits, typename _Alloc>
     int
     basic_string<_CharT, _Traits, _Alloc>::
@@ -873,7 +873,7 @@ namespace std
       __n1 = _M_limit(__pos1, __n1);
       __n2 = __str._M_limit(__pos2, __n2);
       const size_type __len = std::min(__n1, __n2);
-      int __r = traits_type::compare(_M_data() + __pos1, 
+      int __r = traits_type::compare(_M_data() + __pos1,
                                     __str.data() + __pos2, __len);
       if (!__r)
        __r = __n1 - __n2;
@@ -914,7 +914,7 @@ namespace std
   template<typename _CharT, typename _Traits, typename _Alloc>
     int
     basic_string <_CharT, _Traits, _Alloc>::
-    compare(size_type __pos, size_type __n1, const _CharT* __s, 
+    compare(size_type __pos, size_type __n1, const _CharT* __s,
            size_type __n2) const
     {
       __glibcxx_requires_string_len(__s, __n2);
@@ -928,36 +928,36 @@ namespace std
     }
 
   // Inhibit implicit instantiations for required instantiations,
-  // which are defined via explicit instantiations elsewhere.  
+  // which are defined via explicit instantiations elsewhere.
   // NB: This syntax is a GNU extension.
 #if _GLIBCXX_EXTERN_TEMPLATE
   extern template class basic_string<char>;
-  extern template 
-    basic_istream<char>& 
+  extern template
+    basic_istream<char>&
     operator>>(basic_istream<char>&, string&);
-  extern template 
-    basic_ostream<char>& 
+  extern template
+    basic_ostream<char>&
     operator<<(basic_ostream<char>&, const string&);
-  extern template 
-    basic_istream<char>& 
+  extern template
+    basic_istream<char>&
     getline(basic_istream<char>&, string&, char);
-  extern template 
-    basic_istream<char>& 
+  extern template
+    basic_istream<char>&
     getline(basic_istream<char>&, string&);
 
 #ifdef _GLIBCXX_USE_WCHAR_T
   extern template class basic_string<wchar_t>;
-  extern template 
-    basic_istream<wchar_t>& 
+  extern template
+    basic_istream<wchar_t>&
     operator>>(basic_istream<wchar_t>&, wstring&);
-  extern template 
-    basic_ostream<wchar_t>& 
+  extern template
+    basic_ostream<wchar_t>&
     operator<<(basic_ostream<wchar_t>&, const wstring&);
-  extern template 
-    basic_istream<wchar_t>& 
+  extern template
+    basic_istream<wchar_t>&
     getline(basic_istream<wchar_t>&, wstring&, wchar_t);
-  extern template 
-    basic_istream<wchar_t>& 
+  extern template
+    basic_istream<wchar_t>&
     getline(basic_istream<wchar_t>&, wstring&);
 #endif
 #endif
index b8bce64..70037eb 100644 (file)
@@ -87,7 +87,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
 
   template <class _Tp>
   struct _IntegerConcept {
-    void __constraints() { 
+    void __constraints() {
       this->__error_type_must_be_an_integer_type();
     }
   };
@@ -103,7 +103,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
 
   template <class _Tp>
   struct _SignedIntegerConcept {
-    void __constraints() { 
+    void __constraints() {
       this->__error_type_must_be_a_signed_integer_type();
     }
   };
@@ -114,7 +114,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
 
   template <class _Tp>
   struct _UnsignedIntegerConcept {
-    void __constraints() { 
+    void __constraints() {
       this->__error_type_must_be_an_unsigned_integer_type();
     }
   };
@@ -312,7 +312,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
 
   template <class _Func, class _Arg>
   struct _UnaryFunctionConcept<_Func, void, _Arg> {
-    void __constraints() { 
+    void __constraints() {
       __f(__arg);                       // require operator()
     }
     _Func __f;
@@ -322,7 +322,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
   template <class _Func, class _Return, class _First, class _Second>
   struct _BinaryFunctionConcept
   {
-    void __constraints() { 
+    void __constraints() {
       __r = __f(__first, __second);     // require operator()
     }
     _Func __f;
@@ -366,7 +366,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
   // use this when functor is used inside a container class like std::set
   template <class _Func, class _First, class _Second>
   struct _Const_BinaryPredicateConcept {
-    void __constraints() { 
+    void __constraints() {
       __const_constraints(__f);
     }
     void __const_constraints(const _Func& __fun) {
@@ -560,7 +560,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
     typedef typename _Container::reference _Reference;
     typedef typename _Container::iterator _Iterator;
     typedef typename _Container::pointer _Pointer;
-    
+
     void __constraints() {
       __function_requires< _ContainerConcept<_Container> >();
       __function_requires< _AssignableConcept<_Value_type> >();
@@ -582,7 +582,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
       typedef typename _ForwardContainer::const_iterator _Const_iterator;
       __function_requires< _ForwardIteratorConcept<_Const_iterator> >();
     }
-  };  
+  };
 
   template <class _ForwardContainer>
   struct _Mutable_ForwardContainerConcept
@@ -593,7 +593,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
       typedef typename _ForwardContainer::iterator _Iterator;
       __function_requires< _Mutable_ForwardIteratorConcept<_Iterator> >();
     }
-  };  
+  };
 
   template <class _ReversibleContainer>
   struct _ReversibleContainerConcept
@@ -693,7 +693,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
       __function_requires< _Mutable_ForwardContainerConcept<_Sequence> >();
       __function_requires< _DefaultConstructibleConcept<_Sequence> >();
 
-      _Sequence 
+      _Sequence
         __c(__n) _IsUnused,
         __c2(__n, __t) _IsUnused,
         __c3(__first, __last) _IsUnused;
@@ -758,7 +758,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
       __function_requires< _ForwardContainerConcept<_AssociativeContainer> >();
       __function_requires<
         _DefaultConstructibleConcept<_AssociativeContainer> >();
-    
+
       __i = __c.find(__k);
       __r = __c.equal_range(__k);
       __c.erase(__k);
@@ -789,9 +789,9 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
     void __constraints() {
       __function_requires<
         _AssociativeContainerConcept<_UniqueAssociativeContainer> >();
-    
+
       _UniqueAssociativeContainer __c(__first, __last);
-      
+
       __pos_flag = __c.insert(__t);
       __c.insert(__first, __last);
     }
@@ -808,7 +808,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
         _AssociativeContainerConcept<_MultipleAssociativeContainer> >();
 
       _MultipleAssociativeContainer __c(__first, __last);
-      
+
       __pos = __c.insert(__t);
       __c.insert(__first, __last);
 
@@ -855,7 +855,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
       __function_requires<
         _ReversibleContainerConcept<_SortedAssociativeContainer> >();
 
-      _SortedAssociativeContainer 
+      _SortedAssociativeContainer
         __c(__kc) _IsUnused,
         __c2(__first, __last) _IsUnused,
         __c3(__first, __last, __kc) _IsUnused;
@@ -863,7 +863,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
       __p = __c.upper_bound(__k);
       __p = __c.lower_bound(__k);
       __r = __c.equal_range(__k);
-      
+
       __c.insert(__p, __t);
     }
     void __const_constraints(const _SortedAssociativeContainer& __c) {
index 3447975..323fdfb 100644 (file)
@@ -50,12 +50,12 @@ namespace __gnu_cxx
 {
   /**
    *  @brief  Mapping from character type to associated types.
-   * 
+   *
    *
    *  @note This is an implementation class for the generic version
    *  of char_traits.  It defines int_type, off_type, pos_type, and
    *  state_type.  By default these are unsigned long, streamoff,
-   *  streampos, and mbstate_t.  Users who need a different set of 
+   *  streampos, and mbstate_t.  Users who need a different set of
    *  types, but who don't need to change the definitions of any function
    *  defined in char_traits, can specialize __gnu_cxx::_Char_types
    *  while leaving __gnu_cxx::char_traits alone. */
@@ -91,54 +91,54 @@ namespace __gnu_cxx
       typedef typename _Char_types<_CharT>::pos_type    pos_type;
       typedef typename _Char_types<_CharT>::off_type    off_type;
       typedef typename _Char_types<_CharT>::state_type  state_type;
-      
-      static void 
+
+      static void
       assign(char_type& __c1, const char_type& __c2)
       { __c1 = __c2; }
 
-      static bool 
+      static bool
       eq(const char_type& __c1, const char_type& __c2)
       { return __c1 == __c2; }
 
-      static bool 
+      static bool
       lt(const char_type& __c1, const char_type& __c2)
       { return __c1 < __c2; }
 
-      static int 
+      static int
       compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
 
       static std::size_t
       length(const char_type* __s);
 
-      static const char_type* 
+      static const char_type*
       find(const char_type* __s, std::size_t __n, const char_type& __a);
 
-      static char_type* 
+      static char_type*
       move(char_type* __s1, const char_type* __s2, std::size_t __n);
 
-      static char_type* 
+      static char_type*
       copy(char_type* __s1, const char_type* __s2, std::size_t __n);
 
-      static char_type* 
+      static char_type*
       assign(char_type* __s, std::size_t __n, char_type __a);
 
-      static char_type 
+      static char_type
       to_char_type(const int_type& __c)
       { return static_cast<char_type>(__c); }
 
-      static int_type 
+      static int_type
       to_int_type(const char_type& __c)
       { return static_cast<int_type>(__c); }
 
-      static bool 
+      static bool
       eq_int_type(const int_type& __c1, const int_type& __c2)
       { return __c1 == __c2; }
 
-      static int_type 
+      static int_type
       eof()
       { return static_cast<int_type>(EOF); }
 
-      static int_type 
+      static int_type
       not_eof(const int_type& __c)
       { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
     };
@@ -168,7 +168,7 @@ namespace __gnu_cxx
     }
 
   template<typename _CharT>
-    const typename char_traits<_CharT>::char_type* 
+    const typename char_traits<_CharT>::char_type*
     char_traits<_CharT>::
     find(const char_type* __s, std::size_t __n, const char_type& __a)
     {
@@ -188,7 +188,7 @@ namespace __gnu_cxx
     }
 
   template<typename _CharT>
-    typename char_traits<_CharT>::char_type* 
+    typename char_traits<_CharT>::char_type*
     char_traits<_CharT>::
     copy(char_type* __s1, const char_type* __s2, std::size_t __n)
     {
@@ -197,7 +197,7 @@ namespace __gnu_cxx
     }
 
   template<typename _CharT>
-    typename char_traits<_CharT>::char_type* 
+    typename char_traits<_CharT>::char_type*
     char_traits<_CharT>::
     assign(char_type* __s, std::size_t __n, char_type __a)
     {
@@ -206,7 +206,7 @@ namespace __gnu_cxx
     }
 }
 
-namespace std 
+namespace std
 {
   // 21.1
   /**
@@ -237,19 +237,19 @@ namespace std
       typedef streamoff         off_type;
       typedef mbstate_t         state_type;
 
-      static void 
+      static void
       assign(char_type& __c1, const char_type& __c2)
       { __c1 = __c2; }
 
-      static bool 
+      static bool
       eq(const char_type& __c1, const char_type& __c2)
       { return __c1 == __c2; }
 
-      static bool 
+      static bool
       lt(const char_type& __c1, const char_type& __c2)
       { return __c1 < __c2; }
 
-      static int 
+      static int
       compare(const char_type* __s1, const char_type* __s2, size_t __n)
       { return memcmp(__s1, __s2, __n); }
 
@@ -257,40 +257,40 @@ namespace std
       length(const char_type* __s)
       { return strlen(__s); }
 
-      static const char_type* 
+      static const char_type*
       find(const char_type* __s, size_t __n, const char_type& __a)
       { return static_cast<const char_type*>(memchr(__s, __a, __n)); }
 
-      static char_type* 
+      static char_type*
       move(char_type* __s1, const char_type* __s2, size_t __n)
       { return static_cast<char_type*>(memmove(__s1, __s2, __n)); }
 
-      static char_type* 
+      static char_type*
       copy(char_type* __s1, const char_type* __s2, size_t __n)
       { return static_cast<char_type*>(memcpy(__s1, __s2, __n)); }
 
-      static char_type* 
+      static char_type*
       assign(char_type* __s, size_t __n, char_type __a)
       { return static_cast<char_type*>(memset(__s, __a, __n)); }
 
-      static char_type 
+      static char_type
       to_char_type(const int_type& __c)
       { return static_cast<char_type>(__c); }
 
       // To keep both the byte 0xff and the eof symbol 0xffffffff
       // from ending up as 0xffffffff.
-      static int_type 
+      static int_type
       to_int_type(const char_type& __c)
       { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
 
-      static bool 
+      static bool
       eq_int_type(const int_type& __c1, const int_type& __c2)
       { return __c1 == __c2; }
 
-      static int_type 
+      static int_type
       eof() { return static_cast<int_type>(EOF); }
 
-      static int_type 
+      static int_type
       not_eof(const int_type& __c)
       { return (__c == eof()) ? 0 : __c; }
   };
@@ -306,20 +306,20 @@ namespace std
       typedef streamoff         off_type;
       typedef wstreampos        pos_type;
       typedef mbstate_t         state_type;
-      
-      static void 
+
+      static void
       assign(char_type& __c1, const char_type& __c2)
       { __c1 = __c2; }
 
-      static bool 
+      static bool
       eq(const char_type& __c1, const char_type& __c2)
       { return __c1 == __c2; }
 
-      static bool 
+      static bool
       lt(const char_type& __c1, const char_type& __c2)
       { return __c1 < __c2; }
 
-      static int 
+      static int
       compare(const char_type* __s1, const char_type* __s2, size_t __n)
       { return wmemcmp(__s1, __s2, __n); }
 
@@ -327,36 +327,36 @@ namespace std
       length(const char_type* __s)
       { return wcslen(__s); }
 
-      static const char_type* 
+      static const char_type*
       find(const char_type* __s, size_t __n, const char_type& __a)
       { return wmemchr(__s, __a, __n); }
 
-      static char_type* 
+      static char_type*
       move(char_type* __s1, const char_type* __s2, size_t __n)
       { return wmemmove(__s1, __s2, __n); }
 
-      static char_type* 
+      static char_type*
       copy(char_type* __s1, const char_type* __s2, size_t __n)
       { return wmemcpy(__s1, __s2, __n); }
 
-      static char_type* 
+      static char_type*
       assign(char_type* __s, size_t __n, char_type __a)
       { return wmemset(__s, __a, __n); }
 
-      static char_type 
+      static char_type
       to_char_type(const int_type& __c) { return char_type(__c); }
 
-      static int_type 
+      static int_type
       to_int_type(const char_type& __c) { return int_type(__c); }
 
-      static bool 
+      static bool
       eq_int_type(const int_type& __c1, const int_type& __c2)
       { return __c1 == __c2; }
 
-      static int_type 
+      static int_type
       eof() { return static_cast<int_type>(WEOF); }
 
-      static int_type 
+      static int_type
       not_eof(const int_type& __c)
       { return eq_int_type(__c, eof()) ? 0 : __c; }
   };
@@ -368,7 +368,7 @@ namespace std
       _CharT _M_c;
       _Char_traits_match(_CharT const& __c) : _M_c(__c) { }
 
-      bool 
+      bool
       operator()(_CharT const& __a) { return _Traits::eq(_M_c, __a); }
     };
 } // namespace std
index 33d2b95..56b5553 100644 (file)
    *  functions.
   */
   template<typename _InternT, typename _ExternT, typename _StateT>
-    class __codecvt_abstract_base 
+    class __codecvt_abstract_base
     : public locale::facet, public codecvt_base
     {
     public:
       // Types:
       typedef codecvt_base::result     result;
-      typedef _InternT                         intern_type;
-      typedef _ExternT                         extern_type;
-      typedef _StateT                          state_type;
-      
+      typedef _InternT                 intern_type;
+      typedef _ExternT                 extern_type;
+      typedef _StateT                  state_type;
+
       // 22.2.1.5.1 codecvt members
       /**
        *  @brief  Convert from internal to external character set.
        *  @return  codecvt_base::result.
       */
       result
-      out(state_type& __state, const intern_type* __from, 
+      out(state_type& __state, const intern_type* __from,
          const intern_type* __from_end, const intern_type*& __from_next,
-         extern_type* __to, extern_type* __to_end, 
+         extern_type* __to, extern_type* __to_end,
          extern_type*& __to_next) const
-      { 
-       return this->do_out(__state, __from, __from_end, __from_next, 
-                           __to, __to_end, __to_next); 
+      {
+       return this->do_out(__state, __from, __from_end, __from_next,
+                           __to, __to_end, __to_next);
       }
 
       /**
        *  @return  codecvt_base::result.
       */
       result
-      in(state_type& __state, const extern_type* __from, 
+      in(state_type& __state, const extern_type* __from,
         const extern_type* __from_end, const extern_type*& __from_next,
-        intern_type* __to, intern_type* __to_end, 
+        intern_type* __to, intern_type* __to_end,
         intern_type*& __to_next) const
-      { 
+      {
        return this->do_in(__state, __from, __from_end, __from_next,
-                          __to, __to_end, __to_next); 
+                          __to, __to_end, __to_next);
       }
 
-      int 
+      int
       encoding() const throw()
       { return this->do_encoding(); }
 
-      bool 
+      bool
       always_noconv() const throw()
       { return this->do_always_noconv(); }
 
             const extern_type* __end, size_t __max) const
       { return this->do_length(__state, __from, __end, __max); }
 
-      int 
+      int
       max_length() const throw()
       { return this->do_max_length(); }
 
     protected:
-      explicit 
+      explicit
       __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { }
 
-      virtual 
+      virtual
       ~__codecvt_abstract_base() { }
 
       /**
        *  the value returned.  @see out for more information.
       */
       virtual result
-      do_out(state_type& __state, const intern_type* __from, 
+      do_out(state_type& __state, const intern_type* __from,
             const intern_type* __from_end, const intern_type*& __from_next,
             extern_type* __to, extern_type* __to_end,
             extern_type*& __to_next) const = 0;
 
       virtual result
-      do_unshift(state_type& __state, extern_type* __to, 
+      do_unshift(state_type& __state, extern_type* __to,
                 extern_type* __to_end, extern_type*& __to_next) const = 0;
-      
+
       virtual result
-      do_in(state_type& __state, const extern_type* __from, 
-           const extern_type* __from_end, const extern_type*& __from_next, 
-           intern_type* __to, intern_type* __to_end, 
+      do_in(state_type& __state, const extern_type* __from,
+           const extern_type* __from_end, const extern_type*& __from_next,
+           intern_type* __to, intern_type* __to_end,
            intern_type*& __to_next) const = 0;
-      
-      virtual int 
+
+      virtual int
       do_encoding() const throw() = 0;
 
-      virtual bool 
+      virtual bool
       do_always_noconv() const throw() = 0;
 
-      virtual int 
-      do_length(state_type&, const extern_type* __from, 
+      virtual int
+      do_length(state_type&, const extern_type* __from,
                const extern_type* __end, size_t __max) const = 0;
 
-      virtual int 
+      virtual int
       do_max_length() const throw() = 0;
     };
 
   // 22.2.1.5 Template class codecvt
   // NB: Generic, mostly useless implementation.
   template<typename _InternT, typename _ExternT, typename _StateT>
-    class codecvt 
+    class codecvt
     : public __codecvt_abstract_base<_InternT, _ExternT, _StateT>
     {
-    public:      
+    public:
       // Types:
       typedef codecvt_base::result     result;
-      typedef _InternT                         intern_type;
-      typedef _ExternT                         extern_type;
-      typedef _StateT                          state_type;
+      typedef _InternT                 intern_type;
+      typedef _ExternT                 extern_type;
+      typedef _StateT                  state_type;
 
     protected:
       __c_locale                       _M_c_locale_codecvt;
 
     public:
-      static locale::id                id;
+      static locale::id                        id;
 
-      explicit 
-      codecvt(size_t __refs = 0) 
+      explicit
+      codecvt(size_t __refs = 0)
       : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs) { }
 
-      explicit 
+      explicit
       codecvt(__c_locale __cloc, size_t __refs = 0);
 
     protected:
-      virtual 
+      virtual
       ~codecvt() { }
 
       virtual result
-      do_out(state_type& __state, const intern_type* __from, 
+      do_out(state_type& __state, const intern_type* __from,
             const intern_type* __from_end, const intern_type*& __from_next,
             extern_type* __to, extern_type* __to_end,
             extern_type*& __to_next) const;
 
       virtual result
-      do_unshift(state_type& __state, extern_type* __to, 
+      do_unshift(state_type& __state, extern_type* __to,
                 extern_type* __to_end, extern_type*& __to_next) const;
-      
+
       virtual result
-      do_in(state_type& __state, const extern_type* __from, 
-           const extern_type* __from_end, const extern_type*& __from_next, 
-           intern_type* __to, intern_type* __to_end, 
+      do_in(state_type& __state, const extern_type* __from,
+           const extern_type* __from_end, const extern_type*& __from_next,
+           intern_type* __to, intern_type* __to_end,
            intern_type*& __to_next) const;
-      
-      virtual int 
+
+      virtual int
       do_encoding() const throw();
 
-      virtual bool 
+      virtual bool
       do_always_noconv() const throw();
 
-      virtual int 
-      do_length(state_type&, const extern_type* __from, 
+      virtual int
+      do_length(state_type&, const extern_type* __from,
                const extern_type* __end, size_t __max) const;
 
-      virtual int 
+      virtual int
       do_max_length() const throw();
     };
 
 
   // codecvt<char, char, mbstate_t> required specialization
   template<>
-    class codecvt<char, char, mbstate_t> 
+    class codecvt<char, char, mbstate_t>
     : public __codecvt_abstract_base<char, char, mbstate_t>
     {
-    public:      
+    public:
       // Types:
-      typedef char                     intern_type;
-      typedef char                     extern_type;
-      typedef mbstate_t                state_type;
+      typedef char                     intern_type;
+      typedef char                     extern_type;
+      typedef mbstate_t                        state_type;
 
     protected:
       __c_locale                       _M_c_locale_codecvt;
     public:
       static locale::id id;
 
-      explicit 
+      explicit
       codecvt(size_t __refs = 0);
 
-      explicit 
+      explicit
       codecvt(__c_locale __cloc, size_t __refs = 0);
 
     protected:
-      virtual 
+      virtual
       ~codecvt();
 
       virtual result
-      do_out(state_type& __state, const intern_type* __from, 
+      do_out(state_type& __state, const intern_type* __from,
             const intern_type* __from_end, const intern_type*& __from_next,
             extern_type* __to, extern_type* __to_end,
             extern_type*& __to_next) const;
 
       virtual result
-      do_unshift(state_type& __state, extern_type* __to, 
+      do_unshift(state_type& __state, extern_type* __to,
                 extern_type* __to_end, extern_type*& __to_next) const;
 
       virtual result
-      do_in(state_type& __state, const extern_type* __from, 
+      do_in(state_type& __state, const extern_type* __from,
            const extern_type* __from_end, const extern_type*& __from_next,
-           intern_type* __to, intern_type* __to_end, 
+           intern_type* __to, intern_type* __to_end,
            intern_type*& __to_next) const;
 
-      virtual int 
+      virtual int
       do_encoding() const throw();
 
-      virtual bool 
+      virtual bool
       do_always_noconv() const throw();
 
-      virtual int 
-      do_length(state_type&, const extern_type* __from, 
+      virtual int
+      do_length(state_type&, const extern_type* __from,
                const extern_type* __end, size_t __max) const;
 
-      virtual int 
+      virtual int
       do_max_length() const throw();
   };
 
 #ifdef _GLIBCXX_USE_WCHAR_T
   // codecvt<wchar_t, char, mbstate_t> required specialization
   template<>
-    class codecvt<wchar_t, char, mbstate_t> 
+    class codecvt<wchar_t, char, mbstate_t>
     : public __codecvt_abstract_base<wchar_t, char, mbstate_t>
     {
     public:
       // Types:
-      typedef wchar_t                  intern_type;
-      typedef char                     extern_type;
-      typedef mbstate_t                state_type;
+      typedef wchar_t                  intern_type;
+      typedef char                     extern_type;
+      typedef mbstate_t                        state_type;
 
     protected:
       __c_locale                       _M_c_locale_codecvt;
 
     public:
-      static locale::id                id;
+      static locale::id                        id;
 
-      explicit 
+      explicit
       codecvt(size_t __refs = 0);
 
-      explicit 
+      explicit
       codecvt(__c_locale __cloc, size_t __refs = 0);
 
     protected:
-      virtual 
+      virtual
       ~codecvt();
 
       virtual result
-      do_out(state_type& __state, const intern_type* __from, 
+      do_out(state_type& __state, const intern_type* __from,
             const intern_type* __from_end, const intern_type*& __from_next,
             extern_type* __to, extern_type* __to_end,
             extern_type*& __to_next) const;
             intern_type* __to, intern_type* __to_end,
             intern_type*& __to_next) const;
 
-      virtual 
+      virtual
       int do_encoding() const throw();
 
-      virtual 
+      virtual
       bool do_always_noconv() const throw();
 
-      virtual 
+      virtual
       int do_length(state_type&, const extern_type* __from,
                    const extern_type* __end, size_t __max) const;
 
-      virtual int 
+      virtual int
       do_max_length() const throw();
     };
 #endif //_GLIBCXX_USE_WCHAR_T
     class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
     {
     public:
-      explicit 
-      codecvt_byname(const char* __s, size_t __refs = 0) 
+      explicit
+      codecvt_byname(const char* __s, size_t __refs = 0)
       : codecvt<_InternT, _ExternT, _StateT>(__refs)
-      { 
+      {
        if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
          {
            _S_destroy_c_locale(this->_M_c_locale_codecvt);
-           _S_create_c_locale(this->_M_c_locale_codecvt, __s); 
+           _S_create_c_locale(this->_M_c_locale_codecvt, __s);
          }
       }
 
     protected:
-      virtual 
+      virtual
       ~codecvt_byname() { }
     };
 
index 68b9ab7..fe67881 100644 (file)
@@ -27,7 +27,7 @@
 // the GNU General Public License.  This exception does not however
 // invalidate any other reasons why the executable file might be covered by
 // the GNU General Public License.
+
 #ifndef _CONCURRENCE
 #define _CONCURRENCE 1
 
@@ -47,8 +47,8 @@ __GTHREAD_MUTEX_INIT_FUNCTION(&NAME)
 # define __glibcxx_mutex_unlock(LOCK) __gthread_mutex_unlock(&LOCK)
 #else
 # define __glibcxx_mutex_define_initialized(NAME)
-# define __glibcxx_mutex_lock(LOCK) 
-# define __glibcxx_mutex_unlock(LOCK) 
+# define __glibcxx_mutex_lock(LOCK)
+# define __glibcxx_mutex_unlock(LOCK)
 #endif
 
 #endif
index 00fe560..7a0e65f 100644 (file)
@@ -139,7 +139,7 @@ namespace std
        _M_type = 1
       };
     };
-  
+
   template<>
     struct __is_integer<char>
     {
@@ -157,7 +157,7 @@ namespace std
        _M_type = 1
       };
     };
-  
+
   template<>
   struct __is_integer<unsigned char>
   {
@@ -177,7 +177,7 @@ namespace std
     };
   };
 # endif
-  
+
   template<>
   struct __is_integer<short>
   {
index 2c24016..021276a 100644 (file)
@@ -73,7 +73,7 @@ namespace __gnu_cxx
       int M_start_pos;
       substitution_nt M_type;
       int M_number_of_prefixes;
-      
+
       substitution_st(int start_pos,
                      substitution_nt type,
                      int number_of_prefixes)
@@ -209,7 +209,7 @@ namespace __gnu_cxx
       class qualifier_list
       {
        typedef typename Allocator::template rebind<char>::other
-         char_Allocator;
+         char_Allocator;
        typedef std::basic_string<char, std::char_traits<char>, char_Allocator>
          string_type;
 
@@ -250,7 +250,7 @@ namespace __gnu_cxx
 
        void
        add_qualifier_start(param_qualifier_nt param_qualifier,
-                           int start_pos,
+                           int start_pos,
                            string_type optional_type,
                            int inside_substitution)
        { M_qualifier_starts.
@@ -259,7 +259,7 @@ namespace __gnu_cxx
 
        void
        decode_qualifiers(string_type& prefix,
-                         string_type& postfix,
+                         string_type& postfix,
                          bool member_function_pointer_qualifiers) const;
 
        bool
@@ -307,7 +307,7 @@ namespace __gnu_cxx
        // Use (void) instead of ():                    int f(void)
 
         static unsigned int const style_literal = 2;
-       // Default behaviour:                           (long)13, 
+       // Default behaviour:                           (long)13,
        //                                              (unsigned long long)19
        // Use extensions 'u', 'l' and 'll' for integral
        // literals (as in template arguments):         13l, 19ull
@@ -352,7 +352,7 @@ namespace __gnu_cxx
       {
        friend class qualifier_list<Allocator>;
        typedef typename Allocator::template rebind<char>::other
-           char_Allocator;
+           char_Allocator;
        typedef std::basic_string<char, std::char_traits<char>, char_Allocator>
            string_type;
 
@@ -498,7 +498,7 @@ namespace __gnu_cxx
          int n = M_substitutions_pos.size() - 1;
          if (n > 0)
            substitution_name += (n <= 10) ? (char)(n + '0' - 1)
-                                          : (char)(n + 'A' - 11);
+                                          : (char)(n + 'A' - 11);
          substitution_name += '_';
          string_type subst;
          int saved_pos = M_pos;
@@ -1051,56 +1051,56 @@ namespace __gnu_cxx
       }
 
     // <operator-name> ::=
-    //   nw                            # new           
+    //   nw                            # new
     //   na                            # new[]
-    //   dl                            # delete        
-    //   da                            # delete[]      
+    //   dl                            # delete
+    //   da                            # delete[]
     //   ps                            # + (unary)
-    //   ng                            # - (unary)     
-    //   ad                            # & (unary)     
-    //   de                            # * (unary)     
-    //   co                            # ~             
-    //   pl                            # +             
-    //   mi                            # -             
-    //   ml                            # *             
-    //   dv                            # /             
-    //   rm                            # %             
-    //   an                            # &             
-    //   or                            # |             
-    //   eo                            # ^             
-    //   aS                            # =             
-    //   pL                            # +=            
-    //   mI                            # -=            
-    //   mL                            # *=            
-    //   dV                            # /=            
-    //   rM                            # %=            
-    //   aN                            # &=            
-    //   oR                            # |=            
-    //   eO                            # ^=            
-    //   ls                            # <<            
-    //   rs                            # >>            
-    //   lS                            # <<=           
-    //   rS                            # >>=           
-    //   eq                            # ==            
-    //   ne                            # !=            
-    //   lt                            # <             
-    //   gt                            # >             
-    //   le                            # <=            
-    //   ge                            # >=            
-    //   nt                            # !             
-    //   aa                            # &&            
-    //   oo                            # ||            
-    //   pp                            # ++            
-    //   mm                            # --            
-    //   cm                            # ,             
-    //   pm                            # ->*           
-    //   pt                            # ->            
-    //   cl                            # ()            
-    //   ix                            # []            
+    //   ng                            # - (unary)
+    //   ad                            # & (unary)
+    //   de                            # * (unary)
+    //   co                            # ~
+    //   pl                            # +
+    //   mi                            # -
+    //   ml                            # *
+    //   dv                            # /
+    //   rm                            # %
+    //   an                            # &
+    //   or                            # |
+    //   eo                            # ^
+    //   aS                            # =
+    //   pL                            # +=
+    //   mI                            # -=
+    //   mL                            # *=
+    //   dV                            # /=
+    //   rM                            # %=
+    //   aN                            # &=
+    //   oR                            # |=
+    //   eO                            # ^=
+    //   ls                            # <<
+    //   rs                            # >>
+    //   lS                            # <<=
+    //   rS                            # >>=
+    //   eq                            # ==
+    //   ne                            # !=
+    //   lt                            # <
+    //   gt                            # >
+    //   le                            # <=
+    //   ge                            # >=
+    //   nt                            # !
+    //   aa                            # &&
+    //   oo                            # ||
+    //   pp                            # ++
+    //   mm                            # --
+    //   cm                            # ,
+    //   pm                            # ->*
+    //   pt                            # ->
+    //   cl                            # ()
+    //   ix                            # []
     //   qu                            # ?
     //   st                            # sizeof (a type)
     //   sz                            # sizeof (an expression)
-    //   cv <type>                     # (cast)        
+    //   cv <type>                     # (cast)
     //   v <digit> <source-name>       # vendor extended operator
     //
     // Symbol operator codes exist of two characters, we need to find a
@@ -1579,15 +1579,15 @@ namespace __gnu_cxx
     //   <builtin-type>                # Starts with a lower case character != r.
     //   <function-type>       # Starts with F
     //   <class-enum-type>     # Starts with N, S, C, D, Z, a digit or a lower
-    //                         # case character.  Since a lower case character
-    //                         # would be an operator name, that would be an
-    //                         # error.  The S is a substitution or St
-    //                         # (::std::).  A 'C' would be a constructor and
-    //                         # thus also an error.
+    //                         # case character.  Since a lower case character
+    //                         # would be an operator name, that would be an
+    //                         # error.  The S is a substitution or St
+    //                         # (::std::).  A 'C' would be a constructor and
+    //                         # thus also an error.
     //   <template-param>      # Starts with T
     //   <substitution>         # Starts with S
     //   <template-template-param> <template-args>  # Starts with T or S,
-    //                                             # equivalent with the above.
+    //                                             # equivalent with the above.
     //
     //   <array-type>                  # Starts with A
     //   <pointer-to-member-type>      # Starts with M
@@ -1596,8 +1596,8 @@ namespace __gnu_cxx
     //   R <type>   # reference-to     # Starts with R
     //   C <type>   # complex (C 2000) # Starts with C
     //   G <type>   # imaginary (C 2000)# Starts with G
-    //   U <source-name> <type>        # vendor extended type qualifier,
-    //                                 # starts with U
+    //   U <source-name> <type>                # vendor extended type qualifier,
+    //                                 # starts with U
     //
     // <template-template-param> ::= <template-param>
     //                           ::= <substitution>
@@ -1613,9 +1613,9 @@ namespace __gnu_cxx
     // <I> is the array index.
     //                                         Substitutions:
     // <Q>M<C><Q2>F<R><B>E  ==> R (C::*Q)B Q2  "<C>", "F<R><B>E"
-    //                                                     (<R> and <B> recursive),
-    //                                                     "M<C><Q2>F<R><B>E".
-    // <Q>F<R><B>E         ==> R (Q)B          "<R>", "<B>" (<B> recursive)
+    //                                             (<R> and <B> recursive),
+    //                                             "M<C><Q2>F<R><B>E".
+    // <Q>F<R><B>E         ==> R (Q)B          "<R>", "<B>" (<B> recursive)
     //                                              and "F<R><B>E".
     //
     // Note that if <R> has postfix qualifiers (an array or function), then
@@ -1623,14 +1623,14 @@ namespace __gnu_cxx
     // <Q>FPA<R><B>E ==> R (*(Q)B) [], where the PA added the prefix
     // "(*" and the postfix ") []".
     //
-    // <Q>G<T>             ==> imaginary T Q   "<T>", "G<T>" (<T> recursive).
-    // <Q>C<T>             ==> complex T Q     "<T>", "C<T>" (<T> recursive).
-    // <Q><T>              ==> T Q             "<T>" (<T> recursive).
+    // <Q>G<T>             ==> imaginary T Q   "<T>", "G<T>" (<T> recursive).
+    // <Q>C<T>             ==> complex T Q     "<T>", "C<T>" (<T> recursive).
+    // <Q><T>              ==> T Q             "<T>" (<T> recursive).
     //
     // where <Q> is any of:
     //
-    // <Q>P            ==> *Q                          "P..."
-    // <Q>R            ==> &Q                          "R..."
+    // <Q>P            ==> *Q                          "P..."
+    // <Q>R            ==> &Q                          "R..."
     // <Q>[K|V|r]+     ==> [ const| volatile| restrict]+Q      "KVr..."
     // <Q>U<S>         ==>  SQ                         "U<S>..."
     // <Q>M<C>         ==> C::*Q                       "M<C>..." (<C> recurs.)
@@ -1641,7 +1641,7 @@ namespace __gnu_cxx
     //   A<I2>A<I>     ==>  [I2][I]
     //   If <Q> ends on [KVr]+, which can happen in combination with
     //   substitutions only, then special handling is required, see below.
-    //  
+    //
     // A <substitution> is handled with an input position switch during which
     // new substitutions are turned off.  Because recursive handling of types
     // (and therefore the order in which substitutions must be generated) must
@@ -1653,7 +1653,7 @@ namespace __gnu_cxx
     //
     // The following comment was for the demangling of g++ version 3.0.x.  The
     // mangling (and I believe even the ABI description) have been fixed now
-    // (as of g++ version 3.1).        
+    // (as of g++ version 3.1).
     //
     // g++ 3.0.x only:
     // The ABI specifies for pointer-to-member function types the format
@@ -1696,7 +1696,7 @@ namespace __gnu_cxx
     static int const cvq_A = 8;                // Saw at least one A
     static int const cvq_last = 16;    // No remaining qualifiers.
     static int const cvq_A_cnt = 32;   // Bit 5 and higher represent the
-                                       //   number of A's in the series.
+                                       //   number of A's in the series.
     // In the function below, iter_array points to the first (right most)
     // A in the series, if any.
     template<typename Allocator>
@@ -2011,9 +2011,9 @@ namespace __gnu_cxx
        }
        if (!failure)
        {
-         // <Q>G<T>                    ==> imaginary T Q
+         // <Q>G<T>                    ==> imaginary T Q
          //     substitutions: "<T>", "G<T>" (<T> recursive).
-         // <Q>C<T>                    ==> complex T Q
+         // <Q>C<T>                    ==> complex T Q
          //     substitutions: "<T>", "C<T>" (<T> recursive).
          if (current() == 'C' || current() == 'G')
          {
@@ -2034,8 +2034,8 @@ namespace __gnu_cxx
              bool extern_C = (next() == 'Y');
              if (extern_C)
                eat_current();
-               
-             // <Q>F<R><B>E            ==> R (Q)B
+
+             // <Q>F<R><B>E            ==> R (Q)B
              //     substitution: "<R>", "<B>" (<B> recursive) and "F<R><B>E".
 
              // Return type.
@@ -2143,7 +2143,7 @@ namespace __gnu_cxx
            case '7':
            case '8':
            case '9':
-             // <Q><T>                 ==> T Q
+             // <Q><T>                 ==> T Q
              //     substitutions: "<T>" (<T> recursive).
              if (!decode_class_enum_type(prefix))
              {
@@ -2161,7 +2161,7 @@ namespace __gnu_cxx
                qualifiers->printing_suppressed();
              break;
            default:
-             // <Q><T>                 ==> T Q
+             // <Q><T>                 ==> T Q
              //     substitutions: "<T>" (<T> recursive).
              if (!decode_builtin_type(prefix))
              {
@@ -2246,7 +2246,7 @@ namespace __gnu_cxx
            {
              // substitution: "<template-prefix> <template-args>".
              add_substitution(substitution_start, nested_name_prefix,
-                              number_of_prefixes);
+                              number_of_prefixes);
            }
          }
          else
@@ -2348,7 +2348,7 @@ namespace __gnu_cxx
 
     // <unqualified-name> ::= <operator-name>  # Starts with lower case.
     //                    ::= <ctor-dtor-name>  # Starts with 'C' or 'D'.
-    //                    ::= <source-name>    # Starts with a digit.
+    //                    ::= <source-name>    # Starts with a digit.
     //
     template<typename Allocator>
       bool
@@ -2446,8 +2446,8 @@ namespace __gnu_cxx
     //   <unscoped-template-name> <template-args> # idem
     //   <local-name>                          # Starts with 'Z'
     //   <unscoped-name>                       # Starts with 'S', 'C', 'D',
-    //                                         # a digit or a lower case
-    //                                         # character.
+    //                                         # a digit or a lower case
+    //                                         # character.
     //
     // <unscoped-template-name> ::= <unscoped-name>
     //                          ::= <substitution>
@@ -2488,7 +2488,7 @@ namespace __gnu_cxx
 
     // <call-offset> ::= h <nv-offset> _
     //               ::= v <v-offset> _
-    // <nv-offset>   ::= <offset number> 
+    // <nv-offset>   ::= <offset number>
     //     non-virtual base override
     //
     // <v-offset>    ::= <offset number> _ <virtual offset number>
@@ -2538,10 +2538,10 @@ namespace __gnu_cxx
     //   TS <type>                     # typeinfo name (null-terminated
     //                                    byte string).
     //   GV <object name>              # Guard variable for one-time
-    //                                   initialization of static objects in
-    //                                   a local scope.
+    //                                   initialization of static objects in
+    //                                   a local scope.
     //   T <call-offset> <base encoding># base is the nominal target function
-    //                                   of thunk.
+    //                                   of thunk.
     //   Tc <call-offset> <call-offset> <base encoding> # base is the nominal
     //                                    target function of thunk; first
     //                                    call-offset is 'this' adjustment;
@@ -2629,8 +2629,8 @@ namespace __gnu_cxx
 
     // <encoding> ::=
     //   <function name> <bare-function-type>  # Starts with 'C', 'D', 'N',
-    //                                           'S', a digit or a lower case
-    //                                           character.
+    //                                           'S', a digit or a lower case
+    //                                           character.
     //   <data name>                           # Idem.
     //   <special-name>                                # Starts with 'T' or 'G'.
     template<typename Allocator>
@@ -2691,7 +2691,7 @@ namespace __gnu_cxx
     struct demangle
     {
       typedef typename Allocator::template rebind<char>::other char_Allocator;
-      typedef std::basic_string<char, std::char_traits<char>, char_Allocator> 
+      typedef std::basic_string<char, std::char_traits<char>, char_Allocator>
          string_type;
       static string_type symbol(char const* in,
                                 demangler::implementation_details const& id);
@@ -2769,7 +2769,7 @@ namespace __gnu_cxx
            || demangler_session.remaining_input_characters())
        {
          // Failure to demangle, return the mangled name.
-         result = input;                               
+         result = input;
        }
       }
       return result;
index 2f26edf..a30c851 100644 (file)
@@ -62,7 +62,7 @@
 #define _DEQUE_TCC 1
 
 namespace __gnu_norm
-{ 
+{
   template <typename _Tp, typename _Alloc>
     deque<_Tp,_Alloc>&
     deque<_Tp,_Alloc>::
@@ -82,10 +82,10 @@ namespace __gnu_norm
            }
        }
       return *this;
-    }        
-  
+    }
+
   template <typename _Tp, typename _Alloc>
-    typename deque<_Tp,_Alloc>::iterator 
+    typename deque<_Tp,_Alloc>::iterator
     deque<_Tp,_Alloc>::
     insert(iterator position, const value_type& __x)
     {
@@ -104,9 +104,9 @@ namespace __gnu_norm
       else
         return _M_insert_aux(position, __x);
     }
-  
+
   template <typename _Tp, typename _Alloc>
-    typename deque<_Tp,_Alloc>::iterator 
+    typename deque<_Tp,_Alloc>::iterator
     deque<_Tp,_Alloc>::
     erase(iterator __position)
     {
@@ -125,9 +125,9 @@ namespace __gnu_norm
        }
       return this->_M_start + __index;
     }
-  
+
   template <typename _Tp, typename _Alloc>
-    typename deque<_Tp,_Alloc>::iterator 
+    typename deque<_Tp,_Alloc>::iterator
     deque<_Tp,_Alloc>::
     erase(iterator __first, iterator __last)
     {
@@ -160,8 +160,8 @@ namespace __gnu_norm
          return this->_M_start + __elems_before;
        }
     }
-    
-  template <typename _Tp, typename _Alloc> 
+
+  template <typename _Tp, typename _Alloc>
     void
     deque<_Tp,_Alloc>::
     clear()
@@ -173,7 +173,7 @@ namespace __gnu_norm
          std::_Destroy(*__node, *__node + _S_buffer_size());
          _M_deallocate_node(*__node);
        }
-    
+
       if (this->_M_start._M_node != this->_M_finish._M_node)
        {
          std::_Destroy(this->_M_start._M_cur, this->_M_start._M_last);
@@ -182,10 +182,10 @@ namespace __gnu_norm
        }
       else
         std::_Destroy(this->_M_start._M_cur, this->_M_finish._M_cur);
-      
+
       this->_M_finish = this->_M_start;
     }
-    
+
   template <typename _Tp, class _Alloc>
     template <typename _InputIterator>
       void
@@ -201,7 +201,7 @@ namespace __gnu_norm
         else
           insert(end(), __first, __last);
       }
-    
+
   template <typename _Tp, typename _Alloc>
     void
     deque<_Tp,_Alloc>::
@@ -232,14 +232,14 @@ namespace __gnu_norm
          catch(...)
            {
              _M_destroy_nodes(this->_M_finish._M_node + 1,
-                              __new_finish._M_node + 1);    
+                              __new_finish._M_node + 1);
              __throw_exception_again;
            }
        }
-      else 
+      else
         _M_insert_aux(__pos, __n, __x);
     }
-    
+
   template <typename _Tp, typename _Alloc>
     void
     deque<_Tp,_Alloc>::
@@ -262,7 +262,7 @@ namespace __gnu_norm
           __throw_exception_again;
         }
     }
-    
+
   template <typename _Tp, typename _Alloc>
     template <typename _InputIterator>
       void
@@ -282,7 +282,7 @@ namespace __gnu_norm
             __throw_exception_again;
           }
       }
-    
+
   template <typename _Tp, typename _Alloc>
     template <typename _ForwardIterator>
       void
@@ -292,12 +292,12 @@ namespace __gnu_norm
       {
         const size_type __n = std::distance(__first, __last);
         this->_M_initialize_map(__n);
-      
+
         _Map_pointer __cur_node;
         try
           {
-            for (__cur_node = this->_M_start._M_node; 
-                 __cur_node < this->_M_finish._M_node; 
+            for (__cur_node = this->_M_start._M_node;
+                 __cur_node < this->_M_finish._M_node;
                  ++__cur_node)
             {
               _ForwardIterator __mid = __first;
@@ -313,7 +313,7 @@ namespace __gnu_norm
             __throw_exception_again;
           }
       }
-    
+
   // Called only if _M_finish._M_cur == _M_finish._M_last - 1.
   template <typename _Tp, typename _Alloc>
     void
@@ -335,7 +335,7 @@ namespace __gnu_norm
           __throw_exception_again;
         }
     }
-    
+
   // Called only if _M_start._M_cur == _M_start._M_first.
   template <typename _Tp, typename _Alloc>
     void
@@ -357,8 +357,8 @@ namespace __gnu_norm
           _M_deallocate_node(*(this->_M_start._M_node - 1));
           __throw_exception_again;
         }
-    } 
-    
+    }
+
   // Called only if _M_finish._M_cur == _M_finish._M_first.
   template <typename _Tp, typename _Alloc>
     void deque<_Tp,_Alloc>::
@@ -369,10 +369,10 @@ namespace __gnu_norm
       this->_M_finish._M_cur = this->_M_finish._M_last - 1;
       std::_Destroy(this->_M_finish._M_cur);
     }
-    
-  // Called only if _M_start._M_cur == _M_start._M_last - 1.  Note that 
-  // if the deque has at least one element (a precondition for this member 
-  // function), and if _M_start._M_cur == _M_start._M_last, then the deque 
+
+  // Called only if _M_start._M_cur == _M_start._M_last - 1.  Note that
+  // if the deque has at least one element (a precondition for this member
+  // function), and if _M_start._M_cur == _M_start._M_last, then the deque
   // must have at least two nodes.
   template <typename _Tp, typename _Alloc>
     void deque<_Tp,_Alloc>::
@@ -382,8 +382,8 @@ namespace __gnu_norm
       _M_deallocate_node(this->_M_start._M_first);
       this->_M_start._M_set_node(this->_M_start._M_node + 1);
       this->_M_start._M_cur = this->_M_start._M_first;
-    }      
-    
+    }
+
   template <typename _Tp, typename _Alloc>
     template <typename _InputIterator>
       void
@@ -392,7 +392,7 @@ namespace __gnu_norm
                           _InputIterator __first, _InputIterator __last,
                           input_iterator_tag)
       { std::copy(__first, __last, std::inserter(*this, __pos)); }
-    
+
   template <typename _Tp, typename _Alloc>
     template <typename _ForwardIterator>
       void
@@ -434,7 +434,7 @@ namespace __gnu_norm
         else
           _M_insert_aux(__pos, __first, __last, __n);
       }
-    
+
   template <typename _Tp, typename _Alloc>
     typename deque<_Tp, _Alloc>::iterator
     deque<_Tp,_Alloc>::
@@ -467,7 +467,7 @@ namespace __gnu_norm
       *__pos = __x_copy;
       return __pos;
     }
-    
+
   template <typename _Tp, typename _Alloc>
     void
     deque<_Tp,_Alloc>::
@@ -495,14 +495,14 @@ namespace __gnu_norm
              else
                {
                  std::__uninitialized_copy_fill(this->_M_start, __pos,
-                                                __new_start, 
+                                                __new_start,
                                                 this->_M_start, __x_copy);
                  this->_M_start = __new_start;
                  std::fill(__old_start, __pos, __x_copy);
                }
            }
          catch(...)
-           { 
+           {
              _M_destroy_nodes(__new_start._M_node, this->_M_start._M_node);
              __throw_exception_again;
            }
@@ -511,7 +511,7 @@ namespace __gnu_norm
        {
          iterator __new_finish = _M_reserve_elements_at_back(__n);
          iterator __old_finish = this->_M_finish;
-         const difference_type __elems_after = 
+         const difference_type __elems_after =
            difference_type(__length) - __elems_before;
          __pos = this->_M_finish - __elems_after;
          try
@@ -536,14 +536,14 @@ namespace __gnu_norm
                }
            }
          catch(...)
-           { 
+           {
              _M_destroy_nodes(this->_M_finish._M_node + 1,
                               __new_finish._M_node + 1);
              __throw_exception_again;
            }
        }
     }
-  
+
   template <typename _Tp, typename _Alloc>
     template <typename _ForwardIterator>
       void
@@ -563,7 +563,7 @@ namespace __gnu_norm
              {
                if (__elemsbefore >= difference_type(__n))
                  {
-                   iterator __start_n = this->_M_start + difference_type(__n); 
+                   iterator __start_n = this->_M_start + difference_type(__n);
                    std::uninitialized_copy(this->_M_start, __start_n,
                                            __new_start);
                    this->_M_start = __new_start;
@@ -590,7 +590,7 @@ namespace __gnu_norm
         {
           iterator __new_finish = _M_reserve_elements_at_back(__n);
           iterator __old_finish = this->_M_finish;
-          const difference_type __elemsafter = 
+          const difference_type __elemsafter =
             difference_type(__length) - __elemsbefore;
           __pos = this->_M_finish - __elemsafter;
           try
@@ -624,7 +624,7 @@ namespace __gnu_norm
             }
         }
       }
-    
+
   template <typename _Tp, typename _Alloc>
     void
     deque<_Tp,_Alloc>::
@@ -642,11 +642,11 @@ namespace __gnu_norm
       catch(...)
         {
           for (size_type __j = 1; __j < __i; ++__j)
-            _M_deallocate_node(*(this->_M_start._M_node - __j));      
+            _M_deallocate_node(*(this->_M_start._M_node - __j));
           __throw_exception_again;
         }
     }
-    
+
   template <typename _Tp, typename _Alloc>
     void
     deque<_Tp,_Alloc>::
@@ -664,11 +664,11 @@ namespace __gnu_norm
       catch(...)
         {
           for (size_type __j = 1; __j < __i; ++__j)
-            _M_deallocate_node(*(this->_M_finish._M_node + __j));      
+            _M_deallocate_node(*(this->_M_finish._M_node + __j));
           __throw_exception_again;
         }
     }
-    
+
   template <typename _Tp, typename _Alloc>
     void
     deque<_Tp,_Alloc>::
@@ -677,12 +677,12 @@ namespace __gnu_norm
       size_type __old_num_nodes
        = this->_M_finish._M_node - this->_M_start._M_node + 1;
       size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
-    
+
       _Map_pointer __new_nstart;
       if (this->_M_map_size > 2 * __new_num_nodes)
        {
          __new_nstart = this->_M_map + (this->_M_map_size
-                                        - __new_num_nodes) / 2 
+                                        - __new_num_nodes) / 2
                         + (__add_at_front ? __nodes_to_add : 0);
          if (__new_nstart < this->_M_start._M_node)
            std::copy(this->_M_start._M_node,
@@ -690,7 +690,7 @@ namespace __gnu_norm
                    __new_nstart);
          else
            std::copy_backward(this->_M_start._M_node,
-                              this->_M_finish._M_node + 1, 
+                              this->_M_finish._M_node + 1,
                               __new_nstart + __old_num_nodes);
        }
       else
@@ -698,7 +698,7 @@ namespace __gnu_norm
          size_type __new_map_size = this->_M_map_size
                                     + std::max(this->_M_map_size,
                                                __nodes_to_add) + 2;
-    
+
          _Map_pointer __new_map = this->_M_allocate_map(__new_map_size);
          __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
                         + (__add_at_front ? __nodes_to_add : 0);
@@ -706,11 +706,11 @@ namespace __gnu_norm
                    this->_M_finish._M_node + 1,
                    __new_nstart);
          _M_deallocate_map(this->_M_map, this->_M_map_size);
-         
+
          this->_M_map = __new_map;
          this->_M_map_size = __new_map_size;
        }
-      
+
       this->_M_start._M_set_node(__new_nstart);
       this->_M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
     }
index f28160c..9022b58 100644 (file)
@@ -73,20 +73,20 @@ namespace std
 
   template<typename _CharT, typename _Traits>
     basic_filebuf<_CharT, _Traits>::
-    basic_filebuf() : __streambuf_type(), _M_file(&_M_lock), 
+    basic_filebuf() : __streambuf_type(), _M_file(&_M_lock),
     _M_mode(ios_base::openmode(0)), _M_state_beg(), _M_state_cur(),
     _M_state_last(), _M_buf(NULL), _M_buf_size(BUFSIZ),
     _M_buf_allocated(false), _M_reading(false), _M_writing(false),
     _M_pback_cur_save(0), _M_pback_end_save(0), _M_pback_init(false),
     _M_codecvt(0), _M_ext_buf(0), _M_ext_buf_size(0), _M_ext_next(0),
     _M_ext_end(0)
-    { 
+    {
       if (has_facet<__codecvt_type>(this->_M_buf_locale))
        _M_codecvt = &use_facet<__codecvt_type>(this->_M_buf_locale);
     }
 
   template<typename _CharT, typename _Traits>
-    typename basic_filebuf<_CharT, _Traits>::__filebuf_type* 
+    typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
     basic_filebuf<_CharT, _Traits>::
     open(const char* __s, ios_base::openmode __mode)
     {
@@ -108,8 +108,8 @@ namespace std
              _M_state_last = _M_state_cur = _M_state_beg;
 
              // 27.8.1.3,4
-             if ((__mode & ios_base::ate) 
-                 && this->seekoff(0, ios_base::end, __mode) 
+             if ((__mode & ios_base::ate)
+                 && this->seekoff(0, ios_base::end, __mode)
                  == pos_type(off_type(-1)))
                this->close();
              else
@@ -120,7 +120,7 @@ namespace std
     }
 
   template<typename _CharT, typename _Traits>
-    typename basic_filebuf<_CharT, _Traits>::__filebuf_type* 
+    typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
     basic_filebuf<_CharT, _Traits>::
     close() throw()
     {
@@ -135,7 +135,7 @@ namespace std
            }
          catch(...)
            { __testfail = true; }
-             
+
          // NB: Do this here so that re-opened filebufs will be cool...
          this->_M_mode = ios_base::openmode(0);
          this->_M_pback_init = false;
@@ -144,7 +144,7 @@ namespace std
          _M_writing = false;
          _M_set_buffer(-1);
          _M_state_last = _M_state_cur = _M_state_beg;
-         
+
          if (!_M_file.close())
            __testfail = true;
 
@@ -155,7 +155,7 @@ namespace std
     }
 
   template<typename _CharT, typename _Traits>
-    streamsize 
+    streamsize
     basic_filebuf<_CharT, _Traits>::
     showmanyc()
     {
@@ -173,7 +173,7 @@ namespace std
     }
 
   template<typename _CharT, typename _Traits>
-    typename basic_filebuf<_CharT, _Traits>::int_type 
+    typename basic_filebuf<_CharT, _Traits>::int_type
     basic_filebuf<_CharT, _Traits>::
     underflow()
     {
@@ -192,15 +192,15 @@ namespace std
          // Get and convert input sequence.
          const size_t __buflen = this->_M_buf_size > 1
                                  ? this->_M_buf_size - 1 : 1;
-         
+
          // Will be set to true if ::read() returns 0 indicating EOF.
          bool __got_eof = false;
          // Number of internal characters produced.
          streamsize __ilen = 0;
-         codecvt_base::result __r = codecvt_base::ok;    
+         codecvt_base::result __r = codecvt_base::ok;
          if (__check_facet(_M_codecvt).always_noconv())
            {
-             __ilen = _M_file.xsgetn(reinterpret_cast<char*>(this->eback()), 
+             __ilen = _M_file.xsgetn(reinterpret_cast<char*>(this->eback()),
                                      __buflen);
              if (__ilen == 0)
                __got_eof = true;
@@ -226,7 +226,7 @@ namespace std
              // chars already present.
              if (_M_reading && this->egptr() == this->eback() && __remainder)
                __rlen = 0;
-      
+
              // Allocate buffer if necessary and move unconverted
              // bytes to front.
              if (_M_ext_buf_size < __blen)
@@ -269,7 +269,7 @@ namespace std
 
                  char_type* __iend;
                  __r = _M_codecvt->in(_M_state_cur, _M_ext_next,
-                                      _M_ext_end, _M_ext_next, this->eback(), 
+                                      _M_ext_end, _M_ext_next, this->eback(),
                                       this->eback() + __buflen, __iend);
                  if (__r == codecvt_base::noconv)
                    {
@@ -302,7 +302,7 @@ namespace std
          else if (__got_eof)
            {
              // If the actual end of file is reached, set 'uncommitted'
-             // mode, thus allowing an immediate write without an 
+             // mode, thus allowing an immediate write without an
              // intervening seek.
              _M_set_buffer(-1);
              _M_reading = false;
@@ -317,13 +317,13 @@ namespace std
                                "invalid byte sequence in file"));
          else
            __throw_ios_failure(__N("basic_filebuf::underflow "
-                               "error reading the file"));         
+                               "error reading the file"));
        }
       return __ret;
     }
 
   template<typename _CharT, typename _Traits>
-    typename basic_filebuf<_CharT, _Traits>::int_type 
+    typename basic_filebuf<_CharT, _Traits>::int_type
     basic_filebuf<_CharT, _Traits>::
     pbackfail(int_type __i)
     {
@@ -333,7 +333,7 @@ namespace std
        {
          // Remember whether the pback buffer is active, otherwise below
          // we may try to store in it a second char (libstdc++/9761).
-         const bool __testpb = this->_M_pback_init;       
+         const bool __testpb = this->_M_pback_init;
          const bool __testeof = traits_type::eq_int_type(__i, __ret);
          int_type __tmp;
          if (this->eback() < this->gptr())
@@ -367,7 +367,7 @@ namespace std
            {
              _M_create_pback();
              _M_reading = true;
-             *this->gptr() = traits_type::to_char_type(__i); 
+             *this->gptr() = traits_type::to_char_type(__i);
              __ret = __i;
            }
        }
@@ -375,7 +375,7 @@ namespace std
     }
 
   template<typename _CharT, typename _Traits>
-    typename basic_filebuf<_CharT, _Traits>::int_type 
+    typename basic_filebuf<_CharT, _Traits>::int_type
     basic_filebuf<_CharT, _Traits>::
     overflow(int_type __c)
     {
@@ -392,7 +392,7 @@ namespace std
                  *this->pptr() = traits_type::to_char_type(__c);
                  this->pbump(1);
                }
-             
+
              // Convert pending sequence to external representation,
              // and output.
              if (_M_convert_to_external(this->pbase(),
@@ -422,7 +422,7 @@ namespace std
              // Unbuffered.
              char_type __conv = traits_type::to_char_type(__c);
              if (__testeof || _M_convert_to_external(&__conv, 1))
-               {                 
+               {
                  _M_writing = true;
                  __ret = traits_type::not_eof(__c);
                }
@@ -430,7 +430,7 @@ namespace std
        }
       return __ret;
     }
-  
+
   template<typename _CharT, typename _Traits>
     bool
     basic_filebuf<_CharT, _Traits>::
@@ -456,7 +456,7 @@ namespace std
          codecvt_base::result __r;
          __r = _M_codecvt->out(_M_state_cur, __ibuf, __ibuf + __ilen,
                                __iend, __buf, __buf + __blen, __bend);
-         
+
          if (__r == codecvt_base::ok || __r == codecvt_base::partial)
            __blen = __bend - __buf;
          else if (__r == codecvt_base::noconv)
@@ -470,20 +470,20 @@ namespace std
              // Result == error.
              __blen = 0;
            }
-         
+
          if (__blen)
            {
              __elen += _M_file.xsputn(__buf, __blen);
              __plen += __blen;
            }
-         
+
          // Try once more for partial conversions.
          if (__r == codecvt_base::partial)
            {
              const char_type* __iresume = __iend;
              streamsize __rlen = this->pptr() - __iend;
              __r = _M_codecvt->out(_M_state_cur, __iresume,
-                                   __iresume + __rlen, __iend, __buf, 
+                                   __iresume + __rlen, __iend, __buf,
                                    __buf + __blen, __bend);
              if (__r != codecvt_base::error)
                {
@@ -500,7 +500,7 @@ namespace std
      streamsize
      basic_filebuf<_CharT, _Traits>::
      xsputn(const _CharT* __s, streamsize __n)
-     { 
+     {
        // Optimization in the always_noconv() case, to be generalized in the
        // future: when __n is sufficiently large we write directly instead of
        // using the buffer.
@@ -523,7 +523,7 @@ namespace std
              const streamsize __buffill = this->pptr() - this->pbase();
              const char* __buf = reinterpret_cast<const char*>(this->pbase());
              __ret = _M_file.xsputn_2(__buf, __buffill,
-                                      reinterpret_cast<const char*>(__s), 
+                                      reinterpret_cast<const char*>(__s),
                                       __n);
              if (__ret == __buffill + __n)
                {
@@ -539,12 +539,12 @@ namespace std
            __ret = __streambuf_type::xsputn(__s, __n);
        }
        else
-        __ret = __streambuf_type::xsputn(__s, __n);      
+        __ret = __streambuf_type::xsputn(__s, __n);
        return __ret;
     }
 
   template<typename _CharT, typename _Traits>
-    typename basic_filebuf<_CharT, _Traits>::__streambuf_type* 
+    typename basic_filebuf<_CharT, _Traits>::__streambuf_type*
     basic_filebuf<_CharT, _Traits>::
     setbuf(char_type* __s, streamsize __n)
     {
@@ -564,9 +564,9 @@ namespace std
            this->_M_buf = __s;
            this->_M_buf_size = __n;
          }
-      return this; 
+      return this;
     }
-  
+
 
   // According to 27.8.1.4 p11 - 13, seekoff should ignore the last
   // argument (of type openmode).
@@ -581,9 +581,9 @@ namespace std
       if (__width < 0)
        __width = 0;
 
-      pos_type __ret =  pos_type(off_type(-1)); 
+      pos_type __ret =  pos_type(off_type(-1));
       const bool __testfail = __off != 0 && __width <= 0;
-      if (this->is_open() && !__testfail) 
+      if (this->is_open() && !__testfail)
        {
          // Ditch any pback buffers to avoid confusion.
          _M_destroy_pback();
@@ -608,10 +608,10 @@ namespace std
                    _M_codecvt->length(_M_state_last, _M_ext_buf, _M_ext_next,
                                       this->gptr() - this->eback());
                  __computed_off += _M_ext_buf + __gptr_off - _M_ext_end;
-                 
+
                  // _M_state_last is modified by codecvt::length() so
-                 // it now corresponds to gptr().
-                 __state = _M_state_last;
+                 // it now corresponds to gptr().
+                 __state = _M_state_last;
                }
            }
          __ret = _M_seek(__computed_off, __way, __state);
@@ -628,8 +628,8 @@ namespace std
     basic_filebuf<_CharT, _Traits>::
     seekpos(pos_type __pos, ios_base::openmode)
     {
-      pos_type __ret =  pos_type(off_type(-1)); 
-      if (this->is_open()) 
+      pos_type __ret =  pos_type(off_type(-1));
+      if (this->is_open())
        {
          // Ditch any pback buffers to avoid confusion.
          _M_destroy_pback();
@@ -645,9 +645,9 @@ namespace std
     {
       pos_type __ret = pos_type(off_type(-1));
       if (_M_terminate_output())
-       {         
+       {
          // Returns pos_type(off_type(-1)) in case of failure.
-         __ret = pos_type(_M_file.seekoff(__off, __way));        
+         __ret = pos_type(_M_file.seekoff(__off, __way));
          _M_reading = false;
          _M_writing = false;
          _M_ext_next = _M_ext_end = _M_ext_buf;
@@ -671,9 +671,9 @@ namespace std
          if (traits_type::eq_int_type(__tmp, traits_type::eof()))
            __testvalid = false;
        }
-             
+
       // Part two: output unshift sequence.
-      if (_M_writing && !__check_facet(_M_codecvt).always_noconv() 
+      if (_M_writing && !__check_facet(_M_codecvt).always_noconv()
          && __testvalid)
        {
          // Note: this value is arbitrary, since there is no way to
@@ -694,7 +694,7 @@ namespace std
              else if (__r == codecvt_base::ok ||
                       __r == codecvt_base::partial)
                {
-                 __ilen = __next - __buf;                
+                 __ilen = __next - __buf;
                  if (__ilen > 0)
                    {
                      const streamsize __elen = _M_file.xsputn(__buf, __ilen);
@@ -733,7 +733,7 @@ namespace std
          const int_type __tmp = this->overflow();
          if (traits_type::eq_int_type(__tmp, traits_type::eof()))
            __ret = -1;
-       }      
+       }
       return __ret;
     }
 
@@ -745,8 +745,8 @@ namespace std
       bool __testvalid = true;
 
       const __codecvt_type* _M_codecvt_tmp = 0;
-      if (__builtin_expect(has_facet<__codecvt_type>(__loc), true))          
-       _M_codecvt_tmp = &use_facet<__codecvt_type>(__loc);      
+      if (__builtin_expect(has_facet<__codecvt_type>(__loc), true))
+       _M_codecvt_tmp = &use_facet<__codecvt_type>(__loc);
 
       if (this->is_open())
        {
@@ -768,7 +768,7 @@ namespace std
                  else
                    {
                      // External position corresponding to gptr().
-                     _M_ext_next = _M_ext_buf 
+                     _M_ext_next = _M_ext_buf
                        + _M_codecvt->length(_M_state_last, _M_ext_buf, _M_ext_next,
                                             this->gptr() - this->eback());
                      const streamsize __remainder = _M_ext_end - _M_ext_next;
@@ -791,7 +791,7 @@ namespace std
     }
 
   // Inhibit implicit instantiations for required instantiations,
-  // which are defined via explicit instantiations elsewhere.  
+  // which are defined via explicit instantiations elsewhere.
   // NB:  This syntax is a GNU extension.
 #if _GLIBCXX_EXTERN_TEMPLATE
   extern template class basic_filebuf<char>;
@@ -808,4 +808,4 @@ namespace std
 #endif
 } // namespace std
 
-#endif 
+#endif
index eac2c95..8b1d16c 100644 (file)
 
 namespace std
 {
-  // Helper for exception objects in <except> 
+  // Helper for exception objects in <except>
   void
   __throw_bad_exception(void);
 
-  // Helper for exception objects in <new> 
+  // Helper for exception objects in <new>
   void
   __throw_bad_alloc(void);
 
-  // Helper for exception objects in <typeinfo> 
+  // Helper for exception objects in <typeinfo>
   void
   __throw_bad_cast(void);
 
   void
   __throw_bad_typeid(void);
 
-  // Helpers for exception objects in <stdexcept> 
+  // Helpers for exception objects in <stdexcept>
   void
   __throw_logic_error(const char* __s);
 
index 43cdc16..ea8a9b4 100644 (file)
@@ -41,7 +41,7 @@
 #pragma GCC system_header
 
 namespace std {
-    
+
   /**
    *  @brief  Class defining multi-dimensional subset of an array.
    *
@@ -90,7 +90,7 @@ namespace std {
       // XXX: See the note above.
       ///  Assignment operator.
       gslice& operator=(const gslice&);
-        
+
       ///  Return array offset of first slice element.
       size_t           start() const;
 
@@ -99,7 +99,7 @@ namespace std {
 
       ///  Return array of array strides for each dimension.
       valarray<size_t> stride() const;
-        
+
     private:
       struct _Indexer {
        size_t _M_count;
@@ -114,22 +114,22 @@ namespace std {
       };
 
       _Indexer* _M_index;
-        
+
       template<typename _Tp> friend class valarray;
     };
-    
+
     inline size_t
     gslice::start () const
     { return _M_index ? _M_index->_M_start : 0; }
-    
+
     inline valarray<size_t>
     gslice::size () const
     { return _M_index ? _M_index->_M_size : valarray<size_t>(); }
-    
+
     inline valarray<size_t>
     gslice::stride () const
     { return _M_index ? _M_index->_M_stride : valarray<size_t>(); }
-    
+
     inline gslice::gslice () : _M_index(0) {}
 
     inline
@@ -140,7 +140,7 @@ namespace std {
     inline
     gslice::gslice(const gslice& __g) : _M_index(__g._M_index)
     { if (_M_index) _M_index->_M_increment_use(); }
-    
+
     inline
     gslice::~gslice()
     { if (_M_index && _M_index->_M_decrement_use() == 0) delete _M_index; }
@@ -153,8 +153,8 @@ namespace std {
         _M_index = __g._M_index;
         return *this;
     }
-            
-    
+
+
 } // std::
 
 
index 60e5b37..292eaec 100644 (file)
@@ -108,13 +108,13 @@ namespace std {
         void operator<<=(const _Expr<_Dom,_Tp>&) const;
       template<class _Dom>
         void operator>>=(const _Expr<_Dom,_Tp>&) const;
-        
+
     private:
       _Array<_Tp>    _M_array;
       const valarray<size_t>& _M_index;
-        
+
       friend class valarray<_Tp>;
-      
+
       gslice_array(_Array<_Tp>, const valarray<size_t>&);
 
       // this constructor needs to be implemented.
@@ -141,13 +141,13 @@ namespace std {
     gslice_array<_Tp>::gslice_array(const gslice_array<_Tp>& __a)
       : _M_array(__a._M_array), _M_index(__a._M_index) {}
 
-    
+
   template<typename _Tp>
     inline void
     gslice_array<_Tp>::operator=(const _Tp& __t) const
-    { 
+    {
       std::__valarray_fill(_M_array, _Array<size_t>(_M_index),
-                          _M_index.size(), __t); 
+                          _M_index.size(), __t);
     }
 
   template<typename _Tp>
@@ -178,8 +178,8 @@ namespace std {
     }                                                                  \
                                                                        \
   template<typename _Tp>                                                \
-    template<class _Dom>                                               \
-      inline void                                                      \
+    template<class _Dom>                                               \
+      inline void                                                      \
       gslice_array<_Tp>::operator _Op##= (const _Expr<_Dom, _Tp>& __e) const\
       {                                                                        \
        _Array_augmented_##_Name(_M_array, _Array<size_t>(_M_index), __e,\
@@ -187,9 +187,9 @@ namespace std {
       }
 
 _DEFINE_VALARRAY_OPERATOR(*, __multiplies)
-_DEFINE_VALARRAY_OPERATOR(/, __divides)    
+_DEFINE_VALARRAY_OPERATOR(/, __divides)
 _DEFINE_VALARRAY_OPERATOR(%, __modulus)
-_DEFINE_VALARRAY_OPERATOR(+, __plus)    
+_DEFINE_VALARRAY_OPERATOR(+, __plus)
 _DEFINE_VALARRAY_OPERATOR(-, __minus)
 _DEFINE_VALARRAY_OPERATOR(^, __bitwise_xor)
 _DEFINE_VALARRAY_OPERATOR(&, __bitwise_and)
index 7e9632e..7f240a9 100644 (file)
@@ -67,7 +67,7 @@ namespace std
       ///  Assignment operator.  Assigns elements to corresponding elements
       ///  of @a a.
       indirect_array& operator=(const indirect_array&);
-       
+
       ///  Assign slice elements to corresponding elements of @a v.
       void operator=(const valarray<_Tp>&) const;
       ///  Multiply slice elements by corresponding elements of @a v.
@@ -75,11 +75,11 @@ namespace std
       ///  Divide slice elements by corresponding elements of @a v.
       void operator/=(const valarray<_Tp>&) const;
       ///  Modulo slice elements by corresponding elements of @a v.
-      void operator%=(const valarray<_Tp>&) const; 
+      void operator%=(const valarray<_Tp>&) const;
       ///  Add corresponding elements of @a v to slice elements.
       void operator+=(const valarray<_Tp>&) const;
       ///  Subtract corresponding elements of @a v from slice elements.
-      void operator-=(const valarray<_Tp>&) const;  
+      void operator-=(const valarray<_Tp>&) const;
       ///  Logical xor slice elements with corresponding elements of @a v.
       void operator^=(const valarray<_Tp>&) const;
       ///  Logical and slice elements with corresponding elements of @a v.
@@ -89,11 +89,11 @@ namespace std
       ///  Left shift slice elements by corresponding elements of @a v.
       void operator<<=(const valarray<_Tp>&) const;
       ///  Right shift slice elements by corresponding elements of @a v.
-      void operator>>=(const valarray<_Tp>&) const; 
+      void operator>>=(const valarray<_Tp>&) const;
       ///  Assign all slice elements to @a t.
       void operator= (const _Tp&) const;
       //    ~indirect_array();
-       
+
       template<class _Dom>
       void operator=(const _Expr<_Dom, _Tp>&) const;
       template<class _Dom>
@@ -115,7 +115,7 @@ namespace std
       template<class _Dom>
       void operator<<=(const _Expr<_Dom, _Tp>&) const;
       template<class _Dom>
-      void operator>>=(const _Expr<_Dom, _Tp>&) const; 
+      void operator>>=(const _Expr<_Dom, _Tp>&) const;
 
     private:
       ///  Copy constructor.  Both slices refer to the same underlying array.
@@ -124,23 +124,23 @@ namespace std
 
       friend class valarray<_Tp>;
       friend class gslice_array<_Tp>;
-       
-      const size_t      _M_sz;
+
+      const size_t      _M_sz;
       const _Array<size_t> _M_index;
-      const _Array<_Tp>         _M_array;
-       
+      const _Array<_Tp>         _M_array;
+
       // not implemented
       indirect_array();
     };
 
   template<typename _Tp>
-    inline 
+    inline
     indirect_array<_Tp>::indirect_array(const indirect_array<_Tp>& __a)
       : _M_sz(__a._M_sz), _M_index(__a._M_index), _M_array(__a._M_array) {}
 
   template<typename _Tp>
      inline
-     indirect_array<_Tp>::indirect_array(_Array<_Tp> __a, size_t __s, 
+     indirect_array<_Tp>::indirect_array(_Array<_Tp> __a, size_t __s,
                                         _Array<size_t> __i)
        : _M_sz(__s), _M_index(__i), _M_array(__a) {}
 
index b937ac5..3c05be0 100644 (file)
@@ -54,93 +54,93 @@ namespace std
   // expressions involving them are no longer compile-time constants.
   enum _Ios_Fmtflags { _S_ios_fmtflags_end = 1L << 16 };
 
-  inline _Ios_Fmtflags 
+  inline _Ios_Fmtflags
   operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
   { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
 
-  inline _Ios_Fmtflags 
+  inline _Ios_Fmtflags
   operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
   { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
 
-  inline _Ios_Fmtflags 
+  inline _Ios_Fmtflags
   operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
   { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
 
-  inline _Ios_Fmtflags 
+  inline _Ios_Fmtflags
   operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
   { return __a = __a | __b; }
 
-  inline _Ios_Fmtflags 
+  inline _Ios_Fmtflags
   operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
   { return __a = __a & __b; }
 
-  inline _Ios_Fmtflags 
+  inline _Ios_Fmtflags
   operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
   { return __a = __a ^ __b; }
 
-  inline _Ios_Fmtflags 
+  inline _Ios_Fmtflags
   operator~(_Ios_Fmtflags __a)
   { return _Ios_Fmtflags(~static_cast<int>(__a)); }
 
 
   enum _Ios_Openmode { _S_ios_openmode_end = 1L << 16 };
 
-  inline _Ios_Openmode 
+  inline _Ios_Openmode
   operator&(_Ios_Openmode __a, _Ios_Openmode __b)
   { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
 
-  inline _Ios_Openmode 
+  inline _Ios_Openmode
   operator|(_Ios_Openmode __a, _Ios_Openmode __b)
   { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
 
-  inline _Ios_Openmode 
+  inline _Ios_Openmode
   operator^(_Ios_Openmode __a, _Ios_Openmode __b)
   { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
 
-  inline _Ios_Openmode 
+  inline _Ios_Openmode
   operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
   { return __a = __a | __b; }
 
-  inline _Ios_Openmode 
+  inline _Ios_Openmode
   operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
   { return __a = __a & __b; }
 
-  inline _Ios_Openmode 
+  inline _Ios_Openmode
   operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
   { return __a = __a ^ __b; }
 
-  inline _Ios_Openmode 
+  inline _Ios_Openmode
   operator~(_Ios_Openmode __a)
   { return _Ios_Openmode(~static_cast<int>(__a)); }
 
 
   enum _Ios_Iostate { _S_ios_iostate_end = 1L << 16 };
 
-  inline _Ios_Iostate 
+  inline _Ios_Iostate
   operator&(_Ios_Iostate __a, _Ios_Iostate __b)
   { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
 
-  inline _Ios_Iostate 
+  inline _Ios_Iostate
   operator|(_Ios_Iostate __a, _Ios_Iostate __b)
   { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
 
-  inline _Ios_Iostate 
+  inline _Ios_Iostate
   operator^(_Ios_Iostate __a, _Ios_Iostate __b)
   { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
 
-  inline _Ios_Iostate 
+  inline _Ios_Iostate
   operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
   { return __a = __a | __b; }
 
-  inline _Ios_Iostate 
+  inline _Ios_Iostate
   operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
   { return __a = __a & __b; }
 
-  inline _Ios_Iostate 
+  inline _Ios_Iostate
   operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
   { return __a = __a ^ __b; }
 
-  inline _Ios_Iostate 
+  inline _Ios_Iostate
   operator~(_Ios_Iostate __a)
   { return _Ios_Iostate(~static_cast<int>(__a)); }
 
@@ -158,7 +158,7 @@ namespace std
   class ios_base
   {
   public:
-    
+
     // 27.4.2.1.1  Class ios_base::failure
     /// These are thrown to indicate problems.  Doc me.
     class failure : public exception
@@ -166,17 +166,17 @@ namespace std
     public:
       // _GLIBCXX_RESOLVE_LIB_DEFECTS
       // 48.  Use of non-existent exception constructor
-      explicit 
+      explicit
       failure(const string& __str) throw();
 
       // This declaration is not useless:
       // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
-      virtual 
+      virtual
       ~failure() throw();
 
       virtual const char*
       what() const throw();
-      
+
     private:
       string _M_msg;
     };
@@ -286,18 +286,18 @@ namespace std
 
     /// Indicates a loss of integrity in an input or output sequence (such
     /// as an irrecoverable read error from a file).
-    static const iostate badbit =      iostate(__ios_flags::_S_badbit);
+    static const iostate badbit =      iostate(__ios_flags::_S_badbit);
 
     /// Indicates that an input operation reached the end of an input sequence.
-    static const iostate eofbit =      iostate(__ios_flags::_S_eofbit);
+    static const iostate eofbit =      iostate(__ios_flags::_S_eofbit);
 
     /// Indicates that an input operation failed to read the expected
     /// characters, or that an output operation failed to generate the
     /// desired characters.
-    static const iostate failbit =     iostate(__ios_flags::_S_failbit);
+    static const iostate failbit =     iostate(__ios_flags::_S_failbit);
 
     /// Indicates all is well.
-    static const iostate goodbit =     iostate(0);
+    static const iostate goodbit =     iostate(0);
 
     // 27.4.2.1.4  Type ios_base::openmode
     /**
@@ -316,25 +316,25 @@ namespace std
     typedef _Ios_Openmode openmode;
 
     /// Seek to end before each write.
-    static const openmode app =        openmode(__ios_flags::_S_app);
+    static const openmode app =                openmode(__ios_flags::_S_app);
 
     /// Open and seek to end immediately after opening.
-    static const openmode ate =        openmode(__ios_flags::_S_ate);
+    static const openmode ate =                openmode(__ios_flags::_S_ate);
 
     /// Perform input and output in binary mode (as opposed to text mode).
     /// This is probably not what you think it is; see
     /// http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#3 and
     /// http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#7 for more.
-    static const openmode binary =     openmode(__ios_flags::_S_bin);
+    static const openmode binary =     openmode(__ios_flags::_S_bin);
 
     /// Open for input.  Default for @c ifstream and fstream.
-    static const openmode in =         openmode(__ios_flags::_S_in);
+    static const openmode in =         openmode(__ios_flags::_S_in);
 
     /// Open for output.  Default for @c ofstream and fstream.
-    static const openmode out =        openmode(__ios_flags::_S_out);
+    static const openmode out =                openmode(__ios_flags::_S_out);
 
     /// Open for input.  Default for @c ofstream.
-    static const openmode trunc =      openmode(__ios_flags::_S_trunc);
+    static const openmode trunc =      openmode(__ios_flags::_S_trunc);
 
     // 27.4.2.1.5  Type ios_base::seekdir
     /**
@@ -349,20 +349,20 @@ namespace std
     typedef _Ios_Seekdir seekdir;
 
     /// Request a seek relative to the beginning of the stream.
-    static const seekdir beg =                 seekdir(0);
+    static const seekdir beg =         seekdir(0);
 
     /// Request a seek relative to the current position within the sequence.
-    static const seekdir cur =                 seekdir(SEEK_CUR);
+    static const seekdir cur =         seekdir(SEEK_CUR);
 
     /// Request a seek relative to the current end of the sequence.
-    static const seekdir end =                 seekdir(SEEK_END);
+    static const seekdir end =         seekdir(SEEK_END);
 
 #ifdef _GLIBCXX_DEPRECATED
     // Annex D.6
     typedef int io_state;
     typedef int open_mode;
     typedef int seek_dir;
-    
+
     typedef std::streampos streampos;
     typedef std::streamoff streamoff;
 #endif
@@ -403,7 +403,7 @@ namespace std
      *  function are allowed.  If there are multiple callbacks, they are
      *  invoked in the order they were registered.
     */
-    void 
+    void
     register_callback(event_callback __fn, int __index);
 
   protected:
@@ -413,11 +413,11 @@ namespace std
      *  ios_base data members (doc me)
      *  @endif
     */
-    streamsize                 _M_precision;
-    streamsize                 _M_width;
-    fmtflags           _M_flags;
-    iostate            _M_exception;
-    iostate            _M_streambuf_state;
+    streamsize         _M_precision;
+    streamsize         _M_width;
+    fmtflags           _M_flags;
+    iostate            _M_exception;
+    iostate            _M_streambuf_state;
     //@}
 
     // 27.4.2.6  Members for callbacks
@@ -425,58 +425,58 @@ namespace std
     struct _Callback_list
     {
       // Data Members
-      _Callback_list*          _M_next;
-      ios_base::event_callback         _M_fn;
-      int                      _M_index;
+      _Callback_list*          _M_next;
+      ios_base::event_callback _M_fn;
+      int                      _M_index;
       _Atomic_word             _M_refcount;  // 0 means one reference.
-    
-      _Callback_list(ios_base::event_callback __fn, int __index, 
+
+      _Callback_list(ios_base::event_callback __fn, int __index,
                     _Callback_list* __cb)
       : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
-      
-      void 
+
+      void
       _M_add_reference() { __atomic_add(&_M_refcount, 1); }
 
       // 0 => OK to delete.
-      int 
+      int
       _M_remove_reference() { return __exchange_and_add(&_M_refcount, -1); }
     };
 
-     _Callback_list*   _M_callbacks;
+     _Callback_list*   _M_callbacks;
 
-    void 
+    void
     _M_call_callbacks(event __ev) throw();
 
-    void 
+    void
     _M_dispose_callbacks(void);
 
     // 27.4.2.5  Members for iword/pword storage
-    struct _Words 
-    { 
-      void*    _M_pword; 
-      long     _M_iword; 
+    struct _Words
+    {
+      void*    _M_pword;
+      long     _M_iword;
       _Words() : _M_pword(0), _M_iword(0) { }
     };
 
     // Only for failed iword/pword calls.
-    _Words             _M_word_zero;    
+    _Words             _M_word_zero;
 
     // Guaranteed storage.
     // The first 5 iword and pword slots are reserved for internal use.
-    static const int   _S_local_word_size = 8;
-    _Words             _M_local_word[_S_local_word_size];  
+    static const int   _S_local_word_size = 8;
+    _Words             _M_local_word[_S_local_word_size];
 
     // Allocated storage.
-    int                _M_word_size;
-    _Words*            _M_word;
-    _Words& 
+    int                        _M_word_size;
+    _Words*            _M_word;
+
+    _Words&
     _M_grow_words(int __index, bool __iword);
 
     // Members for locale and locale caching.
-    locale             _M_ios_locale;
+    locale             _M_ios_locale;
 
-    void 
+    void
     _M_init();
 
   public:
@@ -484,14 +484,14 @@ namespace std
     // 27.4.2.1.6  Class ios_base::Init
     // Used to initialize standard streams. In theory, g++ could use
     // -finit-priority to order this stuff correctly without going
-    // through these machinations. 
-    class Init 
+    // through these machinations.
+    class Init
     {
       friend class ios_base;
     public:
       Init();
       ~Init();
-      
+
     private:
       static _Atomic_word      _S_refcount;
       static bool              _S_synced_with_stdio;
@@ -502,7 +502,7 @@ namespace std
      *  @brief  Access to format flags.
      *  @return  The format control flags for both input and output.
     */
-    inline fmtflags 
+    inline fmtflags
     flags() const { return _M_flags; }
 
     /**
@@ -512,12 +512,12 @@ namespace std
      *
      *  This function overwrites all the format flags with @a fmtfl.
     */
-    inline fmtflags 
+    inline fmtflags
     flags(fmtflags __fmtfl)
-    { 
-      fmtflags __old = _M_flags; 
-      _M_flags = __fmtfl; 
-      return __old; 
+    {
+      fmtflags __old = _M_flags;
+      _M_flags = __fmtfl;
+      return __old;
     }
 
     /**
@@ -528,12 +528,12 @@ namespace std
      *  This function sets additional flags in format control.  Flags that
      *  were previously set remain set.
     */
-    inline fmtflags 
+    inline fmtflags
     setf(fmtflags __fmtfl)
-    { 
-      fmtflags __old = _M_flags; 
-      _M_flags |= __fmtfl; 
-      return __old; 
+    {
+      fmtflags __old = _M_flags;
+      _M_flags |= __fmtfl;
+      return __old;
     }
 
     /**
@@ -545,7 +545,7 @@ namespace std
      *  This function clears @a mask in the format flags, then sets
      *  @a fmtfl @c & @a mask.  An example mask is @c ios_base::adjustfield.
     */
-    inline fmtflags 
+    inline fmtflags
     setf(fmtflags __fmtfl, fmtflags __mask)
     {
       fmtflags __old = _M_flags;
@@ -560,7 +560,7 @@ namespace std
      *
      *  This function clears @a mask in the format flags.
     */
-    inline void 
+    inline void
     unsetf(fmtflags __mask) { _M_flags &= ~__mask; }
 
     /**
@@ -572,7 +572,7 @@ namespace std
      *  DR 189.
      *  @endif
     */
-    inline streamsize 
+    inline streamsize
     precision() const { return _M_precision; }
 
     /**
@@ -580,12 +580,12 @@ namespace std
      *  @param  prec  The new precision value.
      *  @return  The previous value of precision().
     */
-    inline streamsize 
+    inline streamsize
     precision(streamsize __prec)
-    { 
-      streamsize __old = _M_precision; 
-      _M_precision = __prec; 
-      return __old; 
+    {
+      streamsize __old = _M_precision;
+      _M_precision = __prec;
+      return __old;
     }
 
     /**
@@ -594,7 +594,7 @@ namespace std
      *
      *  "Minimum field width" refers to the number of characters.
     */
-    inline streamsize 
+    inline streamsize
     width() const { return _M_width; }
 
     /**
@@ -602,12 +602,12 @@ namespace std
      *  @param  wide  The new width value.
      *  @return  The previous value of width().
     */
-    inline streamsize 
+    inline streamsize
     width(streamsize __wide)
-    { 
-      streamsize __old = _M_width; 
-      _M_width = __wide; 
-      return __old; 
+    {
+      streamsize __old = _M_width;
+      _M_width = __wide;
+      return __old;
     }
 
     // [27.4.2.4] ios_base static members
@@ -621,7 +621,7 @@ namespace std
      *  cout).  User-declared streams are unaffected.  See
      *  http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#8 for more.
     */
-    static bool 
+    static bool
     sync_with_stdio(bool __sync = true);
 
     // [27.4.2.3] ios_base locale functions
@@ -633,7 +633,7 @@ namespace std
      *  Sets the new locale for this stream, and then invokes each callback
      *  with imbue_event.
     */
-    locale 
+    locale
     imbue(const locale& __loc);
 
     /**
@@ -644,7 +644,7 @@ namespace std
      *  returns @c loc.  Otherwise, it returns a copy of @c std::locale(),
      *  the global C++ locale.
     */
-    inline locale 
+    inline locale
     getloc() const { return _M_ios_locale; }
 
     /**
@@ -654,7 +654,7 @@ namespace std
      *  Like getloc above, but returns a reference instead of
      *  generating a copy.
     */
-    inline const locale& 
+    inline const locale&
     _M_getloc() const { return _M_ios_locale; }
 
     // [27.4.2.5] ios_base storage functions
@@ -672,7 +672,7 @@ namespace std
      *  returned on each invocation.  xalloc is guaranteed to return an index
      *  that is safe to use in the iword and pword arrays.
     */
-    static int 
+    static int
     xalloc() throw();
 
     /**
@@ -688,10 +688,10 @@ namespace std
      *  obtain an index that is safe to use.  Also note that since the array
      *  can grow dynamically, it is not safe to hold onto the reference.
     */
-    inline long& 
+    inline long&
     iword(int __ix)
     {
-      _Words& __word = (__ix < _M_word_size) 
+      _Words& __word = (__ix < _M_word_size)
                        ? _M_word[__ix] : _M_grow_words(__ix, true);
       return __word._M_iword;
     }
@@ -709,10 +709,10 @@ namespace std
      *  obtain an index that is safe to use.  Also note that since the array
      *  can grow dynamically, it is not safe to hold onto the reference.
     */
-    inline void*& 
+    inline void*&
     pword(int __ix)
     {
-      _Words& __word = (__ix < _M_word_size) 
+      _Words& __word = (__ix < _M_word_size)
                        ? _M_word[__ix] : _M_grow_words(__ix, false);
       return __word._M_pword;
     }
@@ -736,13 +736,13 @@ namespace std
   private:
     ios_base(const ios_base&);
 
-    ios_base& 
+    ios_base&
     operator=(const ios_base&);
   };
+
   // [27.4.5.1] fmtflags manipulators
   /// Calls base.setf(ios_base::boolalpha).
-  inline ios_base& 
+  inline ios_base&
   boolalpha(ios_base& __base)
   {
     __base.setf(ios_base::boolalpha);
@@ -750,7 +750,7 @@ namespace std
   }
 
   /// Calls base.unsetf(ios_base::boolalpha).
-  inline ios_base& 
+  inline ios_base&
   noboolalpha(ios_base& __base)
   {
     __base.unsetf(ios_base::boolalpha);
@@ -758,7 +758,7 @@ namespace std
   }
 
   /// Calls base.setf(ios_base::showbase).
-  inline ios_base& 
+  inline ios_base&
   showbase(ios_base& __base)
   {
     __base.setf(ios_base::showbase);
@@ -766,7 +766,7 @@ namespace std
   }
 
   /// Calls base.unsetf(ios_base::showbase).
-  inline ios_base& 
+  inline ios_base&
   noshowbase(ios_base& __base)
   {
     __base.unsetf(ios_base::showbase);
@@ -774,7 +774,7 @@ namespace std
   }
 
   /// Calls base.setf(ios_base::showpoint).
-  inline ios_base& 
+  inline ios_base&
   showpoint(ios_base& __base)
   {
     __base.setf(ios_base::showpoint);
@@ -782,7 +782,7 @@ namespace std
   }
 
   /// Calls base.unsetf(ios_base::showpoint).
-  inline ios_base& 
+  inline ios_base&
   noshowpoint(ios_base& __base)
   {
     __base.unsetf(ios_base::showpoint);
@@ -790,7 +790,7 @@ namespace std
   }
 
   /// Calls base.setf(ios_base::showpos).
-  inline ios_base& 
+  inline ios_base&
   showpos(ios_base& __base)
   {
     __base.setf(ios_base::showpos);
@@ -798,7 +798,7 @@ namespace std
   }
 
   /// Calls base.unsetf(ios_base::showpos).
-  inline ios_base& 
+  inline ios_base&
   noshowpos(ios_base& __base)
   {
     __base.unsetf(ios_base::showpos);
@@ -806,15 +806,15 @@ namespace std
   }
 
   /// Calls base.setf(ios_base::skipws).
-  inline ios_base& 
+  inline ios_base&
   skipws(ios_base& __base)
   {
     __base.setf(ios_base::skipws);
     return __base;
   }
-  
+
   /// Calls base.unsetf(ios_base::skipws).
-  inline ios_base& 
+  inline ios_base&
   noskipws(ios_base& __base)
   {
     __base.unsetf(ios_base::skipws);
@@ -822,7 +822,7 @@ namespace std
   }
 
   /// Calls base.setf(ios_base::uppercase).
-  inline ios_base& 
+  inline ios_base&
   uppercase(ios_base& __base)
   {
     __base.setf(ios_base::uppercase);
@@ -830,7 +830,7 @@ namespace std
   }
 
   /// Calls base.unsetf(ios_base::uppercase).
-  inline ios_base& 
+  inline ios_base&
   nouppercase(ios_base& __base)
   {
     __base.unsetf(ios_base::uppercase);
@@ -838,57 +838,57 @@ namespace std
   }
 
   /// Calls base.setf(ios_base::unitbuf).
-  inline ios_base& 
+  inline ios_base&
   unitbuf(ios_base& __base)
   {
-     __base.setf(ios_base::unitbuf);      
+     __base.setf(ios_base::unitbuf);
      return __base;
   }
 
   /// Calls base.unsetf(ios_base::unitbuf).
-  inline ios_base& 
+  inline ios_base&
   nounitbuf(ios_base& __base)
   {
      __base.unsetf(ios_base::unitbuf);
-     return __base;    
+     return __base;
   }
 
   // [27.4.5.2] adjustfield anipulators
   /// Calls base.setf(ios_base::internal, ios_base::adjustfield).
-  inline ios_base& 
+  inline ios_base&
   internal(ios_base& __base)
   {
      __base.setf(ios_base::internal, ios_base::adjustfield);
-     return __base;    
+     return __base;
   }
 
   /// Calls base.setf(ios_base::left, ios_base::adjustfield).
-  inline ios_base& 
+  inline ios_base&
   left(ios_base& __base)
   {
     __base.setf(ios_base::left, ios_base::adjustfield);
     return __base;
   }
-  
+
   /// Calls base.setf(ios_base::right, ios_base::adjustfield).
-  inline ios_base& 
+  inline ios_base&
   right(ios_base& __base)
   {
     __base.setf(ios_base::right, ios_base::adjustfield);
     return __base;
   }
-  
+
   // [27.4.5.3] basefield anipulators
   /// Calls base.setf(ios_base::dec, ios_base::basefield).
-  inline ios_base& 
+  inline ios_base&
   dec(ios_base& __base)
   {
     __base.setf(ios_base::dec, ios_base::basefield);
     return __base;
   }
-  
+
   /// Calls base.setf(ios_base::hex, ios_base::basefield).
-  inline ios_base& 
+  inline ios_base&
   hex(ios_base& __base)
   {
     __base.setf(ios_base::hex, ios_base::basefield);
@@ -896,16 +896,16 @@ namespace std
   }
 
   /// Calls base.setf(ios_base::oct, ios_base::basefield).
-  inline ios_base& 
+  inline ios_base&
   oct(ios_base& __base)
   {
     __base.setf(ios_base::oct, ios_base::basefield);
     return __base;
   }
-  
+
   // [27.4.5.4] floatfield anipulators
   /// Calls base.setf(ios_base::fixed, ios_base::floatfield).
-  inline ios_base& 
+  inline ios_base&
   fixed(ios_base& __base)
   {
     __base.setf(ios_base::fixed, ios_base::floatfield);
@@ -913,7 +913,7 @@ namespace std
   }
 
   /// Calls base.setf(ios_base::scientific, ios_base::floatfield).
-  inline ios_base& 
+  inline ios_base&
   scientific(ios_base& __base)
   {
     __base.setf(ios_base::scientific, ios_base::floatfield);
index abe7950..3edb8cd 100644 (file)
 #include <locale>
 #include <ostream> // For flush()
 
-namespace std 
+namespace std
 {
   template<typename _CharT, typename _Traits>
     basic_istream<_CharT, _Traits>::sentry::
     sentry(basic_istream<_CharT, _Traits>& __in, bool __noskipws)
     {
       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-      if (__in.good()) 
+      if (__in.good())
        {
          if (__in.tie())
            __in.tie()->flush();
          if (!__noskipws && (__in.flags() & ios_base::skipws))
-           {     
+           {
              const __int_type __eof = traits_type::eof();
              __streambuf_type* __sb = __in.rdbuf();
              __int_type __c = __sb->sgetc();
 
              const __ctype_type& __ct = __check_facet(__in._M_ctype);
              while (!traits_type::eq_int_type(__c, __eof)
-                    && __ct.is(ctype_base::space, 
+                    && __ct.is(ctype_base::space,
                                traits_type::to_char_type(__c)))
                __c = __sb->snextc();
 
@@ -82,39 +82,39 @@ namespace std
     }
 
   template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>& 
+    basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
     operator>>(__istream_type& (*__pf)(__istream_type&))
     { return __pf(*this); }
 
   template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>& 
+    basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
     operator>>(__ios_type& (*__pf)(__ios_type&))
     {
       __pf(*this);
       return *this;
     }
-  
+
   template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>& 
+    basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
     operator>>(ios_base& (*__pf)(ios_base&))
     {
       __pf(*this);
       return *this;
     }
-  
+
   template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>& 
+    basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
     operator>>(bool& __n)
     {
       sentry __cerb(*this, false);
-      if (__cerb) 
+      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
              __ng.get(*this, 0, *this, __err, __n);
@@ -128,15 +128,15 @@ namespace std
     }
 
   template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>& 
+    basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
     operator>>(short& __n)
     {
       sentry __cerb(*this, false);
-      if (__cerb) 
+      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              long __l;
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
@@ -144,7 +144,7 @@ namespace std
              // _GLIBCXX_RESOLVE_LIB_DEFECTS
              // 118. basic_istream uses nonexistent num_get member functions.
              if (!(__err & ios_base::failbit)
-                 && (numeric_limits<short>::min() <= __l 
+                 && (numeric_limits<short>::min() <= __l
                      && __l <= numeric_limits<short>::max()))
                __n = __l;
              else
@@ -159,15 +159,15 @@ namespace std
     }
 
   template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>& 
+    basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
     operator>>(unsigned short& __n)
     {
       sentry __cerb(*this, false);
-      if (__cerb) 
+      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
              __ng.get(*this, 0, *this, __err, __n);
@@ -181,15 +181,15 @@ namespace std
     }
 
   template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>& 
+    basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
     operator>>(int& __n)
     {
       sentry __cerb(*this, false);
-      if (__cerb) 
+      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              long __l;
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
@@ -197,7 +197,7 @@ namespace std
              // _GLIBCXX_RESOLVE_LIB_DEFECTS
              // 118. basic_istream uses nonexistent num_get member functions.
              if (!(__err & ios_base::failbit)
-                 && (numeric_limits<int>::min() <= __l 
+                 && (numeric_limits<int>::min() <= __l
                      && __l <= numeric_limits<int>::max()))
                __n = __l;
              else
@@ -212,15 +212,15 @@ namespace std
     }
 
   template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>& 
+    basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
     operator>>(unsigned int& __n)
     {
       sentry __cerb(*this, false);
-      if (__cerb) 
+      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
              __ng.get(*this, 0, *this, __err, __n);
@@ -234,15 +234,15 @@ namespace std
     }
 
   template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>& 
+    basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
     operator>>(long& __n)
     {
       sentry __cerb(*this, false);
-      if (__cerb) 
+      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
              __ng.get(*this, 0, *this, __err, __n);
@@ -256,15 +256,15 @@ namespace std
     }
 
   template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>& 
+    basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
     operator>>(unsigned long& __n)
     {
       sentry __cerb(*this, false);
-      if (__cerb) 
+      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
              __ng.get(*this, 0, *this, __err, __n);
@@ -279,15 +279,15 @@ namespace std
 
 #ifdef _GLIBCXX_USE_LONG_LONG
   template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>& 
+    basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
     operator>>(long long& __n)
     {
       sentry __cerb(*this, false);
-      if (__cerb) 
+      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
              __ng.get(*this, 0, *this, __err, __n);
@@ -301,15 +301,15 @@ namespace std
     }
 
   template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>& 
+    basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
     operator>>(unsigned long long& __n)
     {
       sentry __cerb(*this, false);
-      if (__cerb) 
+      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
              __ng.get(*this, 0, *this, __err, __n);
@@ -324,15 +324,15 @@ namespace std
 #endif
 
   template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>& 
+    basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
     operator>>(float& __n)
     {
       sentry __cerb(*this, false);
-      if (__cerb) 
+      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
              __ng.get(*this, 0, *this, __err, __n);
@@ -346,15 +346,15 @@ namespace std
     }
 
   template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>& 
+    basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
     operator>>(double& __n)
     {
       sentry __cerb(*this, false);
-      if (__cerb) 
+      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
              __ng.get(*this, 0, *this, __err, __n);
@@ -368,15 +368,15 @@ namespace std
     }
 
   template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>& 
+    basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
     operator>>(long double& __n)
     {
       sentry __cerb(*this, false);
-      if (__cerb) 
+      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
              __ng.get(*this, 0, *this, __err, __n);
@@ -390,15 +390,15 @@ namespace std
     }
 
   template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>& 
+    basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
     operator>>(void*& __n)
     {
       sentry __cerb(*this, false);
-      if (__cerb) 
+      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
              __ng.get(*this, 0, *this, __err, __n);
@@ -412,7 +412,7 @@ namespace std
     }
 
   template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>& 
+    basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
     operator>>(__streambuf_type* __sbout)
     {
@@ -445,9 +445,9 @@ namespace std
       _M_gcount = 0;
       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
       sentry __cerb(*this, true);
-      if (__cerb) 
+      if (__cerb)
        {
-         try 
+         try
            {
              __c = this->rdbuf()->sbumpc();
              // 27.6.1.1 paragraph 3
@@ -474,9 +474,9 @@ namespace std
       _M_gcount = 0;
       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
       sentry __cerb(*this, true);
-      if (__cerb) 
+      if (__cerb)
        {
-         try 
+         try
            {
              int_type __cb = this->rdbuf()->sbumpc();
              // 27.6.1.1 paragraph 3
@@ -506,16 +506,16 @@ namespace std
       _M_gcount = 0;
       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
       sentry __cerb(*this, true);
-      if (__cerb) 
+      if (__cerb)
        {
-         try 
+         try
            {
              const int_type __idelim = traits_type::to_int_type(__delim);
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
-             int_type __c = __sb->sgetc();     
-             
-             while (_M_gcount + 1 < __n 
+             int_type __c = __sb->sgetc();
+
+             while (_M_gcount + 1 < __n
                     && !traits_type::eq_int_type(__c, __eof)
                     && !traits_type::eq_int_type(__c, __idelim))
                {
@@ -545,18 +545,18 @@ namespace std
       _M_gcount = 0;
       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
       sentry __cerb(*this, true);
-      if (__cerb) 
+      if (__cerb)
        {
-         try 
+         try
            {
              const int_type __idelim = traits_type::to_int_type(__delim);
-             const int_type __eof = traits_type::eof();              
+             const int_type __eof = traits_type::eof();
              __streambuf_type* __this_sb = this->rdbuf();
              int_type __c = __this_sb->sgetc();
              char_type __c2 = traits_type::to_char_type(__c);
-             
-             while (!traits_type::eq_int_type(__c, __eof) 
-                    && !traits_type::eq_int_type(__c, __idelim) 
+
+             while (!traits_type::eq_int_type(__c, __eof)
+                    && !traits_type::eq_int_type(__c, __idelim)
                     && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
                {
                  ++_M_gcount;
@@ -584,16 +584,16 @@ namespace std
       _M_gcount = 0;
       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
       sentry __cerb(*this, true);
-      if (__cerb) 
+      if (__cerb)
        {
-          try 
+          try
            {
              const int_type __idelim = traits_type::to_int_type(__delim);
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sgetc();
-           
-             while (_M_gcount + 1 < __n 
+
+             while (_M_gcount + 1 < __n
                     && !traits_type::eq_int_type(__c, __eof)
                     && !traits_type::eq_int_type(__c, __idelim))
                {
@@ -624,7 +624,7 @@ namespace std
        this->setstate(__err);
       return *this;
     }
-  
+
   template<typename _CharT, typename _Traits>
     basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
@@ -632,17 +632,17 @@ namespace std
     {
       _M_gcount = 0;
       sentry __cerb(*this, true);
-      if (__cerb && __n > 0) 
+      if (__cerb && __n > 0)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c;
-             
+
              __n = std::min(__n, numeric_limits<streamsize>::max());
-             while (_M_gcount < __n  
+             while (_M_gcount < __n
                     && !traits_type::eq_int_type(__c = __sb->sbumpc(), __eof))
                {
                  ++_M_gcount;
@@ -659,7 +659,7 @@ namespace std
        }
       return *this;
     }
-  
+
   template<typename _CharT, typename _Traits>
     typename basic_istream<_CharT, _Traits>::int_type
     basic_istream<_CharT, _Traits>::
@@ -671,7 +671,7 @@ namespace std
       if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              __c = this->rdbuf()->sgetc();
              if (traits_type::eq_int_type(__c, traits_type::eof()))
@@ -681,7 +681,7 @@ namespace std
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
-       } 
+       }
       return __c;
     }
 
@@ -692,15 +692,15 @@ namespace std
     {
       _M_gcount = 0;
       sentry __cerb(*this, true);
-      if (__cerb) 
+      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              _M_gcount = this->rdbuf()->sgetn(__s, __n);
              if (_M_gcount != __n)
                __err |= (ios_base::eofbit | ios_base::failbit);
-           }       
+           }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
@@ -708,18 +708,18 @@ namespace std
        }
       return *this;
     }
-  
+
   template<typename _CharT, typename _Traits>
-    streamsize 
+    streamsize
     basic_istream<_CharT, _Traits>::
     readsome(char_type* __s, streamsize __n)
     {
       _M_gcount = 0;
       sentry __cerb(*this, true);
-      if (__cerb) 
+      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              // Cannot compare int_type with streamsize generically.
              streamsize __num = this->rdbuf()->in_avail();
@@ -739,7 +739,7 @@ namespace std
        }
       return _M_gcount;
     }
-      
+
   template<typename _CharT, typename _Traits>
     basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
@@ -749,14 +749,14 @@ namespace std
       // 60. What is a formatted input function?
       _M_gcount = 0;
       sentry __cerb(*this, true);
-      if (__cerb) 
+      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
-             if (!__sb 
+             if (!__sb
                  || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
                __err |= ios_base::badbit;
            }
@@ -767,7 +767,7 @@ namespace std
        }
       return *this;
     }
-  
+
   template<typename _CharT, typename _Traits>
     basic_istream<_CharT, _Traits>&
     basic_istream<_CharT, _Traits>::
@@ -777,14 +777,14 @@ namespace std
       // 60. What is a formatted input function?
       _M_gcount = 0;
       sentry __cerb(*this, true);
-      if (__cerb) 
+      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
-             if (!__sb 
+             if (!__sb
                  || traits_type::eq_int_type(__sb->sungetc(), __eof))
                __err |= ios_base::badbit;
            }
@@ -795,7 +795,7 @@ namespace std
        }
       return *this;
     }
-  
+
   template<typename _CharT, typename _Traits>
     int
     basic_istream<_CharT, _Traits>::
@@ -805,17 +805,17 @@ namespace std
       // DR60.  Do not change _M_gcount.
       int __ret = -1;
       sentry __cerb(*this, true);
-      if (__cerb) 
+      if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              __streambuf_type* __sb = this->rdbuf();
              if (__sb)
                {
                  if (__sb->pubsync() == -1)
                    __err |= ios_base::badbit;
-                 else 
+                 else
                    __ret = 0;
                }
            }
@@ -826,7 +826,7 @@ namespace std
        }
       return __ret;
     }
-  
+
   template<typename _CharT, typename _Traits>
     typename basic_istream<_CharT, _Traits>::pos_type
     basic_istream<_CharT, _Traits>::
@@ -885,9 +885,9 @@ namespace std
          if (!this->fail())
            {
              // 136.  seekp, seekg setting wrong streams?
-             pos_type __p = this->rdbuf()->pubseekoff(__off, __dir, 
+             pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
                                                       ios_base::in);
-             
+
              // 129. Need error indication from seekp() and seekg()
              if (__p == pos_type(off_type(-1)))
                __err |= ios_base::failbit;
@@ -905,12 +905,12 @@ namespace std
     basic_istream<_CharT, _Traits>&
     operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
     {
-      typedef basic_istream<_CharT, _Traits>           __istream_type;
+      typedef basic_istream<_CharT, _Traits>           __istream_type;
       typename __istream_type::sentry __cerb(__in, false);
       if (__cerb)
        {
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
-         try 
+         try
            {
              typename __istream_type::int_type __cb = __in.rdbuf()->sbumpc();
              if (!_Traits::eq_int_type(__cb, _Traits::eof()))
@@ -930,33 +930,33 @@ namespace std
     basic_istream<_CharT, _Traits>&
     operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
     {
-      typedef basic_istream<_CharT, _Traits>           __istream_type;
+      typedef basic_istream<_CharT, _Traits>           __istream_type;
       typedef typename __istream_type::__streambuf_type __streambuf_type;
-      typedef typename _Traits::int_type               int_type;
-      typedef _CharT                                   char_type;
-      typedef ctype<_CharT>                            __ctype_type;
+      typedef typename _Traits::int_type               int_type;
+      typedef _CharT                                   char_type;
+      typedef ctype<_CharT>                            __ctype_type;
 
       streamsize __extracted = 0;
       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
       typename __istream_type::sentry __cerb(__in, false);
       if (__cerb)
        {
-         try 
+         try
            {
              // Figure out how many characters to extract.
              streamsize __num = __in.width();
              if (__num <= 0)
                __num = numeric_limits<streamsize>::max();
-             
+
              const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
 
              const int_type __eof = _Traits::eof();
              __streambuf_type* __sb = __in.rdbuf();
              int_type __c = __sb->sgetc();
-             
-             while (__extracted < __num - 1 
+
+             while (__extracted < __num - 1
                     && !_Traits::eq_int_type(__c, __eof)
-                    && !__ct.is(ctype_base::space, 
+                    && !__ct.is(ctype_base::space,
                                 _Traits::to_char_type(__c)))
                {
                  *__s++ = _Traits::to_char_type(__c);
@@ -983,20 +983,20 @@ namespace std
 
   // 27.6.1.4 Standard basic_istream manipulators
   template<typename _CharT, typename _Traits>
-    basic_istream<_CharT,_Traits>& 
+    basic_istream<_CharT,_Traits>&
     ws(basic_istream<_CharT,_Traits>& __in)
     {
-      typedef basic_istream<_CharT, _Traits>           __istream_type;
+      typedef basic_istream<_CharT, _Traits>           __istream_type;
       typedef typename __istream_type::__streambuf_type __streambuf_type;
-      typedef typename __istream_type::__ctype_type    __ctype_type;
-      typedef typename __istream_type::int_type        __int_type;
+      typedef typename __istream_type::__ctype_type    __ctype_type;
+      typedef typename __istream_type::int_type                __int_type;
 
       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
-      const __int_type __eof = _Traits::eof();       
+      const __int_type __eof = _Traits::eof();
       __streambuf_type* __sb = __in.rdbuf();
       __int_type __c = __sb->sgetc();
 
-      while (!_Traits::eq_int_type(__c, __eof) 
+      while (!_Traits::eq_int_type(__c, __eof)
             && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
        __c = __sb->snextc();
 
@@ -1011,17 +1011,17 @@ namespace std
     operator>>(basic_istream<_CharT, _Traits>& __in,
               basic_string<_CharT, _Traits, _Alloc>& __str)
     {
-      typedef basic_istream<_CharT, _Traits>           __istream_type;
-      typedef typename __istream_type::int_type        __int_type;
+      typedef basic_istream<_CharT, _Traits>           __istream_type;
+      typedef typename __istream_type::int_type                __int_type;
       typedef typename __istream_type::__streambuf_type __streambuf_type;
-      typedef typename __istream_type::__ctype_type    __ctype_type;
-      typedef basic_string<_CharT, _Traits, _Alloc>    __string_type;
+      typedef typename __istream_type::__ctype_type    __ctype_type;
+      typedef basic_string<_CharT, _Traits, _Alloc>    __string_type;
       typedef typename __string_type::size_type                __size_type;
 
       __size_type __extracted = 0;
       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
       typename __istream_type::sentry __cerb(__in, false);
-      if (__cerb) 
+      if (__cerb)
        {
          try
            {
@@ -1029,13 +1029,13 @@ namespace std
              streamsize __w = __in.width();
              __size_type __n;
              __n = __w > 0 ? static_cast<__size_type>(__w) : __str.max_size();
-             
+
              const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
              const __int_type __eof = _Traits::eof();
              __streambuf_type* __sb = __in.rdbuf();
              __int_type __c = __sb->sgetc();
-             
-             while (__extracted < __n 
+
+             while (__extracted < __n
                     && !_Traits::eq_int_type(__c, __eof)
                     && !__ct.is(ctype_base::space, _Traits::to_char_type(__c)))
                {
@@ -1068,11 +1068,11 @@ namespace std
     getline(basic_istream<_CharT, _Traits>& __in,
            basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
     {
-      typedef basic_istream<_CharT, _Traits>           __istream_type;
-      typedef typename __istream_type::int_type        __int_type;
+      typedef basic_istream<_CharT, _Traits>           __istream_type;
+      typedef typename __istream_type::int_type                __int_type;
       typedef typename __istream_type::__streambuf_type __streambuf_type;
-      typedef typename __istream_type::__ctype_type    __ctype_type;
-      typedef basic_string<_CharT, _Traits, _Alloc>    __string_type;
+      typedef typename __istream_type::__ctype_type    __ctype_type;
+      typedef basic_string<_CharT, _Traits, _Alloc>    __string_type;
       typedef typename __string_type::size_type                __size_type;
 
       __size_type __extracted = 0;
@@ -1080,7 +1080,7 @@ namespace std
       bool __testdelim = false;
       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
       typename __istream_type::sentry __cerb(__in, true);
-      if (__cerb) 
+      if (__cerb)
        {
          try
            {
@@ -1090,7 +1090,7 @@ namespace std
              __int_type __c = __sb->sbumpc();
              const __int_type __eof = _Traits::eof();
              __testdelim = _Traits::eq_int_type(__c, __idelim);
-             
+
              while (!_Traits::eq_int_type(__c, __eof) && !__testdelim
                     && __extracted < __n)
                {
@@ -1119,12 +1119,12 @@ namespace std
 
   template<class _CharT, class _Traits, class _Alloc>
     inline basic_istream<_CharT,_Traits>&
-    getline(basic_istream<_CharT, _Traits>& __in, 
+    getline(basic_istream<_CharT, _Traits>& __in,
            basic_string<_CharT,_Traits,_Alloc>& __str)
     { return getline(__in, __str, __in.widen('\n')); }
 
   // Inhibit implicit instantiations for required instantiations,
-  // which are defined via explicit instantiations elsewhere.  
+  // which are defined via explicit instantiations elsewhere.
   // NB:  This syntax is a GNU extension.
 #if _GLIBCXX_EXTERN_TEMPLATE
   extern template class basic_istream<char>;
index 2c3e670..c5e20f8 100644 (file)
@@ -78,7 +78,7 @@ namespace __gnu_norm
         _M_put_node(__tmp);
       }
     }
+
   template<typename _Tp, typename _Alloc>
     typename list<_Tp,_Alloc>::iterator
     list<_Tp,_Alloc>::
@@ -88,7 +88,7 @@ namespace __gnu_norm
       __tmp->hook(__position._M_node);
       return __tmp;
     }
-  
+
   template<typename _Tp, typename _Alloc>
     typename list<_Tp,_Alloc>::iterator
     list<_Tp,_Alloc>::
@@ -98,7 +98,7 @@ namespace __gnu_norm
       _M_erase(__position);
       return __ret;
     }
-  
+
   template<typename _Tp, typename _Alloc>
     void
     list<_Tp,_Alloc>::
@@ -113,7 +113,7 @@ namespace __gnu_norm
       else                          // __i == end()
         insert(end(), __new_size - __len, __x);
     }
-  
+
   template<typename _Tp, typename _Alloc>
     list<_Tp,_Alloc>&
     list<_Tp,_Alloc>::
@@ -134,7 +134,7 @@ namespace __gnu_norm
        }
       return *this;
     }
-  
+
   template<typename _Tp, typename _Alloc>
     void
     list<_Tp,_Alloc>::
@@ -148,17 +148,17 @@ namespace __gnu_norm
       else
         erase(__i, end());
     }
-  
+
   template<typename _Tp, typename _Alloc>
     template <typename _InputIterator>
       void
       list<_Tp,_Alloc>::
-      _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2, 
+      _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2,
                         __false_type)
       {
         iterator __first1 = begin();
         iterator __last1 = end();
-        for (; __first1 != __last1 && __first2 != __last2; 
+        for (; __first1 != __last1 && __first2 != __last2;
             ++__first1, ++__first2)
           *__first1 = *__first2;
         if (__first2 == __last2)
@@ -166,7 +166,7 @@ namespace __gnu_norm
         else
           insert(__last1, __first2, __last2);
       }
-  
+
   template<typename _Tp, typename _Alloc>
     void
     list<_Tp,_Alloc>::
@@ -183,7 +183,7 @@ namespace __gnu_norm
         __first = __next;
       }
     }
-  
+
   template<typename _Tp, typename _Alloc>
     void
     list<_Tp,_Alloc>::
@@ -203,7 +203,7 @@ namespace __gnu_norm
         __next = __first;
       }
     }
-  
+
   template<typename _Tp, typename _Alloc>
     void
     list<_Tp,_Alloc>::
@@ -230,14 +230,14 @@ namespace __gnu_norm
            _M_transfer(__last1, __first2, __last2);
        }
     }
-  
+
   template<typename _Tp, typename _Alloc>
     void
     list<_Tp,_Alloc>::
     sort()
     {
       // Do nothing if the list has length 0 or 1.
-      if (this->_M_node._M_next != &this->_M_node 
+      if (this->_M_node._M_next != &this->_M_node
          && this->_M_node._M_next->_M_next != &this->_M_node)
       {
         list __carry;
@@ -248,7 +248,7 @@ namespace __gnu_norm
         do
          {
            __carry.splice(__carry.begin(), *this, begin());
-           
+
            for(__counter = &__tmp[0];
                (__counter != __fill) && !__counter->empty();
                ++__counter)
@@ -267,7 +267,7 @@ namespace __gnu_norm
         swap( *(__fill-1) );
       }
     }
-  
+
   template<typename _Tp, typename _Alloc>
     template <typename _Predicate>
       void
@@ -285,7 +285,7 @@ namespace __gnu_norm
           __first = __next;
         }
       }
-  
+
   template<typename _Tp, typename _Alloc>
     template <typename _BinaryPredicate>
       void
@@ -305,7 +305,7 @@ namespace __gnu_norm
           __next = __first;
         }
       }
-  
+
   template<typename _Tp, typename _Alloc>
     template <typename _StrictWeakOrdering>
       void
@@ -313,7 +313,7 @@ namespace __gnu_norm
       merge(list& __x, _StrictWeakOrdering __comp)
       {
        // _GLIBCXX_RESOLVE_LIB_DEFECTS
-       // 300. list::merge() specification incomplete  
+       // 300. list::merge() specification incomplete
        if (this != &__x)
          {
            iterator __first1 = begin();
@@ -333,7 +333,7 @@ namespace __gnu_norm
              _M_transfer(__last1, __first2, __last2);
          }
       }
-  
+
   template<typename _Tp, typename _Alloc>
     template <typename _StrictWeakOrdering>
       void
@@ -348,11 +348,11 @@ namespace __gnu_norm
            list __tmp[64];
            list * __fill = &__tmp[0];
            list * __counter;
-           
+
            do
              {
                __carry.splice(__carry.begin(), *this, begin());
-               
+
                for(__counter = &__tmp[0];
                    (__counter != __fill) && !__counter->empty();
                    ++__counter)
@@ -365,7 +365,7 @@ namespace __gnu_norm
                  ++__fill;
              }
            while ( !empty() );
-           
+
            for (__counter =  &__tmp[1]; __counter != __fill; ++__counter)
              __counter->merge( *(__counter-1), __comp );
            swap( *(__fill-1) );
index 52bf1fc..33eb475 100644 (file)
@@ -80,16 +80,16 @@ namespace std
     friend class _Impl;
 
     template<typename _Facet>
-      friend bool 
+      friend bool
       has_facet(const locale&) throw();
 
     template<typename _Facet>
-      friend const _Facet& 
+      friend const _Facet&
       use_facet(const locale&);
 
     template<typename _Cache>
       friend struct __use_cache;
-   
+
     //@{
     /**
      *  @brief  Category values.
@@ -103,18 +103,18 @@ namespace std
      *  @endif
     */
     static const category none         = 0;
-    static const category ctype        = 1L << 0;
-    static const category numeric      = 1L << 1;
-    static const category collate      = 1L << 2;
-    static const category time                 = 1L << 3;
-    static const category monetary     = 1L << 4;
-    static const category messages     = 1L << 5;
-    static const category all          = (ctype | numeric | collate |
-                                          time  | monetary | messages);
+    static const category ctype                = 1L << 0;
+    static const category numeric      = 1L << 1;
+    static const category collate      = 1L << 2;
+    static const category time         = 1L << 3;
+    static const category monetary     = 1L << 4;
+    static const category messages     = 1L << 5;
+    static const category all          = (ctype | numeric | collate |
+                                          time  | monetary | messages);
     //@}
 
     // Construct/copy/destroy:
-    
+
     /**
      *  @brief  Default constructor.
      *
@@ -140,7 +140,7 @@ namespace std
      *  @param  s  Name of the locale to construct.
      *  @throw  std::runtime_error if s is null or an undefined locale.
     */
-    explicit  
+    explicit
     locale(const char* __s);
 
     /**
@@ -152,7 +152,7 @@ namespace std
      *
      *  @param  base  The locale to copy.
      *  @param  s  Name of the locale to use facets from.
-     *  @param  cat  Set of categories defining the facets to use from s.  
+     *  @param  cat  Set of categories defining the facets to use from s.
      *  @throw  std::runtime_error if s is null or an undefined locale.
     */
     locale(const locale& __base, const char* __s, category __cat);
@@ -210,7 +210,7 @@ namespace std
      *  @throw  std::runtime_error if other has no facet of type Facet.
     */
     template<typename _Facet>
-      locale  
+      locale
       combine(const locale& __other) const;
 
     // Locale operations:
@@ -218,7 +218,7 @@ namespace std
      *  @brief  Return locale name.
      *  @return  Locale name or "*" if unnamed.
     */
-    string 
+    string
     name() const;
 
     /**
@@ -226,9 +226,9 @@ namespace std
      *
      *  @param  other  The locale to compare against.
      *  @return  True if other and this refer to the same locale instance, are
-     *          copies, or have the same name.  False otherwise.
+     *          copies, or have the same name.  False otherwise.
     */
-    bool 
+    bool
     operator==(const locale& __other) const throw ();
 
     /**
@@ -237,7 +237,7 @@ namespace std
      *  @param  other  The locale to compare against.
      *  @return  ! (*this == other)
     */
-    inline bool  
+    inline bool
     operator!=(const locale& __other) const throw ()
     { return !(this->operator==(__other));  }
 
@@ -257,7 +257,7 @@ namespace std
      *  @return  True if collate<Char> facet compares s1 < s2, else false.
     */
     template<typename _Char, typename _Traits, typename _Alloc>
-      bool  
+      bool
       operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
                 const basic_string<_Char, _Traits, _Alloc>& __s2) const;
 
@@ -272,26 +272,26 @@ namespace std
      *  @param  locale  The new locale to make global.
      *  @return  Copy of the old global locale.
     */
-    static locale 
+    static locale
     global(const locale&);
 
     /**
      *  @brief  Return reference to the "C" locale.
     */
-    static const locale& 
+    static const locale&
     classic();
 
   private:
     // The (shared) implementation
-    _Impl*             _M_impl;  
+    _Impl*             _M_impl;
 
     // The "C" reference locale
     static _Impl*       _S_classic;
 
     // Current global locale
-    static _Impl*      _S_global;  
+    static _Impl*      _S_global;
 
-    // Names of underlying locale categories.  
+    // Names of underlying locale categories.
     // NB: locale::global() has to know how to modify all the
     // underlying categories, not just the ones required by the C++
     // standard.
@@ -313,16 +313,16 @@ namespace std
     static __gthread_once_t _S_once;
 #endif
 
-    explicit 
+    explicit
     locale(_Impl*) throw();
 
-    static void  
+    static void
     _S_initialize();
 
     static void
     _S_initialize_once();
 
-    static category  
+    static category
     _S_normalize_category(category);
 
     void
@@ -355,10 +355,10 @@ namespace std
     static const char                  _S_c_name[2];
 
 #ifdef __GTHREADS
-    static __gthread_once_t            _S_once;
+    static __gthread_once_t            _S_once;
 #endif
 
-    static void 
+    static void
     _S_initialize_once();
 
   protected:
@@ -371,16 +371,16 @@ namespace std
      *
      *  @param refs  The initial value for reference count.
     */
-    explicit 
+    explicit
     facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
     { }
 
     /// Facet destructor.
-    virtual 
+    virtual
     ~facet();
 
     static void
-    _S_create_c_locale(__c_locale& __cloc, const char* __s, 
+    _S_create_c_locale(__c_locale& __cloc, const char* __s,
                       __c_locale __old = 0);
 
     static __c_locale
@@ -407,16 +407,16 @@ namespace std
     {
       if (__exchange_and_add(&_M_refcount, -1) == 1)
        {
-         try 
-           { delete this; }  
-         catch (...) 
+         try
+           { delete this; }
+         catch (...)
            { }
        }
     }
 
     facet(const facet&);  // Not defined.
 
-    void 
+    void
     operator=(const facet&);  // Not defined.
   };
 
@@ -438,22 +438,22 @@ namespace std
     friend class locale::_Impl;
 
     template<typename _Facet>
-      friend const _Facet&  
+      friend const _Facet&
       use_facet(const locale&);
 
     template<typename _Facet>
-      friend bool           
+      friend bool
       has_facet(const locale&) throw ();
 
     // NB: There is no accessor for _M_index because it may be used
     // before the constructor is run; the effect of calling a member
     // function (even an inline) would be undefined.
-    mutable size_t             _M_index;
+    mutable size_t             _M_index;
 
     // Last id number assigned.
-    static _Atomic_word        _S_refcount;   
+    static _Atomic_word                _S_refcount;
 
-    void 
+    void
     operator=(const id&);  // Not defined.
 
     id(const id&);  // Not defined.
@@ -478,11 +478,11 @@ namespace std
     friend class locale::facet;
 
     template<typename _Facet>
-      friend bool  
+      friend bool
       has_facet(const locale&) throw();
 
     template<typename _Facet>
-      friend const _Facet&  
+      friend const _Facet&
       use_facet(const locale&);
 
     template<typename _Cache>
@@ -492,29 +492,29 @@ namespace std
     // Data Members.
     _Atomic_word                       _M_refcount;
     const facet**                      _M_facets;
-    size_t                             _M_facets_size;
+    size_t                             _M_facets_size;
     const facet**                      _M_caches;
-    char**                             _M_names;
-    static const locale::id* const     _S_id_ctype[];
-    static const locale::id* const     _S_id_numeric[];
-    static const locale::id* const     _S_id_collate[];
-    static const locale::id* const     _S_id_time[];
-    static const locale::id* const     _S_id_monetary[];
-    static const locale::id* const     _S_id_messages[];
+    char**                             _M_names;
+    static const locale::id* const     _S_id_ctype[];
+    static const locale::id* const     _S_id_numeric[];
+    static const locale::id* const     _S_id_collate[];
+    static const locale::id* const     _S_id_time[];
+    static const locale::id* const     _S_id_monetary[];
+    static const locale::id* const     _S_id_messages[];
     static const locale::id* const* const _S_facet_categories[];
 
-    inline void 
+    inline void
     _M_add_reference() throw()
     { __atomic_add(&_M_refcount, 1); }
 
-    inline void 
+    inline void
     _M_remove_reference() throw()
     {
       if (__exchange_and_add(&_M_refcount, -1) == 1)
        {
-         try 
-           { delete this; } 
-         catch(...) 
+         try
+           { delete this; }
+         catch(...)
            { }
        }
     }
@@ -527,7 +527,7 @@ namespace std
 
     _Impl(const _Impl&);  // Not defined.
 
-    void 
+    void
     operator=(const _Impl&);  // Not defined.
 
     inline bool
@@ -539,29 +539,29 @@ namespace std
       return __ret;
     }
 
-    void 
+    void
     _M_replace_categories(const _Impl*, category);
 
-    void 
+    void
     _M_replace_category(const _Impl*, const locale::id* const*);
 
-    void 
+    void
     _M_replace_facet(const _Impl*, const locale::id*);
 
-    void 
+    void
     _M_install_facet(const locale::id*, const facet*);
 
     template<typename _Facet>
-      inline void 
+      inline void
       _M_init_facet(_Facet* __facet)
       { _M_install_facet(&_Facet::id, __facet); }
 
     void
     _M_install_cache(const facet* __cache, size_t __index) throw()
-    { 
+    {
       __cache->_M_add_reference();
-      _M_caches[__index] = __cache; 
-    }      
+      _M_caches[__index] = __cache;
+    }
   };
 
   template<typename _Facet>
@@ -584,7 +584,7 @@ namespace std
        {
          _M_impl->_M_remove_reference();
          for (size_t __j = 0; __j < __i; ++__j)
-           delete [] _M_tmp_names[__j];          
+           delete [] _M_tmp_names[__j];
          __throw_exception_again;
        }
 
index 3b1315d..14fb84c 100644 (file)
@@ -57,28 +57,28 @@ namespace std
 # define  _GLIBCXX_NUM_FACETS 14
 #endif
 
-  // Convert string to numeric value of type _Tv and store results.  
+  // Convert string to numeric value of type _Tv and store results.
   // NB: This is specialized for all required types, there is no
   // generic definition.
   template<typename _Tv>
     void
-    __convert_to_v(const char* __in, _Tv& __out, ios_base::iostate& __err, 
+    __convert_to_v(const char* __in, _Tv& __out, ios_base::iostate& __err,
                   const __c_locale& __cloc);
 
   // Explicit specializations for required types.
   template<>
     void
-    __convert_to_v(const char*, float&, ios_base::iostate&, 
+    __convert_to_v(const char*, float&, ios_base::iostate&,
                   const __c_locale&);
 
   template<>
     void
-    __convert_to_v(const char*, double&, ios_base::iostate&, 
+    __convert_to_v(const char*, double&, ios_base::iostate&,
                   const __c_locale&);
 
   template<>
     void
-    __convert_to_v(const char*, long double&, ios_base::iostate&, 
+    __convert_to_v(const char*, long double&, ios_base::iostate&,
                   const __c_locale&);
 
   // NB: __pad is a struct, rather than a function, so it can be
@@ -87,8 +87,8 @@ namespace std
     struct __pad
     {
       static void
-      _S_pad(ios_base& __io, _CharT __fill, _CharT* __news, 
-            const _CharT* __olds, const streamsize __newlen, 
+      _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
+            const _CharT* __olds, const streamsize __newlen,
             const streamsize __oldlen, const bool __num);
     };
 
@@ -99,8 +99,8 @@ namespace std
   // only with __glen != 0.
   template<typename _CharT>
     _CharT*
-    __add_grouping(_CharT* __s, _CharT __sep,  
-                  const char* __gbeg, size_t __gsize, 
+    __add_grouping(_CharT* __s, _CharT __sep,
+                  const char* __gbeg, size_t __gsize,
                   const _CharT* __first, const _CharT* __last);
 
   // This template permits specializing facet output code for
@@ -131,7 +131,7 @@ namespace std
   // Include host and configuration specific ctype enums for ctype_base.
   #include <bits/ctype_base.h>
 
-  // Common base for ctype<_CharT>.  
+  // Common base for ctype<_CharT>.
   /**
    *  @brief  Common base for ctype facet
    *
@@ -159,7 +159,7 @@ namespace std
        *  @param m  The mask to compare against.
        *  @return  (M & m) != 0.
       */
-      bool 
+      bool
       is(mask __m, char_type __c) const
       { return this->do_is(__m, __c); }
 
@@ -177,7 +177,7 @@ namespace std
        *  @return  @a hi.
       */
       const char_type*
-      is(const char_type *__lo, const char_type *__hi, mask *__vec) const   
+      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
       { return this->do_is(__lo, __hi, __vec); }
 
       /**
@@ -222,7 +222,7 @@ namespace std
        *  @param c  The char_type to convert.
        *  @return  The uppercase char_type if convertible, else @a c.
       */
-      char_type 
+      char_type
       toupper(char_type __c) const
       { return this->do_toupper(__c); }
 
@@ -321,7 +321,7 @@ namespace std
        *  @param dfault  Char to return if conversion fails.
        *  @return  The converted char.
       */
-      char 
+      char
       narrow(char_type __c, char __dfault) const
       { return this->do_narrow(__c, __dfault); }
 
@@ -349,12 +349,12 @@ namespace std
       { return this->do_narrow(__lo, __hi, __dfault, __to); }
 
     protected:
-      explicit 
+      explicit
       __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
 
-      virtual 
+      virtual
       ~__ctype_abstract_base() { }
-      
+
       /**
        *  @brief  Test char_type classification.
        *
@@ -388,7 +388,7 @@ namespace std
        *  @return  @a hi.
       */
       virtual const char_type*
-      do_is(const char_type* __lo, const char_type* __hi, 
+      do_is(const char_type* __lo, const char_type* __hi,
            mask* __vec) const = 0;
 
       /**
@@ -426,7 +426,7 @@ namespace std
        *  @return  Pointer to a non-matching char_type if found, else @a hi.
       */
       virtual const char_type*
-      do_scan_not(mask __m, const char_type* __lo, 
+      do_scan_not(mask __m, const char_type* __lo,
                  const char_type* __hi) const = 0;
 
       /**
@@ -443,7 +443,7 @@ namespace std
        *  @param c  The char_type to convert.
        *  @return  The uppercase char_type if convertible, else @a c.
       */
-      virtual char_type 
+      virtual char_type
       do_toupper(char_type) const = 0;
 
       /**
@@ -495,7 +495,7 @@ namespace std
       */
       virtual const char_type*
       do_tolower(char_type* __lo, const char_type* __hi) const = 0;
-      
+
       /**
        *  @brief  Widen char
        *
@@ -512,7 +512,7 @@ namespace std
        *  @param c  The char to convert.
        *  @return  The converted char_type
       */
-      virtual char_type 
+      virtual char_type
       do_widen(char) const = 0;
 
       /**
@@ -534,7 +534,7 @@ namespace std
        *  @return  @a hi.
       */
       virtual const char*
-      do_widen(const char* __lo, const char* __hi, 
+      do_widen(const char* __lo, const char* __hi,
               char_type* __dest) const = 0;
 
       /**
@@ -555,7 +555,7 @@ namespace std
        *  @param dfault  Char to return if conversion fails.
        *  @return  The converted char.
       */
-      virtual char 
+      virtual char
       do_narrow(char_type, char __dfault) const = 0;
 
       /**
@@ -607,20 +607,20 @@ namespace std
     {
     public:
       // Types:
-      typedef _CharT                   char_type;
+      typedef _CharT                   char_type;
       typedef typename __ctype_abstract_base<_CharT>::mask mask;
 
       /// The facet id for ctype<char_type>
-      static locale::id                id;
+      static locale::id                        id;
 
-      explicit 
+      explicit
       ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
 
    protected:
-      virtual 
+      virtual
       ~ctype();
 
-      virtual bool 
+      virtual bool
       do_is(mask __m, char_type __c) const;
 
       virtual const char_type*
@@ -633,25 +633,25 @@ namespace std
       do_scan_not(mask __m, const char_type* __lo,
                  const char_type* __hi) const;
 
-      virtual char_type 
+      virtual char_type
       do_toupper(char_type __c) const;
 
       virtual const char_type*
       do_toupper(char_type* __lo, const char_type* __hi) const;
 
-      virtual char_type 
+      virtual char_type
       do_tolower(char_type __c) const;
 
       virtual const char_type*
       do_tolower(char_type* __lo, const char_type* __hi) const;
 
-      virtual char_type 
+      virtual char_type
       do_widen(char __c) const;
 
       virtual const char*
       do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
 
-      virtual char 
+      virtual char
       do_narrow(char_type, char __dfault) const;
 
       virtual const char_type*
@@ -677,21 +677,21 @@ namespace std
     public:
       // Types:
       /// Typedef for the template parameter char.
-      typedef char             char_type;
+      typedef char             char_type;
 
     protected:
       // Data Members:
       __c_locale               _M_c_locale_ctype;
-      bool                     _M_del;
-      __to_type                _M_toupper;
-      __to_type                _M_tolower;
-      const mask*                      _M_table;
+      bool                     _M_del;
+      __to_type                        _M_toupper;
+      __to_type                        _M_tolower;
+      const mask*              _M_table;
       mutable char             _M_widen_ok;
       mutable char             _M_widen[1 + static_cast<unsigned char>(-1)];
       mutable char             _M_narrow[1 + static_cast<unsigned char>(-1)];
       mutable char             _M_narrow_ok;   // 0 uninitialized, 1 init,
                                                // 2 non-consecutive
-      
+
     public:
       /// The facet id for ctype<char>
       static locale::id        id;
@@ -708,7 +708,7 @@ namespace std
        *  @param del   If true, passes ownership of table to this facet.
        *  @param refs  Passed to the base facet class.
       */
-      explicit 
+      explicit
       ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
 
       /**
@@ -721,8 +721,8 @@ namespace std
        *  @param del   If true, passes ownership of table to this facet.
        *  @param refs  Passed to the base facet class.
       */
-      explicit 
-      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false, 
+      explicit
+      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
            size_t __refs = 0);
 
       /**
@@ -736,7 +736,7 @@ namespace std
       */
       inline bool
       is(mask __m, char __c) const;
+
       /**
        *  @brief  Return a mask array.
        *
@@ -751,7 +751,7 @@ namespace std
       */
       inline const char*
       is(const char* __lo, const char* __hi, mask* __vec) const;
+
       /**
        *  @brief  Find char matching a mask
        *
@@ -779,7 +779,7 @@ namespace std
       */
       inline const char*
       scan_not(mask __m, const char* __lo, const char* __hi) const;
-     
+
       /**
        *  @brief  Convert to uppercase.
        *
@@ -792,7 +792,7 @@ namespace std
        *  @param c  The char to convert.
        *  @return  The uppercase char if convertible, else @a c.
       */
-      char_type 
+      char_type
       toupper(char_type __c) const
       { return this->do_toupper(__c); }
 
@@ -825,7 +825,7 @@ namespace std
        *  @param c  The char to convert.
        *  @return  The lowercase char if convertible, else @a c.
       */
-      char_type 
+      char_type
       tolower(char_type __c) const
       { return this->do_tolower(__c); }
 
@@ -862,9 +862,9 @@ namespace std
        *  @param c  The char to convert.
        *  @return  The converted character.
       */
-      char_type 
+      char_type
       widen(char __c) const
-      { 
+      {
        if (_M_widen_ok) return _M_widen[static_cast<unsigned char>(__c)];
        this->_M_widen_init();
        return this->do_widen(__c);
@@ -918,7 +918,7 @@ namespace std
        *  @param dfault  Char to return if conversion fails.
        *  @return  The converted character.
       */
-      char 
+      char
       narrow(char_type __c, char __dfault) const
       {
        if (_M_narrow[static_cast<unsigned char>(__c)])
@@ -967,12 +967,12 @@ namespace std
     protected:
       /// Returns a pointer to the mask table provided to the constructor, or
       /// the default from classic_table() if none was provided.
-      const mask* 
+      const mask*
       table() const throw()
       { return _M_table; }
 
       /// Returns a pointer to the C locale mask table.
-      static const mask* 
+      static const mask*
       classic_table() throw();
 
       /**
@@ -981,7 +981,7 @@ namespace std
        *  This function deletes table() if @a del was true in the
        *  constructor.
       */
-      virtual 
+      virtual
       ~ctype();
 
       /**
@@ -997,7 +997,7 @@ namespace std
        *  @param c  The char to convert.
        *  @return  The uppercase char if convertible, else @a c.
       */
-      virtual char_type 
+      virtual char_type
       do_toupper(char_type) const;
 
       /**
@@ -1030,7 +1030,7 @@ namespace std
        *  @param c  The char to convert.
        *  @return  The lowercase char if convertible, else @a c.
       */
-      virtual char_type 
+      virtual char_type
       do_tolower(char_type) const;
 
       /**
@@ -1049,7 +1049,7 @@ namespace std
       */
       virtual const char_type*
       do_tolower(char_type* __lo, const char_type* __hi) const;
-      
+
       /**
        *  @brief  Widen char
        *
@@ -1067,7 +1067,7 @@ namespace std
        *  @param c  The char to convert.
        *  @return  The converted character.
       */
-      virtual char_type 
+      virtual char_type
       do_widen(char __c) const
       { return __c; }
 
@@ -1116,7 +1116,7 @@ namespace std
        *  @param dfault  Char to return if conversion fails.
        *  @return  The converted char.
       */
-      virtual char 
+      virtual char
       do_narrow(char_type __c, char) const
       { return __c; }
 
@@ -1158,7 +1158,7 @@ namespace std
        for (size_t __i = 0; __i < sizeof(_M_widen); ++__i)
          __tmp[__i] = __i;
        do_widen(__tmp, __tmp + sizeof(__tmp), _M_widen);
-           
+
        _M_widen_ok = 1;
        // Set _M_widen_ok to 2 if memcpy can't be used.
        for (size_t __i = 0; __i < sizeof(_M_widen); ++__i)
@@ -1196,7 +1196,7 @@ namespace std
        _M_narrow_ok = __consecutive ? 1 : 2;
       }
     };
+
   template<>
     const ctype<char>&
     use_facet<ctype<char> >(const locale& __loc);
@@ -1219,8 +1219,8 @@ namespace std
     public:
       // Types:
       /// Typedef for the template parameter wchar_t.
-      typedef wchar_t          char_type;
-      typedef wctype_t         __wmask_type;
+      typedef wchar_t          char_type;
+      typedef wctype_t         __wmask_type;
 
     protected:
       __c_locale               _M_c_locale_ctype;
@@ -1237,7 +1237,7 @@ namespace std
     public:
       // Data Members:
       /// The facet id for ctype<wchar_t>
-      static locale::id                id;
+      static locale::id                id;
 
       /**
        *  @brief  Constructor performs initialization.
@@ -1246,7 +1246,7 @@ namespace std
        *
        *  @param refs  Passed to the base facet class.
       */
-      explicit 
+      explicit
       ctype(size_t __refs = 0);
 
       /**
@@ -1257,7 +1257,7 @@ namespace std
        *  @param cloc  Handle to C locale data.
        *  @param refs  Passed to the base facet class.
       */
-      explicit 
+      explicit
       ctype(__c_locale __cloc, size_t __refs = 0);
 
     protected:
@@ -1265,7 +1265,7 @@ namespace std
       _M_convert_to_wmask(const mask __m) const;
 
       /// Destructor
-      virtual 
+      virtual
       ~ctype();
 
       /**
@@ -1281,7 +1281,7 @@ namespace std
        *  @param m  The mask to compare against.
        *  @return  (M & m) != 0.
       */
-      virtual bool 
+      virtual bool
       do_is(mask __m, char_type __c) const;
 
       /**
@@ -1337,7 +1337,7 @@ namespace std
        *  @return  Pointer to a non-matching wchar_t if found, else @a hi.
       */
       virtual const char_type*
-      do_scan_not(mask __m, const char_type* __lo, 
+      do_scan_not(mask __m, const char_type* __lo,
                  const char_type* __hi) const;
 
       /**
@@ -1353,7 +1353,7 @@ namespace std
        *  @param c  The wchar_t to convert.
        *  @return  The uppercase wchar_t if convertible, else @a c.
       */
-      virtual char_type 
+      virtual char_type
       do_toupper(char_type) const;
 
       /**
@@ -1386,7 +1386,7 @@ namespace std
        *  @param c  The wchar_t to convert.
        *  @return  The lowercase wchar_t if convertible, else @a c.
       */
-      virtual char_type 
+      virtual char_type
       do_tolower(char_type) const;
 
       /**
@@ -1405,7 +1405,7 @@ namespace std
       */
       virtual const char_type*
       do_tolower(char_type* __lo, const char_type* __hi) const;
-      
+
       /**
        *  @brief  Widen char to wchar_t
        *
@@ -1423,7 +1423,7 @@ namespace std
        *  @param c  The char to convert.
        *  @return  The converted wchar_t.
       */
-      virtual char_type 
+      virtual char_type
       do_widen(char) const;
 
       /**
@@ -1467,7 +1467,7 @@ namespace std
        *  @param dfault  Char to return if conversion fails.
        *  @return  The converted char.
       */
-      virtual char 
+      virtual char
       do_narrow(char_type, char __dfault) const;
 
       /**
@@ -1498,7 +1498,7 @@ namespace std
                char __dfault, char* __dest) const;
 
       // For use at construction time only.
-      void 
+      void
       _M_initialize_ctype();
     };
 
@@ -1515,13 +1515,13 @@ namespace std
     class ctype_byname : public ctype<_CharT>
     {
     public:
-      typedef _CharT           char_type;
+      typedef _CharT           char_type;
 
-      explicit 
+      explicit
       ctype_byname(const char* __s, size_t __refs = 0);
 
     protected:
-      virtual 
+      virtual
       ~ctype_byname() { };
     };
 
@@ -1536,26 +1536,26 @@ namespace std
   #include <bits/codecvt.h>
 
   // 22.2.2  The numeric category.
-  class __num_base 
+  class __num_base
   {
   public:
     // NB: Code depends on the order of _S_atoms_out elements.
     // Below are the indices into _S_atoms_out.
-    enum 
-      {  
-        _S_ominus, 
-        _S_oplus, 
-        _S_ox, 
-        _S_oX, 
+    enum
+      {
+        _S_ominus,
+        _S_oplus,
+        _S_ox,
+        _S_oX,
         _S_odigits,
         _S_odigits_end = _S_odigits + 16,
-        _S_oudigits = _S_odigits_end,  
+        _S_oudigits = _S_odigits_end,
         _S_oudigits_end = _S_oudigits + 16,
         _S_oe = _S_odigits + 14,  // For scientific notation, 'e'
         _S_oE = _S_oudigits + 14, // For scientific notation, 'E'
        _S_oend = _S_oudigits_end
       };
-    
+
     // A list of valid numeric literals for output.  This array
     // contains chars that will be passed through the current locale's
     // ctype<_CharT>.widen() and then used to render numbers.
@@ -1567,12 +1567,12 @@ namespace std
     // "-+xX0123456789abcdefABCDEF"
     static const char* _S_atoms_in;
 
-    enum 
-    {  
-      _S_iminus, 
-      _S_iplus, 
-      _S_ix, 
-      _S_iX, 
+    enum
+    {
+      _S_iminus,
+      _S_iplus,
+      _S_ix,
+      _S_iX,
       _S_izero,
       _S_ie = _S_izero + 14,
       _S_iE = _S_izero + 20,
@@ -1588,36 +1588,36 @@ namespace std
   template<typename _CharT>
     struct __numpunct_cache : public locale::facet
     {
-      const char*                      _M_grouping;
+      const char*                      _M_grouping;
       size_t                            _M_grouping_size;
       bool                             _M_use_grouping;
-      const _CharT*                    _M_truename;
+      const _CharT*                    _M_truename;
       size_t                            _M_truename_size;
       const _CharT*                    _M_falsename;
-      size_t                            _M_falsename_size;     
-      _CharT                           _M_decimal_point;
-      _CharT                           _M_thousands_sep;
-      
+      size_t                            _M_falsename_size;
+      _CharT                           _M_decimal_point;
+      _CharT                           _M_thousands_sep;
+
       // A list of valid numeric literals for output: in the standard
       // "C" locale, this is "-+xX0123456789abcdef0123456789ABCDEF".
       // This array contains the chars after having been passed
       // through the current locale's ctype<_CharT>.widen().
-      _CharT                           _M_atoms_out[__num_base::_S_oend];
+      _CharT                           _M_atoms_out[__num_base::_S_oend];
 
       // A list of valid numeric literals for input: in the standard
       // "C" locale, this is "-+xX0123456789abcdefABCDEF"
       // This array contains the chars after having been passed
       // through the current locale's ctype<_CharT>.widen().
-      _CharT                           _M_atoms_in[__num_base::_S_iend];
+      _CharT                           _M_atoms_in[__num_base::_S_iend];
 
       bool                             _M_allocated;
 
-      __numpunct_cache(size_t __refs = 0) : facet(__refs), 
+      __numpunct_cache(size_t __refs = 0) : facet(__refs),
       _M_grouping(NULL), _M_grouping_size(0), _M_use_grouping(false),
       _M_truename(NULL), _M_truename_size(0), _M_falsename(NULL),
       _M_falsename_size(0), _M_decimal_point(_CharT()),
       _M_thousands_sep(_CharT()), _M_allocated(false)
-      { } 
+      { }
 
       ~__numpunct_cache();
 
@@ -1648,14 +1648,14 @@ namespace std
       _CharT* __falsename = new _CharT[_M_falsename_size];
       __np.falsename().copy(__falsename, _M_falsename_size);
       _M_falsename = __falsename;
-          
+
       _M_decimal_point = __np.decimal_point();
       _M_thousands_sep = __np.thousands_sep();
-      
+
       const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
-      __ct.widen(__num_base::_S_atoms_out, 
+      __ct.widen(__num_base::_S_atoms_out,
                 __num_base::_S_atoms_out + __num_base::_S_oend, _M_atoms_out);
-      __ct.widen(__num_base::_S_atoms_in, 
+      __ct.widen(__num_base::_S_atoms_in,
                 __num_base::_S_atoms_in + __num_base::_S_iend, _M_atoms_in);
     }
 
@@ -1690,8 +1690,8 @@ namespace std
       // Types:
       //@{
       /// Public typedefs
-      typedef _CharT                   char_type;
-      typedef basic_string<_CharT>     string_type;
+      typedef _CharT                   char_type;
+      typedef basic_string<_CharT>     string_type;
       //@}
       typedef __numpunct_cache<_CharT>  __cache_type;
 
@@ -1700,14 +1700,14 @@ namespace std
 
     public:
       /// Numpunct facet id.
-      static locale::id                id;
+      static locale::id                        id;
 
       /**
        *  @brief  Numpunct constructor.
        *
        *  @param  refs  Refcount to pass to the base class.
        */
-      explicit 
+      explicit
       numpunct(size_t __refs = 0) : facet(__refs), _M_data(NULL)
       { _M_initialize_numpunct(); }
 
@@ -1720,8 +1720,8 @@ namespace std
        *  @param  cache  __numpunct_cache object.
        *  @param  refs  Refcount to pass to the base class.
        */
-      explicit 
-      numpunct(__cache_type* __cache, size_t __refs = 0) 
+      explicit
+      numpunct(__cache_type* __cache, size_t __refs = 0)
       : facet(__refs), _M_data(__cache)
       { _M_initialize_numpunct(); }
 
@@ -1734,8 +1734,8 @@ namespace std
        *  @param  cloc  The "C" locale.
        *  @param  refs  Refcount to pass to the base class.
        */
-      explicit 
-      numpunct(__c_locale __cloc, size_t __refs = 0) 
+      explicit
+      numpunct(__c_locale __cloc, size_t __refs = 0)
       : facet(__refs), _M_data(NULL)
       { _M_initialize_numpunct(__cloc); }
 
@@ -1748,7 +1748,7 @@ namespace std
        *
        *  @return  @a char_type representing a decimal point.
       */
-      char_type    
+      char_type
       decimal_point() const
       { return this->do_decimal_point(); }
 
@@ -1761,7 +1761,7 @@ namespace std
        *
        *  @return  char_type representing a thousands separator.
       */
-      char_type    
+      char_type
       thousands_sep() const
       { return this->do_thousands_sep(); }
 
@@ -1790,7 +1790,7 @@ namespace std
        *
        *  @return  string representing grouping specification.
       */
-      string       
+      string
       grouping() const
       { return this->do_grouping(); }
 
@@ -1803,7 +1803,7 @@ namespace std
        *
        *  @return  string_type representing printed form of true.
       */
-      string_type  
+      string_type
       truename() const
       { return this->do_truename(); }
 
@@ -1816,13 +1816,13 @@ namespace std
        *
        *  @return  string_type representing printed form of false.
       */
-      string_type  
+      string_type
       falsename() const
       { return this->do_falsename(); }
 
     protected:
       /// Destructor.
-      virtual 
+      virtual
       ~numpunct();
 
       /**
@@ -1833,7 +1833,7 @@ namespace std
        *
        *  @return  @a char_type representing a decimal point.
       */
-      virtual char_type    
+      virtual char_type
       do_decimal_point() const
       { return _M_data->_M_decimal_point; }