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