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 #ifndef _STLP_OSTREAM_C 19 #define _STLP_OSTREAM_C 20 21 #ifndef _STLP_INTERNAL_OSTREAM_H 22 # include <stl/_ostream.h> 23 #endif 24 25 #if !defined (_STLP_INTERNAL_NUM_PUT_H) 26 # include <stl/_num_put.h> // For basic_streambuf and iterators 27 #endif 28 29 _STLP_BEGIN_NAMESPACE 30 31 //---------------------------------------------------------------------- 32 // Definitions of non-inline member functions. 33 34 // Constructor, destructor 35 36 template <class _CharT, class _Traits> 37 basic_ostream<_CharT, _Traits>::basic_ostream(basic_streambuf<_CharT, _Traits>* __buf) 38 : basic_ios<_CharT, _Traits>() { 39 this->init(__buf); 40 } 41 42 template <class _CharT, class _Traits> 43 basic_ostream<_CharT, _Traits>::~basic_ostream() 44 {} 45 46 // Output directly from a streambuf. 47 template <class _CharT, class _Traits> 48 basic_ostream<_CharT, _Traits>& 49 basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<_CharT, _Traits>* __from) { 50 sentry __sentry(*this); 51 if (__sentry) { 52 if (__from) { 53 bool __any_inserted = __from->gptr() != __from->egptr() 54 ? this->_M_copy_buffered(__from, this->rdbuf()) 55 : this->_M_copy_unbuffered(__from, this->rdbuf()); 56 if (!__any_inserted) 57 this->setstate(ios_base::failbit); 58 } 59 else 60 this->setstate(ios_base::badbit); 61 } 62 63 return *this; 64 } 65 66 // Helper functions for the streambuf version of operator<<. The 67 // exception-handling code is complicated because exceptions thrown 68 // while extracting characters are treated differently than exceptions 69 // thrown while inserting characters. 70 71 template <class _CharT, class _Traits> 72 bool basic_ostream<_CharT, _Traits> 73 ::_M_copy_buffered(basic_streambuf<_CharT, _Traits>* __from, 74 basic_streambuf<_CharT, _Traits>* __to) { 75 bool __any_inserted = false; 76 77 while (__from->egptr() != __from->gptr()) { 78 const ptrdiff_t __avail = __from->egptr() - __from->gptr(); 79 80 streamsize __nwritten; 81 _STLP_TRY { 82 __nwritten = __to->sputn(__from->gptr(), __avail); 83 __from->gbump((int)__nwritten); 84 } 85 _STLP_CATCH_ALL { 86 this->_M_handle_exception(ios_base::badbit); 87 return __any_inserted; 88 } 89 90 if (__nwritten == __avail) { 91 _STLP_TRY { 92 if (this->_S_eof(__from->sgetc())) 93 return true; 94 else 95 __any_inserted = true; 96 } 97 _STLP_CATCH_ALL { 98 this->_M_handle_exception(ios_base::failbit); 99 return false; 100 } 101 } 102 else if (__nwritten != 0) 103 return true; 104 else 105 return __any_inserted; 106 } 107 108 // No characters are in the buffer, but we aren't at EOF. Switch to 109 // unbuffered mode. 110 return __any_inserted || this->_M_copy_unbuffered(__from, __to); 111 } 112 113 /* 114 * Helper struct (guard) to put back a character in a streambuf 115 * whenever an exception or an eof occur. 116 */ 117 template <class _CharT, class _Traits> 118 struct _SPutBackC { 119 typedef basic_streambuf<_CharT, _Traits> _StreamBuf; 120 typedef typename _StreamBuf::int_type int_type; 121 _SPutBackC(_StreamBuf *pfrom) 122 : __pfrom(pfrom), __c(0), __do_guard(false) {} 123 ~_SPutBackC() { 124 if (__do_guard) { 125 __pfrom->sputbackc(_Traits::to_char_type(__c)); 126 } 127 } 128 129 void guard(int_type c) { 130 __c = c; 131 __do_guard = true; 132 } 133 void release() { 134 __do_guard = false; 135 } 136 137 private: 138 _StreamBuf *__pfrom; 139 int_type __c; 140 bool __do_guard; 141 }; 142 143 template <class _CharT, class _Traits> 144 bool basic_ostream<_CharT, _Traits> 145 ::_M_copy_unbuffered(basic_streambuf<_CharT, _Traits>* __from, 146 basic_streambuf<_CharT, _Traits>* __to) { 147 typedef _SPutBackC<_CharT, _Traits> _SPutBackCGuard; 148 bool __any_inserted = false; 149 int_type __c; 150 151 _STLP_TRY { 152 _SPutBackCGuard __cguard(__from); 153 for (;;) { 154 _STLP_TRY { 155 __c = __from->sbumpc(); 156 } 157 _STLP_CATCH_ALL { 158 this->_M_handle_exception(ios_base::failbit); 159 break; 160 } 161 162 if (this->_S_eof(__c)) 163 break; 164 165 __cguard.guard(__c); 166 #if defined (__DMC__) 167 _STLP_TRY { 168 #endif 169 if (this->_S_eof(__to->sputc(_Traits::to_char_type(__c)))) 170 break; 171 172 #if defined (__DMC__) 173 } 174 _STLP_CATCH_ALL { 175 this->_M_handle_exception(ios_base::badbit); 176 break; 177 } 178 #endif 179 __cguard.release(); 180 __any_inserted = true; 181 } 182 } 183 _STLP_CATCH_ALL { 184 this->_M_handle_exception(ios_base::badbit); 185 } 186 return __any_inserted; 187 } 188 189 _STLP_MOVE_TO_PRIV_NAMESPACE 190 191 // Helper function for numeric output. 192 template <class _CharT, class _Traits, class _Number> 193 basic_ostream<_CharT, _Traits>& _STLP_CALL 194 __put_num(basic_ostream<_CharT, _Traits>& __os, _Number __x) { 195 typedef typename basic_ostream<_CharT, _Traits>::sentry _Sentry; 196 _Sentry __sentry(__os); 197 bool __failed = true; 198 199 if (__sentry) { 200 _STLP_TRY { 201 typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> > _NumPut; 202 __failed = (use_facet<_NumPut>(__os.getloc())).put(ostreambuf_iterator<_CharT, _Traits>(__os.rdbuf()), 203 __os, __os.fill(), 204 __x).failed(); 205 } 206 _STLP_CATCH_ALL { 207 __os._M_handle_exception(ios_base::badbit); 208 } 209 } 210 if (__failed) 211 __os.setstate(ios_base::badbit); 212 return __os; 213 } 214 215 _STLP_MOVE_TO_STD_NAMESPACE 216 217 /* 218 * In the following operators we try to limit code bloat by limiting the 219 * number of __put_num instanciations. 220 */ 221 template <class _CharT, class _Traits> 222 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(short __x) { 223 _STLP_STATIC_ASSERT( sizeof(short) <= sizeof(long) ) 224 long __tmp = ((this->flags() & _Basic_ios::basefield) != ios_base::dec) ? 225 __STATIC_CAST(long, __STATIC_CAST(unsigned short, __x)): __x; 226 return _STLP_PRIV __put_num(*this, __tmp); 227 } 228 229 template <class _CharT, class _Traits> 230 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned short __x) { 231 _STLP_STATIC_ASSERT( sizeof(unsigned short) <= sizeof(unsigned long) ) 232 return _STLP_PRIV __put_num(*this, __STATIC_CAST(unsigned long,__x)); 233 } 234 235 template <class _CharT, class _Traits> 236 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(int __x) { 237 _STLP_STATIC_ASSERT( sizeof(int) <= sizeof(long) ) 238 long __tmp = ((this->flags() & _Basic_ios::basefield) != ios_base::dec) ? 239 __STATIC_CAST(long, __STATIC_CAST(unsigned int, __x)): __x; 240 return _STLP_PRIV __put_num(*this, __tmp); 241 } 242 243 template <class _CharT, class _Traits> 244 #if defined (_WIN64) || !defined (_STLP_MSVC) || (_STLP_MSVC < 1300) 245 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned int __x) { 246 _STLP_STATIC_ASSERT( sizeof(unsigned int) <= sizeof(unsigned long) ) 247 #else 248 /* We define this operator with size_t rather than unsigned int to avoid 249 * 64 bits warning. 250 */ 251 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(size_t __x) { 252 _STLP_STATIC_ASSERT( sizeof(size_t) <= sizeof(unsigned long) ) 253 #endif 254 return _STLP_PRIV __put_num(*this, __STATIC_CAST(unsigned long,__x)); 255 } 256 257 template <class _CharT, class _Traits> 258 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(long __x) 259 { return _STLP_PRIV __put_num(*this, __x); } 260 261 template <class _CharT, class _Traits> 262 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned long __x) 263 { return _STLP_PRIV __put_num(*this, __x); } 264 265 #ifdef _STLP_LONG_LONG 266 template <class _CharT, class _Traits> 267 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<< (_STLP_LONG_LONG __x) 268 { return _STLP_PRIV __put_num(*this, __x); } 269 270 template <class _CharT, class _Traits> 271 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<< (unsigned _STLP_LONG_LONG __x) 272 { return _STLP_PRIV __put_num(*this, __x); } 273 #endif 274 275 template <class _CharT, class _Traits> 276 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(float __x) 277 { return _STLP_PRIV __put_num(*this, __STATIC_CAST(double,__x)); } 278 279 template <class _CharT, class _Traits> 280 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(double __x) 281 { return _STLP_PRIV __put_num(*this, __x); } 282 283 #ifndef _STLP_NO_LONG_DOUBLE 284 template <class _CharT, class _Traits> 285 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(long double __x) 286 { return _STLP_PRIV __put_num(*this, __x); } 287 #endif 288 289 template <class _CharT, class _Traits> 290 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(const void* __x) 291 { return _STLP_PRIV __put_num(*this, __x); } 292 293 #ifndef _STLP_NO_BOOL 294 template <class _CharT, class _Traits> 295 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(bool __x) 296 { return _STLP_PRIV __put_num(*this, __x); } 297 #endif 298 299 template <class _CharT, class _Traits> 300 void basic_ostream<_CharT, _Traits>::_M_put_char(_CharT __c) { 301 sentry __sentry(*this); 302 if (__sentry) { 303 bool __failed = true; 304 _STLP_TRY { 305 streamsize __npad = this->width() > 0 ? this->width() - 1 : 0; 306 // if (__npad <= 1) 307 if (__npad == 0) 308 __failed = this->_S_eof(this->rdbuf()->sputc(__c)); 309 else if ((this->flags() & ios_base::adjustfield) == ios_base::left) { 310 __failed = this->_S_eof(this->rdbuf()->sputc(__c)); 311 __failed = __failed || 312 this->rdbuf()->_M_sputnc(this->fill(), __npad) != __npad; 313 } 314 else { 315 __failed = this->rdbuf()->_M_sputnc(this->fill(), __npad) != __npad; 316 __failed = __failed || this->_S_eof(this->rdbuf()->sputc(__c)); 317 } 318 319 this->width(0); 320 } 321 _STLP_CATCH_ALL { 322 this->_M_handle_exception(ios_base::badbit); 323 } 324 325 if (__failed) 326 this->setstate(ios_base::badbit); 327 } 328 } 329 330 template <class _CharT, class _Traits> 331 void basic_ostream<_CharT, _Traits>::_M_put_nowiden(const _CharT* __s) { 332 sentry __sentry(*this); 333 if (__sentry) { 334 bool __failed = true; 335 streamsize __n = _Traits::length(__s); 336 streamsize __npad = this->width() > __n ? this->width() - __n : 0; 337 338 _STLP_TRY { 339 if (__npad == 0) 340 __failed = this->rdbuf()->sputn(__s, __n) != __n; 341 else if ((this->flags() & ios_base::adjustfield) == ios_base::left) { 342 __failed = this->rdbuf()->sputn(__s, __n) != __n; 343 __failed = __failed || 344 this->rdbuf()->_M_sputnc(this->fill(), __npad) != __npad; 345 } 346 else { 347 __failed = this->rdbuf()->_M_sputnc(this->fill(), __npad) != __npad; 348 __failed = __failed || this->rdbuf()->sputn(__s, __n) != __n; 349 } 350 351 this->width(0); 352 } 353 _STLP_CATCH_ALL { 354 this->_M_handle_exception(ios_base::badbit); 355 } 356 357 if (__failed) 358 this->setstate(ios_base::failbit); 359 } 360 } 361 362 template <class _CharT, class _Traits> 363 void basic_ostream<_CharT, _Traits>::_M_put_widen(const char* __s) { 364 sentry __sentry(*this); 365 if (__sentry) { 366 bool __failed = true; 367 streamsize __n = char_traits<char>::length(__s); 368 streamsize __npad = this->width() > __n ? this->width() - __n : 0; 369 370 _STLP_TRY { 371 if (__npad == 0) 372 __failed = !this->_M_put_widen_aux(__s, __n); 373 else if ((this->flags() & ios_base::adjustfield) == ios_base::left) { 374 __failed = !this->_M_put_widen_aux(__s, __n); 375 __failed = __failed || 376 this->rdbuf()->_M_sputnc(this->fill(), __npad) != __npad; 377 } 378 else { 379 __failed = this->rdbuf()->_M_sputnc(this->fill(), __npad) != __npad; 380 __failed = __failed || !this->_M_put_widen_aux(__s, __n); 381 } 382 383 this->width(0); 384 } 385 _STLP_CATCH_ALL { 386 this->_M_handle_exception(ios_base::badbit); 387 } 388 389 if (__failed) 390 this->setstate(ios_base::failbit); 391 } 392 } 393 394 template <class _CharT, class _Traits> 395 bool basic_ostream<_CharT, _Traits>::_M_put_widen_aux(const char* __s, 396 streamsize __n) { 397 basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf(); 398 399 for ( ; __n > 0 ; --__n) 400 if (this->_S_eof(__buf->sputc(this->widen(*__s++)))) 401 return false; 402 return true; 403 } 404 405 // Unformatted output of a single character. 406 template <class _CharT, class _Traits> 407 basic_ostream<_CharT, _Traits>& 408 basic_ostream<_CharT, _Traits>::put(char_type __c) { 409 sentry __sentry(*this); 410 bool __failed = true; 411 412 if (__sentry) { 413 _STLP_TRY { 414 __failed = this->_S_eof(this->rdbuf()->sputc(__c)); 415 } 416 _STLP_CATCH_ALL { 417 this->_M_handle_exception(ios_base::badbit); 418 } 419 } 420 421 if (__failed) 422 this->setstate(ios_base::badbit); 423 424 return *this; 425 } 426 427 // Unformatted output of a single character. 428 template <class _CharT, class _Traits> 429 basic_ostream<_CharT, _Traits>& 430 basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n) { 431 sentry __sentry(*this); 432 bool __failed = true; 433 434 if (__sentry) { 435 _STLP_TRY { 436 __failed = this->rdbuf()->sputn(__s, __n) != __n; 437 } 438 _STLP_CATCH_ALL { 439 this->_M_handle_exception(ios_base::badbit); 440 } 441 } 442 443 if (__failed) 444 this->setstate(ios_base::badbit); 445 446 return *this; 447 } 448 449 _STLP_END_NAMESPACE 450 451 #endif /* _STLP_OSTREAM_C */ 452 453 // Local Variables: 454 // mode:C++ 455 // End: 456
