contrib/libc++/include/fstream

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