163 lines
4.9 KiB
Plaintext
163 lines
4.9 KiB
Plaintext
// ----------------------------------------------------------------------------
|
|
// 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
|