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