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_CXX03_LANG
 197     basic_filebuf(basic_filebuf&& __rhs);
 198 #endif
 199     virtual ~basic_filebuf();
 200
 201     // 27.9.1.3 Assign/swap:
 202 #ifndef _LIBCPP_CXX03_LANG
 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_CXX03_LANG
 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_CXX03_LANG
 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_CXX03_LANG
1021     _LIBCPP_INLINE_VISIBILITY
1022     basic_ifstream(basic_ifstream&& __rhs);
1023
1024     _LIBCPP_INLINE_VISIBILITY
1025     basic_ifstream& operator=(basic_ifstream&& __rhs);
1026 #endif
1027     _LIBCPP_INLINE_VISIBILITY
1028     void swap(basic_ifstream& __rhs);
1029
1030     _LIBCPP_INLINE_VISIBILITY
1031     basic_filebuf<char_type, traits_type>* rdbuf() const;
1032     _LIBCPP_INLINE_VISIBILITY
1033     bool is_open() const;
1034 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
1035     void open(const char* __s, ios_base::openmode __mode = ios_base::in);
1036     void open(const string& __s, ios_base::openmode __mode = ios_base::in);
1037 #endif
1038     _LIBCPP_INLINE_VISIBILITY
1039     void close();
1040
1041 private:
1042     basic_filebuf<char_type, traits_type> __sb_;
1043 };
1044
1045 template <class _CharT, class _Traits>
1046 inline
1047 basic_ifstream<_CharT, _Traits>::basic_ifstream()
1048     : basic_istream<char_type, traits_type>(&__sb_)
1049 {
1050 }
1051
1052 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
1053 template <class _CharT, class _Traits>
1054 inline
1055 basic_ifstream<_CharT, _Traits>::basic_ifstream(const char* __s, ios_base::openmode __mode)
1056     : basic_istream<char_type, traits_type>(&__sb_)
1057 {
1058     if (__sb_.open(__s, __mode | ios_base::in) == 0)
1059         this->setstate(ios_base::failbit);
1060 }
1061
1062 template <class _CharT, class _Traits>
1063 inline
1064 basic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::openmode __mode)
1065     : basic_istream<char_type, traits_type>(&__sb_)
1066 {
1067     if (__sb_.open(__s, __mode | ios_base::in) == 0)
1068         this->setstate(ios_base::failbit);
1069 }
1070 #endif
1071
1072 #ifndef _LIBCPP_CXX03_LANG
1073
1074 template <class _CharT, class _Traits>
1075 inline
1076 basic_ifstream<_CharT, _Traits>::basic_ifstream(basic_ifstream&& __rhs)
1077     : basic_istream<char_type, traits_type>(_VSTD::move(__rhs)),
1078       __sb_(_VSTD::move(__rhs.__sb_))
1079 {
1080     this->set_rdbuf(&__sb_);
1081 }
1082
1083 template <class _CharT, class _Traits>
1084 inline
1085 basic_ifstream<_CharT, _Traits>&
1086 basic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs)
1087 {
1088     basic_istream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
1089     __sb_ = _VSTD::move(__rhs.__sb_);
1090     return *this;
1091 }
1092
1093 #endif  // _LIBCPP_CXX03_LANG
1094
1095 template <class _CharT, class _Traits>
1096 inline
1097 void
1098 basic_ifstream<_CharT, _Traits>::swap(basic_ifstream& __rhs)
1099 {
1100     basic_istream<char_type, traits_type>::swap(__rhs);
1101     __sb_.swap(__rhs.__sb_);
1102 }
1103
1104 template <class _CharT, class _Traits>
1105 inline _LIBCPP_INLINE_VISIBILITY
1106 void
1107 swap(basic_ifstream<_CharT, _Traits>& __x, basic_ifstream<_CharT, _Traits>& __y)
1108 {
1109     __x.swap(__y);
1110 }
1111
1112 template <class _CharT, class _Traits>
1113 inline
1114 basic_filebuf<_CharT, _Traits>*
1115 basic_ifstream<_CharT, _Traits>::rdbuf() const
1116 {
1117     return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);
1118 }
1119
1120 template <class _CharT, class _Traits>
1121 inline
1122 bool
1123 basic_ifstream<_CharT, _Traits>::is_open() const
1124 {
1125     return __sb_.is_open();
1126 }
1127
1128 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
1129 template <class _CharT, class _Traits>
1130 void
1131 basic_ifstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
1132 {
1133     if (__sb_.open(__s, __mode | ios_base::in))
1134         this->clear();
1135     else
1136         this->setstate(ios_base::failbit);
1137 }
1138
1139 template <class _CharT, class _Traits>
1140 void
1141 basic_ifstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
1142 {
1143     if (__sb_.open(__s, __mode | ios_base::in))
1144         this->clear();
1145     else
1146         this->setstate(ios_base::failbit);
1147 }
1148 #endif
1149
1150 template <class _CharT, class _Traits>
1151 inline
1152 void
1153 basic_ifstream<_CharT, _Traits>::close()
1154 {
1155     if (__sb_.close() == 0)
1156         this->setstate(ios_base::failbit);
1157 }
1158
1159 // basic_ofstream
1160
1161 template <class _CharT, class _Traits>
1162 class _LIBCPP_TEMPLATE_VIS basic_ofstream
1163     : public basic_ostream<_CharT, _Traits>
1164 {
1165 public:
1166     typedef _CharT                         char_type;
1167     typedef _Traits                        traits_type;
1168     typedef typename traits_type::int_type int_type;
1169     typedef typename traits_type::pos_type pos_type;
1170     typedef typename traits_type::off_type off_type;
1171
1172     _LIBCPP_INLINE_VISIBILITY
1173     basic_ofstream();
1174     _LIBCPP_INLINE_VISIBILITY
1175     explicit basic_ofstream(const char* __s, ios_base::openmode __mode = ios_base::out);
1176     _LIBCPP_INLINE_VISIBILITY
1177     explicit basic_ofstream(const string& __s, ios_base::openmode __mode = ios_base::out);
1178 #ifndef _LIBCPP_CXX03_LANG
1179     _LIBCPP_INLINE_VISIBILITY
1180     basic_ofstream(basic_ofstream&& __rhs);
1181
1182     _LIBCPP_INLINE_VISIBILITY
1183     basic_ofstream& operator=(basic_ofstream&& __rhs);
1184 #endif
1185     _LIBCPP_INLINE_VISIBILITY
1186     void swap(basic_ofstream& __rhs);
1187
1188     _LIBCPP_INLINE_VISIBILITY
1189     basic_filebuf<char_type, traits_type>* rdbuf() const;
1190     _LIBCPP_INLINE_VISIBILITY
1191     bool is_open() const;
1192 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
1193     void open(const char* __s, ios_base::openmode __mode = ios_base::out);
1194     void open(const string& __s, ios_base::openmode __mode = ios_base::out);
1195 #endif
1196     _LIBCPP_INLINE_VISIBILITY
1197     void close();
1198
1199 private:
1200     basic_filebuf<char_type, traits_type> __sb_;
1201 };
1202
1203 template <class _CharT, class _Traits>
1204 inline
1205 basic_ofstream<_CharT, _Traits>::basic_ofstream()
1206     : basic_ostream<char_type, traits_type>(&__sb_)
1207 {
1208 }
1209
1210 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
1211 template <class _CharT, class _Traits>
1212 inline
1213 basic_ofstream<_CharT, _Traits>::basic_ofstream(const char* __s, ios_base::openmode __mode)
1214     : basic_ostream<char_type, traits_type>(&__sb_)
1215 {
1216     if (__sb_.open(__s, __mode | ios_base::out) == 0)
1217         this->setstate(ios_base::failbit);
1218 }
1219
1220 template <class _CharT, class _Traits>
1221 inline
1222 basic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::openmode __mode)
1223     : basic_ostream<char_type, traits_type>(&__sb_)
1224 {
1225     if (__sb_.open(__s, __mode | ios_base::out) == 0)
1226         this->setstate(ios_base::failbit);
1227 }
1228 #endif
1229
1230 #ifndef _LIBCPP_CXX03_LANG
1231
1232 template <class _CharT, class _Traits>
1233 inline
1234 basic_ofstream<_CharT, _Traits>::basic_ofstream(basic_ofstream&& __rhs)
1235     : basic_ostream<char_type, traits_type>(_VSTD::move(__rhs)),
1236       __sb_(_VSTD::move(__rhs.__sb_))
1237 {
1238     this->set_rdbuf(&__sb_);
1239 }
1240
1241 template <class _CharT, class _Traits>
1242 inline
1243 basic_ofstream<_CharT, _Traits>&
1244 basic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs)
1245 {
1246     basic_ostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
1247     __sb_ = _VSTD::move(__rhs.__sb_);
1248     return *this;
1249 }
1250
1251 #endif  // _LIBCPP_CXX03_LANG
1252
1253 template <class _CharT, class _Traits>
1254 inline
1255 void
1256 basic_ofstream<_CharT, _Traits>::swap(basic_ofstream& __rhs)
1257 {
1258     basic_ostream<char_type, traits_type>::swap(__rhs);
1259     __sb_.swap(__rhs.__sb_);
1260 }
1261
1262 template <class _CharT, class _Traits>
1263 inline _LIBCPP_INLINE_VISIBILITY
1264 void
1265 swap(basic_ofstream<_CharT, _Traits>& __x, basic_ofstream<_CharT, _Traits>& __y)
1266 {
1267     __x.swap(__y);
1268 }
1269
1270 template <class _CharT, class _Traits>
1271 inline
1272 basic_filebuf<_CharT, _Traits>*
1273 basic_ofstream<_CharT, _Traits>::rdbuf() const
1274 {
1275     return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);
1276 }
1277
1278 template <class _CharT, class _Traits>
1279 inline
1280 bool
1281 basic_ofstream<_CharT, _Traits>::is_open() const
1282 {
1283     return __sb_.is_open();
1284 }
1285
1286 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
1287 template <class _CharT, class _Traits>
1288 void
1289 basic_ofstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
1290 {
1291     if (__sb_.open(__s, __mode | ios_base::out))
1292         this->clear();
1293     else
1294         this->setstate(ios_base::failbit);
1295 }
1296
1297 template <class _CharT, class _Traits>
1298 void
1299 basic_ofstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
1300 {
1301     if (__sb_.open(__s, __mode | ios_base::out))
1302         this->clear();
1303     else
1304         this->setstate(ios_base::failbit);
1305 }
1306 #endif
1307
1308 template <class _CharT, class _Traits>
1309 inline
1310 void
1311 basic_ofstream<_CharT, _Traits>::close()
1312 {
1313     if (__sb_.close() == 0)
1314         this->setstate(ios_base::failbit);
1315 }
1316
1317 // basic_fstream
1318
1319 template <class _CharT, class _Traits>
1320 class _LIBCPP_TEMPLATE_VIS basic_fstream
1321     : public basic_iostream<_CharT, _Traits>
1322 {
1323 public:
1324     typedef _CharT                         char_type;
1325     typedef _Traits                        traits_type;
1326     typedef typename traits_type::int_type int_type;
1327     typedef typename traits_type::pos_type pos_type;
1328     typedef typename traits_type::off_type off_type;
1329
1330     _LIBCPP_INLINE_VISIBILITY
1331     basic_fstream();
1332 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
1333     _LIBCPP_INLINE_VISIBILITY
1334     explicit basic_fstream(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
1335     _LIBCPP_INLINE_VISIBILITY
1336     explicit basic_fstream(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
1337 #endif
1338 #ifndef _LIBCPP_CXX03_LANG
1339     _LIBCPP_INLINE_VISIBILITY
1340     basic_fstream(basic_fstream&& __rhs);
1341
1342     _LIBCPP_INLINE_VISIBILITY
1343     basic_fstream& operator=(basic_fstream&& __rhs);
1344 #endif
1345     _LIBCPP_INLINE_VISIBILITY
1346     void swap(basic_fstream& __rhs);
1347
1348     _LIBCPP_INLINE_VISIBILITY
1349     basic_filebuf<char_type, traits_type>* rdbuf() const;
1350     _LIBCPP_INLINE_VISIBILITY
1351     bool is_open() const;
1352 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
1353     void open(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
1354     void open(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
1355 #endif
1356     _LIBCPP_INLINE_VISIBILITY
1357     void close();
1358
1359 private:
1360     basic_filebuf<char_type, traits_type> __sb_;
1361 };
1362
1363 template <class _CharT, class _Traits>
1364 inline
1365 basic_fstream<_CharT, _Traits>::basic_fstream()
1366     : basic_iostream<char_type, traits_type>(&__sb_)
1367 {
1368 }
1369
1370 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
1371 template <class _CharT, class _Traits>
1372 inline
1373 basic_fstream<_CharT, _Traits>::basic_fstream(const char* __s, ios_base::openmode __mode)
1374     : basic_iostream<char_type, traits_type>(&__sb_)
1375 {
1376     if (__sb_.open(__s, __mode) == 0)
1377         this->setstate(ios_base::failbit);
1378 }
1379
1380 template <class _CharT, class _Traits>
1381 inline
1382 basic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openmode __mode)
1383     : basic_iostream<char_type, traits_type>(&__sb_)
1384 {
1385     if (__sb_.open(__s, __mode) == 0)
1386         this->setstate(ios_base::failbit);
1387 }
1388 #endif
1389
1390 #ifndef _LIBCPP_CXX03_LANG
1391
1392 template <class _CharT, class _Traits>
1393 inline
1394 basic_fstream<_CharT, _Traits>::basic_fstream(basic_fstream&& __rhs)
1395     : basic_iostream<char_type, traits_type>(_VSTD::move(__rhs)),
1396       __sb_(_VSTD::move(__rhs.__sb_))
1397 {
1398     this->set_rdbuf(&__sb_);
1399 }
1400
1401 template <class _CharT, class _Traits>
1402 inline
1403 basic_fstream<_CharT, _Traits>&
1404 basic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs)
1405 {
1406     basic_iostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
1407     __sb_ = _VSTD::move(__rhs.__sb_);
1408     return *this;
1409 }
1410
1411 #endif  // _LIBCPP_CXX03_LANG
1412
1413 template <class _CharT, class _Traits>
1414 inline
1415 void
1416 basic_fstream<_CharT, _Traits>::swap(basic_fstream& __rhs)
1417 {
1418     basic_iostream<char_type, traits_type>::swap(__rhs);
1419     __sb_.swap(__rhs.__sb_);
1420 }
1421
1422 template <class _CharT, class _Traits>
1423 inline _LIBCPP_INLINE_VISIBILITY
1424 void
1425 swap(basic_fstream<_CharT, _Traits>& __x, basic_fstream<_CharT, _Traits>& __y)
1426 {
1427     __x.swap(__y);
1428 }
1429
1430 template <class _CharT, class _Traits>
1431 inline
1432 basic_filebuf<_CharT, _Traits>*
1433 basic_fstream<_CharT, _Traits>::rdbuf() const
1434 {
1435     return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);
1436 }
1437
1438 template <class _CharT, class _Traits>
1439 inline
1440 bool
1441 basic_fstream<_CharT, _Traits>::is_open() const
1442 {
1443     return __sb_.is_open();
1444 }
1445
1446 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
1447 template <class _CharT, class _Traits>
1448 void
1449 basic_fstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
1450 {
1451     if (__sb_.open(__s, __mode))
1452         this->clear();
1453     else
1454         this->setstate(ios_base::failbit);
1455 }
1456
1457 template <class _CharT, class _Traits>
1458 void
1459 basic_fstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
1460 {
1461     if (__sb_.open(__s, __mode))
1462         this->clear();
1463     else
1464         this->setstate(ios_base::failbit);
1465 }
1466 #endif
1467
1468 template <class _CharT, class _Traits>
1469 inline
1470 void
1471 basic_fstream<_CharT, _Traits>::close()
1472 {
1473     if (__sb_.close() == 0)
1474         this->setstate(ios_base::failbit);
1475 }
1476
1477 _LIBCPP_END_NAMESPACE_STD
1478
1479 #endif  // _LIBCPP_FSTREAM