1 // -*- C++ -*- 2 //===------------------------- fstream ------------------------------------===// 3 // 4 // The LLVM Compiler Infrastructure 5 // 6 // This file is dual licensed under the MIT and the University of Illinois Open 7 // Source Licenses. See LICENSE.TXT for details. 8 // 9 //===----------------------------------------------------------------------===// 10 11 #ifndef _LIBCPP_FSTREAM 12 #define _LIBCPP_FSTREAM 13 14 /* 15 fstream synopsis 16 17 template <class charT, class traits = char_traits<charT> > 18 class basic_filebuf 19 : public basic_streambuf<charT, traits> 20 { 21 public: 22 typedef charT char_type; 23 typedef traits traits_type; 24 typedef typename traits_type::int_type int_type; 25 typedef typename traits_type::pos_type pos_type; 26 typedef typename traits_type::off_type off_type; 27 28 // 27.9.1.2 Constructors/destructor: 29 basic_filebuf(); 30 basic_filebuf(basic_filebuf&& rhs); 31 virtual ~basic_filebuf(); 32 33 // 27.9.1.3 Assign/swap: 34 basic_filebuf& operator=(basic_filebuf&& rhs); 35 void swap(basic_filebuf& rhs); 36 37 // 27.9.1.4 Members: 38 bool is_open() const; 39 basic_filebuf* open(const char* s, ios_base::openmode mode); 40 basic_filebuf* open(const string& s, ios_base::openmode mode); 41 basic_filebuf* close(); 42 43 protected: 44 // 27.9.1.5 Overridden virtual functions: 45 virtual streamsize showmanyc(); 46 virtual int_type underflow(); 47 virtual int_type uflow(); 48 virtual int_type pbackfail(int_type c = traits_type::eof()); 49 virtual int_type overflow (int_type c = traits_type::eof()); 50 virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* s, streamsize n); 51 virtual pos_type seekoff(off_type off, ios_base::seekdir way, 52 ios_base::openmode which = ios_base::in | ios_base::out); 53 virtual pos_type seekpos(pos_type sp, 54 ios_base::openmode which = ios_base::in | ios_base::out); 55 virtual int sync(); 56 virtual void imbue(const locale& loc); 57 }; 58 59 template <class charT, class traits> 60 void 61 swap(basic_filebuf<charT, traits>& x, basic_filebuf<charT, traits>& y); 62 63 typedef basic_filebuf<char> filebuf; 64 typedef basic_filebuf<wchar_t> wfilebuf; 65 66 template <class charT, class traits = char_traits<charT> > 67 class basic_ifstream 68 : public basic_istream<charT,traits> 69 { 70 public: 71 typedef charT char_type; 72 typedef traits traits_type; 73 typedef typename traits_type::int_type int_type; 74 typedef typename traits_type::pos_type pos_type; 75 typedef typename traits_type::off_type off_type; 76 77 basic_ifstream(); 78 explicit basic_ifstream(const char* s, ios_base::openmode mode = ios_base::in); 79 explicit basic_ifstream(const string& s, ios_base::openmode mode = ios_base::in); 80 basic_ifstream(basic_ifstream&& rhs); 81 82 basic_ifstream& operator=(basic_ifstream&& rhs); 83 void swap(basic_ifstream& rhs); 84 85 basic_filebuf<char_type, traits_type>* rdbuf() const; 86 bool is_open() const; 87 void open(const char* s, ios_base::openmode mode = ios_base::in); 88 void open(const string& s, ios_base::openmode mode = ios_base::in); 89 void close(); 90 }; 91 92 template <class charT, class traits> 93 void 94 swap(basic_ifstream<charT, traits>& x, basic_ifstream<charT, traits>& y); 95 96 typedef basic_ifstream<char> ifstream; 97 typedef basic_ifstream<wchar_t> wifstream; 98 99 template <class charT, class traits = char_traits<charT> > 100 class basic_ofstream 101 : public basic_ostream<charT,traits> 102 { 103 public: 104 typedef charT char_type; 105 typedef traits traits_type; 106 typedef typename traits_type::int_type int_type; 107 typedef typename traits_type::pos_type pos_type; 108 typedef typename traits_type::off_type off_type; 109 110 basic_ofstream(); 111 explicit basic_ofstream(const char* s, ios_base::openmode mode = ios_base::out); 112 explicit basic_ofstream(const string& s, ios_base::openmode mode = ios_base::out); 113 basic_ofstream(basic_ofstream&& rhs); 114 115 basic_ofstream& operator=(basic_ofstream&& rhs); 116 void swap(basic_ofstream& rhs); 117 118 basic_filebuf<char_type, traits_type>* rdbuf() const; 119 bool is_open() const; 120 void open(const char* s, ios_base::openmode mode = ios_base::out); 121 void open(const string& s, ios_base::openmode mode = ios_base::out); 122 void close(); 123 }; 124 125 template <class charT, class traits> 126 void 127 swap(basic_ofstream<charT, traits>& x, basic_ofstream<charT, traits>& y); 128 129 typedef basic_ofstream<char> ofstream; 130 typedef basic_ofstream<wchar_t> wofstream; 131 132 template <class charT, class traits=char_traits<charT> > 133 class basic_fstream 134 : public basic_iostream<charT,traits> 135 { 136 public: 137 typedef charT char_type; 138 typedef traits traits_type; 139 typedef typename traits_type::int_type int_type; 140 typedef typename traits_type::pos_type pos_type; 141 typedef typename traits_type::off_type off_type; 142 143 basic_fstream(); 144 explicit basic_fstream(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out); 145 explicit basic_fstream(const string& s, ios_base::openmode mode = ios_base::in|ios_base::out); 146 basic_fstream(basic_fstream&& rhs); 147 148 basic_fstream& operator=(basic_fstream&& rhs); 149 void swap(basic_fstream& rhs); 150 151 basic_filebuf<char_type, traits_type>* rdbuf() const; 152 bool is_open() const; 153 void open(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out); 154 void open(const string& s, ios_base::openmode mode = ios_base::in|ios_base::out); 155 void close(); 156 }; 157 158 template <class charT, class traits> 159 void swap(basic_fstream<charT, traits>& x, basic_fstream<charT, traits>& y); 160 161 typedef basic_fstream<char> fstream; 162 typedef basic_fstream<wchar_t> wfstream; 163 164 } // std 165 166 */ 167 168 #include <__config> 169 #include <ostream> 170 #include <istream> 171 #include <__locale> 172 #include <cstdio> 173 174 #include <__undef_min_max> 175 176 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 177 #pragma GCC system_header 178 #endif 179 180 _LIBCPP_BEGIN_NAMESPACE_STD 181 182 template <class _CharT, class _Traits> 183 class _LIBCPP_TEMPLATE_VIS basic_filebuf 184 : public basic_streambuf<_CharT, _Traits> 185 { 186 public: 187 typedef _CharT char_type; 188 typedef _Traits traits_type; 189 typedef typename traits_type::int_type int_type; 190 typedef typename traits_type::pos_type pos_type; 191 typedef typename traits_type::off_type off_type; 192 typedef typename traits_type::state_type state_type; 193 194 // 27.9.1.2 Constructors/destructor: 195 basic_filebuf(); 196 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 197 basic_filebuf(basic_filebuf&& __rhs); 198 #endif 199 virtual ~basic_filebuf(); 200 201 // 27.9.1.3 Assign/swap: 202 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 203 _LIBCPP_INLINE_VISIBILITY 204 basic_filebuf& operator=(basic_filebuf&& __rhs); 205 #endif 206 void swap(basic_filebuf& __rhs); 207 208 // 27.9.1.4 Members: 209 _LIBCPP_INLINE_VISIBILITY 210 bool is_open() const; 211 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE 212 basic_filebuf* open(const char* __s, ios_base::openmode __mode); 213 _LIBCPP_INLINE_VISIBILITY 214 basic_filebuf* open(const string& __s, ios_base::openmode __mode); 215 #endif 216 basic_filebuf* close(); 217 218 protected: 219 // 27.9.1.5 Overridden virtual functions: 220 virtual int_type underflow(); 221 virtual int_type pbackfail(int_type __c = traits_type::eof()); 222 virtual int_type overflow (int_type __c = traits_type::eof()); 223 virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* __s, streamsize __n); 224 virtual pos_type seekoff(off_type __off, ios_base::seekdir __way, 225 ios_base::openmode __wch = ios_base::in | ios_base::out); 226 virtual pos_type seekpos(pos_type __sp, 227 ios_base::openmode __wch = ios_base::in | ios_base::out); 228 virtual int sync(); 229 virtual void imbue(const locale& __loc); 230 231 private: 232 char* __extbuf_; 233 const char* __extbufnext_; 234 const char* __extbufend_; 235 char __extbuf_min_[8]; 236 size_t __ebs_; 237 char_type* __intbuf_; 238 size_t __ibs_; 239 FILE* __file_; 240 const codecvt<char_type, char, state_type>* __cv_; 241 state_type __st_; 242 state_type __st_last_; 243 ios_base::openmode __om_; 244 ios_base::openmode __cm_; 245 bool __owns_eb_; 246 bool __owns_ib_; 247 bool __always_noconv_; 248 249 bool __read_mode(); 250 void __write_mode(); 251 }; 252 253 template <class _CharT, class _Traits> 254 basic_filebuf<_CharT, _Traits>::basic_filebuf() 255 : __extbuf_(0), 256 __extbufnext_(0), 257 __extbufend_(0), 258 __ebs_(0), 259 __intbuf_(0), 260 __ibs_(0), 261 __file_(0), 262 __cv_(nullptr), 263 __st_(), 264 __st_last_(), 265 __om_(0), 266 __cm_(0), 267 __owns_eb_(false), 268 __owns_ib_(false), 269 __always_noconv_(false) 270 { 271 if (has_facet<codecvt<char_type, char, state_type> >(this->getloc())) 272 { 273 __cv_ = &use_facet<codecvt<char_type, char, state_type> >(this->getloc()); 274 __always_noconv_ = __cv_->always_noconv(); 275 } 276 setbuf(0, 4096); 277 } 278 279 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 280 281 template <class _CharT, class _Traits> 282 basic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs) 283 : basic_streambuf<_CharT, _Traits>(__rhs) 284 { 285 if (__rhs.__extbuf_ == __rhs.__extbuf_min_) 286 { 287 __extbuf_ = __extbuf_min_; 288 __extbufnext_ = __extbuf_ + (__rhs.__extbufnext_ - __rhs.__extbuf_); 289 __extbufend_ = __extbuf_ + (__rhs.__extbufend_ - __rhs.__extbuf_); 290 } 291 else 292 { 293 __extbuf_ = __rhs.__extbuf_; 294 __extbufnext_ = __rhs.__extbufnext_; 295 __extbufend_ = __rhs.__extbufend_; 296 } 297 __ebs_ = __rhs.__ebs_; 298 __intbuf_ = __rhs.__intbuf_; 299 __ibs_ = __rhs.__ibs_; 300 __file_ = __rhs.__file_; 301 __cv_ = __rhs.__cv_; 302 __st_ = __rhs.__st_; 303 __st_last_ = __rhs.__st_last_; 304 __om_ = __rhs.__om_; 305 __cm_ = __rhs.__cm_; 306 __owns_eb_ = __rhs.__owns_eb_; 307 __owns_ib_ = __rhs.__owns_ib_; 308 __always_noconv_ = __rhs.__always_noconv_; 309 if (__rhs.pbase()) 310 { 311 if (__rhs.pbase() == __rhs.__intbuf_) 312 this->setp(__intbuf_, __intbuf_ + (__rhs. epptr() - __rhs.pbase())); 313 else 314 this->setp((char_type*)__extbuf_, 315 (char_type*)__extbuf_ + (__rhs. epptr() - __rhs.pbase())); 316 this->pbump(__rhs. pptr() - __rhs.pbase()); 317 } 318 else if (__rhs.eback()) 319 { 320 if (__rhs.eback() == __rhs.__intbuf_) 321 this->setg(__intbuf_, __intbuf_ + (__rhs.gptr() - __rhs.eback()), 322 __intbuf_ + (__rhs.egptr() - __rhs.eback())); 323 else 324 this->setg((char_type*)__extbuf_, 325 (char_type*)__extbuf_ + (__rhs.gptr() - __rhs.eback()), 326 (char_type*)__extbuf_ + (__rhs.egptr() - __rhs.eback())); 327 } 328 __rhs.__extbuf_ = 0; 329 __rhs.__extbufnext_ = 0; 330 __rhs.__extbufend_ = 0; 331 __rhs.__ebs_ = 0; 332 __rhs.__intbuf_ = 0; 333 __rhs.__ibs_ = 0; 334 __rhs.__file_ = 0; 335 __rhs.__st_ = state_type(); 336 __rhs.__st_last_ = state_type(); 337 __rhs.__om_ = 0; 338 __rhs.__cm_ = 0; 339 __rhs.__owns_eb_ = false; 340 __rhs.__owns_ib_ = false; 341 __rhs.setg(0, 0, 0); 342 __rhs.setp(0, 0); 343 } 344 345 template <class _CharT, class _Traits> 346 inline 347 basic_filebuf<_CharT, _Traits>& 348 basic_filebuf<_CharT, _Traits>::operator=(basic_filebuf&& __rhs) 349 { 350 close(); 351 swap(__rhs); 352 return *this; 353 } 354 355 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 356 357 template <class _CharT, class _Traits> 358 basic_filebuf<_CharT, _Traits>::~basic_filebuf() 359 { 360 #ifndef _LIBCPP_NO_EXCEPTIONS 361 try 362 { 363 #endif // _LIBCPP_NO_EXCEPTIONS 364 close(); 365 #ifndef _LIBCPP_NO_EXCEPTIONS 366 } 367 catch (...) 368 { 369 } 370 #endif // _LIBCPP_NO_EXCEPTIONS 371 if (__owns_eb_) 372 delete [] __extbuf_; 373 if (__owns_ib_) 374 delete [] __intbuf_; 375 } 376 377 template <class _CharT, class _Traits> 378 void 379 basic_filebuf<_CharT, _Traits>::swap(basic_filebuf& __rhs) 380 { 381 basic_streambuf<char_type, traits_type>::swap(__rhs); 382 if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_) 383 { 384 _VSTD::swap(__extbuf_, __rhs.__extbuf_); 385 _VSTD::swap(__extbufnext_, __rhs.__extbufnext_); 386 _VSTD::swap(__extbufend_, __rhs.__extbufend_); 387 } 388 else 389 { 390 ptrdiff_t __ln = __extbufnext_ - __extbuf_; 391 ptrdiff_t __le = __extbufend_ - __extbuf_; 392 ptrdiff_t __rn = __rhs.__extbufnext_ - __rhs.__extbuf_; 393 ptrdiff_t __re = __rhs.__extbufend_ - __rhs.__extbuf_; 394 if (__extbuf_ == __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_) 395 { 396 __extbuf_ = __rhs.__extbuf_; 397 __rhs.__extbuf_ = __rhs.__extbuf_min_; 398 } 399 else if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ == __rhs.__extbuf_min_) 400 { 401 __rhs.__extbuf_ = __extbuf_; 402 __extbuf_ = __extbuf_min_; 403 } 404 __extbufnext_ = __extbuf_ + __rn; 405 __extbufend_ = __extbuf_ + __re; 406 __rhs.__extbufnext_ = __rhs.__extbuf_ + __ln; 407 __rhs.__extbufend_ = __rhs.__extbuf_ + __le; 408 } 409 _VSTD::swap(__ebs_, __rhs.__ebs_); 410 _VSTD::swap(__intbuf_, __rhs.__intbuf_); 411 _VSTD::swap(__ibs_, __rhs.__ibs_); 412 _VSTD::swap(__file_, __rhs.__file_); 413 _VSTD::swap(__cv_, __rhs.__cv_); 414 _VSTD::swap(__st_, __rhs.__st_); 415 _VSTD::swap(__st_last_, __rhs.__st_last_); 416 _VSTD::swap(__om_, __rhs.__om_); 417 _VSTD::swap(__cm_, __rhs.__cm_); 418 _VSTD::swap(__owns_eb_, __rhs.__owns_eb_); 419 _VSTD::swap(__owns_ib_, __rhs.__owns_ib_); 420 _VSTD::swap(__always_noconv_, __rhs.__always_noconv_); 421 if (this->eback() == (char_type*)__rhs.__extbuf_min_) 422 { 423 ptrdiff_t __n = this->gptr() - this->eback(); 424 ptrdiff_t __e = this->egptr() - this->eback(); 425 this->setg((char_type*)__extbuf_min_, 426 (char_type*)__extbuf_min_ + __n, 427 (char_type*)__extbuf_min_ + __e); 428 } 429 else if (this->pbase() == (char_type*)__rhs.__extbuf_min_) 430 { 431 ptrdiff_t __n = this->pptr() - this->pbase(); 432 ptrdiff_t __e = this->epptr() - this->pbase(); 433 this->setp((char_type*)__extbuf_min_, 434 (char_type*)__extbuf_min_ + __e); 435 this->pbump(__n); 436 } 437 if (__rhs.eback() == (char_type*)__extbuf_min_) 438 { 439 ptrdiff_t __n = __rhs.gptr() - __rhs.eback(); 440 ptrdiff_t __e = __rhs.egptr() - __rhs.eback(); 441 __rhs.setg((char_type*)__rhs.__extbuf_min_, 442 (char_type*)__rhs.__extbuf_min_ + __n, 443 (char_type*)__rhs.__extbuf_min_ + __e); 444 } 445 else if (__rhs.pbase() == (char_type*)__extbuf_min_) 446 { 447 ptrdiff_t __n = __rhs.pptr() - __rhs.pbase(); 448 ptrdiff_t __e = __rhs.epptr() - __rhs.pbase(); 449 __rhs.setp((char_type*)__rhs.__extbuf_min_, 450 (char_type*)__rhs.__extbuf_min_ + __e); 451 __rhs.pbump(__n); 452 } 453 } 454 455 template <class _CharT, class _Traits> 456 inline _LIBCPP_INLINE_VISIBILITY 457 void 458 swap(basic_filebuf<_CharT, _Traits>& __x, basic_filebuf<_CharT, _Traits>& __y) 459 { 460 __x.swap(__y); 461 } 462 463 template <class _CharT, class _Traits> 464 inline 465 bool 466 basic_filebuf<_CharT, _Traits>::is_open() const 467 { 468 return __file_ != 0; 469 } 470 471 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE 472 template <class _CharT, class _Traits> 473 basic_filebuf<_CharT, _Traits>* 474 basic_filebuf<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) 475 { 476 basic_filebuf<_CharT, _Traits>* __rt = 0; 477 if (__file_ == 0) 478 { 479 __rt = this; 480 const char* __mdstr; 481 switch (__mode & ~ios_base::ate) 482 { 483 case ios_base::out: 484 case ios_base::out | ios_base::trunc: 485 __mdstr = "w"; 486 break; 487 case ios_base::out | ios_base::app: 488 case ios_base::app: 489 __mdstr = "a"; 490 break; 491 case ios_base::in: 492 __mdstr = "r"; 493 break; 494 case ios_base::in | ios_base::out: 495 __mdstr = "r+"; 496 break; 497 case ios_base::in | ios_base::out | ios_base::trunc: 498 __mdstr = "w+"; 499 break; 500 case ios_base::in | ios_base::out | ios_base::app: 501 case ios_base::in | ios_base::app: 502 __mdstr = "a+"; 503 break; 504 case ios_base::out | ios_base::binary: 505 case ios_base::out | ios_base::trunc | ios_base::binary: 506 __mdstr = "wb"; 507 break; 508 case ios_base::out | ios_base::app | ios_base::binary: 509 case ios_base::app | ios_base::binary: 510 __mdstr = "ab"; 511 break; 512 case ios_base::in | ios_base::binary: 513 __mdstr = "rb"; 514 break; 515 case ios_base::in | ios_base::out | ios_base::binary: 516 __mdstr = "r+b"; 517 break; 518 case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary: 519 __mdstr = "w+b"; 520 break; 521 case ios_base::in | ios_base::out | ios_base::app | ios_base::binary: 522 case ios_base::in | ios_base::app | ios_base::binary: 523 __mdstr = "a+b"; 524 break; 525 default: 526 __rt = 0; 527 break; 528 } 529 if (__rt) 530 { 531 __file_ = fopen(__s, __mdstr); 532 if (__file_) 533 { 534 __om_ = __mode; 535 if (__mode & ios_base::ate) 536 { 537 if (fseek(__file_, 0, SEEK_END)) 538 { 539 fclose(__file_); 540 __file_ = 0; 541 __rt = 0; 542 } 543 } 544 } 545 else 546 __rt = 0; 547 } 548 } 549 return __rt; 550 } 551 552 template <class _CharT, class _Traits> 553 inline 554 basic_filebuf<_CharT, _Traits>* 555 basic_filebuf<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) 556 { 557 return open(__s.c_str(), __mode); 558 } 559 #endif 560 561 template <class _CharT, class _Traits> 562 basic_filebuf<_CharT, _Traits>* 563 basic_filebuf<_CharT, _Traits>::close() 564 { 565 basic_filebuf<_CharT, _Traits>* __rt = 0; 566 if (__file_) 567 { 568 __rt = this; 569 unique_ptr<FILE, int(*)(FILE*)> __h(__file_, fclose); 570 if (sync()) 571 __rt = 0; 572 if (fclose(__h.release()) == 0) 573 __file_ = 0; 574 else 575 __rt = 0; 576 } 577 return __rt; 578 } 579 580 template <class _CharT, class _Traits> 581 typename basic_filebuf<_CharT, _Traits>::int_type 582 basic_filebuf<_CharT, _Traits>::underflow() 583 { 584 if (__file_ == 0) 585 return traits_type::eof(); 586 bool __initial = __read_mode(); 587 char_type __1buf; 588 if (this->gptr() == 0) 589 this->setg(&__1buf, &__1buf+1, &__1buf+1); 590 const size_t __unget_sz = __initial ? 0 : min<size_t>((this->egptr() - this->eback()) / 2, 4); 591 int_type __c = traits_type::eof(); 592 if (this->gptr() == this->egptr()) 593 { 594 memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz * sizeof(char_type)); 595 if (__always_noconv_) 596 { 597 size_t __nmemb = static_cast<size_t>(this->egptr() - this->eback() - __unget_sz); 598 __nmemb = fread(this->eback() + __unget_sz, 1, __nmemb, __file_); 599 if (__nmemb != 0) 600 { 601 this->setg(this->eback(), 602 this->eback() + __unget_sz, 603 this->eback() + __unget_sz + __nmemb); 604 __c = traits_type::to_int_type(*this->gptr()); 605 } 606 } 607 else 608 { 609 _LIBCPP_ASSERT ( !(__extbufnext_ == NULL && (__extbufend_ != __extbufnext_)), "underflow moving from NULL" ); 610 if (__extbufend_ != __extbufnext_) 611 memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_); 612 __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_); 613 __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_); 614 size_t __nmemb = _VSTD::min(static_cast<size_t>(__ibs_ - __unget_sz), 615 static_cast<size_t>(__extbufend_ - __extbufnext_)); 616 codecvt_base::result __r; 617 __st_last_ = __st_; 618 size_t __nr = fread((void*)__extbufnext_, 1, __nmemb, __file_); 619 if (__nr != 0) 620 { 621 if (!__cv_) 622 __throw_bad_cast(); 623 624 __extbufend_ = __extbufnext_ + __nr; 625 char_type* __inext; 626 __r = __cv_->in(__st_, __extbuf_, __extbufend_, __extbufnext_, 627 this->eback() + __unget_sz, 628 this->eback() + __ibs_, __inext); 629 if (__r == codecvt_base::noconv) 630 { 631 this->setg((char_type*)__extbuf_, (char_type*)__extbuf_, (char_type*)__extbufend_); 632 __c = traits_type::to_int_type(*this->gptr()); 633 } 634 else if (__inext != this->eback() + __unget_sz) 635 { 636 this->setg(this->eback(), this->eback() + __unget_sz, __inext); 637 __c = traits_type::to_int_type(*this->gptr()); 638 } 639 } 640 } 641 } 642 else 643 __c = traits_type::to_int_type(*this->gptr()); 644 if (this->eback() == &__1buf) 645 this->setg(0, 0, 0); 646 return __c; 647 } 648 649 template <class _CharT, class _Traits> 650 typename basic_filebuf<_CharT, _Traits>::int_type 651 basic_filebuf<_CharT, _Traits>::pbackfail(int_type __c) 652 { 653 if (__file_ && this->eback() < this->gptr()) 654 { 655 if (traits_type::eq_int_type(__c, traits_type::eof())) 656 { 657 this->gbump(-1); 658 return traits_type::not_eof(__c); 659 } 660 if ((__om_ & ios_base::out) || 661 traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1])) 662 { 663 this->gbump(-1); 664 *this->gptr() = traits_type::to_char_type(__c); 665 return __c; 666 } 667 } 668 return traits_type::eof(); 669 } 670 671 template <class _CharT, class _Traits> 672 typename basic_filebuf<_CharT, _Traits>::int_type 673 basic_filebuf<_CharT, _Traits>::overflow(int_type __c) 674 { 675 if (__file_ == 0) 676 return traits_type::eof(); 677 __write_mode(); 678 char_type __1buf; 679 char_type* __pb_save = this->pbase(); 680 char_type* __epb_save = this->epptr(); 681 if (!traits_type::eq_int_type(__c, traits_type::eof())) 682 { 683 if (this->pptr() == 0) 684 this->setp(&__1buf, &__1buf+1); 685 *this->pptr() = traits_type::to_char_type(__c); 686 this->pbump(1); 687 } 688 if (this->pptr() != this->pbase()) 689 { 690 if (__always_noconv_) 691 { 692 size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase()); 693 if (fwrite(this->pbase(), sizeof(char_type), __nmemb, __file_) != __nmemb) 694 return traits_type::eof(); 695 } 696 else 697 { 698 char* __extbe = __extbuf_; 699 codecvt_base::result __r; 700 do 701 { 702 if (!__cv_) 703 __throw_bad_cast(); 704 705 const char_type* __e; 706 __r = __cv_->out(__st_, this->pbase(), this->pptr(), __e, 707 __extbuf_, __extbuf_ + __ebs_, __extbe); 708 if (__e == this->pbase()) 709 return traits_type::eof(); 710 if (__r == codecvt_base::noconv) 711 { 712 size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase()); 713 if (fwrite(this->pbase(), 1, __nmemb, __file_) != __nmemb) 714 return traits_type::eof(); 715 } 716 else if (__r == codecvt_base::ok || __r == codecvt_base::partial) 717 { 718 size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_); 719 if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb) 720 return traits_type::eof(); 721 if (__r == codecvt_base::partial) 722 { 723 this->setp((char_type*)__e, this->pptr()); 724 this->pbump(this->epptr() - this->pbase()); 725 } 726 } 727 else 728 return traits_type::eof(); 729 } while (__r == codecvt_base::partial); 730 } 731 this->setp(__pb_save, __epb_save); 732 } 733 return traits_type::not_eof(__c); 734 } 735 736 template <class _CharT, class _Traits> 737 basic_streambuf<_CharT, _Traits>* 738 basic_filebuf<_CharT, _Traits>::setbuf(char_type* __s, streamsize __n) 739 { 740 this->setg(0, 0, 0); 741 this->setp(0, 0); 742 if (__owns_eb_) 743 delete [] __extbuf_; 744 if (__owns_ib_) 745 delete [] __intbuf_; 746 __ebs_ = __n; 747 if (__ebs_ > sizeof(__extbuf_min_)) 748 { 749 if (__always_noconv_ && __s) 750 { 751 __extbuf_ = (char*)__s; 752 __owns_eb_ = false; 753 } 754 else 755 { 756 __extbuf_ = new char[__ebs_]; 757 __owns_eb_ = true; 758 } 759 } 760 else 761 { 762 __extbuf_ = __extbuf_min_; 763 __ebs_ = sizeof(__extbuf_min_); 764 __owns_eb_ = false; 765 } 766 if (!__always_noconv_) 767 { 768 __ibs_ = max<streamsize>(__n, sizeof(__extbuf_min_)); 769 if (__s && __ibs_ >= sizeof(__extbuf_min_)) 770 { 771 __intbuf_ = __s; 772 __owns_ib_ = false; 773 } 774 else 775 { 776 __intbuf_ = new char_type[__ibs_]; 777 __owns_ib_ = true; 778 } 779 } 780 else 781 { 782 __ibs_ = 0; 783 __intbuf_ = 0; 784 __owns_ib_ = false; 785 } 786 return this; 787 } 788 789 template <class _CharT, class _Traits> 790 typename basic_filebuf<_CharT, _Traits>::pos_type 791 basic_filebuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way, 792 ios_base::openmode) 793 { 794 if (!__cv_) 795 __throw_bad_cast(); 796 797 int __width = __cv_->encoding(); 798 if (__file_ == 0 || (__width <= 0 && __off != 0) || sync()) 799 return pos_type(off_type(-1)); 800 // __width > 0 || __off == 0 801 int __whence; 802 switch (__way) 803 { 804 case ios_base::beg: 805 __whence = SEEK_SET; 806 break; 807 case ios_base::cur: 808 __whence = SEEK_CUR; 809 break; 810 case ios_base::end: 811 __whence = SEEK_END; 812 break; 813 default: 814 return pos_type(off_type(-1)); 815 } 816 #if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS) 817 if (fseek(__file_, __width > 0 ? __width * __off : 0, __whence)) 818 return pos_type(off_type(-1)); 819 pos_type __r = ftell(__file_); 820 #else 821 if (fseeko(__file_, __width > 0 ? __width * __off : 0, __whence)) 822 return pos_type(off_type(-1)); 823 pos_type __r = ftello(__file_); 824 #endif 825 __r.state(__st_); 826 return __r; 827 } 828 829 template <class _CharT, class _Traits> 830 typename basic_filebuf<_CharT, _Traits>::pos_type 831 basic_filebuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode) 832 { 833 if (__file_ == 0 || sync()) 834 return pos_type(off_type(-1)); 835 #if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS) 836 if (fseek(__file_, __sp, SEEK_SET)) 837 return pos_type(off_type(-1)); 838 #else 839 if (fseeko(__file_, __sp, SEEK_SET)) 840 return pos_type(off_type(-1)); 841 #endif 842 __st_ = __sp.state(); 843 return __sp; 844 } 845 846 template <class _CharT, class _Traits> 847 int 848 basic_filebuf<_CharT, _Traits>::sync() 849 { 850 if (__file_ == 0) 851 return 0; 852 if (!__cv_) 853 __throw_bad_cast(); 854 855 if (__cm_ & ios_base::out) 856 { 857 if (this->pptr() != this->pbase()) 858 if (overflow() == traits_type::eof()) 859 return -1; 860 codecvt_base::result __r; 861 do 862 { 863 char* __extbe; 864 __r = __cv_->unshift(__st_, __extbuf_, __extbuf_ + __ebs_, __extbe); 865 size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_); 866 if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb) 867 return -1; 868 } while (__r == codecvt_base::partial); 869 if (__r == codecvt_base::error) 870 return -1; 871 if (fflush(__file_)) 872 return -1; 873 } 874 else if (__cm_ & ios_base::in) 875 { 876 off_type __c; 877 state_type __state = __st_last_; 878 bool __update_st = false; 879 if (__always_noconv_) 880 __c = this->egptr() - this->gptr(); 881 else 882 { 883 int __width = __cv_->encoding(); 884 __c = __extbufend_ - __extbufnext_; 885 if (__width > 0) 886 __c += __width * (this->egptr() - this->gptr()); 887 else 888 { 889 if (this->gptr() != this->egptr()) 890 { 891 const int __off = __cv_->length(__state, __extbuf_, 892 __extbufnext_, 893 this->gptr() - this->eback()); 894 __c += __extbufnext_ - __extbuf_ - __off; 895 __update_st = true; 896 } 897 } 898 } 899 #if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS) 900 if (fseek(__file_, -__c, SEEK_CUR)) 901 return -1; 902 #else 903 if (fseeko(__file_, -__c, SEEK_CUR)) 904 return -1; 905 #endif 906 if (__update_st) 907 __st_ = __state; 908 __extbufnext_ = __extbufend_ = __extbuf_; 909 this->setg(0, 0, 0); 910 __cm_ = 0; 911 } 912 return 0; 913 } 914 915 template <class _CharT, class _Traits> 916 void 917 basic_filebuf<_CharT, _Traits>::imbue(const locale& __loc) 918 { 919 sync(); 920 __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc); 921 bool __old_anc = __always_noconv_; 922 __always_noconv_ = __cv_->always_noconv(); 923 if (__old_anc != __always_noconv_) 924 { 925 this->setg(0, 0, 0); 926 this->setp(0, 0); 927 // invariant, char_type is char, else we couldn't get here 928 if (__always_noconv_) // need to dump __intbuf_ 929 { 930 if (__owns_eb_) 931 delete [] __extbuf_; 932 __owns_eb_ = __owns_ib_; 933 __ebs_ = __ibs_; 934 __extbuf_ = (char*)__intbuf_; 935 __ibs_ = 0; 936 __intbuf_ = 0; 937 __owns_ib_ = false; 938 } 939 else // need to obtain an __intbuf_. 940 { // If __extbuf_ is user-supplied, use it, else new __intbuf_ 941 if (!__owns_eb_ && __extbuf_ != __extbuf_min_) 942 { 943 __ibs_ = __ebs_; 944 __intbuf_ = (char_type*)__extbuf_; 945 __owns_ib_ = false; 946 __extbuf_ = new char[__ebs_]; 947 __owns_eb_ = true; 948 } 949 else 950 { 951 __ibs_ = __ebs_; 952 __intbuf_ = new char_type[__ibs_]; 953 __owns_ib_ = true; 954 } 955 } 956 } 957 } 958 959 template <class _CharT, class _Traits> 960 bool 961 basic_filebuf<_CharT, _Traits>::__read_mode() 962 { 963 if (!(__cm_ & ios_base::in)) 964 { 965 this->setp(0, 0); 966 if (__always_noconv_) 967 this->setg((char_type*)__extbuf_, 968 (char_type*)__extbuf_ + __ebs_, 969 (char_type*)__extbuf_ + __ebs_); 970 else 971 this->setg(__intbuf_, __intbuf_ + __ibs_, __intbuf_ + __ibs_); 972 __cm_ = ios_base::in; 973 return true; 974 } 975 return false; 976 } 977 978 template <class _CharT, class _Traits> 979 void 980 basic_filebuf<_CharT, _Traits>::__write_mode() 981 { 982 if (!(__cm_ & ios_base::out)) 983 { 984 this->setg(0, 0, 0); 985 if (__ebs_ > sizeof(__extbuf_min_)) 986 { 987 if (__always_noconv_) 988 this->setp((char_type*)__extbuf_, 989 (char_type*)__extbuf_ + (__ebs_ - 1)); 990 else 991 this->setp(__intbuf_, __intbuf_ + (__ibs_ - 1)); 992 } 993 else 994 this->setp(0, 0); 995 __cm_ = ios_base::out; 996 } 997 } 998 999 // basic_ifstream 1000 1001 template <class _CharT, class _Traits> 1002 class _LIBCPP_TEMPLATE_VIS basic_ifstream 1003 : public basic_istream<_CharT, _Traits> 1004 { 1005 public: 1006 typedef _CharT char_type; 1007 typedef _Traits traits_type; 1008 typedef typename traits_type::int_type int_type; 1009 typedef typename traits_type::pos_type pos_type; 1010 typedef typename traits_type::off_type off_type; 1011 1012 _LIBCPP_INLINE_VISIBILITY 1013 basic_ifstream(); 1014 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE 1015 _LIBCPP_INLINE_VISIBILITY 1016 explicit basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in); 1017 _LIBCPP_INLINE_VISIBILITY 1018 explicit basic_ifstream(const string& __s, ios_base::openmode __mode = ios_base::in); 1019 #endif 1020 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1021 _LIBCPP_INLINE_VISIBILITY 1022 basic_ifstream(basic_ifstream&& __rhs); 1023 #endif 1024 1025 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1026 _LIBCPP_INLINE_VISIBILITY 1027 basic_ifstream& operator=(basic_ifstream&& __rhs); 1028 #endif 1029 _LIBCPP_INLINE_VISIBILITY 1030 void swap(basic_ifstream& __rhs); 1031 1032 _LIBCPP_INLINE_VISIBILITY 1033 basic_filebuf<char_type, traits_type>* rdbuf() const; 1034 _LIBCPP_INLINE_VISIBILITY 1035 bool is_open() const; 1036 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE 1037 void open(const char* __s, ios_base::openmode __mode = ios_base::in); 1038 void open(const string& __s, ios_base::openmode __mode = ios_base::in); 1039 #endif 1040 _LIBCPP_INLINE_VISIBILITY 1041 void close(); 1042 1043 private: 1044 basic_filebuf<char_type, traits_type> __sb_; 1045 }; 1046 1047 template <class _CharT, class _Traits> 1048 inline 1049 basic_ifstream<_CharT, _Traits>::basic_ifstream() 1050 : basic_istream<char_type, traits_type>(&__sb_) 1051 { 1052 } 1053 1054 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE 1055 template <class _CharT, class _Traits> 1056 inline 1057 basic_ifstream<_CharT, _Traits>::basic_ifstream(const char* __s, ios_base::openmode __mode) 1058 : basic_istream<char_type, traits_type>(&__sb_) 1059 { 1060 if (__sb_.open(__s, __mode | ios_base::in) == 0) 1061 this->setstate(ios_base::failbit); 1062 } 1063 1064 template <class _CharT, class _Traits> 1065 inline 1066 basic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::openmode __mode) 1067 : basic_istream<char_type, traits_type>(&__sb_) 1068 { 1069 if (__sb_.open(__s, __mode | ios_base::in) == 0) 1070 this->setstate(ios_base::failbit); 1071 } 1072 #endif 1073 1074 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1075 1076 template <class _CharT, class _Traits> 1077 inline 1078 basic_ifstream<_CharT, _Traits>::basic_ifstream(basic_ifstream&& __rhs) 1079 : basic_istream<char_type, traits_type>(_VSTD::move(__rhs)), 1080 __sb_(_VSTD::move(__rhs.__sb_)) 1081 { 1082 this->set_rdbuf(&__sb_); 1083 } 1084 1085 template <class _CharT, class _Traits> 1086 inline 1087 basic_ifstream<_CharT, _Traits>& 1088 basic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs) 1089 { 1090 basic_istream<char_type, traits_type>::operator=(_VSTD::move(__rhs)); 1091 __sb_ = _VSTD::move(__rhs.__sb_); 1092 return *this; 1093 } 1094 1095 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1096 1097 template <class _CharT, class _Traits> 1098 inline 1099 void 1100 basic_ifstream<_CharT, _Traits>::swap(basic_ifstream& __rhs) 1101 { 1102 basic_istream<char_type, traits_type>::swap(__rhs); 1103 __sb_.swap(__rhs.__sb_); 1104 } 1105 1106 template <class _CharT, class _Traits> 1107 inline _LIBCPP_INLINE_VISIBILITY 1108 void 1109 swap(basic_ifstream<_CharT, _Traits>& __x, basic_ifstream<_CharT, _Traits>& __y) 1110 { 1111 __x.swap(__y); 1112 } 1113 1114 template <class _CharT, class _Traits> 1115 inline 1116 basic_filebuf<_CharT, _Traits>* 1117 basic_ifstream<_CharT, _Traits>::rdbuf() const 1118 { 1119 return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_); 1120 } 1121 1122 template <class _CharT, class _Traits> 1123 inline 1124 bool 1125 basic_ifstream<_CharT, _Traits>::is_open() const 1126 { 1127 return __sb_.is_open(); 1128 } 1129 1130 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE 1131 template <class _CharT, class _Traits> 1132 void 1133 basic_ifstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) 1134 { 1135 if (__sb_.open(__s, __mode | ios_base::in)) 1136 this->clear(); 1137 else 1138 this->setstate(ios_base::failbit); 1139 } 1140 1141 template <class _CharT, class _Traits> 1142 void 1143 basic_ifstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) 1144 { 1145 if (__sb_.open(__s, __mode | ios_base::in)) 1146 this->clear(); 1147 else 1148 this->setstate(ios_base::failbit); 1149 } 1150 #endif 1151 1152 template <class _CharT, class _Traits> 1153 inline 1154 void 1155 basic_ifstream<_CharT, _Traits>::close() 1156 { 1157 if (__sb_.close() == 0) 1158 this->setstate(ios_base::failbit); 1159 } 1160 1161 // basic_ofstream 1162 1163 template <class _CharT, class _Traits> 1164 class _LIBCPP_TEMPLATE_VIS basic_ofstream 1165 : public basic_ostream<_CharT, _Traits> 1166 { 1167 public: 1168 typedef _CharT char_type; 1169 typedef _Traits traits_type; 1170 typedef typename traits_type::int_type int_type; 1171 typedef typename traits_type::pos_type pos_type; 1172 typedef typename traits_type::off_type off_type; 1173 1174 _LIBCPP_INLINE_VISIBILITY 1175 basic_ofstream(); 1176 _LIBCPP_INLINE_VISIBILITY 1177 explicit basic_ofstream(const char* __s, ios_base::openmode __mode = ios_base::out); 1178 _LIBCPP_INLINE_VISIBILITY 1179 explicit basic_ofstream(const string& __s, ios_base::openmode __mode = ios_base::out); 1180 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1181 _LIBCPP_INLINE_VISIBILITY 1182 basic_ofstream(basic_ofstream&& __rhs); 1183 #endif 1184 1185 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1186 _LIBCPP_INLINE_VISIBILITY 1187 basic_ofstream& operator=(basic_ofstream&& __rhs); 1188 #endif 1189 _LIBCPP_INLINE_VISIBILITY 1190 void swap(basic_ofstream& __rhs); 1191 1192 _LIBCPP_INLINE_VISIBILITY 1193 basic_filebuf<char_type, traits_type>* rdbuf() const; 1194 _LIBCPP_INLINE_VISIBILITY 1195 bool is_open() const; 1196 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE 1197 void open(const char* __s, ios_base::openmode __mode = ios_base::out); 1198 void open(const string& __s, ios_base::openmode __mode = ios_base::out); 1199 #endif 1200 _LIBCPP_INLINE_VISIBILITY 1201 void close(); 1202 1203 private: 1204 basic_filebuf<char_type, traits_type> __sb_; 1205 }; 1206 1207 template <class _CharT, class _Traits> 1208 inline 1209 basic_ofstream<_CharT, _Traits>::basic_ofstream() 1210 : basic_ostream<char_type, traits_type>(&__sb_) 1211 { 1212 } 1213 1214 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE 1215 template <class _CharT, class _Traits> 1216 inline 1217 basic_ofstream<_CharT, _Traits>::basic_ofstream(const char* __s, ios_base::openmode __mode) 1218 : basic_ostream<char_type, traits_type>(&__sb_) 1219 { 1220 if (__sb_.open(__s, __mode | ios_base::out) == 0) 1221 this->setstate(ios_base::failbit); 1222 } 1223 1224 template <class _CharT, class _Traits> 1225 inline 1226 basic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::openmode __mode) 1227 : basic_ostream<char_type, traits_type>(&__sb_) 1228 { 1229 if (__sb_.open(__s, __mode | ios_base::out) == 0) 1230 this->setstate(ios_base::failbit); 1231 } 1232 #endif 1233 1234 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1235 1236 template <class _CharT, class _Traits> 1237 inline 1238 basic_ofstream<_CharT, _Traits>::basic_ofstream(basic_ofstream&& __rhs) 1239 : basic_ostream<char_type, traits_type>(_VSTD::move(__rhs)), 1240 __sb_(_VSTD::move(__rhs.__sb_)) 1241 { 1242 this->set_rdbuf(&__sb_); 1243 } 1244 1245 template <class _CharT, class _Traits> 1246 inline 1247 basic_ofstream<_CharT, _Traits>& 1248 basic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs) 1249 { 1250 basic_ostream<char_type, traits_type>::operator=(_VSTD::move(__rhs)); 1251 __sb_ = _VSTD::move(__rhs.__sb_); 1252 return *this; 1253 } 1254 1255 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1256 1257 template <class _CharT, class _Traits> 1258 inline 1259 void 1260 basic_ofstream<_CharT, _Traits>::swap(basic_ofstream& __rhs) 1261 { 1262 basic_ostream<char_type, traits_type>::swap(__rhs); 1263 __sb_.swap(__rhs.__sb_); 1264 } 1265 1266 template <class _CharT, class _Traits> 1267 inline _LIBCPP_INLINE_VISIBILITY 1268 void 1269 swap(basic_ofstream<_CharT, _Traits>& __x, basic_ofstream<_CharT, _Traits>& __y) 1270 { 1271 __x.swap(__y); 1272 } 1273 1274 template <class _CharT, class _Traits> 1275 inline 1276 basic_filebuf<_CharT, _Traits>* 1277 basic_ofstream<_CharT, _Traits>::rdbuf() const 1278 { 1279 return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_); 1280 } 1281 1282 template <class _CharT, class _Traits> 1283 inline 1284 bool 1285 basic_ofstream<_CharT, _Traits>::is_open() const 1286 { 1287 return __sb_.is_open(); 1288 } 1289 1290 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE 1291 template <class _CharT, class _Traits> 1292 void 1293 basic_ofstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) 1294 { 1295 if (__sb_.open(__s, __mode | ios_base::out)) 1296 this->clear(); 1297 else 1298 this->setstate(ios_base::failbit); 1299 } 1300 1301 template <class _CharT, class _Traits> 1302 void 1303 basic_ofstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) 1304 { 1305 if (__sb_.open(__s, __mode | ios_base::out)) 1306 this->clear(); 1307 else 1308 this->setstate(ios_base::failbit); 1309 } 1310 #endif 1311 1312 template <class _CharT, class _Traits> 1313 inline 1314 void 1315 basic_ofstream<_CharT, _Traits>::close() 1316 { 1317 if (__sb_.close() == 0) 1318 this->setstate(ios_base::failbit); 1319 } 1320 1321 // basic_fstream 1322 1323 template <class _CharT, class _Traits> 1324 class _LIBCPP_TEMPLATE_VIS basic_fstream 1325 : public basic_iostream<_CharT, _Traits> 1326 { 1327 public: 1328 typedef _CharT char_type; 1329 typedef _Traits traits_type; 1330 typedef typename traits_type::int_type int_type; 1331 typedef typename traits_type::pos_type pos_type; 1332 typedef typename traits_type::off_type off_type; 1333 1334 _LIBCPP_INLINE_VISIBILITY 1335 basic_fstream(); 1336 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE 1337 _LIBCPP_INLINE_VISIBILITY 1338 explicit basic_fstream(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 1339 _LIBCPP_INLINE_VISIBILITY 1340 explicit basic_fstream(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 1341 #endif 1342 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1343 _LIBCPP_INLINE_VISIBILITY 1344 basic_fstream(basic_fstream&& __rhs); 1345 #endif 1346 1347 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1348 _LIBCPP_INLINE_VISIBILITY 1349 basic_fstream& operator=(basic_fstream&& __rhs); 1350 #endif 1351 _LIBCPP_INLINE_VISIBILITY 1352 void swap(basic_fstream& __rhs); 1353 1354 _LIBCPP_INLINE_VISIBILITY 1355 basic_filebuf<char_type, traits_type>* rdbuf() const; 1356 _LIBCPP_INLINE_VISIBILITY 1357 bool is_open() const; 1358 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE 1359 void open(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 1360 void open(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 1361 #endif 1362 _LIBCPP_INLINE_VISIBILITY 1363 void close(); 1364 1365 private: 1366 basic_filebuf<char_type, traits_type> __sb_; 1367 }; 1368 1369 template <class _CharT, class _Traits> 1370 inline 1371 basic_fstream<_CharT, _Traits>::basic_fstream() 1372 : basic_iostream<char_type, traits_type>(&__sb_) 1373 { 1374 } 1375 1376 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE 1377 template <class _CharT, class _Traits> 1378 inline 1379 basic_fstream<_CharT, _Traits>::basic_fstream(const char* __s, ios_base::openmode __mode) 1380 : basic_iostream<char_type, traits_type>(&__sb_) 1381 { 1382 if (__sb_.open(__s, __mode) == 0) 1383 this->setstate(ios_base::failbit); 1384 } 1385 1386 template <class _CharT, class _Traits> 1387 inline 1388 basic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openmode __mode) 1389 : basic_iostream<char_type, traits_type>(&__sb_) 1390 { 1391 if (__sb_.open(__s, __mode) == 0) 1392 this->setstate(ios_base::failbit); 1393 } 1394 #endif 1395 1396 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1397 1398 template <class _CharT, class _Traits> 1399 inline 1400 basic_fstream<_CharT, _Traits>::basic_fstream(basic_fstream&& __rhs) 1401 : basic_iostream<char_type, traits_type>(_VSTD::move(__rhs)), 1402 __sb_(_VSTD::move(__rhs.__sb_)) 1403 { 1404 this->set_rdbuf(&__sb_); 1405 } 1406 1407 template <class _CharT, class _Traits> 1408 inline 1409 basic_fstream<_CharT, _Traits>& 1410 basic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs) 1411 { 1412 basic_iostream<char_type, traits_type>::operator=(_VSTD::move(__rhs)); 1413 __sb_ = _VSTD::move(__rhs.__sb_); 1414 return *this; 1415 } 1416 1417 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1418 1419 template <class _CharT, class _Traits> 1420 inline 1421 void 1422 basic_fstream<_CharT, _Traits>::swap(basic_fstream& __rhs) 1423 { 1424 basic_iostream<char_type, traits_type>::swap(__rhs); 1425 __sb_.swap(__rhs.__sb_); 1426 } 1427 1428 template <class _CharT, class _Traits> 1429 inline _LIBCPP_INLINE_VISIBILITY 1430 void 1431 swap(basic_fstream<_CharT, _Traits>& __x, basic_fstream<_CharT, _Traits>& __y) 1432 { 1433 __x.swap(__y); 1434 } 1435 1436 template <class _CharT, class _Traits> 1437 inline 1438 basic_filebuf<_CharT, _Traits>* 1439 basic_fstream<_CharT, _Traits>::rdbuf() const 1440 { 1441 return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_); 1442 } 1443 1444 template <class _CharT, class _Traits> 1445 inline 1446 bool 1447 basic_fstream<_CharT, _Traits>::is_open() const 1448 { 1449 return __sb_.is_open(); 1450 } 1451 1452 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE 1453 template <class _CharT, class _Traits> 1454 void 1455 basic_fstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) 1456 { 1457 if (__sb_.open(__s, __mode)) 1458 this->clear(); 1459 else 1460 this->setstate(ios_base::failbit); 1461 } 1462 1463 template <class _CharT, class _Traits> 1464 void 1465 basic_fstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) 1466 { 1467 if (__sb_.open(__s, __mode)) 1468 this->clear(); 1469 else 1470 this->setstate(ios_base::failbit); 1471 } 1472 #endif 1473 1474 template <class _CharT, class _Traits> 1475 inline 1476 void 1477 basic_fstream<_CharT, _Traits>::close() 1478 { 1479 if (__sb_.close() == 0) 1480 this->setstate(ios_base::failbit); 1481 } 1482 1483 _LIBCPP_END_NAMESPACE_STD 1484 1485 #endif // _LIBCPP_FSTREAM 1486
