* Removed references to char_traits so that boost/format also works on

  GCC 2.95.

10 files changed, 198 insertions, 225 deletions

diff --git a/boost/format/Makefile.am b/boost/format/Makefile.am
new file mode 100644
index 000000000000..43a44a216ba9
--- /dev/null
+++ b/boost/format/Makefile.am
@@ -0,0 +1,3 @@
+noinst_LIBRARIES = libformat.a
+
+libformat_a_SOURCES = format_implementation.cc free_funcs.cc parsing.cc
diff --git a/boost/format/feed_args.hpp b/boost/format/feed_args.hpp
index 2e678ca3b4b0..ba107dce66d5 100644
--- a/boost/format/feed_args.hpp
+++ b/boost/format/feed_args.hpp
@@ -31,17 +31,16 @@ namespace io {
 namespace detail {
 namespace  { 
 
-  template<class Tr, class Ch> inline
-  void empty_buf(BOOST_IO_STD basic_ostringstream<Ch,Tr> & os) { 
-    static const std::basic_string<Ch, Tr> emptyStr;
+  inline
+  void empty_buf(BOOST_IO_STD ostringstream & os) { 
+    static const std::string emptyStr;
     os.str(emptyStr); 
   }
 
-  template<class Ch, class Tr>
-  void do_pad( std::basic_string<Ch,Tr> & s, 
+  void do_pad( std::string & s, 
                 std::streamsize w, 
-                const Ch c, 
-                std::ios_base::fmtflags f, 
+                const char c, 
+                std::ios::fmtflags f, 
                 bool center) 
     // applies centered / left / right  padding  to the string s.
     // Effects : string s is padded.
@@ -59,7 +58,7 @@ namespace  {
       } 
     else 
       {
-        if(f & std::ios_base::left) {
+        if(f & std::ios::left) {
           s.append(n, c);
         }
         else {
@@ -69,32 +68,32 @@ namespace  {
   } // -do_pad(..) 
 
 
-  template< class Ch, class Tr, class T> inline
-  void put_head(BOOST_IO_STD basic_ostream<Ch, Tr>& , const T& ) {
+  template<class T> inline
+  void put_head(BOOST_IO_STD ostream& , const T& ) {
   }
 
-  template< class Ch, class Tr, class T> inline
-  void put_head( BOOST_IO_STD basic_ostream<Ch, Tr>& os, const group1<T>& x ) {
+  template<class T> inline
+  void put_head( BOOST_IO_STD ostream& os, const group1<T>& x ) {
     os << group_head(x.a1_); // send the first N-1 items, not the last
   }
 
-  template< class Ch, class Tr, class T> inline
-  void put_last( BOOST_IO_STD basic_ostream<Ch, Tr>& os, const T& x ) {
+  template<class T> inline
+  void put_last( BOOST_IO_STD ostream& os, const T& x ) {
     os << x ;
   }
 
-  template< class Ch, class Tr, class T> inline
-  void put_last( BOOST_IO_STD basic_ostream<Ch, Tr>& os, const group1<T>& x ) {
+  template<class T> inline
+  void put_last( BOOST_IO_STD ostream& os, const group1<T>& x ) {
     os << group_last(x.a1_); // this selects the last element
   }
 
 #ifndef BOOST_NO_OVERLOAD_FOR_NON_CONST 
-  template< class Ch, class Tr, class T> inline
-  void put_head( BOOST_IO_STD basic_ostream<Ch, Tr>& , T& ) {
+  template<class T> inline
+  void put_head( BOOST_IO_STD ostream& , T& ) {
   }
 
-  template< class Ch, class Tr, class T> inline
-  void put_last( BOOST_IO_STD basic_ostream<Ch, Tr>& os, T& x ) {
+  template<class T> inline
+  void put_last( BOOST_IO_STD ostream& os, T& x ) {
     os << x ;
   }
 #endif
@@ -102,19 +101,19 @@ namespace  {
 
 
   
-template< class Ch, class Tr, class T> 
+template<class T> 
 void put( T x, 
-          const format_item<Ch, Tr>& specs, 
-          std::basic_string<Ch, Tr> & res, 
-          BOOST_IO_STD basic_ostringstream<Ch, Tr>& oss_ )
+          const format_item& specs, 
+          std::string & res, 
+          BOOST_IO_STD ostringstream& oss_ )
 {
   // does the actual conversion of x, with given params, into a string
   // using the *supplied* strinstream. (the stream state is important)
 
-  typedef std::basic_string<Ch, Tr> string_t;
-  typedef format_item<Ch, Tr>  format_item_t;
+  typedef std::string string_t;
+  typedef format_item  format_item_t;
 
-  stream_format_state<Ch, Tr>   prev_state(oss_);
+  stream_format_state   prev_state(oss_);
     
   specs.state_.apply_on(oss_);
 
@@ -124,8 +123,8 @@ void put( T x,
   empty_buf( oss_);
 
   const std::streamsize w=oss_.width();
-  const std::ios_base::fmtflags fl=oss_.flags();
-  const bool internal = (fl & std::ios_base::internal) != 0;
+  const std::ios::fmtflags fl=oss_.flags();
+  const bool internal = (fl & std::ios::internal) != 0;
   const bool two_stepped_padding = internal
     &&  ! ( specs.pad_scheme_ & format_item_t::spacepad ) 
     && specs.truncate_ < 0 ;
@@ -203,8 +202,8 @@ void put( T x,
 
 
 
-template< class Ch, class Tr, class T> 
-void distribute(basic_format<Ch,Tr>& self, T x) 
+template<class T> 
+void distribute(basic_format& self, T x) 
   // call put(x, ..) on every occurence of the current argument :
 {
   if(self.cur_arg_ >= self.num_args_)
@@ -217,16 +216,16 @@ void distribute(basic_format<Ch,Tr>& self, T x)
     {
       if(self.items_[i].argN_ == self.cur_arg_)
         {
-          put<Ch, Tr, T> (x, self.items_[i], self.items_[i].res_, self.oss_ );
+          put<T> (x, self.items_[i], self.items_[i].res_, self.oss_ );
         }
     }
 }
 
-template<class Ch, class Tr, class T> 
-basic_format<Ch, Tr>&  feed(basic_format<Ch,Tr>& self, T x) 
+template<class T> 
+basic_format&  feed(basic_format& self, T x) 
 {
   if(self.dumped_) self.clear();
-  distribute<Ch, Tr, T> (self, x);
+  distribute<T> (self, x);
   ++self.cur_arg_;
   if(self.bound_.size() != 0)
     {
diff --git a/boost/format/format_class.hpp b/boost/format/format_class.hpp
index 9126bfad3639..6875623acb47 100644
--- a/boost/format/format_class.hpp
+++ b/boost/format/format_class.hpp
@@ -30,26 +30,21 @@
 
 namespace boost {
 
-template<class Ch, class Tr>
 class basic_format 
 {
 public:
-  typedef Ch  CharT;   // those 2 are necessary for borland compatibilty,
-  typedef Tr  Traits;  // in the body of the operator% template.
-
-
-  typedef std::basic_string<Ch, Tr>                string_t;
-  typedef BOOST_IO_STD basic_ostringstream<Ch, Tr> internal_stream_t;
+  typedef std::string                string_t;
+  typedef BOOST_IO_STD ostringstream internal_stream_t;
 private:
-  typedef BOOST_IO_STD basic_ostream<Ch, Tr>       stream_t;
-  typedef io::detail::stream_format_state<Ch, Tr>  stream_format_state;
-  typedef io::detail::format_item<Ch, Tr>          format_item_t;
+  typedef BOOST_IO_STD ostream       stream_t;
+  typedef io::detail::stream_format_state  stream_format_state;
+  typedef io::detail::format_item          format_item_t;
 
 public:
-  basic_format(const Ch* str);
+  basic_format(const char* str);
   basic_format(const string_t& s);
 #ifndef BOOST_NO_STD_LOCALE
-  basic_format(const Ch* str, const std::locale & loc);
+  basic_format(const char* str, const std::locale & loc);
   basic_format(const string_t& s, const std::locale & loc);
 #endif // no locale
   basic_format(const basic_format& x);
@@ -60,13 +55,13 @@ public:
   // pass arguments through those operators :
   template<class T>  basic_format&   operator%(const T& x) 
   { 
-    return io::detail::feed<CharT, Traits, const T&>(*this,x);
+    return io::detail::feed<const T&>(*this,x);
   }
 
 #ifndef BOOST_NO_OVERLOAD_FOR_NON_CONST
   template<class T>  basic_format&   operator%(T& x) 
   {
-    return io::detail::feed<CharT, Traits, T&>(*this,x);
+    return io::detail::feed<T&>(*this,x);
   }
 #endif
 
@@ -93,21 +88,21 @@ public:
 
   // final output
   string_t str() const;
-  friend BOOST_IO_STD basic_ostream<Ch, Tr>& 
-  operator<< <Ch, Tr> ( BOOST_IO_STD basic_ostream<Ch, Tr>& , const basic_format& ); 
+  friend BOOST_IO_STD ostream& 
+  operator<< ( BOOST_IO_STD ostream& , const basic_format& ); 
                       
 
-  template<class Ch2, class Tr2, class T>  friend basic_format<Ch2, Tr2>&  
-  io::detail::feed(basic_format<Ch2,Tr2>&, T);
+  template<class T>  friend basic_format&  
+  io::detail::feed(basic_format&, T);
     
-  template<class Ch2, class Tr2, class T>  friend   
-  void io::detail::distribute(basic_format<Ch2,Tr2>&, T);
+  template<class T>  friend   
+  void io::detail::distribute(basic_format&, T);
   
-  template<class Ch2, class Tr2, class T>  friend
-  basic_format<Ch2, Tr2>&  io::detail::modify_item_body(basic_format<Ch2, Tr2>&, int, const T&);
+  template<class T>  friend
+  basic_format&  io::detail::modify_item_body(basic_format&, int, const T&);
 
-  template<class Ch2, class Tr2, class T> friend
-  basic_format<Ch2, Tr2>&  io::detail::bind_arg_body(basic_format<Ch2, Tr2>&, int, const T&);
+  template<class T> friend
+  basic_format&  io::detail::bind_arg_body(basic_format&, int, const T&);
 
 // make the members private only if the friend templates are supported
 private:
diff --git a/boost/format/format_fwd.hpp b/boost/format/format_fwd.hpp
index bad2f7238537..97c55f6684c3 100644
--- a/boost/format/format_fwd.hpp
+++ b/boost/format/format_fwd.hpp
@@ -24,13 +24,9 @@
 
 namespace boost {
 
-template<class charT, class Traits = BOOST_IO_STD char_traits<charT> > class basic_format;
+class basic_format;
 
-typedef basic_format<char >     format;
-
-#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_STD_WSTREAMBUF)
-typedef basic_format<wchar_t >  wformat;
-#endif
+typedef basic_format    format;
 
 namespace io {
 enum format_error_bits { bad_format_string_bit = 1, 
@@ -39,15 +35,13 @@ enum format_error_bits { bad_format_string_bit = 1,
                          all_error_bits = 255, no_error_bits=0 };
                   
 // Convertion:  format   to   string
-template<class Ch, class Tr> 
-std::basic_string<Ch, Tr>     str(const basic_format<Ch, Tr>& ) ;
+std::string     str(const basic_format& ) ;
 
 } // namespace io
 
 
-template< class Ch, class Tr> 
-BOOST_IO_STD basic_ostream<Ch, Tr>& 
-operator<<( BOOST_IO_STD basic_ostream<Ch, Tr>&, const basic_format<Ch, Tr>&);
+BOOST_IO_STD ostream& 
+operator<<( BOOST_IO_STD ostream&, const basic_format&);
 
 
 } // namespace boost
diff --git a/boost/format/format_implementation.hpp b/boost/format/format_implementation.cc
index 58372bb13b02..41cb5fc9fa2d 100644
--- a/boost/format/format_implementation.hpp
+++ b/boost/format/format_implementation.cc
@@ -22,13 +22,12 @@
 
 //#include <boost/throw_exception.hpp>
 //#include <boost/assert.hpp>
-#include <boost/format/format_class.hpp>
+#include <boost/format.hpp>
 
 namespace boost {
 
 // --------  format:: -------------------------------------------
-template< class Ch, class Tr>
-basic_format<Ch, Tr> ::basic_format(const Ch* str)
+basic_format::basic_format(const char* str)
     : style_(0), cur_arg_(0), num_args_(0), dumped_(false),
       items_(), oss_(), exceptions_(io::all_error_bits)
 {
@@ -39,8 +38,7 @@ basic_format<Ch, Tr> ::basic_format(const Ch* str)
 }
 
 #ifndef BOOST_NO_STD_LOCALE
-template< class Ch, class Tr>
-basic_format<Ch, Tr> ::basic_format(const Ch* str, const std::locale & loc)
+basic_format::basic_format(const char* str, const std::locale & loc)
     : style_(0), cur_arg_(0), num_args_(0), dumped_(false),
       items_(), oss_(), exceptions_(io::all_error_bits)
 {
@@ -51,8 +49,7 @@ basic_format<Ch, Tr> ::basic_format(const Ch* str, const std::locale & loc)
     parse( str );
 }
 
-template< class Ch, class Tr>
-basic_format<Ch, Tr> ::basic_format(const string_t& s, const std::locale & loc)
+basic_format::basic_format(const string_t& s, const std::locale & loc)
     : style_(0), cur_arg_(0), num_args_(0), dumped_(false),
       items_(),  oss_(), exceptions_(io::all_error_bits)
 {
@@ -62,8 +59,7 @@ basic_format<Ch, Tr> ::basic_format(const string_t& s, const std::locale & loc)
 }
 #endif //BOOST_NO_STD_LOCALE
 
-template< class Ch, class Tr>
-basic_format<Ch, Tr> ::basic_format(const string_t& s)
+basic_format::basic_format(const string_t& s)
     : style_(0), cur_arg_(0), num_args_(0), dumped_(false),
       items_(),  oss_(), exceptions_(io::all_error_bits)
 {
@@ -71,8 +67,7 @@ basic_format<Ch, Tr> ::basic_format(const string_t& s)
     parse(s);  
 }
 
-template< class Ch, class Tr>
-basic_format<Ch, Tr> :: basic_format(const basic_format& x)
+basic_format:: basic_format(const basic_format& x)
     : style_(x.style_), cur_arg_(x.cur_arg_), num_args_(x.num_args_), dumped_(false), 
       items_(x.items_), prefix_(x.prefix_), bound_(x.bound_), 
       oss_(),   // <- we obviously can't copy x.oss_
@@ -81,8 +76,7 @@ basic_format<Ch, Tr> :: basic_format(const basic_format& x)
     state0_.apply_on(oss_);
 } 
 
-template< class Ch, class Tr>
-basic_format<Ch, Tr>& basic_format<Ch, Tr> ::operator= (const basic_format& x)
+basic_format& basic_format::operator= (const basic_format& x)
 {
     if(this == &x)
       return *this;
@@ -102,14 +96,12 @@ basic_format<Ch, Tr>& basic_format<Ch, Tr> ::operator= (const basic_format& x)
 }
 
 
-template< class Ch, class Tr>
-unsigned char basic_format<Ch,Tr> ::exceptions() const 
+unsigned char basic_format::exceptions() const 
 {
   return exceptions_; 
 }
 
-template< class Ch, class Tr>
-unsigned char basic_format<Ch,Tr> ::exceptions(unsigned char newexcept) 
+unsigned char basic_format::exceptions(unsigned char newexcept) 
 { 
   unsigned char swp = exceptions_; 
   exceptions_ = newexcept; 
@@ -117,8 +109,7 @@ unsigned char basic_format<Ch,Tr> ::exceptions(unsigned char newexcept)
 }
 
 
-template< class Ch, class Tr>
-basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear()
+basic_format& basic_format ::clear()
   // empty the string buffers (except bound arguments, see clear_binds() )
   // and make the format object ready for formatting a new set of arguments
 {
@@ -138,8 +129,7 @@ basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear()
     return *this;
 }
 
-template< class Ch, class Tr>
-basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear_binds() 
+basic_format& basic_format ::clear_binds() 
   // cancel all bindings, and clear()
 {
     bound_.resize(0);
@@ -147,8 +137,7 @@ basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear_binds()
     return *this;
 }
 
-template< class Ch, class Tr>
-basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear_bind(int argN) 
+basic_format& basic_format::clear_bind(int argN) 
   // cancel the binding of ONE argument, and clear()
 {
     if(argN<1 || argN > num_args_ || bound_.size()==0 || !bound_[argN-1] ) 
@@ -164,8 +153,7 @@ basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear_bind(int argN)
 
 
 
-template< class Ch, class Tr>
-std::basic_string<Ch,Tr> basic_format<Ch,Tr> ::str() const
+std::string basic_format::str() const
 {
   dumped_=true;
   if(items_.size()==0)
@@ -201,8 +189,8 @@ std::basic_string<Ch,Tr> basic_format<Ch,Tr> ::str() const
 namespace io {
 namespace detail {
 
-template<class Ch, class Tr, class T> 
-basic_format<Ch, Tr>&  bind_arg_body( basic_format<Ch, Tr>& self, 
+template<class T>
+basic_format&  bind_arg_body( basic_format& self, 
                                       int argN, 
                                       const T& val)
   // bind one argument to a fixed value
@@ -239,8 +227,8 @@ basic_format<Ch, Tr>&  bind_arg_body( basic_format<Ch, Tr>& self,
     return self;
 }
 
-template<class Ch, class Tr, class T> 
-basic_format<Ch, Tr>&  modify_item_body( basic_format<Ch, Tr>& self,
+template<class T>
+basic_format&  modify_item_body( basic_format& self,
                                       int itemN, 
                                       const T& manipulator)
   // applies a manipulator to the format_item describing a given directive.
diff --git a/boost/format/free_funcs.hpp b/boost/format/free_funcs.cc
index d552e8baa2af..b2ac01774bdf 100644
--- a/boost/format/free_funcs.hpp
+++ b/boost/format/free_funcs.cc
@@ -19,27 +19,26 @@
 #ifndef BOOST_FORMAT_FUNCS_HPP
 #define BOOST_FORMAT_FUNCS_HPP
 
-#include "boost/format/format_class.hpp"
+#include "boost/format.hpp"
 //#include "boost/throw_exception.hpp"
 
 namespace boost {
 
 namespace io {
-  template<class Ch, class Tr> inline 
-  std::basic_string<Ch, Tr> str(const basic_format<Ch, Tr>& f) 
+  inline 
+  std::string str(const basic_format& f) 
     // adds up all pieces of strings and converted items, and return the formatted string
   {
     return f.str();
   }
 }   // - namespace io
 
-template< class Ch, class Tr>
-BOOST_IO_STD basic_ostream<Ch, Tr>& 
-operator<<( BOOST_IO_STD basic_ostream<Ch, Tr>& os, 
-            const boost::basic_format<Ch, Tr>& f) 
+BOOST_IO_STD ostream& 
+operator<<( BOOST_IO_STD ostream& os, 
+            const boost::basic_format& f) 
   // effect: "return os << str(f);" but we can try to do it faster
 {
-  typedef boost::basic_format<Ch, Tr>   format_t;
+  typedef boost::basic_format   format_t;
   if(f.items_.size()==0) 
     os << f.prefix_;
   else {
@@ -53,7 +52,7 @@ operator<<( BOOST_IO_STD basic_ostream<Ch, Tr>& os,
       os << f.prefix_;
       for(unsigned long i=0; i<f.items_.size(); ++i) 
         {
-          const typename format_t::format_item_t& item = f.items_[i];
+          const format_t::format_item_t& item = f.items_[i];
           os << item.res_;
           os << item.appendix_;
 
diff --git a/boost/format/group.hpp b/boost/format/group.hpp
index d7785427ee6e..ac63f3f0bab0 100644
--- a/boost/format/group.hpp
+++ b/boost/format/group.hpp
@@ -45,8 +45,8 @@ struct group0
 
 template <class Ch, class Tr>
 inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << ( BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << ( BOOST_IO_STD ostream& os,
              const group0& )
 { 
    return os; 
@@ -63,8 +63,8 @@ struct group1
 
 template <class Ch, class Tr, class T1>
 inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
              const group1<T1>& x)
 { 
    os << x.a1_;  
@@ -86,8 +86,8 @@ struct group2
 
 template <class Ch, class Tr, class T1,class T2>
 inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
              const group2<T1,T2>& x)
 { 
    os << x.a1_<< x.a2_;  
@@ -107,8 +107,8 @@ struct group3
 
 template <class Ch, class Tr, class T1,class T2,class T3>
 inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
              const group3<T1,T2,T3>& x)
 { 
    os << x.a1_<< x.a2_<< x.a3_;  
@@ -129,8 +129,8 @@ struct group4
 
 template <class Ch, class Tr, class T1,class T2,class T3,class T4>
 inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
              const group4<T1,T2,T3,T4>& x)
 { 
    os << x.a1_<< x.a2_<< x.a3_<< x.a4_;  
@@ -152,8 +152,8 @@ struct group5
 
 template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5>
 inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
              const group5<T1,T2,T3,T4,T5>& x)
 { 
    os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_;  
@@ -176,8 +176,8 @@ struct group6
 
 template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6>
 inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
              const group6<T1,T2,T3,T4,T5,T6>& x)
 { 
    os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_;  
@@ -201,8 +201,8 @@ struct group7
 
 template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6,class T7>
 inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
              const group7<T1,T2,T3,T4,T5,T6,T7>& x)
 { 
    os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_;  
@@ -227,8 +227,8 @@ struct group8
 
 template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
 inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
              const group8<T1,T2,T3,T4,T5,T6,T7,T8>& x)
 { 
    os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_<< x.a8_;  
@@ -254,8 +254,8 @@ struct group9
 
 template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
 inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
              const group9<T1,T2,T3,T4,T5,T6,T7,T8,T9>& x)
 { 
    os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_<< x.a8_<< x.a9_;  
@@ -282,8 +282,8 @@ struct group10
 
 template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
 inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
              const group10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>& x)
 { 
    os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_<< x.a8_<< x.a9_<< x.a10_;  
diff --git a/boost/format/internals.hpp b/boost/format/internals.hpp
index 52448b731c2f..d25eb4c864c4 100644
--- a/boost/format/internals.hpp
+++ b/boost/format/internals.hpp
@@ -33,22 +33,21 @@ namespace detail {
 // --------------
 // set of params that define the format state of a stream
 
-template<class Ch, class Tr> 
 struct stream_format_state 
 {
-  typedef BOOST_IO_STD basic_ios<Ch, Tr>   basic_ios;
+  typedef std::ios   basic_ios;
 
   std::streamsize width_;
   std::streamsize precision_;
-  Ch fill_; 
-  std::ios_base::fmtflags flags_;
+  char fill_; 
+  std::ios::fmtflags flags_;
 
-  stream_format_state()       : width_(-1), precision_(-1), fill_(0), flags_(std::ios_base::dec)  {}
+  stream_format_state()       : width_(-1), precision_(-1), fill_(0), flags_(std::ios::dec)  {}
   stream_format_state(basic_ios& os)                  {set_by_stream(os); }
 
   void apply_on(basic_ios & os) const;                //- applies format_state to the stream
   template<class T> void apply_manip(T manipulator)   //- modifies state by applying manipulator.
-       { apply_manip_body<Ch, Tr, T>( *this, manipulator) ; }
+       { apply_manip_body<T>( *this, manipulator) ; }
   void reset();                                       //- sets to default state.
   void set_by_stream(const basic_ios& os);            //- sets to os's state.
 };  
@@ -58,7 +57,6 @@ struct stream_format_state
 // --------------
 // format_item : stores all parameters that can be defined by directives in the format-string
 
-template<class Ch, class Tr>  
 struct format_item 
 {     
   enum pad_values { zeropad = 1, spacepad =2, centered=4, tabulation = 8 };
@@ -67,10 +65,10 @@ struct format_item
                     argN_tabulation = -2, // tabulation directive. (no argument read) 
                     argN_ignored    = -3  // ignored directive. (no argument read)
   };
-  typedef BOOST_IO_STD basic_ios<Ch, Tr>              basic_ios;
-  typedef detail::stream_format_state<Ch, Tr>         stream_format_state;
-  typedef std::basic_string<Ch, Tr>           string_t;
-  typedef BOOST_IO_STD basic_ostringstream<Ch, Tr>    internal_stream_t;
+  typedef BOOST_IO_STD ios              basic_ios;
+  typedef detail::stream_format_state         stream_format_state;
+  typedef std::string           string_t;
+  typedef BOOST_IO_STD ostringstream    internal_stream_t;
 
 
   int         argN_;           //- argument number (starts at 0,  eg : %1 => argN=0)
@@ -98,8 +96,8 @@ struct format_item
 // -----------------------------------------------------------
 
 // --- stream_format_state:: -------------------------------------------
-template<class Ch, class Tr> inline
-void stream_format_state<Ch,Tr> ::apply_on(basic_ios & os) const
+inline
+void stream_format_state::apply_on(basic_ios & os) const
   // set the state of this stream according to our params
 {
       if(width_ != -1)
@@ -111,8 +109,8 @@ void stream_format_state<Ch,Tr> ::apply_on(basic_ios & os) const
       os.flags(flags_);
 }
 
-template<class Ch, class Tr>      inline
-void stream_format_state<Ch,Tr> ::set_by_stream(const basic_ios& os) 
+inline
+void stream_format_state::set_by_stream(const basic_ios& os) 
   // set our params according to the state of this stream
 {
       flags_ = os.flags();
@@ -121,42 +119,42 @@ void stream_format_state<Ch,Tr> ::set_by_stream(const basic_ios& os)
       fill_ = os.fill();
 }
 
-template<class Ch, class Tr, class T>  inline
-void apply_manip_body( stream_format_state<Ch, Tr>& self,
+template<class T>  inline
+void apply_manip_body( stream_format_state& self,
                        T manipulator) 
   // modify our params according to the manipulator
 {
-      BOOST_IO_STD basic_stringstream<Ch, Tr>  ss;
+      BOOST_IO_STD stringstream  ss;
       self.apply_on( ss );
       ss << manipulator;
       self.set_by_stream( ss );
 }
 
-template<class Ch, class Tr> inline
-void stream_format_state<Ch,Tr> ::reset() 
+inline
+void stream_format_state::reset() 
   // set our params to standard's default state
 {
       width_=-1; precision_=-1; fill_=0; 
-      flags_ = std::ios_base::dec; 
+      flags_ = std::ios::dec; 
 }
 
 
 // --- format_items:: -------------------------------------------
-template<class Ch, class Tr> inline
-void format_item<Ch, Tr> ::compute_states() 
+inline
+void format_item::compute_states() 
   // reflect pad_scheme_   on  state_ and ref_state_ 
   //   because some pad_schemes has complex consequences on several state params.
 {
   if(pad_scheme_ & zeropad) 
   {
-    if(ref_state_.flags_ & std::ios_base::left) 
+    if(ref_state_.flags_ & std::ios::left) 
     {
       pad_scheme_ = pad_scheme_ & (~zeropad); // ignore zeropad in left alignment
     }
     else 
     { 
       ref_state_.fill_='0'; 
-      ref_state_.flags_ |= std::ios_base::internal;
+      ref_state_.flags_ |= std::ios::internal;
     }
   }
   state_ = ref_state_;
diff --git a/boost/format/internals_fwd.hpp b/boost/format/internals_fwd.hpp
index f260e6dec9f9..a8ebf7c3abc1 100644
--- a/boost/format/internals_fwd.hpp
+++ b/boost/format/internals_fwd.hpp
@@ -26,8 +26,8 @@ namespace boost {
 namespace io {
 
 namespace detail {
-  template<class Ch, class Tr> struct stream_format_state;
-  template<class Ch, class Tr> struct format_item;
+  struct stream_format_state;
+  struct format_item;
 }
 
 
@@ -37,24 +37,24 @@ namespace detail {
   // but MSVC have problems with template member functions :
 
   // defined in format_implementation.hpp :
-     template<class Ch, class Tr, class T> 
-     basic_format<Ch, Tr>&  modify_item_body( basic_format<Ch, Tr>& self, 
+     template<class T> 
+     basic_format&  modify_item_body( basic_format& self, 
                                           int itemN, const T& manipulator);
 
-     template<class Ch, class Tr, class T> 
-     basic_format<Ch, Tr>&  bind_arg_body( basic_format<Ch, Tr>& self,
+     template<class T> 
+     basic_format&  bind_arg_body( basic_format& self,
                                            int argN, const T& val);
 
-    template<class Ch, class Tr, class T> 
-    void apply_manip_body( stream_format_state<Ch, Tr>& self,
+    template<class T> 
+    void apply_manip_body( stream_format_state& self,
                            T manipulator);
 
   // argument feeding (defined in feed_args.hpp ) :
-     template<class Ch, class Tr, class T> 
-     void distribute(basic_format<Ch,Tr>& self, T x);
+     template<class T> 
+     void distribute(basic_format& self, T x);
 
-     template<class Ch, class Tr, class T> 
-     basic_format<Ch, Tr>& feed(basic_format<Ch,Tr>& self, T x);
+     template<class T> 
+     basic_format& feed(basic_format& self, T x);
  
 } // namespace detail
 
diff --git a/boost/format/parsing.hpp b/boost/format/parsing.cc
index a461314f9828..1e12dea9bfc6 100644
--- a/boost/format/parsing.hpp
+++ b/boost/format/parsing.cc
@@ -22,7 +22,7 @@
 #define BOOST_FORMAT_PARSING_HPP
 
 
-#include <boost/format/format_class.hpp>
+#include <boost/format.hpp>
 //#include <boost/throw_exception.hpp>
 //#include <boost/assert.hpp>
 
@@ -31,8 +31,8 @@ namespace boost {
 namespace io {
 namespace detail {
 
-  template<class Ch, class Stream> inline
-  bool wrap_isdigit(Ch c, Stream &os) 
+  template<class Stream> inline
+  bool wrap_isdigit(char c, Stream &os) 
   {
 #ifndef BOOST_NO_LOCALE_ISIDIGIT
     return std::isdigit(c, os.rdbuf()->getloc() );
@@ -42,10 +42,10 @@ namespace detail {
 #endif 
   } //end- wrap_isdigit(..)
 
-  template<class Res, class Ch, class Tr> inline
-  Res str2int(const std::basic_string<Ch, Tr>& s, 
-              typename std::basic_string<Ch, Tr>::size_type start, 
-              BOOST_IO_STD basic_ios<Ch,Tr> &os,
+  template<class Res> inline
+  Res str2int(const std::string& s, 
+              std::string::size_type start, 
+              BOOST_IO_STD ios &os,
               const Res = Res(0)  ) 
     // Input : char string, with starting index
     //         a basic_ios& merely to call its widen/narrow member function in the desired locale.
@@ -54,7 +54,7 @@ namespace detail {
   {
     Res n = 0;
     while(start<s.size() && wrap_isdigit(s[start], os) ) {
-      char cur_ch = os.narrow( s[start], 0);
+      char cur_ch = s[start];
       BOOST_ASSERT(cur_ch != 0 ); // since we called isdigit, this should not happen.
       n *= 10;
       n += cur_ch - '0'; // 22.2.1.1.2 of the C++ standard
@@ -63,10 +63,9 @@ namespace detail {
     return n;
   }
 
-  template<class Ch, class Tr>
-  void skip_asterisk(const std::basic_string<Ch,Tr> & buf, 
-                     typename std::basic_string<Ch,Tr>::size_type * pos_p,
-                     BOOST_IO_STD basic_ios<Ch, Tr> &os)
+  void skip_asterisk(const std::string & buf, 
+                     std::string::size_type * pos_p,
+                     BOOST_IO_STD ios &os)
     // skip printf's "asterisk-fields" directives in the format-string buf
     // Input : char string, with starting index *pos_p
     //         a basic_ios& merely to call its widen/narrow member function in the desired locale.
@@ -76,10 +75,10 @@ namespace detail {
     using namespace std;
     BOOST_ASSERT( pos_p != 0);
     if(*pos_p >= buf.size() ) return;
-    if(buf[ *pos_p]==os.widen('*')) {
+    if(buf[ *pos_p]=='*') {
       ++ (*pos_p);
       while (*pos_p < buf.size() && wrap_isdigit(buf[*pos_p],os)) ++(*pos_p);
-      if(buf[*pos_p]==os.widen('$')) ++(*pos_p);
+      if(buf[*pos_p]=='$') ++(*pos_p);
     }
   }
 
@@ -95,11 +94,10 @@ namespace detail {
     
 
 
-  template<class Ch, class Tr>
-  bool parse_printf_directive(const std::basic_string<Ch, Tr> & buf,
-                              typename std::basic_string<Ch, Tr>::size_type * pos_p,
-                              detail::format_item<Ch, Tr> * fpar,
-                              BOOST_IO_STD basic_ios<Ch,Tr> &os,
+  bool parse_printf_directive(const std::string & buf,
+                              std::string::size_type * pos_p,
+                              detail::format_item * fpar,
+                              BOOST_IO_STD ios &os,
                               unsigned char exceptions)
     // Input   : a 'printf-directive' in the format-string, starting at buf[ *pos_p ]
     //           a basic_ios& merely to call its widen/narrow member function in the desired locale.
@@ -109,14 +107,14 @@ namespace detail {
     // Effects : - *pos_p is incremented so that buf[*pos_p] is the first char after the directive
     //           - *fpar is set with the parameters read in the directive
   {
-    typedef format_item<Ch, Tr>  format_item_t;
+    typedef format_item  format_item_t;
     BOOST_ASSERT( pos_p != 0);
-    typename std::basic_string<Ch, Tr>::size_type       &i1 = *pos_p,      
+    std::string::size_type       &i1 = *pos_p,      
                                                         i0; 
     fpar->argN_ = format_item_t::argN_no_posit;  // if no positional-directive
 
     bool in_brackets=false;
-    if(buf[i1]==os.widen('|'))
+    if(buf[i1]=='|')
       {
         in_brackets=true;
         if( ++i1 >= buf.size() ) {
@@ -126,7 +124,7 @@ namespace detail {
       }
 
     // the flag '0' would be picked as a digit for argument order, but here it's a flag :
-    if(buf[i1]==os.widen('0')) 
+    if(buf[i1]=='0') 
       goto parse_flags;
 
     // handle argument order (%2$d)  or possibly width specification: %2d
@@ -142,7 +140,7 @@ namespace detail {
         int n=str2int(buf,i0, os, int(0) );
         
         // %N% case : this is already the end of the directive
-        if( buf[i1] == os.widen('%') ) 
+        if( buf[i1] == '%' ) 
           {
             fpar->argN_ = n-1;
             ++i1;
@@ -152,7 +150,7 @@ namespace detail {
             else return true;
           }
 
-        if ( buf[i1]==os.widen('$') ) 
+        if ( buf[i1]=='$' ) 
           {
             fpar->argN_ = n-1;
             ++i1;
@@ -171,14 +169,14 @@ namespace detail {
     while ( i1 <buf.size()) // as long as char is one of + - = # 0 l h   or ' '
       {  
         // misc switches
-        switch (os.narrow(buf[i1], 0)) 
+        switch (buf[i1]) 
           {
           case '\'' : break; // no effect yet. (painful to implement)
           case 'l':
           case 'h':  // short/long modifier : for printf-comaptibility (no action needed)
              break;
           case '-':
-            fpar->ref_state_.flags_ |= std::ios_base::left;
+            fpar->ref_state_.flags_ |= std::ios::left;
             break;
           case '=':
             fpar->pad_scheme_ |= format_item_t::centered;
@@ -187,7 +185,7 @@ namespace detail {
             fpar->pad_scheme_ |= format_item_t::spacepad;
             break;
           case '+':
-            fpar->ref_state_.flags_ |= std::ios_base::showpos;
+            fpar->ref_state_.flags_ |= std::ios::showpos;
             break;
           case '0':
             fpar->pad_scheme_ |= format_item_t::zeropad; 
@@ -195,7 +193,7 @@ namespace detail {
             // so just add 'zeropad' flag for now, it will be processed later.
             break;
           case '#':
-            fpar->ref_state_.flags_ |= std::ios_base::showpoint | std::ios_base::showbase;
+            fpar->ref_state_.flags_ |= std::ios::showpoint | std::ios::showbase;
             break;
           default:
             goto parse_width;
@@ -223,7 +221,7 @@ namespace detail {
       return true;
     }
     // handle precision spec
-    if (buf[i1]==os.widen('.'))  
+    if (buf[i1]=='.')  
       {
         ++i1;
         skip_asterisk(buf, &i1, os);
@@ -239,51 +237,51 @@ namespace detail {
     
     // handle  formatting-type flags :
     while( i1<buf.size() && 
-           ( buf[i1]==os.widen('l') || buf[i1]==os.widen('L') || buf[i1]==os.widen('h')) )
+           ( buf[i1]=='l' || buf[i1]=='L' || buf[i1]=='h') )
       ++i1;
     if( i1>=buf.size()) {
       maybe_throw_exception(exceptions);
       return true;
     }
     
-    if( in_brackets && buf[i1]==os.widen('|') ) 
+    if( in_brackets && buf[i1]=='|' ) 
       {
         ++i1;
         return true;
       }
-    switch (os.narrow(buf[i1], 0) )  
+    switch (buf[i1])  
       {
       case 'X':
-        fpar->ref_state_.flags_ |= std::ios_base::uppercase;
+        fpar->ref_state_.flags_ |= std::ios::uppercase;
       case 'p': // pointer => set hex.
       case 'x':
-        fpar->ref_state_.flags_ &= ~std::ios_base::basefield;
-        fpar->ref_state_.flags_ |= std::ios_base::hex;
+        fpar->ref_state_.flags_ &= ~std::ios::basefield;
+        fpar->ref_state_.flags_ |= std::ios::hex;
         break;
       
       case 'o':
-        fpar->ref_state_.flags_ &= ~std::ios_base::basefield;
-        fpar->ref_state_.flags_ |=  std::ios_base::oct;
+        fpar->ref_state_.flags_ &= ~std::ios::basefield;
+        fpar->ref_state_.flags_ |=  std::ios::oct;
         break;
 
       case 'E':
-        fpar->ref_state_.flags_ |=  std::ios_base::uppercase;
+        fpar->ref_state_.flags_ |=  std::ios::uppercase;
       case 'e':
-        fpar->ref_state_.flags_ &= ~std::ios_base::floatfield;
-        fpar->ref_state_.flags_ |=  std::ios_base::scientific;
+        fpar->ref_state_.flags_ &= ~std::ios::floatfield;
+        fpar->ref_state_.flags_ |=  std::ios::scientific;
 
-        fpar->ref_state_.flags_ &= ~std::ios_base::basefield;
-        fpar->ref_state_.flags_ |=  std::ios_base::dec;
+        fpar->ref_state_.flags_ &= ~std::ios::basefield;
+        fpar->ref_state_.flags_ |=  std::ios::dec;
         break;
       
       case 'f':
-        fpar->ref_state_.flags_ &= ~std::ios_base::floatfield;
-        fpar->ref_state_.flags_ |=  std::ios_base::fixed;
+        fpar->ref_state_.flags_ &= ~std::ios::floatfield;
+        fpar->ref_state_.flags_ |=  std::ios::fixed;
       case 'u':
       case 'd':
       case 'i':
-        fpar->ref_state_.flags_ &= ~std::ios_base::basefield;
-        fpar->ref_state_.flags_ |=  std::ios_base::dec;
+        fpar->ref_state_.flags_ &= ~std::ios::basefield;
+        fpar->ref_state_.flags_ |=  std::ios::dec;
         break;
 
       case 'T':
@@ -296,20 +294,20 @@ namespace detail {
         fpar->argN_ = format_item_t::argN_tabulation; 
         break;
       case 't': 
-        fpar->ref_state_.fill_ = os.widen(' ');
+        fpar->ref_state_.fill_ = ' ';
         fpar->pad_scheme_ |= format_item_t::tabulation;
         fpar->argN_ = format_item_t::argN_tabulation; 
         break;
 
       case 'G':
-        fpar->ref_state_.flags_ |= std::ios_base::uppercase;
+        fpar->ref_state_.flags_ |= std::ios::uppercase;
         break;
       case 'g': // 'g' conversion is default for floats.
-        fpar->ref_state_.flags_ &= ~std::ios_base::basefield;
-        fpar->ref_state_.flags_ |=  std::ios_base::dec;
+        fpar->ref_state_.flags_ &= ~std::ios::basefield;
+        fpar->ref_state_.flags_ |=  std::ios::dec;
 
         // CLEAR all floatield flags, so stream will CHOOSE
-        fpar->ref_state_.flags_ &= ~std::ios_base::floatfield; 
+        fpar->ref_state_.flags_ &= ~std::ios::floatfield; 
         break;
 
       case 'C':
@@ -331,7 +329,7 @@ namespace detail {
 
     if( in_brackets )
       {
-        if( i1<buf.size() && buf[i1]==os.widen('|') ) 
+        if( i1<buf.size() && buf[i1]=='|' ) 
           {
             ++i1;
             return true;
@@ -348,15 +346,14 @@ namespace detail {
 // -----------------------------------------------
 //  format :: parse(..)
 
-template<class Ch, class Traits>
-void basic_format<Ch, Traits> ::parse(const string_t & buf) 
+void basic_format::parse(const string_t & buf) 
   // parse the format-string
 {
     using namespace std;
-    const Ch arg_mark = oss_.widen('%');
+    const char arg_mark = '%';
     bool ordered_args=true; 
     int max_argN=-1;
-    typename string_t::size_type i1=0;
+    string_t::size_type i1=0;
     int num_items=0;
     
     // A: find upper_bound on num_items and allocates arrays
@@ -382,7 +379,7 @@ void basic_format<Ch, Traits> ::parse(const string_t & buf)
     // B: Now the real parsing of the format string :
     num_items=0;
     i1 = 0;
-    typename string_t::size_type i0 = i1;
+    string_t::size_type i0 = i1;
     bool special_things=false;
     int cur_it=0;
     while( (i1=buf.find(arg_mark,i1)) != string::npos )