// ---------------------------------------------------------------------------- | |
// workarounds for gcc < 3.0. | |
// ---------------------------------------------------------------------------- | |
// Copyright Samuel Krempp 2003. Use, modification, and distribution are | |
// subject to the Boost Software License, Version 1.0. (See accompanying | |
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
// See http://www.boost.org/libs/format for library home page | |
// ---------------------------------------------------------------------------- | |
// There's a lot to do, the stdlib shipped with gcc prior to 3.x | |
// was terribly non-conforming. | |
// . defines macros switches | |
// . supplies template classes basic_foo<char,Tr> where gcc only supplies foo. | |
// i.e : | |
// - basic_ios<char, Tr> from ios | |
// - basic_ostream<char, Tr> from ostream | |
// - basic_srteambuf<char, Tr> from streambuf | |
// these can be used transparently. (it obviously does not work for wchar_t) | |
// . specialise CompatAlloc and CompatTraits to wrap gcc-2.95's | |
// string_char_traits and std::alloc | |
#if BOOST_WORKAROUND(__GNUC__, < 3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) | |
// only for gcc-2.95's native stdlib | |
#ifndef BOOST_FORMAT_WORKAROUNDS_GCC295_H | |
#define BOOST_FORMAT_WORKAROUNDS_GCC295_H | |
// SGI STL doesnt have <ostream> and others, so we need iostream. | |
#include <iostream> | |
#define BOOST_FORMAT_OSTREAM_DEFINED | |
#include <streambuf.h> | |
#define BOOST_FORMAT_STREAMBUF_DEFINED | |
#define BOOST_NO_TEMPLATE_STD_STREAM | |
#ifndef BOOST_IO_STD | |
# define BOOST_IO_STD std:: | |
#endif | |
// *** | |
// gcc's simple classes turned into standard-like template classes : | |
namespace std { | |
// gcc has string_char_traits, it's incomplete. | |
// we declare a std::char_traits, and specialize CompatTraits<..> on it | |
// to do what is required | |
template<class Ch> | |
class char_traits; // no definition here, we will just use it as a tag. | |
template <class Ch, class Tr> | |
class basic_streambuf; | |
template <class Tr> | |
class basic_streambuf<char, Tr> : public streambuf { | |
}; | |
template <class Ch, class Tr=::std::char_traits<Ch> > | |
class basic_ios; | |
template <class Tr> | |
class basic_ios<char, Tr> : public ostream { | |
public: | |
basic_ios(streambuf * p) : ostream(p) {}; | |
char fill() const { return ios::fill(); } // gcc returns wchar.. | |
char fill(char c) { return ios::fill(c); } // gcc takes wchar.. | |
char widen(char c) { return c; } | |
char narrow(char c, char def) { return c; } | |
basic_ios& copyfmt(const ios& right) { | |
fill(right.fill()); | |
flags(right.flags() ); | |
exceptions(right.exceptions()); | |
width(right.width()); | |
precision(right.precision()); | |
return *this; | |
} | |
}; | |
typedef ios ios_base; | |
template <class Ch, class Tr> | |
class basic_ostream; | |
template <class Tr> | |
class basic_ostream<char, Tr> : public basic_ios<char, Tr> | |
{ | |
public: | |
basic_ostream(streambuf * p) : basic_ios<char,Tr> (p) {} | |
}; | |
} // namespace std | |
namespace boost { | |
namespace io { | |
// ** CompatTraits gcc2.95 specialisations ---------------------------- | |
template<class Ch> | |
class CompatTraits< ::std::string_char_traits<Ch> > | |
: public ::std::string_char_traits<Ch> | |
{ | |
public: | |
typedef CompatTraits compatible_type; | |
typedef Ch char_type; | |
typedef int int_type; | |
typedef ::std::streampos pos_type; | |
typedef ::std::streamoff off_type; | |
static char_type | |
to_char_type(const int_type& meta) { | |
return static_cast<char_type>(meta); } | |
static int_type | |
to_int_type(const char_type& ch) { | |
return static_cast<int_type>(static_cast<unsigned char>(ch) );} | |
static bool | |
eq_int_type(const int_type& left, const int_type& right) { | |
return left == right; } | |
static int_type | |
eof() { | |
return static_cast<int_type>(EOF); | |
} | |
static int_type | |
not_eof(const int_type& meta) { | |
return (meta == eof()) ? 0 : meta; | |
} | |
}; | |
template<class Ch> | |
class CompatTraits< ::std::char_traits<Ch> > { | |
public: | |
typedef CompatTraits< ::std::string_char_traits<Ch> > compatible_type; | |
}; | |
// ** CompatAlloc gcc-2.95 specialisations --------------------------- | |
template<> | |
class CompatAlloc< ::std::alloc> | |
{ | |
public: | |
typedef ::std::allocator<char> compatible_type; | |
}; | |
} // N.S. io | |
} // N.S. boost | |
#endif // include guard | |
#endif // if workaround |