1 /*
2 * Copyright (c) 1999
3 * Silicon Graphics Computer Systems, Inc.
4 *
5 * Copyright (c) 1999
6 * Boris Fomitchev
7 *
8 * This material is provided "as is", with absolutely no warranty expressed
9 * or implied. Any use is at your own risk.
10 *
11 * Permission to use or copy this software for any purpose is hereby granted
12 * without fee, provided the above notices are retained on all copies.
13 * Permission to modify the code and to distribute modified code is granted,
14 * provided the above notices are retained, and a notice that the code was
15 * modified is included with the above copyright notice.
16 *
17 */
18
19
20 #ifndef _STLP_INTERNAL_OSTREAM_H
21 #define _STLP_INTERNAL_OSTREAM_H
22
23 #ifndef _STLP_INTERNAL_IOS_H
24 # include <stl/_ios.h> // For basic_ios<>. Includes <iosfwd>.
25 #endif
26
27 #ifndef _STLP_INTERNAL_OSTREAMBUF_ITERATOR_H
28 # include <stl/_ostreambuf_iterator.h>
29 #endif
30
31 #if !defined (_STLP_NO_UNCAUGHT_EXCEPT_SUPPORT) && !defined (_STLP_INTERNAL_EXCEPTION)
32 # include <stl/_exception.h>
33 #endif
34
35 _STLP_BEGIN_NAMESPACE
36
37 #if defined (_STLP_USE_TEMPLATE_EXPORT)
38 template <class _CharT, class _Traits>
39 class _Osentry;
40 #endif
41
42 _STLP_MOVE_TO_PRIV_NAMESPACE
43
44 template <class _CharT, class _Traits>
45 bool __init_bostr(basic_ostream<_CharT, _Traits>& __str);
46
47 _STLP_MOVE_TO_STD_NAMESPACE
48
49 //----------------------------------------------------------------------
50 // class basic_ostream<>
51
52 template <class _CharT, class _Traits>
53 class basic_ostream : virtual public basic_ios<_CharT, _Traits> {
54 typedef basic_ostream<_CharT, _Traits> _Self;
55
56 #if defined (_STLP_MSVC) && (_STLP_MSVC >= 1300 && _STLP_MSVC <= 1310)
57 //explicitely defined as private to avoid warnings:
58 basic_ostream(_Self const&);
59 _Self& operator = (_Self const&);
60 #endif
61
62 public: // Types
63 typedef _CharT char_type;
64 typedef typename _Traits::int_type int_type;
65 typedef typename _Traits::pos_type pos_type;
66 typedef typename _Traits::off_type off_type;
67 typedef _Traits traits_type;
68 typedef basic_ios<_CharT, _Traits> _Basic_ios;
69
70 public: // Constructor and destructor.
71 explicit basic_ostream(basic_streambuf<_CharT, _Traits>* __buf);
72 ~basic_ostream();
73
74 public: // Hooks for manipulators.
75 typedef basic_ios<_CharT, _Traits>& (_STLP_CALL *__ios_fn)(basic_ios<_CharT, _Traits>&);
76 typedef ios_base& (_STLP_CALL *__ios_base_fn)(ios_base&);
77 typedef _Self& (_STLP_CALL *__ostream_fn)(_Self&);
78 _Self& operator<< (__ostream_fn __f) { return __f(*this); }
79 _Self & operator<< (__ios_base_fn __f) { __f(*this); return *this; }
80 _Self& operator<< (__ios_fn __ff) { __ff(*this); return *this; }
81
82 private:
83 bool _M_copy_buffered(basic_streambuf<_CharT, _Traits>* __from,
84 basic_streambuf<_CharT, _Traits>* __to);
85 bool _M_copy_unbuffered(basic_streambuf<_CharT, _Traits>* __from,
86 basic_streambuf<_CharT, _Traits>* __to);
87
88 public:
89 void _M_put_char(_CharT __c);
90
91 void _M_put_nowiden(const _CharT* __s);
92 void _M_put_widen(const char* __s);
93 bool _M_put_widen_aux(const char* __s, streamsize __n);
94
95 public: // Unformatted output.
96 _Self& put(char_type __c);
97 _Self& write(const char_type* __s, streamsize __n);
98
99 public: // Formatted output.
100 // Formatted output from a streambuf.
101 _Self& operator<<(basic_streambuf<_CharT, _Traits>* __buf);
102 # ifndef _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER
103 // this is needed for compiling with option char = unsigned
104 _Self& operator<<(unsigned char __x) { _M_put_char(__x); return *this; }
105 # endif
106 _Self& operator<<(short __x);
107 _Self& operator<<(unsigned short __x);
108 _Self& operator<<(int __x);
109 #if defined (_WIN64) || !defined (_STLP_MSVC) || (_STLP_MSVC < 1300)
110 _Self& operator<<(unsigned int __x);
111 #else
112 /* We define this operator with size_t rather than unsigned int to avoid
113 * 64 bits warning.
114 */
115 _Self& operator<<(size_t __x);
116 #endif
117 _Self& operator<<(long __x);
118 _Self& operator<<(unsigned long __x);
119 #ifdef _STLP_LONG_LONG
120 _Self& operator<< (_STLP_LONG_LONG __x);
121 _Self& operator<< (unsigned _STLP_LONG_LONG __x);
122 #endif
123 _Self& operator<<(float __x);
124 _Self& operator<<(double __x);
125 # ifndef _STLP_NO_LONG_DOUBLE
126 _Self& operator<<(long double __x);
127 # endif
128 _Self& operator<<(const void* __x);
129 # ifndef _STLP_NO_BOOL
130 _Self& operator<<(bool __x);
131 # endif
132
133 public: // Buffer positioning and manipulation.
flush()134 _Self& flush() {
135 if (this->rdbuf())
136 if (this->rdbuf()->pubsync() == -1)
137 this->setstate(ios_base::badbit);
138 return *this;
139 }
140
tellp()141 pos_type tellp() {
142 return this->rdbuf() && !this->fail()
143 ? this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out)
144 : pos_type(-1);
145 }
146
seekp(pos_type __pos)147 _Self& seekp(pos_type __pos) {
148 if (this->rdbuf() && !this->fail()) {
149 if (this->rdbuf()->pubseekpos(__pos, ios_base::out) == pos_type(-1)) {
150 this->setstate(ios_base::failbit);
151 }
152 }
153 return *this;
154 }
155
seekp(off_type __off,ios_base::seekdir __dir)156 _Self& seekp(off_type __off, ios_base::seekdir __dir) {
157 if (this->rdbuf() && !this->fail())
158 this->rdbuf()->pubseekoff(__off, __dir, ios_base::out);
159 return *this;
160 }
161
162 #if defined (_STLP_USE_TEMPLATE_EXPORT)
163 // If we are using DLL specs, we have not to use inner classes
164 // end class declaration here
165 typedef _Osentry<_CharT, _Traits> sentry;
166 };
167 # define sentry _Osentry
168 template <class _CharT, class _Traits>
169 class _Osentry {
170 typedef _Osentry<_CharT, _Traits> _Self;
171 #else
172 class sentry {
173 typedef sentry _Self;
174 #endif
175 private:
176 basic_ostream<_CharT, _Traits>& _M_str;
177 // basic_streambuf<_CharT, _Traits>* _M_buf;
178 bool _M_ok;
179 public:
sentry(basic_ostream<_CharT,_Traits> & __str)180 explicit sentry(basic_ostream<_CharT, _Traits>& __str)
181 : _M_str(__str), /* _M_buf(__str.rdbuf()), */ _M_ok(_STLP_PRIV __init_bostr(__str))
182 {}
183
~sentry()184 ~sentry() {
185 if (_M_str.flags() & ios_base::unitbuf)
186 #if !defined (_STLP_NO_UNCAUGHT_EXCEPT_SUPPORT)
187 if (!uncaught_exception())
188 #endif
189 _M_str.flush();
190 }
191
192 operator bool() const { return _M_ok; }
193 private: // Disable assignment and copy constructor.
194 //Implementation is here only to avoid warning with some compilers.
sentry(const _Self & __s)195 sentry(const _Self& __s) : _M_str(__s._M_str) {}
196 _Self& operator=(const _Self&) { return *this; }
197 };
198 #if defined (_STLP_USE_TEMPLATE_EXPORT)
199 # undef sentry
200 #else
201 // close basic_ostream class definition here
202 };
203 #endif
204
205 #if defined (_STLP_USE_TEMPLATE_EXPORT)
206 _STLP_EXPORT_TEMPLATE_CLASS basic_ostream<char, char_traits<char> >;
207 _STLP_EXPORT_TEMPLATE_CLASS _Osentry<char, char_traits<char> >;
208 # if !defined (_STLP_NO_WCHAR_T)
209 _STLP_EXPORT_TEMPLATE_CLASS basic_ostream<wchar_t, char_traits<wchar_t> >;
210 _STLP_EXPORT_TEMPLATE_CLASS _Osentry<wchar_t, char_traits<wchar_t> >;
211 # endif
212 #endif /* _STLP_USE_TEMPLATE_EXPORT */
213
214 _STLP_MOVE_TO_PRIV_NAMESPACE
215
216 // Helper functions for istream<>::sentry constructor.
217 template <class _CharT, class _Traits>
__init_bostr(basic_ostream<_CharT,_Traits> & __str)218 bool __init_bostr(basic_ostream<_CharT, _Traits>& __str) {
219 if (__str.good()) {
220 // boris : check if this is needed !
221 if (!__str.rdbuf())
222 __str.setstate(ios_base::badbit);
223 if (__str.tie())
224 __str.tie()->flush();
225 return __str.good();
226 }
227 else
228 return false;
229 }
230
231 template <class _CharT, class _Traits>
232 inline basic_streambuf<_CharT, _Traits>* _STLP_CALL
__get_ostreambuf(basic_ostream<_CharT,_Traits> & __St)233 __get_ostreambuf(basic_ostream<_CharT, _Traits>& __St)
234 { return __St.rdbuf(); }
235
236 _STLP_MOVE_TO_STD_NAMESPACE
237
238 // Non-member functions.
239 template <class _CharT, class _Traits>
240 inline basic_ostream<_CharT, _Traits>& _STLP_CALL
241 operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c){
242 __os._M_put_char(__c);
243 return __os;
244 }
245
246 template <class _CharT, class _Traits>
247 inline basic_ostream<_CharT, _Traits>& _STLP_CALL
248 operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __s) {
249 __os._M_put_nowiden(__s);
250 return __os;
251 }
252
253 #if defined (_STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER)
254 // some specializations
255
256 inline basic_ostream<char, char_traits<char> >& _STLP_CALL
257 operator<<(basic_ostream<char, char_traits<char> >& __os, char __c) {
258 __os._M_put_char(__c);
259 return __os;
260 }
261
262 inline basic_ostream<char, char_traits<char> >& _STLP_CALL
263 operator<<(basic_ostream<char, char_traits<char> >& __os, signed char __c) {
264 __os._M_put_char(__c);
265 return __os;
266 }
267
268 inline basic_ostream<char, char_traits<char> >& _STLP_CALL
269 operator<<(basic_ostream<char, char_traits<char> >& __os, unsigned char __c) {
270 __os._M_put_char(__c);
271 return __os;
272 }
273
274 inline basic_ostream<char, char_traits<char> >& _STLP_CALL
275 operator<<(basic_ostream<char, char_traits<char> >& __os, const char* __s) {
276 __os._M_put_nowiden(__s);
277 return __os;
278 }
279
280 inline basic_ostream<char, char_traits<char> >& _STLP_CALL
281 operator<<(basic_ostream<char, char_traits<char> >& __os, const signed char* __s) {
282 __os._M_put_nowiden(__REINTERPRET_CAST(const char*,__s));
283 return __os;
284 }
285
286 inline basic_ostream<char, char_traits<char> >&
287 operator<<(basic_ostream<char, char_traits<char> >& __os, const unsigned char* __s) {
288 __os._M_put_nowiden(__REINTERPRET_CAST(const char*,__s));
289 return __os;
290 }
291
292 #else
293
294 // also for compilers who might use that
295 template <class _CharT, class _Traits>
296 inline basic_ostream<_CharT, _Traits>& _STLP_CALL
297 operator<<(basic_ostream<_CharT, _Traits>& __os, char __c) {
298 __os._M_put_char(__os.widen(__c));
299 return __os;
300 }
301
302 template <class _Traits>
303 inline basic_ostream<char, _Traits>& _STLP_CALL
304 operator<<(basic_ostream<char, _Traits>& __os, char __c) {
305 __os._M_put_char(__c);
306 return __os;
307 }
308
309 template <class _Traits>
310 inline basic_ostream<char, _Traits>& _STLP_CALL
311 operator<<(basic_ostream<char, _Traits>& __os, signed char __c) {
312 __os._M_put_char(__c);
313 return __os;
314 }
315
316 template <class _Traits>
317 inline basic_ostream<char, _Traits>& _STLP_CALL
318 operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c) {
319 __os._M_put_char(__c);
320 return __os;
321 }
322
323 template <class _CharT, class _Traits>
324 inline basic_ostream<_CharT, _Traits>& _STLP_CALL
325 operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __s) {
326 __os._M_put_widen(__s);
327 return __os;
328 }
329
330 template <class _Traits>
331 inline basic_ostream<char, _Traits>& _STLP_CALL
332 operator<<(basic_ostream<char, _Traits>& __os, const char* __s) {
333 __os._M_put_nowiden(__s);
334 return __os;
335 }
336
337 template <class _Traits>
338 inline basic_ostream<char, _Traits>& _STLP_CALL
339 operator<<(basic_ostream<char, _Traits>& __os, const signed char* __s) {
340 __os._M_put_nowiden(__REINTERPRET_CAST(const char*,__s));
341 return __os;
342 }
343
344 template <class _Traits>
345 inline basic_ostream<char, _Traits>&
346 operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __s) {
347 __os._M_put_nowiden(__REINTERPRET_CAST(const char*,__s));
348 return __os;
349 }
350 #endif /* _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER */
351
352 //----------------------------------------------------------------------
353 // basic_ostream manipulators.
354
355 template <class _CharT, class _Traits>
356 inline basic_ostream<_CharT, _Traits>& _STLP_CALL
endl(basic_ostream<_CharT,_Traits> & __os)357 endl(basic_ostream<_CharT, _Traits>& __os) {
358 __os.put(__os.widen('\n'));
359 __os.flush();
360 return __os;
361 }
362
363 template <class _CharT, class _Traits>
364 inline basic_ostream<_CharT, _Traits>& _STLP_CALL
ends(basic_ostream<_CharT,_Traits> & __os)365 ends(basic_ostream<_CharT, _Traits>& __os) {
366 __os.put(_STLP_DEFAULT_CONSTRUCTED(_CharT));
367 return __os;
368 }
369
370 template <class _CharT, class _Traits>
371 inline basic_ostream<_CharT, _Traits>& _STLP_CALL
flush(basic_ostream<_CharT,_Traits> & __os)372 flush(basic_ostream<_CharT, _Traits>& __os) {
373 __os.flush();
374 return __os;
375 }
376
377 _STLP_END_NAMESPACE
378
379 #if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)
380 # include <stl/_ostream.c>
381 #endif
382
383 #endif /* _STLP_INTERNAL_OSTREAM_H */
384
385 // Local Variables:
386 // mode:C++
387 // End:
388