Cider Isn't Darwin Emulation, Really
Something went wrong. Try again.
45 kB · 1484 lines
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485// -*- C++ -*-//===------------------------- fstream ------------------------------------===////// The LLVM Compiler Infrastructure//// This file is dual licensed under the MIT and the University of Illinois Open// Source Licenses. See LICENSE.TXT for details.////===----------------------------------------------------------------------===//#ifndef _LIBCPP_FSTREAM#define _LIBCPP_FSTREAM/* fstream synopsistemplate <class charT, class traits = char_traits<charT> >class basic_filebuf : public basic_streambuf<charT, traits>{public: typedef charT char_type; typedef traits traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; // 27.9.1.2 Constructors/destructor: basic_filebuf(); basic_filebuf(basic_filebuf&& rhs); virtual ~basic_filebuf(); // 27.9.1.3 Assign/swap: basic_filebuf& operator=(basic_filebuf&& rhs); void swap(basic_filebuf& rhs); // 27.9.1.4 Members: bool is_open() const; basic_filebuf* open(const char* s, ios_base::openmode mode); basic_filebuf* open(const string& s, ios_base::openmode mode); basic_filebuf* close();protected: // 27.9.1.5 Overridden virtual functions: virtual streamsize showmanyc(); virtual int_type underflow(); virtual int_type uflow(); virtual int_type pbackfail(int_type c = traits_type::eof()); virtual int_type overflow (int_type c = traits_type::eof()); virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* s, streamsize n); virtual pos_type seekoff(off_type off, ios_base::seekdir way, ios_base::openmode which = ios_base::in | ios_base::out); virtual pos_type seekpos(pos_type sp, ios_base::openmode which = ios_base::in | ios_base::out); virtual int sync(); virtual void imbue(const locale& loc);};template <class charT, class traits> void swap(basic_filebuf<charT, traits>& x, basic_filebuf<charT, traits>& y);typedef basic_filebuf<char> filebuf;typedef basic_filebuf<wchar_t> wfilebuf;template <class charT, class traits = char_traits<charT> >class basic_ifstream : public basic_istream<charT,traits>{public: typedef charT char_type; typedef traits traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; basic_ifstream(); explicit basic_ifstream(const char* s, ios_base::openmode mode = ios_base::in); explicit basic_ifstream(const string& s, ios_base::openmode mode = ios_base::in); basic_ifstream(basic_ifstream&& rhs); basic_ifstream& operator=(basic_ifstream&& rhs); void swap(basic_ifstream& rhs); basic_filebuf<char_type, traits_type>* rdbuf() const; bool is_open() const; void open(const char* s, ios_base::openmode mode = ios_base::in); void open(const string& s, ios_base::openmode mode = ios_base::in); void close();};template <class charT, class traits> void swap(basic_ifstream<charT, traits>& x, basic_ifstream<charT, traits>& y);typedef basic_ifstream<char> ifstream;typedef basic_ifstream<wchar_t> wifstream;template <class charT, class traits = char_traits<charT> >class basic_ofstream : public basic_ostream<charT,traits>{public: typedef charT char_type; typedef traits traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; basic_ofstream(); explicit basic_ofstream(const char* s, ios_base::openmode mode = ios_base::out); explicit basic_ofstream(const string& s, ios_base::openmode mode = ios_base::out); basic_ofstream(basic_ofstream&& rhs); basic_ofstream& operator=(basic_ofstream&& rhs); void swap(basic_ofstream& rhs); basic_filebuf<char_type, traits_type>* rdbuf() const; bool is_open() const; void open(const char* s, ios_base::openmode mode = ios_base::out); void open(const string& s, ios_base::openmode mode = ios_base::out); void close();};template <class charT, class traits> void swap(basic_ofstream<charT, traits>& x, basic_ofstream<charT, traits>& y);typedef basic_ofstream<char> ofstream;typedef basic_ofstream<wchar_t> wofstream;template <class charT, class traits=char_traits<charT> >class basic_fstream : public basic_iostream<charT,traits>{public: typedef charT char_type; typedef traits traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; basic_fstream(); explicit basic_fstream(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out); explicit basic_fstream(const string& s, ios_base::openmode mode = ios_base::in|ios_base::out); basic_fstream(basic_fstream&& rhs); basic_fstream& operator=(basic_fstream&& rhs); void swap(basic_fstream& rhs); basic_filebuf<char_type, traits_type>* rdbuf() const; bool is_open() const; void open(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out); void open(const string& s, ios_base::openmode mode = ios_base::in|ios_base::out); void close();};template <class charT, class traits> void swap(basic_fstream<charT, traits>& x, basic_fstream<charT, traits>& y);typedef basic_fstream<char> fstream;typedef basic_fstream<wchar_t> wfstream;} // std*/#include <__config>#include <ostream>#include <istream>#include <__locale>#include <cstdio>#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)#pragma GCC system_header#endif_LIBCPP_PUSH_MACROS#include <__undef_macros>_LIBCPP_BEGIN_NAMESPACE_STDtemplate <class _CharT, class _Traits>class _LIBCPP_TEMPLATE_VIS basic_filebuf : public basic_streambuf<_CharT, _Traits>{public: typedef _CharT char_type; typedef _Traits traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; typedef typename traits_type::state_type state_type; // 27.9.1.2 Constructors/destructor: basic_filebuf();#ifndef _LIBCPP_CXX03_LANG basic_filebuf(basic_filebuf&& __rhs);#endif virtual ~basic_filebuf(); // 27.9.1.3 Assign/swap:#ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY basic_filebuf& operator=(basic_filebuf&& __rhs);#endif void swap(basic_filebuf& __rhs); // 27.9.1.4 Members: _LIBCPP_INLINE_VISIBILITY bool is_open() const;#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE basic_filebuf* open(const char* __s, ios_base::openmode __mode); _LIBCPP_INLINE_VISIBILITY basic_filebuf* open(const string& __s, ios_base::openmode __mode);#endif basic_filebuf* close();protected: // 27.9.1.5 Overridden virtual functions: virtual int_type underflow(); virtual int_type pbackfail(int_type __c = traits_type::eof()); virtual int_type overflow (int_type __c = traits_type::eof()); virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* __s, streamsize __n); virtual pos_type seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __wch = ios_base::in | ios_base::out); virtual pos_type seekpos(pos_type __sp, ios_base::openmode __wch = ios_base::in | ios_base::out); virtual int sync(); virtual void imbue(const locale& __loc);private: char* __extbuf_; const char* __extbufnext_; const char* __extbufend_; char __extbuf_min_[8]; size_t __ebs_; char_type* __intbuf_; size_t __ibs_; FILE* __file_; const codecvt<char_type, char, state_type>* __cv_; state_type __st_; state_type __st_last_; ios_base::openmode __om_; ios_base::openmode __cm_; bool __owns_eb_; bool __owns_ib_; bool __always_noconv_; bool __read_mode(); void __write_mode();};template <class _CharT, class _Traits>basic_filebuf<_CharT, _Traits>::basic_filebuf() : __extbuf_(0), __extbufnext_(0), __extbufend_(0), __ebs_(0), __intbuf_(0), __ibs_(0), __file_(0), __cv_(nullptr), __st_(), __st_last_(), __om_(0), __cm_(0), __owns_eb_(false), __owns_ib_(false), __always_noconv_(false){ if (has_facet<codecvt<char_type, char, state_type> >(this->getloc())) { __cv_ = &use_facet<codecvt<char_type, char, state_type> >(this->getloc()); __always_noconv_ = __cv_->always_noconv(); } setbuf(0, 4096);}#ifndef _LIBCPP_CXX03_LANGtemplate <class _CharT, class _Traits>basic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs) : basic_streambuf<_CharT, _Traits>(__rhs){ if (__rhs.__extbuf_ == __rhs.__extbuf_min_) { __extbuf_ = __extbuf_min_; __extbufnext_ = __extbuf_ + (__rhs.__extbufnext_ - __rhs.__extbuf_); __extbufend_ = __extbuf_ + (__rhs.__extbufend_ - __rhs.__extbuf_); } else { __extbuf_ = __rhs.__extbuf_; __extbufnext_ = __rhs.__extbufnext_; __extbufend_ = __rhs.__extbufend_; } __ebs_ = __rhs.__ebs_; __intbuf_ = __rhs.__intbuf_; __ibs_ = __rhs.__ibs_; __file_ = __rhs.__file_; __cv_ = __rhs.__cv_; __st_ = __rhs.__st_; __st_last_ = __rhs.__st_last_; __om_ = __rhs.__om_; __cm_ = __rhs.__cm_; __owns_eb_ = __rhs.__owns_eb_; __owns_ib_ = __rhs.__owns_ib_; __always_noconv_ = __rhs.__always_noconv_; if (__rhs.pbase()) { if (__rhs.pbase() == __rhs.__intbuf_) this->setp(__intbuf_, __intbuf_ + (__rhs. epptr() - __rhs.pbase())); else this->setp((char_type*)__extbuf_, (char_type*)__extbuf_ + (__rhs. epptr() - __rhs.pbase())); this->pbump(__rhs. pptr() - __rhs.pbase()); } else if (__rhs.eback()) { if (__rhs.eback() == __rhs.__intbuf_) this->setg(__intbuf_, __intbuf_ + (__rhs.gptr() - __rhs.eback()), __intbuf_ + (__rhs.egptr() - __rhs.eback())); else this->setg((char_type*)__extbuf_, (char_type*)__extbuf_ + (__rhs.gptr() - __rhs.eback()), (char_type*)__extbuf_ + (__rhs.egptr() - __rhs.eback())); } __rhs.__extbuf_ = 0; __rhs.__extbufnext_ = 0; __rhs.__extbufend_ = 0; __rhs.__ebs_ = 0; __rhs.__intbuf_ = 0; __rhs.__ibs_ = 0; __rhs.__file_ = 0; __rhs.__st_ = state_type(); __rhs.__st_last_ = state_type(); __rhs.__om_ = 0; __rhs.__cm_ = 0; __rhs.__owns_eb_ = false; __rhs.__owns_ib_ = false; __rhs.setg(0, 0, 0); __rhs.setp(0, 0);}template <class _CharT, class _Traits>inlinebasic_filebuf<_CharT, _Traits>&basic_filebuf<_CharT, _Traits>::operator=(basic_filebuf&& __rhs){ close(); swap(__rhs); return *this;}#endif // _LIBCPP_CXX03_LANGtemplate <class _CharT, class _Traits>basic_filebuf<_CharT, _Traits>::~basic_filebuf(){#ifndef _LIBCPP_NO_EXCEPTIONS try {#endif // _LIBCPP_NO_EXCEPTIONS close();#ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { }#endif // _LIBCPP_NO_EXCEPTIONS if (__owns_eb_) delete [] __extbuf_; if (__owns_ib_) delete [] __intbuf_;}template <class _CharT, class _Traits>voidbasic_filebuf<_CharT, _Traits>::swap(basic_filebuf& __rhs){ basic_streambuf<char_type, traits_type>::swap(__rhs); if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_) { _VSTD::swap(__extbuf_, __rhs.__extbuf_); _VSTD::swap(__extbufnext_, __rhs.__extbufnext_); _VSTD::swap(__extbufend_, __rhs.__extbufend_); } else { ptrdiff_t __ln = __extbufnext_ - __extbuf_; ptrdiff_t __le = __extbufend_ - __extbuf_; ptrdiff_t __rn = __rhs.__extbufnext_ - __rhs.__extbuf_; ptrdiff_t __re = __rhs.__extbufend_ - __rhs.__extbuf_; if (__extbuf_ == __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_) { __extbuf_ = __rhs.__extbuf_; __rhs.__extbuf_ = __rhs.__extbuf_min_; } else if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ == __rhs.__extbuf_min_) { __rhs.__extbuf_ = __extbuf_; __extbuf_ = __extbuf_min_; } __extbufnext_ = __extbuf_ + __rn; __extbufend_ = __extbuf_ + __re; __rhs.__extbufnext_ = __rhs.__extbuf_ + __ln; __rhs.__extbufend_ = __rhs.__extbuf_ + __le; } _VSTD::swap(__ebs_, __rhs.__ebs_); _VSTD::swap(__intbuf_, __rhs.__intbuf_); _VSTD::swap(__ibs_, __rhs.__ibs_); _VSTD::swap(__file_, __rhs.__file_); _VSTD::swap(__cv_, __rhs.__cv_); _VSTD::swap(__st_, __rhs.__st_); _VSTD::swap(__st_last_, __rhs.__st_last_); _VSTD::swap(__om_, __rhs.__om_); _VSTD::swap(__cm_, __rhs.__cm_); _VSTD::swap(__owns_eb_, __rhs.__owns_eb_); _VSTD::swap(__owns_ib_, __rhs.__owns_ib_); _VSTD::swap(__always_noconv_, __rhs.__always_noconv_); if (this->eback() == (char_type*)__rhs.__extbuf_min_) { ptrdiff_t __n = this->gptr() - this->eback(); ptrdiff_t __e = this->egptr() - this->eback(); this->setg((char_type*)__extbuf_min_, (char_type*)__extbuf_min_ + __n, (char_type*)__extbuf_min_ + __e); } else if (this->pbase() == (char_type*)__rhs.__extbuf_min_) { ptrdiff_t __n = this->pptr() - this->pbase(); ptrdiff_t __e = this->epptr() - this->pbase(); this->setp((char_type*)__extbuf_min_, (char_type*)__extbuf_min_ + __e); this->pbump(__n); } if (__rhs.eback() == (char_type*)__extbuf_min_) { ptrdiff_t __n = __rhs.gptr() - __rhs.eback(); ptrdiff_t __e = __rhs.egptr() - __rhs.eback(); __rhs.setg((char_type*)__rhs.__extbuf_min_, (char_type*)__rhs.__extbuf_min_ + __n, (char_type*)__rhs.__extbuf_min_ + __e); } else if (__rhs.pbase() == (char_type*)__extbuf_min_) { ptrdiff_t __n = __rhs.pptr() - __rhs.pbase(); ptrdiff_t __e = __rhs.epptr() - __rhs.pbase(); __rhs.setp((char_type*)__rhs.__extbuf_min_, (char_type*)__rhs.__extbuf_min_ + __e); __rhs.pbump(__n); }}template <class _CharT, class _Traits>inline _LIBCPP_INLINE_VISIBILITYvoidswap(basic_filebuf<_CharT, _Traits>& __x, basic_filebuf<_CharT, _Traits>& __y){ __x.swap(__y);}template <class _CharT, class _Traits>inlineboolbasic_filebuf<_CharT, _Traits>::is_open() const{ return __file_ != 0;}#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACEtemplate <class _CharT, class _Traits>basic_filebuf<_CharT, _Traits>*basic_filebuf<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode){ basic_filebuf<_CharT, _Traits>* __rt = 0; if (__file_ == 0) { __rt = this; const char* __mdstr; switch (__mode & ~ios_base::ate) { case ios_base::out: case ios_base::out | ios_base::trunc: __mdstr = "w"; break; case ios_base::out | ios_base::app: case ios_base::app: __mdstr = "a"; break; case ios_base::in: __mdstr = "r"; break; case ios_base::in | ios_base::out: __mdstr = "r+"; break; case ios_base::in | ios_base::out | ios_base::trunc: __mdstr = "w+"; break; case ios_base::in | ios_base::out | ios_base::app: case ios_base::in | ios_base::app: __mdstr = "a+"; break; case ios_base::out | ios_base::binary: case ios_base::out | ios_base::trunc | ios_base::binary: __mdstr = "wb"; break; case ios_base::out | ios_base::app | ios_base::binary: case ios_base::app | ios_base::binary: __mdstr = "ab"; break; case ios_base::in | ios_base::binary: __mdstr = "rb"; break; case ios_base::in | ios_base::out | ios_base::binary: __mdstr = "r+b"; break; case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary: __mdstr = "w+b"; break; case ios_base::in | ios_base::out | ios_base::app | ios_base::binary: case ios_base::in | ios_base::app | ios_base::binary: __mdstr = "a+b"; break; default: __rt = 0; break; } if (__rt) { __file_ = fopen(__s, __mdstr); if (__file_) { __om_ = __mode; if (__mode & ios_base::ate) { if (fseek(__file_, 0, SEEK_END)) { fclose(__file_); __file_ = 0; __rt = 0; } } } else __rt = 0; } } return __rt;}template <class _CharT, class _Traits>inlinebasic_filebuf<_CharT, _Traits>*basic_filebuf<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode){ return open(__s.c_str(), __mode);}#endiftemplate <class _CharT, class _Traits>basic_filebuf<_CharT, _Traits>*basic_filebuf<_CharT, _Traits>::close(){ basic_filebuf<_CharT, _Traits>* __rt = 0; if (__file_) { __rt = this; unique_ptr<FILE, int(*)(FILE*)> __h(__file_, fclose); if (sync()) __rt = 0; if (fclose(__h.release()) == 0) __file_ = 0; else __rt = 0; } return __rt;}template <class _CharT, class _Traits>typename basic_filebuf<_CharT, _Traits>::int_typebasic_filebuf<_CharT, _Traits>::underflow(){ if (__file_ == 0) return traits_type::eof(); bool __initial = __read_mode(); char_type __1buf; if (this->gptr() == 0) this->setg(&__1buf, &__1buf+1, &__1buf+1); const size_t __unget_sz = __initial ? 0 : min<size_t>((this->egptr() - this->eback()) / 2, 4); int_type __c = traits_type::eof(); if (this->gptr() == this->egptr()) { memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz * sizeof(char_type)); if (__always_noconv_) { size_t __nmemb = static_cast<size_t>(this->egptr() - this->eback() - __unget_sz); __nmemb = fread(this->eback() + __unget_sz, 1, __nmemb, __file_); if (__nmemb != 0) { this->setg(this->eback(), this->eback() + __unget_sz, this->eback() + __unget_sz + __nmemb); __c = traits_type::to_int_type(*this->gptr()); } } else { _LIBCPP_ASSERT ( !(__extbufnext_ == NULL && (__extbufend_ != __extbufnext_)), "underflow moving from NULL" ); if (__extbufend_ != __extbufnext_) memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_); __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_); __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_); size_t __nmemb = _VSTD::min(static_cast<size_t>(__ibs_ - __unget_sz), static_cast<size_t>(__extbufend_ - __extbufnext_)); codecvt_base::result __r; __st_last_ = __st_; size_t __nr = fread((void*) const_cast<char *>(__extbufnext_), 1, __nmemb, __file_); if (__nr != 0) { if (!__cv_) __throw_bad_cast(); __extbufend_ = __extbufnext_ + __nr; char_type* __inext; __r = __cv_->in(__st_, __extbuf_, __extbufend_, __extbufnext_, this->eback() + __unget_sz, this->eback() + __ibs_, __inext); if (__r == codecvt_base::noconv) { this->setg((char_type*)__extbuf_, (char_type*)__extbuf_, (char_type*)const_cast<char *>(__extbufend_)); __c = traits_type::to_int_type(*this->gptr()); } else if (__inext != this->eback() + __unget_sz) { this->setg(this->eback(), this->eback() + __unget_sz, __inext); __c = traits_type::to_int_type(*this->gptr()); } } } } else __c = traits_type::to_int_type(*this->gptr()); if (this->eback() == &__1buf) this->setg(0, 0, 0); return __c;}template <class _CharT, class _Traits>typename basic_filebuf<_CharT, _Traits>::int_typebasic_filebuf<_CharT, _Traits>::pbackfail(int_type __c){ if (__file_ && this->eback() < this->gptr()) { if (traits_type::eq_int_type(__c, traits_type::eof())) { this->gbump(-1); return traits_type::not_eof(__c); } if ((__om_ & ios_base::out) || traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1])) { this->gbump(-1); *this->gptr() = traits_type::to_char_type(__c); return __c; } } return traits_type::eof();}template <class _CharT, class _Traits>typename basic_filebuf<_CharT, _Traits>::int_typebasic_filebuf<_CharT, _Traits>::overflow(int_type __c){ if (__file_ == 0) return traits_type::eof(); __write_mode(); char_type __1buf; char_type* __pb_save = this->pbase(); char_type* __epb_save = this->epptr(); if (!traits_type::eq_int_type(__c, traits_type::eof())) { if (this->pptr() == 0) this->setp(&__1buf, &__1buf+1); *this->pptr() = traits_type::to_char_type(__c); this->pbump(1); } if (this->pptr() != this->pbase()) { if (__always_noconv_) { size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase()); if (fwrite(this->pbase(), sizeof(char_type), __nmemb, __file_) != __nmemb) return traits_type::eof(); } else { char* __extbe = __extbuf_; codecvt_base::result __r; do { if (!__cv_) __throw_bad_cast(); const char_type* __e; __r = __cv_->out(__st_, this->pbase(), this->pptr(), __e, __extbuf_, __extbuf_ + __ebs_, __extbe); if (__e == this->pbase()) return traits_type::eof(); if (__r == codecvt_base::noconv) { size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase()); if (fwrite(this->pbase(), 1, __nmemb, __file_) != __nmemb) return traits_type::eof(); } else if (__r == codecvt_base::ok || __r == codecvt_base::partial) { size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_); if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb) return traits_type::eof(); if (__r == codecvt_base::partial) { this->setp(const_cast<char_type*>(__e), this->pptr()); this->pbump(this->epptr() - this->pbase()); } } else return traits_type::eof(); } while (__r == codecvt_base::partial); } this->setp(__pb_save, __epb_save); } return traits_type::not_eof(__c);}template <class _CharT, class _Traits>basic_streambuf<_CharT, _Traits>*basic_filebuf<_CharT, _Traits>::setbuf(char_type* __s, streamsize __n){ this->setg(0, 0, 0); this->setp(0, 0); if (__owns_eb_) delete [] __extbuf_; if (__owns_ib_) delete [] __intbuf_; __ebs_ = __n; if (__ebs_ > sizeof(__extbuf_min_)) { if (__always_noconv_ && __s) { __extbuf_ = (char*)__s; __owns_eb_ = false; } else { __extbuf_ = new char[__ebs_]; __owns_eb_ = true; } } else { __extbuf_ = __extbuf_min_; __ebs_ = sizeof(__extbuf_min_); __owns_eb_ = false; } if (!__always_noconv_) { __ibs_ = max<streamsize>(__n, sizeof(__extbuf_min_)); if (__s && __ibs_ >= sizeof(__extbuf_min_)) { __intbuf_ = __s; __owns_ib_ = false; } else { __intbuf_ = new char_type[__ibs_]; __owns_ib_ = true; } } else { __ibs_ = 0; __intbuf_ = 0; __owns_ib_ = false; } return this;}template <class _CharT, class _Traits>typename basic_filebuf<_CharT, _Traits>::pos_typebasic_filebuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode){ if (!__cv_) __throw_bad_cast(); int __width = __cv_->encoding(); if (__file_ == 0 || (__width <= 0 && __off != 0) || sync()) return pos_type(off_type(-1)); // __width > 0 || __off == 0 int __whence; switch (__way) { case ios_base::beg: __whence = SEEK_SET; break; case ios_base::cur: __whence = SEEK_CUR; break; case ios_base::end: __whence = SEEK_END; break; default: return pos_type(off_type(-1)); }#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS) if (fseek(__file_, __width > 0 ? __width * __off : 0, __whence)) return pos_type(off_type(-1)); pos_type __r = ftell(__file_);#else if (fseeko(__file_, __width > 0 ? __width * __off : 0, __whence)) return pos_type(off_type(-1)); pos_type __r = ftello(__file_);#endif __r.state(__st_); return __r;}template <class _CharT, class _Traits>typename basic_filebuf<_CharT, _Traits>::pos_typebasic_filebuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode){ if (__file_ == 0 || sync()) return pos_type(off_type(-1));#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS) if (fseek(__file_, __sp, SEEK_SET)) return pos_type(off_type(-1));#else if (fseeko(__file_, __sp, SEEK_SET)) return pos_type(off_type(-1));#endif __st_ = __sp.state(); return __sp;}template <class _CharT, class _Traits>intbasic_filebuf<_CharT, _Traits>::sync(){ if (__file_ == 0) return 0; if (!__cv_) __throw_bad_cast(); if (__cm_ & ios_base::out) { if (this->pptr() != this->pbase()) if (overflow() == traits_type::eof()) return -1; codecvt_base::result __r; do { char* __extbe; __r = __cv_->unshift(__st_, __extbuf_, __extbuf_ + __ebs_, __extbe); size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_); if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb) return -1; } while (__r == codecvt_base::partial); if (__r == codecvt_base::error) return -1; if (fflush(__file_)) return -1; } else if (__cm_ & ios_base::in) { off_type __c; state_type __state = __st_last_; bool __update_st = false; if (__always_noconv_) __c = this->egptr() - this->gptr(); else { int __width = __cv_->encoding(); __c = __extbufend_ - __extbufnext_; if (__width > 0) __c += __width * (this->egptr() - this->gptr()); else { if (this->gptr() != this->egptr()) { const int __off = __cv_->length(__state, __extbuf_, __extbufnext_, this->gptr() - this->eback()); __c += __extbufnext_ - __extbuf_ - __off; __update_st = true; } } }#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS) if (fseek(__file_, -__c, SEEK_CUR)) return -1;#else if (fseeko(__file_, -__c, SEEK_CUR)) return -1;#endif if (__update_st) __st_ = __state; __extbufnext_ = __extbufend_ = __extbuf_; this->setg(0, 0, 0); __cm_ = 0; } return 0;}template <class _CharT, class _Traits>voidbasic_filebuf<_CharT, _Traits>::imbue(const locale& __loc){ sync(); __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc); bool __old_anc = __always_noconv_; __always_noconv_ = __cv_->always_noconv(); if (__old_anc != __always_noconv_) { this->setg(0, 0, 0); this->setp(0, 0); // invariant, char_type is char, else we couldn't get here if (__always_noconv_) // need to dump __intbuf_ { if (__owns_eb_) delete [] __extbuf_; __owns_eb_ = __owns_ib_; __ebs_ = __ibs_; __extbuf_ = (char*)__intbuf_; __ibs_ = 0; __intbuf_ = 0; __owns_ib_ = false; } else // need to obtain an __intbuf_. { // If __extbuf_ is user-supplied, use it, else new __intbuf_ if (!__owns_eb_ && __extbuf_ != __extbuf_min_) { __ibs_ = __ebs_; __intbuf_ = (char_type*)__extbuf_; __owns_ib_ = false; __extbuf_ = new char[__ebs_]; __owns_eb_ = true; } else { __ibs_ = __ebs_; __intbuf_ = new char_type[__ibs_]; __owns_ib_ = true; } } }}template <class _CharT, class _Traits>boolbasic_filebuf<_CharT, _Traits>::__read_mode(){ if (!(__cm_ & ios_base::in)) { this->setp(0, 0); if (__always_noconv_) this->setg((char_type*)__extbuf_, (char_type*)__extbuf_ + __ebs_, (char_type*)__extbuf_ + __ebs_); else this->setg(__intbuf_, __intbuf_ + __ibs_, __intbuf_ + __ibs_); __cm_ = ios_base::in; return true; } return false;}template <class _CharT, class _Traits>voidbasic_filebuf<_CharT, _Traits>::__write_mode(){ if (!(__cm_ & ios_base::out)) { this->setg(0, 0, 0); if (__ebs_ > sizeof(__extbuf_min_)) { if (__always_noconv_) this->setp((char_type*)__extbuf_, (char_type*)__extbuf_ + (__ebs_ - 1)); else this->setp(__intbuf_, __intbuf_ + (__ibs_ - 1)); } else this->setp(0, 0); __cm_ = ios_base::out; }}// basic_ifstreamtemplate <class _CharT, class _Traits>class _LIBCPP_TEMPLATE_VIS basic_ifstream : public basic_istream<_CharT, _Traits>{public: typedef _CharT char_type; typedef _Traits traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; _LIBCPP_INLINE_VISIBILITY basic_ifstream();#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE _LIBCPP_INLINE_VISIBILITY explicit basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in); _LIBCPP_INLINE_VISIBILITY explicit basic_ifstream(const string& __s, ios_base::openmode __mode = ios_base::in);#endif#ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY basic_ifstream(basic_ifstream&& __rhs); _LIBCPP_INLINE_VISIBILITY basic_ifstream& operator=(basic_ifstream&& __rhs);#endif _LIBCPP_INLINE_VISIBILITY void swap(basic_ifstream& __rhs); _LIBCPP_INLINE_VISIBILITY basic_filebuf<char_type, traits_type>* rdbuf() const; _LIBCPP_INLINE_VISIBILITY bool is_open() const;#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE void open(const char* __s, ios_base::openmode __mode = ios_base::in); void open(const string& __s, ios_base::openmode __mode = ios_base::in);#endif _LIBCPP_INLINE_VISIBILITY void close();private: basic_filebuf<char_type, traits_type> __sb_;};template <class _CharT, class _Traits>inlinebasic_ifstream<_CharT, _Traits>::basic_ifstream() : basic_istream<char_type, traits_type>(&__sb_){}#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACEtemplate <class _CharT, class _Traits>inlinebasic_ifstream<_CharT, _Traits>::basic_ifstream(const char* __s, ios_base::openmode __mode) : basic_istream<char_type, traits_type>(&__sb_){ if (__sb_.open(__s, __mode | ios_base::in) == 0) this->setstate(ios_base::failbit);}template <class _CharT, class _Traits>inlinebasic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::openmode __mode) : basic_istream<char_type, traits_type>(&__sb_){ if (__sb_.open(__s, __mode | ios_base::in) == 0) this->setstate(ios_base::failbit);}#endif#ifndef _LIBCPP_CXX03_LANGtemplate <class _CharT, class _Traits>inlinebasic_ifstream<_CharT, _Traits>::basic_ifstream(basic_ifstream&& __rhs) : basic_istream<char_type, traits_type>(_VSTD::move(__rhs)), __sb_(_VSTD::move(__rhs.__sb_)){ this->set_rdbuf(&__sb_);}template <class _CharT, class _Traits>inlinebasic_ifstream<_CharT, _Traits>&basic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs){ basic_istream<char_type, traits_type>::operator=(_VSTD::move(__rhs)); __sb_ = _VSTD::move(__rhs.__sb_); return *this;}#endif // _LIBCPP_CXX03_LANGtemplate <class _CharT, class _Traits>inlinevoidbasic_ifstream<_CharT, _Traits>::swap(basic_ifstream& __rhs){ basic_istream<char_type, traits_type>::swap(__rhs); __sb_.swap(__rhs.__sb_);}template <class _CharT, class _Traits>inline _LIBCPP_INLINE_VISIBILITYvoidswap(basic_ifstream<_CharT, _Traits>& __x, basic_ifstream<_CharT, _Traits>& __y){ __x.swap(__y);}template <class _CharT, class _Traits>inlinebasic_filebuf<_CharT, _Traits>*basic_ifstream<_CharT, _Traits>::rdbuf() const{ return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);}template <class _CharT, class _Traits>inlineboolbasic_ifstream<_CharT, _Traits>::is_open() const{ return __sb_.is_open();}#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACEtemplate <class _CharT, class _Traits>voidbasic_ifstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode){ if (__sb_.open(__s, __mode | ios_base::in)) this->clear(); else this->setstate(ios_base::failbit);}template <class _CharT, class _Traits>voidbasic_ifstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode){ if (__sb_.open(__s, __mode | ios_base::in)) this->clear(); else this->setstate(ios_base::failbit);}#endiftemplate <class _CharT, class _Traits>inlinevoidbasic_ifstream<_CharT, _Traits>::close(){ if (__sb_.close() == 0) this->setstate(ios_base::failbit);}// basic_ofstreamtemplate <class _CharT, class _Traits>class _LIBCPP_TEMPLATE_VIS basic_ofstream : public basic_ostream<_CharT, _Traits>{public: typedef _CharT char_type; typedef _Traits traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; _LIBCPP_INLINE_VISIBILITY basic_ofstream(); _LIBCPP_INLINE_VISIBILITY explicit basic_ofstream(const char* __s, ios_base::openmode __mode = ios_base::out); _LIBCPP_INLINE_VISIBILITY explicit basic_ofstream(const string& __s, ios_base::openmode __mode = ios_base::out);#ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY basic_ofstream(basic_ofstream&& __rhs); _LIBCPP_INLINE_VISIBILITY basic_ofstream& operator=(basic_ofstream&& __rhs);#endif _LIBCPP_INLINE_VISIBILITY void swap(basic_ofstream& __rhs); _LIBCPP_INLINE_VISIBILITY basic_filebuf<char_type, traits_type>* rdbuf() const; _LIBCPP_INLINE_VISIBILITY bool is_open() const;#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE void open(const char* __s, ios_base::openmode __mode = ios_base::out); void open(const string& __s, ios_base::openmode __mode = ios_base::out);#endif _LIBCPP_INLINE_VISIBILITY void close();private: basic_filebuf<char_type, traits_type> __sb_;};template <class _CharT, class _Traits>inlinebasic_ofstream<_CharT, _Traits>::basic_ofstream() : basic_ostream<char_type, traits_type>(&__sb_){}#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACEtemplate <class _CharT, class _Traits>inlinebasic_ofstream<_CharT, _Traits>::basic_ofstream(const char* __s, ios_base::openmode __mode) : basic_ostream<char_type, traits_type>(&__sb_){ if (__sb_.open(__s, __mode | ios_base::out) == 0) this->setstate(ios_base::failbit);}template <class _CharT, class _Traits>inlinebasic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::openmode __mode) : basic_ostream<char_type, traits_type>(&__sb_){ if (__sb_.open(__s, __mode | ios_base::out) == 0) this->setstate(ios_base::failbit);}#endif#ifndef _LIBCPP_CXX03_LANGtemplate <class _CharT, class _Traits>inlinebasic_ofstream<_CharT, _Traits>::basic_ofstream(basic_ofstream&& __rhs) : basic_ostream<char_type, traits_type>(_VSTD::move(__rhs)), __sb_(_VSTD::move(__rhs.__sb_)){ this->set_rdbuf(&__sb_);}template <class _CharT, class _Traits>inlinebasic_ofstream<_CharT, _Traits>&basic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs){ basic_ostream<char_type, traits_type>::operator=(_VSTD::move(__rhs)); __sb_ = _VSTD::move(__rhs.__sb_); return *this;}#endif // _LIBCPP_CXX03_LANGtemplate <class _CharT, class _Traits>inlinevoidbasic_ofstream<_CharT, _Traits>::swap(basic_ofstream& __rhs){ basic_ostream<char_type, traits_type>::swap(__rhs); __sb_.swap(__rhs.__sb_);}template <class _CharT, class _Traits>inline _LIBCPP_INLINE_VISIBILITYvoidswap(basic_ofstream<_CharT, _Traits>& __x, basic_ofstream<_CharT, _Traits>& __y){ __x.swap(__y);}template <class _CharT, class _Traits>inlinebasic_filebuf<_CharT, _Traits>*basic_ofstream<_CharT, _Traits>::rdbuf() const{ return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);}template <class _CharT, class _Traits>inlineboolbasic_ofstream<_CharT, _Traits>::is_open() const{ return __sb_.is_open();}#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACEtemplate <class _CharT, class _Traits>voidbasic_ofstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode){ if (__sb_.open(__s, __mode | ios_base::out)) this->clear(); else this->setstate(ios_base::failbit);}template <class _CharT, class _Traits>voidbasic_ofstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode){ if (__sb_.open(__s, __mode | ios_base::out)) this->clear(); else this->setstate(ios_base::failbit);}#endiftemplate <class _CharT, class _Traits>inlinevoidbasic_ofstream<_CharT, _Traits>::close(){ if (__sb_.close() == 0) this->setstate(ios_base::failbit);}// basic_fstreamtemplate <class _CharT, class _Traits>class _LIBCPP_TEMPLATE_VIS basic_fstream : public basic_iostream<_CharT, _Traits>{public: typedef _CharT char_type; typedef _Traits traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; _LIBCPP_INLINE_VISIBILITY basic_fstream();#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE _LIBCPP_INLINE_VISIBILITY explicit basic_fstream(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); _LIBCPP_INLINE_VISIBILITY explicit basic_fstream(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);#endif#ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY basic_fstream(basic_fstream&& __rhs); _LIBCPP_INLINE_VISIBILITY basic_fstream& operator=(basic_fstream&& __rhs);#endif _LIBCPP_INLINE_VISIBILITY void swap(basic_fstream& __rhs); _LIBCPP_INLINE_VISIBILITY basic_filebuf<char_type, traits_type>* rdbuf() const; _LIBCPP_INLINE_VISIBILITY bool is_open() const;#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE void open(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); void open(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);#endif _LIBCPP_INLINE_VISIBILITY void close();private: basic_filebuf<char_type, traits_type> __sb_;};template <class _CharT, class _Traits>inlinebasic_fstream<_CharT, _Traits>::basic_fstream() : basic_iostream<char_type, traits_type>(&__sb_){}#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACEtemplate <class _CharT, class _Traits>inlinebasic_fstream<_CharT, _Traits>::basic_fstream(const char* __s, ios_base::openmode __mode) : basic_iostream<char_type, traits_type>(&__sb_){ if (__sb_.open(__s, __mode) == 0) this->setstate(ios_base::failbit);}template <class _CharT, class _Traits>inlinebasic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openmode __mode) : basic_iostream<char_type, traits_type>(&__sb_){ if (__sb_.open(__s, __mode) == 0) this->setstate(ios_base::failbit);}#endif#ifndef _LIBCPP_CXX03_LANGtemplate <class _CharT, class _Traits>inlinebasic_fstream<_CharT, _Traits>::basic_fstream(basic_fstream&& __rhs) : basic_iostream<char_type, traits_type>(_VSTD::move(__rhs)), __sb_(_VSTD::move(__rhs.__sb_)){ this->set_rdbuf(&__sb_);}template <class _CharT, class _Traits>inlinebasic_fstream<_CharT, _Traits>&basic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs){ basic_iostream<char_type, traits_type>::operator=(_VSTD::move(__rhs)); __sb_ = _VSTD::move(__rhs.__sb_); return *this;}#endif // _LIBCPP_CXX03_LANGtemplate <class _CharT, class _Traits>inlinevoidbasic_fstream<_CharT, _Traits>::swap(basic_fstream& __rhs){ basic_iostream<char_type, traits_type>::swap(__rhs); __sb_.swap(__rhs.__sb_);}template <class _CharT, class _Traits>inline _LIBCPP_INLINE_VISIBILITYvoidswap(basic_fstream<_CharT, _Traits>& __x, basic_fstream<_CharT, _Traits>& __y){ __x.swap(__y);}template <class _CharT, class _Traits>inlinebasic_filebuf<_CharT, _Traits>*basic_fstream<_CharT, _Traits>::rdbuf() const{ return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);}template <class _CharT, class _Traits>inlineboolbasic_fstream<_CharT, _Traits>::is_open() const{ return __sb_.is_open();}#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACEtemplate <class _CharT, class _Traits>voidbasic_fstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode){ if (__sb_.open(__s, __mode)) this->clear(); else this->setstate(ios_base::failbit);}template <class _CharT, class _Traits>voidbasic_fstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode){ if (__sb_.open(__s, __mode)) this->clear(); else this->setstate(ios_base::failbit);}#endiftemplate <class _CharT, class _Traits>inlinevoidbasic_fstream<_CharT, _Traits>::close(){ if (__sb_.close() == 0) this->setstate(ios_base::failbit);}_LIBCPP_END_NAMESPACE_STD_LIBCPP_POP_MACROS#endif // _LIBCPP_FSTREAM