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