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