contrib/libc++/include/fstream

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