1 : // ostream classes -*- C++ -*-
2 :
3 : // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
4 : // Free Software Foundation, Inc.
5 : //
6 : // This file is part of the GNU ISO C++ Library. This library is free
7 : // software; you can redistribute it and/or modify it under the
8 : // terms of the GNU General Public License as published by the
9 : // Free Software Foundation; either version 2, or (at your option)
10 : // any later version.
11 :
12 : // This library is distributed in the hope that it will be useful,
13 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : // GNU General Public License for more details.
16 :
17 : // You should have received a copy of the GNU General Public License along
18 : // with this library; see the file COPYING. If not, write to the Free
19 : // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
20 : // USA.
21 :
22 : // As a special exception, you may use this file as part of a free software
23 : // library without restriction. Specifically, if other files instantiate
24 : // templates or use macros or inline functions from this file, or you compile
25 : // this file and link it with other files to produce an executable, this
26 : // file does not by itself cause the resulting executable to be covered by
27 : // the GNU General Public License. This exception does not however
28 : // invalidate any other reasons why the executable file might be covered by
29 : // the GNU General Public License.
30 :
31 : /** @file ostream.tcc
32 : * This is an internal header file, included by other library headers.
33 : * You should not attempt to use it directly.
34 : */
35 :
36 : //
37 : // ISO C++ 14882: 27.6.2 Output streams
38 : //
39 :
40 : #ifndef _OSTREAM_TCC
41 : #define _OSTREAM_TCC 1
42 :
43 : #pragma GCC system_header
44 :
45 : #include <locale>
46 :
47 : namespace std
48 : {
49 : template<typename _CharT, typename _Traits>
50 : basic_ostream<_CharT, _Traits>::sentry::
51 : sentry(basic_ostream<_CharT, _Traits>& __os)
52 : : _M_ok(false), _M_os(__os)
53 : {
54 : // XXX MT
55 : if (__os.tie() && __os.good())
56 : __os.tie()->flush();
57 :
58 : if (__os.good())
59 : _M_ok = true;
60 : else
61 : __os.setstate(ios_base::failbit);
62 : }
63 :
64 : template<typename _CharT, typename _Traits>
65 : basic_ostream<_CharT, _Traits>&
66 : basic_ostream<_CharT, _Traits>::
67 : operator<<(__ostream_type& (*__pf)(__ostream_type&))
68 : {
69 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
70 : // DR 60. What is a formatted input function?
71 : // The inserters for manipulators are *not* formatted output functions.
72 80909 : return __pf(*this);
73 : }
74 :
75 : template<typename _CharT, typename _Traits>
76 : basic_ostream<_CharT, _Traits>&
77 : basic_ostream<_CharT, _Traits>::
78 : operator<<(__ios_type& (*__pf)(__ios_type&))
79 : {
80 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
81 : // DR 60. What is a formatted input function?
82 : // The inserters for manipulators are *not* formatted output functions.
83 : __pf(*this);
84 : return *this;
85 : }
86 :
87 : template<typename _CharT, typename _Traits>
88 : basic_ostream<_CharT, _Traits>&
89 : basic_ostream<_CharT, _Traits>::
90 : operator<<(ios_base& (*__pf)(ios_base&))
91 : {
92 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
93 : // DR 60. What is a formatted input function?
94 : // The inserters for manipulators are *not* formatted output functions.
95 : __pf(*this);
96 : return *this;
97 : }
98 :
99 : template<typename _CharT, typename _Traits>
100 : basic_ostream<_CharT, _Traits>&
101 : basic_ostream<_CharT, _Traits>::
102 : operator<<(bool __n)
103 : {
104 : sentry __cerb(*this);
105 : if (__cerb)
106 : {
107 : ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
108 : try
109 : {
110 : const __num_put_type& __np = __check_facet(this->_M_num_put);
111 : if (__np.put(*this, *this, this->fill(), __n).failed())
112 : __err |= ios_base::badbit;
113 : }
114 : catch(...)
115 : { this->_M_setstate(ios_base::badbit); }
116 : if (__err)
117 : this->setstate(__err);
118 : }
119 : return *this;
120 : }
121 :
122 : template<typename _CharT, typename _Traits>
123 : basic_ostream<_CharT, _Traits>&
124 : basic_ostream<_CharT, _Traits>::
125 : operator<<(long __n)
126 : {
127 : sentry __cerb(*this);
128 : if (__cerb)
129 : {
130 : ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
131 : try
132 : {
133 : bool __b = false;
134 : const char_type __c = this->fill();
135 : const ios_base::fmtflags __fmt = (this->flags()
136 : & ios_base::basefield);
137 : const __num_put_type& __np = __check_facet(this->_M_num_put);
138 : if ((__fmt == ios_base::oct) || (__fmt == ios_base::hex))
139 : {
140 : const unsigned long __l = static_cast<unsigned long>(__n);
141 : __b = __np.put(*this, *this, __c, __l).failed();
142 : }
143 : else
144 : __b = __np.put(*this, *this, __c, __n).failed();
145 : if (__b)
146 : __err |= ios_base::badbit;
147 : }
148 : catch(...)
149 : { this->_M_setstate(ios_base::badbit); }
150 : if (__err)
151 : this->setstate(__err);
152 : }
153 : return *this;
154 : }
155 :
156 : template<typename _CharT, typename _Traits>
157 : basic_ostream<_CharT, _Traits>&
158 : basic_ostream<_CharT, _Traits>::
159 : operator<<(unsigned long __n)
160 : {
161 : sentry __cerb(*this);
162 : if (__cerb)
163 : {
164 : ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
165 : try
166 : {
167 : const __num_put_type& __np = __check_facet(this->_M_num_put);
168 : if (__np.put(*this, *this, this->fill(), __n).failed())
169 : __err |= ios_base::badbit;
170 : }
171 : catch(...)
172 : { this->_M_setstate(ios_base::badbit); }
173 : if (__err)
174 : this->setstate(__err);
175 : }
176 : return *this;
177 : }
178 :
179 : #ifdef _GLIBCXX_USE_LONG_LONG
180 : template<typename _CharT, typename _Traits>
181 : basic_ostream<_CharT, _Traits>&
182 : basic_ostream<_CharT, _Traits>::
183 : operator<<(long long __n)
184 : {
185 : sentry __cerb(*this);
186 : if (__cerb)
187 : {
188 : ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
189 : try
190 : {
191 : bool __b = false;
192 : const char_type __c = this->fill();
193 : const ios_base::fmtflags __fmt = (this->flags()
194 : & ios_base::basefield);
195 : const __num_put_type& __np = __check_facet(this->_M_num_put);
196 : if ((__fmt == ios_base::oct) || (__fmt == ios_base::hex))
197 : {
198 : const unsigned long long __l = (static_cast<
199 : unsigned long long>(__n));
200 : __b = __np.put(*this, *this, __c, __l).failed();
201 : }
202 : else
203 : __b = __np.put(*this, *this, __c, __n).failed();
204 : if (__b)
205 : __err |= ios_base::badbit;
206 : }
207 : catch(...)
208 : { this->_M_setstate(ios_base::badbit); }
209 : if (__err)
210 : this->setstate(__err);
211 : }
212 : return *this;
213 : }
214 :
215 : template<typename _CharT, typename _Traits>
216 : basic_ostream<_CharT, _Traits>&
217 : basic_ostream<_CharT, _Traits>::
218 : operator<<(unsigned long long __n)
219 : {
220 : sentry __cerb(*this);
221 : if (__cerb)
222 : {
223 : ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
224 : try
225 : {
226 : const __num_put_type& __np = __check_facet(this->_M_num_put);
227 : if (__np.put(*this, *this, this->fill(), __n).failed())
228 : __err |= ios_base::badbit;
229 : }
230 : catch(...)
231 : { this->_M_setstate(ios_base::badbit); }
232 : if (__err)
233 : this->setstate(__err);
234 : }
235 : return *this;
236 : }
237 : #endif
238 :
239 : template<typename _CharT, typename _Traits>
240 : basic_ostream<_CharT, _Traits>&
241 : basic_ostream<_CharT, _Traits>::
242 : operator<<(double __n)
243 : {
244 : sentry __cerb(*this);
245 : if (__cerb)
246 : {
247 : ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
248 : try
249 : {
250 : const __num_put_type& __np = __check_facet(this->_M_num_put);
251 : if (__np.put(*this, *this, this->fill(), __n).failed())
252 : __err |= ios_base::badbit;
253 : }
254 : catch(...)
255 : { this->_M_setstate(ios_base::badbit); }
256 : if (__err)
257 : this->setstate(__err);
258 : }
259 : return *this;
260 : }
261 :
262 : template<typename _CharT, typename _Traits>
263 : basic_ostream<_CharT, _Traits>&
264 : basic_ostream<_CharT, _Traits>::
265 : operator<<(long double __n)
266 : {
267 : sentry __cerb(*this);
268 : if (__cerb)
269 : {
270 : ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
271 : try
272 : {
273 : const __num_put_type& __np = __check_facet(this->_M_num_put);
274 : if (__np.put(*this, *this, this->fill(), __n).failed())
275 : __err |= ios_base::badbit;
276 : }
277 : catch(...)
278 : { this->_M_setstate(ios_base::badbit); }
279 : if (__err)
280 : this->setstate(__err);
281 : }
282 : return *this;
283 : }
284 :
285 : template<typename _CharT, typename _Traits>
286 : basic_ostream<_CharT, _Traits>&
287 : basic_ostream<_CharT, _Traits>::
288 : operator<<(const void* __n)
289 : {
290 : sentry __cerb(*this);
291 : if (__cerb)
292 : {
293 : ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
294 : try
295 : {
296 : const __num_put_type& __np = __check_facet(this->_M_num_put);
297 : if (__np.put(*this, *this, this->fill(), __n).failed())
298 : __err |= ios_base::badbit;
299 : }
300 : catch(...)
301 : { this->_M_setstate(ios_base::badbit); }
302 : if (__err)
303 : this->setstate(__err);
304 : }
305 : return *this;
306 : }
307 :
308 : template<typename _CharT, typename _Traits>
309 : basic_ostream<_CharT, _Traits>&
310 : basic_ostream<_CharT, _Traits>::
311 : operator<<(__streambuf_type* __sbin)
312 : {
313 : ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
314 : sentry __cerb(*this);
315 : if (__cerb && __sbin)
316 : {
317 : try
318 : {
319 : if (!__copy_streambufs(__sbin, this->rdbuf()))
320 : __err |= ios_base::failbit;
321 : }
322 : catch(...)
323 : { this->_M_setstate(ios_base::failbit); }
324 : }
325 : else if (!__sbin)
326 : __err |= ios_base::badbit;
327 : if (__err)
328 : this->setstate(__err);
329 : return *this;
330 : }
331 :
332 : template<typename _CharT, typename _Traits>
333 : basic_ostream<_CharT, _Traits>&
334 : basic_ostream<_CharT, _Traits>::
335 : put(char_type __c)
336 : {
337 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
338 : // DR 60. What is a formatted input function?
339 : // basic_ostream::put(char_type) is an unformatted output function.
340 : // DR 63. Exception-handling policy for unformatted output.
341 : // Unformatted output functions should catch exceptions thrown
342 : // from streambuf members.
343 : sentry __cerb(*this);
344 : if (__cerb)
345 : {
346 : ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
347 : try
348 : {
349 : const int_type __put = this->rdbuf()->sputc(__c);
350 : if (traits_type::eq_int_type(__put, traits_type::eof()))
351 : __err |= ios_base::badbit;
352 : }
353 : catch (...)
354 : { this->_M_setstate(ios_base::badbit); }
355 : if (__err)
356 : this->setstate(__err);
357 : }
358 : return *this;
359 : }
360 :
361 : template<typename _CharT, typename _Traits>
362 : basic_ostream<_CharT, _Traits>&
363 : basic_ostream<_CharT, _Traits>::
364 : write(const _CharT* __s, streamsize __n)
365 : {
366 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
367 : // DR 60. What is a formatted input function?
368 : // basic_ostream::write(const char_type*, streamsize) is an
369 : // unformatted output function.
370 : // DR 63. Exception-handling policy for unformatted output.
371 : // Unformatted output functions should catch exceptions thrown
372 : // from streambuf members.
373 : sentry __cerb(*this);
374 : if (__cerb)
375 : {
376 : try
377 : { _M_write(__s, __n); }
378 : catch (...)
379 : { this->_M_setstate(ios_base::badbit); }
380 : }
381 : return *this;
382 : }
383 :
384 : template<typename _CharT, typename _Traits>
385 : basic_ostream<_CharT, _Traits>&
386 : basic_ostream<_CharT, _Traits>::
387 : flush()
388 : {
389 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
390 : // DR 60. What is a formatted input function?
391 : // basic_ostream::flush() is *not* an unformatted output function.
392 : ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
393 : try
394 : {
395 : if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
396 : __err |= ios_base::badbit;
397 : }
398 : catch(...)
399 : { this->_M_setstate(ios_base::badbit); }
400 : if (__err)
401 : this->setstate(__err);
402 : return *this;
403 : }
404 :
405 : template<typename _CharT, typename _Traits>
406 : typename basic_ostream<_CharT, _Traits>::pos_type
407 : basic_ostream<_CharT, _Traits>::
408 : tellp()
409 : {
410 : pos_type __ret = pos_type(-1);
411 : try
412 : {
413 : if (!this->fail())
414 : __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
415 : }
416 : catch(...)
417 : { this->_M_setstate(ios_base::badbit); }
418 : return __ret;
419 : }
420 :
421 : template<typename _CharT, typename _Traits>
422 : basic_ostream<_CharT, _Traits>&
423 : basic_ostream<_CharT, _Traits>::
424 : seekp(pos_type __pos)
425 : {
426 : ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
427 : try
428 : {
429 : if (!this->fail())
430 : {
431 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
432 : // 136. seekp, seekg setting wrong streams?
433 : const pos_type __p = this->rdbuf()->pubseekpos(__pos,
434 : ios_base::out);
435 :
436 : // 129. Need error indication from seekp() and seekg()
437 : if (__p == pos_type(off_type(-1)))
438 : __err |= ios_base::failbit;
439 : }
440 : }
441 : catch(...)
442 : { this->_M_setstate(ios_base::badbit); }
443 : if (__err)
444 : this->setstate(__err);
445 : return *this;
446 : }
447 :
448 : template<typename _CharT, typename _Traits>
449 : basic_ostream<_CharT, _Traits>&
450 : basic_ostream<_CharT, _Traits>::
451 : seekp(off_type __off, ios_base::seekdir __dir)
452 : {
453 : ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
454 : try
455 : {
456 : if (!this->fail())
457 : {
458 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
459 : // 136. seekp, seekg setting wrong streams?
460 : const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
461 : ios_base::out);
462 :
463 : // 129. Need error indication from seekp() and seekg()
464 : if (__p == pos_type(off_type(-1)))
465 : __err |= ios_base::failbit;
466 : }
467 : }
468 : catch(...)
469 : { this->_M_setstate(ios_base::badbit); }
470 : if (__err)
471 : this->setstate(__err);
472 : return *this;
473 : }
474 :
475 : // 27.6.2.5.4 Character inserters.
476 : template<typename _CharT, typename _Traits>
477 : basic_ostream<_CharT, _Traits>&
478 : operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
479 : {
480 : typedef basic_ostream<_CharT, _Traits> __ostream_type;
481 : typename __ostream_type::sentry __cerb(__out);
482 : if (__cerb)
483 : {
484 : try
485 : {
486 : const streamsize __w = __out.width();
487 : streamsize __len = 1;
488 : _CharT* __cs = &__c;
489 : if (__w > __len)
490 : {
491 : __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
492 : * __w));
493 : __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
494 : &__c, __w, __len, false);
495 : __len = __w;
496 : }
497 : __out._M_write(__cs, __len);
498 : __out.width(0);
499 : }
500 : catch(...)
501 : { __out._M_setstate(ios_base::badbit); }
502 : }
503 : return __out;
504 : }
505 :
506 : // Specializations.
507 : template <class _Traits>
508 : basic_ostream<char, _Traits>&
509 : operator<<(basic_ostream<char, _Traits>& __out, char __c)
510 : {
511 : typedef basic_ostream<char, _Traits> __ostream_type;
512 : typename __ostream_type::sentry __cerb(__out);
513 : if (__cerb)
514 : {
515 : try
516 : {
517 : const streamsize __w = __out.width();
518 : streamsize __len = 1;
519 : char* __cs = &__c;
520 : if (__w > __len)
521 : {
522 : __cs = static_cast<char*>(__builtin_alloca(__w));
523 : __pad<char, _Traits>::_S_pad(__out, __out.fill(), __cs,
524 : &__c, __w, __len, false);
525 : __len = __w;
526 : }
527 : __out._M_write(__cs, __len);
528 : __out.width(0);
529 : }
530 : catch(...)
531 : { __out._M_setstate(ios_base::badbit); }
532 : }
533 : return __out;
534 : }
535 :
536 : template<typename _CharT, typename _Traits>
537 : basic_ostream<_CharT, _Traits>&
538 : operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
539 : {
540 : typedef basic_ostream<_CharT, _Traits> __ostream_type;
541 : typename __ostream_type::sentry __cerb(__out);
542 : if (__cerb && __s)
543 : {
544 : try
545 : {
546 : const streamsize __w = __out.width();
547 : streamsize __len = static_cast<streamsize>(_Traits::length(__s));
548 : if (__w > __len)
549 : {
550 : _CharT* __cs = (static_cast<
551 : _CharT*>(__builtin_alloca(sizeof(_CharT)
552 : * __w)));
553 : __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
554 : __s, __w, __len, false);
555 : __s = __cs;
556 : __len = __w;
557 : }
558 : __out._M_write(__s, __len);
559 : __out.width(0);
560 : }
561 : catch(...)
562 : { __out._M_setstate(ios_base::badbit); }
563 : }
564 : else if (!__s)
565 : __out.setstate(ios_base::badbit);
566 : return __out;
567 : }
568 :
569 : template<typename _CharT, typename _Traits>
570 : basic_ostream<_CharT, _Traits>&
571 : operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
572 : {
573 : typedef basic_ostream<_CharT, _Traits> __ostream_type;
574 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
575 : // 167. Improper use of traits_type::length()
576 : // Note that this is only in 'Review' status.
577 : typedef char_traits<char> __traits_type;
578 : typename __ostream_type::sentry __cerb(__out);
579 : if (__cerb && __s)
580 : {
581 : size_t __clen = __traits_type::length(__s);
582 : _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
583 : * __clen));
584 : for (size_t __i = 0; __i < __clen; ++__i)
585 : __ws[__i] = __out.widen(__s[__i]);
586 : _CharT* __str = __ws;
587 :
588 : try
589 : {
590 : const streamsize __w = __out.width();
591 : streamsize __len = static_cast<streamsize>(__clen);
592 : if (__w > __len)
593 : {
594 : _CharT* __cs = (static_cast<
595 : _CharT*>(__builtin_alloca(sizeof(_CharT)
596 : * __w)));
597 : __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
598 : __ws, __w, __len, false);
599 : __str = __cs;
600 : __len = __w;
601 : }
602 : __out._M_write(__str, __len);
603 : __out.width(0);
604 : }
605 : catch(...)
606 : { __out._M_setstate(ios_base::badbit); }
607 : }
608 : else if (!__s)
609 : __out.setstate(ios_base::badbit);
610 : return __out;
611 : }
612 :
613 : // Partial specializations.
614 : template<class _Traits>
615 : basic_ostream<char, _Traits>&
616 : operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
617 : {
618 : typedef basic_ostream<char, _Traits> __ostream_type;
619 : typename __ostream_type::sentry __cerb(__out);
620 : if (__cerb && __s)
621 : {
622 : try
623 : {
624 : const streamsize __w = __out.width();
625 : streamsize __len = static_cast<streamsize>(_Traits::length(__s));
626 : if (__w > __len)
627 : {
628 : char* __cs = static_cast<char*>(__builtin_alloca(__w));
629 : __pad<char, _Traits>::_S_pad(__out, __out.fill(), __cs,
630 : __s, __w, __len, false);
631 : __s = __cs;
632 : __len = __w;
633 : }
634 : __out._M_write(__s, __len);
635 : __out.width(0);
636 : }
637 : catch(...)
638 : { __out._M_setstate(ios_base::badbit); }
639 : }
640 : else if (!__s)
641 : __out.setstate(ios_base::badbit);
642 : return __out;
643 : }
644 :
645 : // 21.3.7.9 basic_string::operator<<
646 : template<typename _CharT, typename _Traits, typename _Alloc>
647 : basic_ostream<_CharT, _Traits>&
648 : operator<<(basic_ostream<_CharT, _Traits>& __out,
649 : const basic_string<_CharT, _Traits, _Alloc>& __str)
650 : {
651 : typedef basic_ostream<_CharT, _Traits> __ostream_type;
652 : typename __ostream_type::sentry __cerb(__out);
653 : if (__cerb)
654 : {
655 : const streamsize __w = __out.width();
656 : streamsize __len = static_cast<streamsize>(__str.size());
657 : const _CharT* __s = __str.data();
658 :
659 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
660 : // 25. String operator<< uses width() value wrong
661 : if (__w > __len)
662 : {
663 : _CharT* __cs = (static_cast<
664 : _CharT*>(__builtin_alloca(sizeof(_CharT) * __w)));
665 : __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs, __s,
666 : __w, __len, false);
667 : __s = __cs;
668 : __len = __w;
669 : }
670 : __out._M_write(__s, __len);
671 : __out.width(0);
672 : }
673 : return __out;
674 : }
675 :
676 : // Inhibit implicit instantiations for required instantiations,
677 : // which are defined via explicit instantiations elsewhere.
678 : // NB: This syntax is a GNU extension.
679 : #if _GLIBCXX_EXTERN_TEMPLATE
680 : extern template class basic_ostream<char>;
681 : extern template ostream& endl(ostream&);
682 : extern template ostream& ends(ostream&);
683 : extern template ostream& flush(ostream&);
684 : extern template ostream& operator<<(ostream&, char);
685 : extern template ostream& operator<<(ostream&, unsigned char);
686 : extern template ostream& operator<<(ostream&, signed char);
687 : extern template ostream& operator<<(ostream&, const char*);
688 : extern template ostream& operator<<(ostream&, const unsigned char*);
689 : extern template ostream& operator<<(ostream&, const signed char*);
690 :
691 : #ifdef _GLIBCXX_USE_WCHAR_T
692 : extern template class basic_ostream<wchar_t>;
693 : extern template wostream& endl(wostream&);
694 : extern template wostream& ends(wostream&);
695 : extern template wostream& flush(wostream&);
696 : extern template wostream& operator<<(wostream&, wchar_t);
697 : extern template wostream& operator<<(wostream&, char);
698 : extern template wostream& operator<<(wostream&, const wchar_t*);
699 : extern template wostream& operator<<(wostream&, const char*);
700 : #endif
701 : #endif
702 : } // namespace std
703 :
704 : #endif
|
