1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
// ----------------------------------------------------------------------------
// 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
|
Swift