10b57cec5SDimitry Andric// -*- C++ -*- 2349cc55cSDimitry Andric//===----------------------------------------------------------------------===// 30b57cec5SDimitry Andric// 40b57cec5SDimitry Andric// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 50b57cec5SDimitry Andric// See https://llvm.org/LICENSE.txt for license information. 60b57cec5SDimitry Andric// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 70b57cec5SDimitry Andric// 80b57cec5SDimitry Andric//===----------------------------------------------------------------------===// 90b57cec5SDimitry Andric 100b57cec5SDimitry Andric#ifndef _LIBCPP_FSTREAM 110b57cec5SDimitry Andric#define _LIBCPP_FSTREAM 120b57cec5SDimitry Andric 130b57cec5SDimitry Andric/* 140b57cec5SDimitry Andric fstream synopsis 150b57cec5SDimitry Andric 160b57cec5SDimitry Andrictemplate <class charT, class traits = char_traits<charT> > 170b57cec5SDimitry Andricclass basic_filebuf 180b57cec5SDimitry Andric : public basic_streambuf<charT, traits> 190b57cec5SDimitry Andric{ 200b57cec5SDimitry Andricpublic: 210b57cec5SDimitry Andric typedef charT char_type; 220b57cec5SDimitry Andric typedef traits traits_type; 230b57cec5SDimitry Andric typedef typename traits_type::int_type int_type; 240b57cec5SDimitry Andric typedef typename traits_type::pos_type pos_type; 250b57cec5SDimitry Andric typedef typename traits_type::off_type off_type; 260b57cec5SDimitry Andric 270b57cec5SDimitry Andric // 27.9.1.2 Constructors/destructor: 280b57cec5SDimitry Andric basic_filebuf(); 290b57cec5SDimitry Andric basic_filebuf(basic_filebuf&& rhs); 300b57cec5SDimitry Andric virtual ~basic_filebuf(); 310b57cec5SDimitry Andric 320b57cec5SDimitry Andric // 27.9.1.3 Assign/swap: 330b57cec5SDimitry Andric basic_filebuf& operator=(basic_filebuf&& rhs); 340b57cec5SDimitry Andric void swap(basic_filebuf& rhs); 350b57cec5SDimitry Andric 360b57cec5SDimitry Andric // 27.9.1.4 Members: 370b57cec5SDimitry Andric bool is_open() const; 380b57cec5SDimitry Andric basic_filebuf* open(const char* s, ios_base::openmode mode); 390b57cec5SDimitry Andric basic_filebuf* open(const string& s, ios_base::openmode mode); 400b57cec5SDimitry Andric basic_filebuf* open(const filesystem::path& p, ios_base::openmode mode); // C++17 410b57cec5SDimitry Andric basic_filebuf* close(); 420b57cec5SDimitry Andric 430b57cec5SDimitry Andricprotected: 440b57cec5SDimitry Andric // 27.9.1.5 Overridden virtual functions: 450b57cec5SDimitry Andric virtual streamsize showmanyc(); 460b57cec5SDimitry Andric virtual int_type underflow(); 470b57cec5SDimitry Andric virtual int_type uflow(); 480b57cec5SDimitry Andric virtual int_type pbackfail(int_type c = traits_type::eof()); 490b57cec5SDimitry Andric virtual int_type overflow (int_type c = traits_type::eof()); 500b57cec5SDimitry Andric virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* s, streamsize n); 510b57cec5SDimitry Andric virtual pos_type seekoff(off_type off, ios_base::seekdir way, 520b57cec5SDimitry Andric ios_base::openmode which = ios_base::in | ios_base::out); 530b57cec5SDimitry Andric virtual pos_type seekpos(pos_type sp, 540b57cec5SDimitry Andric ios_base::openmode which = ios_base::in | ios_base::out); 550b57cec5SDimitry Andric virtual int sync(); 560b57cec5SDimitry Andric virtual void imbue(const locale& loc); 570b57cec5SDimitry Andric}; 580b57cec5SDimitry Andric 590b57cec5SDimitry Andrictemplate <class charT, class traits> 600b57cec5SDimitry Andric void 610b57cec5SDimitry Andric swap(basic_filebuf<charT, traits>& x, basic_filebuf<charT, traits>& y); 620b57cec5SDimitry Andric 630b57cec5SDimitry Andrictypedef basic_filebuf<char> filebuf; 640b57cec5SDimitry Andrictypedef basic_filebuf<wchar_t> wfilebuf; 650b57cec5SDimitry Andric 660b57cec5SDimitry Andrictemplate <class charT, class traits = char_traits<charT> > 670b57cec5SDimitry Andricclass basic_ifstream 680b57cec5SDimitry Andric : public basic_istream<charT,traits> 690b57cec5SDimitry Andric{ 700b57cec5SDimitry Andricpublic: 710b57cec5SDimitry Andric typedef charT char_type; 720b57cec5SDimitry Andric typedef traits traits_type; 730b57cec5SDimitry Andric typedef typename traits_type::int_type int_type; 740b57cec5SDimitry Andric typedef typename traits_type::pos_type pos_type; 750b57cec5SDimitry Andric typedef typename traits_type::off_type off_type; 760b57cec5SDimitry Andric 770b57cec5SDimitry Andric basic_ifstream(); 780b57cec5SDimitry Andric explicit basic_ifstream(const char* s, ios_base::openmode mode = ios_base::in); 790b57cec5SDimitry Andric explicit basic_ifstream(const string& s, ios_base::openmode mode = ios_base::in); 800b57cec5SDimitry Andric explicit basic_ifstream(const filesystem::path& p, 810b57cec5SDimitry Andric ios_base::openmode mode = ios_base::in); // C++17 820b57cec5SDimitry Andric basic_ifstream(basic_ifstream&& rhs); 830b57cec5SDimitry Andric 840b57cec5SDimitry Andric basic_ifstream& operator=(basic_ifstream&& rhs); 850b57cec5SDimitry Andric void swap(basic_ifstream& rhs); 860b57cec5SDimitry Andric 870b57cec5SDimitry Andric basic_filebuf<char_type, traits_type>* rdbuf() const; 880b57cec5SDimitry Andric bool is_open() const; 890b57cec5SDimitry Andric void open(const char* s, ios_base::openmode mode = ios_base::in); 900b57cec5SDimitry Andric void open(const string& s, ios_base::openmode mode = ios_base::in); 910b57cec5SDimitry Andric void open(const filesystem::path& s, ios_base::openmode mode = ios_base::in); // C++17 920b57cec5SDimitry Andric 930b57cec5SDimitry Andric void close(); 940b57cec5SDimitry Andric}; 950b57cec5SDimitry Andric 960b57cec5SDimitry Andrictemplate <class charT, class traits> 970b57cec5SDimitry Andric void 980b57cec5SDimitry Andric swap(basic_ifstream<charT, traits>& x, basic_ifstream<charT, traits>& y); 990b57cec5SDimitry Andric 1000b57cec5SDimitry Andrictypedef basic_ifstream<char> ifstream; 1010b57cec5SDimitry Andrictypedef basic_ifstream<wchar_t> wifstream; 1020b57cec5SDimitry Andric 1030b57cec5SDimitry Andrictemplate <class charT, class traits = char_traits<charT> > 1040b57cec5SDimitry Andricclass basic_ofstream 1050b57cec5SDimitry Andric : public basic_ostream<charT,traits> 1060b57cec5SDimitry Andric{ 1070b57cec5SDimitry Andricpublic: 1080b57cec5SDimitry Andric typedef charT char_type; 1090b57cec5SDimitry Andric typedef traits traits_type; 1100b57cec5SDimitry Andric typedef typename traits_type::int_type int_type; 1110b57cec5SDimitry Andric typedef typename traits_type::pos_type pos_type; 1120b57cec5SDimitry Andric typedef typename traits_type::off_type off_type; 1130b57cec5SDimitry Andric 1140b57cec5SDimitry Andric basic_ofstream(); 1150b57cec5SDimitry Andric explicit basic_ofstream(const char* s, ios_base::openmode mode = ios_base::out); 1160b57cec5SDimitry Andric explicit basic_ofstream(const string& s, ios_base::openmode mode = ios_base::out); 1170b57cec5SDimitry Andric explicit basic_ofstream(const filesystem::path& p, 1180b57cec5SDimitry Andric ios_base::openmode mode = ios_base::out); // C++17 1190b57cec5SDimitry Andric basic_ofstream(basic_ofstream&& rhs); 1200b57cec5SDimitry Andric 1210b57cec5SDimitry Andric basic_ofstream& operator=(basic_ofstream&& rhs); 1220b57cec5SDimitry Andric void swap(basic_ofstream& rhs); 1230b57cec5SDimitry Andric 1240b57cec5SDimitry Andric basic_filebuf<char_type, traits_type>* rdbuf() const; 1250b57cec5SDimitry Andric bool is_open() const; 1260b57cec5SDimitry Andric void open(const char* s, ios_base::openmode mode = ios_base::out); 1270b57cec5SDimitry Andric void open(const string& s, ios_base::openmode mode = ios_base::out); 1280b57cec5SDimitry Andric void open(const filesystem::path& p, 1290b57cec5SDimitry Andric ios_base::openmode mode = ios_base::out); // C++17 1300b57cec5SDimitry Andric 1310b57cec5SDimitry Andric void close(); 1320b57cec5SDimitry Andric}; 1330b57cec5SDimitry Andric 1340b57cec5SDimitry Andrictemplate <class charT, class traits> 1350b57cec5SDimitry Andric void 1360b57cec5SDimitry Andric swap(basic_ofstream<charT, traits>& x, basic_ofstream<charT, traits>& y); 1370b57cec5SDimitry Andric 1380b57cec5SDimitry Andrictypedef basic_ofstream<char> ofstream; 1390b57cec5SDimitry Andrictypedef basic_ofstream<wchar_t> wofstream; 1400b57cec5SDimitry Andric 1410b57cec5SDimitry Andrictemplate <class charT, class traits=char_traits<charT> > 1420b57cec5SDimitry Andricclass basic_fstream 1430b57cec5SDimitry Andric : public basic_iostream<charT,traits> 1440b57cec5SDimitry Andric{ 1450b57cec5SDimitry Andricpublic: 1460b57cec5SDimitry Andric typedef charT char_type; 1470b57cec5SDimitry Andric typedef traits traits_type; 1480b57cec5SDimitry Andric typedef typename traits_type::int_type int_type; 1490b57cec5SDimitry Andric typedef typename traits_type::pos_type pos_type; 1500b57cec5SDimitry Andric typedef typename traits_type::off_type off_type; 1510b57cec5SDimitry Andric 1520b57cec5SDimitry Andric basic_fstream(); 1530b57cec5SDimitry Andric explicit basic_fstream(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out); 1540b57cec5SDimitry Andric explicit basic_fstream(const string& s, ios_base::openmode mode = ios_base::in|ios_base::out); 1550b57cec5SDimitry Andric explicit basic_fstream(const filesystem::path& p, 1560b57cec5SDimitry Andric ios_base::openmode mode = ios_base::in|ios_base::out); C++17 1570b57cec5SDimitry Andric basic_fstream(basic_fstream&& rhs); 1580b57cec5SDimitry Andric 1590b57cec5SDimitry Andric basic_fstream& operator=(basic_fstream&& rhs); 1600b57cec5SDimitry Andric void swap(basic_fstream& rhs); 1610b57cec5SDimitry Andric 1620b57cec5SDimitry Andric basic_filebuf<char_type, traits_type>* rdbuf() const; 1630b57cec5SDimitry Andric bool is_open() const; 1640b57cec5SDimitry Andric void open(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out); 1650b57cec5SDimitry Andric void open(const string& s, ios_base::openmode mode = ios_base::in|ios_base::out); 1660b57cec5SDimitry Andric void open(const filesystem::path& s, 1670b57cec5SDimitry Andric ios_base::openmode mode = ios_base::in|ios_base::out); // C++17 1680b57cec5SDimitry Andric 1690b57cec5SDimitry Andric void close(); 1700b57cec5SDimitry Andric}; 1710b57cec5SDimitry Andric 1720b57cec5SDimitry Andrictemplate <class charT, class traits> 1730b57cec5SDimitry Andric void swap(basic_fstream<charT, traits>& x, basic_fstream<charT, traits>& y); 1740b57cec5SDimitry Andric 1750b57cec5SDimitry Andrictypedef basic_fstream<char> fstream; 1760b57cec5SDimitry Andrictypedef basic_fstream<wchar_t> wfstream; 1770b57cec5SDimitry Andric 1780b57cec5SDimitry Andric} // std 1790b57cec5SDimitry Andric 1800b57cec5SDimitry Andric*/ 1810b57cec5SDimitry Andric 182*81ad6265SDimitry Andric#include <__algorithm/max.h> 183*81ad6265SDimitry Andric#include <__assert> // all public C++ headers provide the assertion handler 184e8d8bef9SDimitry Andric#include <__availability> 185fe6060f1SDimitry Andric#include <__config> 1860b57cec5SDimitry Andric#include <__locale> 187*81ad6265SDimitry Andric#include <__utility/move.h> 188*81ad6265SDimitry Andric#include <__utility/swap.h> 189*81ad6265SDimitry Andric#include <__utility/unreachable.h> 1900b57cec5SDimitry Andric#include <cstdio> 1910b57cec5SDimitry Andric#include <cstdlib> 192*81ad6265SDimitry Andric#include <cstring> 193fe6060f1SDimitry Andric#include <istream> 194fe6060f1SDimitry Andric#include <ostream> 19504eeddc0SDimitry Andric#include <version> 196e8d8bef9SDimitry Andric 197e8d8bef9SDimitry Andric#if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) 1980b57cec5SDimitry Andric# include <filesystem> 199e8d8bef9SDimitry Andric#endif 2000b57cec5SDimitry Andric 2010b57cec5SDimitry Andric#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 2020b57cec5SDimitry Andric# pragma GCC system_header 2030b57cec5SDimitry Andric#endif 2040b57cec5SDimitry Andric 2050b57cec5SDimitry Andric_LIBCPP_PUSH_MACROS 2060b57cec5SDimitry Andric#include <__undef_macros> 2070b57cec5SDimitry Andric 208fe6060f1SDimitry Andric#if defined(_LIBCPP_MSVCRT) || defined(_NEWLIB_VERSION) 209fe6060f1SDimitry Andric# define _LIBCPP_HAS_NO_OFF_T_FUNCTIONS 210fe6060f1SDimitry Andric#endif 2110b57cec5SDimitry Andric 2120b57cec5SDimitry Andric_LIBCPP_BEGIN_NAMESPACE_STD 2130b57cec5SDimitry Andric 2140b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 2150b57cec5SDimitry Andricclass _LIBCPP_TEMPLATE_VIS basic_filebuf 2160b57cec5SDimitry Andric : public basic_streambuf<_CharT, _Traits> 2170b57cec5SDimitry Andric{ 2180b57cec5SDimitry Andricpublic: 2190b57cec5SDimitry Andric typedef _CharT char_type; 2200b57cec5SDimitry Andric typedef _Traits traits_type; 2210b57cec5SDimitry Andric typedef typename traits_type::int_type int_type; 2220b57cec5SDimitry Andric typedef typename traits_type::pos_type pos_type; 2230b57cec5SDimitry Andric typedef typename traits_type::off_type off_type; 2240b57cec5SDimitry Andric typedef typename traits_type::state_type state_type; 2250b57cec5SDimitry Andric 2260b57cec5SDimitry Andric // 27.9.1.2 Constructors/destructor: 2270b57cec5SDimitry Andric basic_filebuf(); 2280b57cec5SDimitry Andric basic_filebuf(basic_filebuf&& __rhs); 2290b57cec5SDimitry Andric virtual ~basic_filebuf(); 2300b57cec5SDimitry Andric 2310b57cec5SDimitry Andric // 27.9.1.3 Assign/swap: 2320b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 2330b57cec5SDimitry Andric basic_filebuf& operator=(basic_filebuf&& __rhs); 2340b57cec5SDimitry Andric void swap(basic_filebuf& __rhs); 2350b57cec5SDimitry Andric 2360b57cec5SDimitry Andric // 27.9.1.4 Members: 2370b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 2380b57cec5SDimitry Andric bool is_open() const; 2390b57cec5SDimitry Andric basic_filebuf* open(const char* __s, ios_base::openmode __mode); 2400b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 2410b57cec5SDimitry Andric basic_filebuf* open(const wchar_t* __s, ios_base::openmode __mode); 2420b57cec5SDimitry Andric#endif 2430b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 2440b57cec5SDimitry Andric basic_filebuf* open(const string& __s, ios_base::openmode __mode); 2450b57cec5SDimitry Andric 246e8d8bef9SDimitry Andric#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) 2470b57cec5SDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY 2480b57cec5SDimitry Andric basic_filebuf* open(const _VSTD_FS::path& __p, ios_base::openmode __mode) { 2490b57cec5SDimitry Andric return open(__p.c_str(), __mode); 2500b57cec5SDimitry Andric } 2510b57cec5SDimitry Andric#endif 252d099db25SDimitry Andric _LIBCPP_INLINE_VISIBILITY 2530b57cec5SDimitry Andric basic_filebuf* __open(int __fd, ios_base::openmode __mode); 2540b57cec5SDimitry Andric basic_filebuf* close(); 2550b57cec5SDimitry Andric 2560b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 2570b57cec5SDimitry Andric inline static const char* 2580b57cec5SDimitry Andric __make_mdstring(ios_base::openmode __mode) _NOEXCEPT; 2590b57cec5SDimitry Andric 2600b57cec5SDimitry Andric protected: 2610b57cec5SDimitry Andric // 27.9.1.5 Overridden virtual functions: 2620b57cec5SDimitry Andric virtual int_type underflow(); 2630b57cec5SDimitry Andric virtual int_type pbackfail(int_type __c = traits_type::eof()); 2640b57cec5SDimitry Andric virtual int_type overflow (int_type __c = traits_type::eof()); 2650b57cec5SDimitry Andric virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* __s, streamsize __n); 2660b57cec5SDimitry Andric virtual pos_type seekoff(off_type __off, ios_base::seekdir __way, 2670b57cec5SDimitry Andric ios_base::openmode __wch = ios_base::in | ios_base::out); 2680b57cec5SDimitry Andric virtual pos_type seekpos(pos_type __sp, 2690b57cec5SDimitry Andric ios_base::openmode __wch = ios_base::in | ios_base::out); 2700b57cec5SDimitry Andric virtual int sync(); 2710b57cec5SDimitry Andric virtual void imbue(const locale& __loc); 2720b57cec5SDimitry Andric 2730b57cec5SDimitry Andricprivate: 2740b57cec5SDimitry Andric char* __extbuf_; 2750b57cec5SDimitry Andric const char* __extbufnext_; 2760b57cec5SDimitry Andric const char* __extbufend_; 2770b57cec5SDimitry Andric char __extbuf_min_[8]; 2780b57cec5SDimitry Andric size_t __ebs_; 2790b57cec5SDimitry Andric char_type* __intbuf_; 2800b57cec5SDimitry Andric size_t __ibs_; 2810b57cec5SDimitry Andric FILE* __file_; 2820b57cec5SDimitry Andric const codecvt<char_type, char, state_type>* __cv_; 2830b57cec5SDimitry Andric state_type __st_; 2840b57cec5SDimitry Andric state_type __st_last_; 2850b57cec5SDimitry Andric ios_base::openmode __om_; 2860b57cec5SDimitry Andric ios_base::openmode __cm_; 2870b57cec5SDimitry Andric bool __owns_eb_; 2880b57cec5SDimitry Andric bool __owns_ib_; 2890b57cec5SDimitry Andric bool __always_noconv_; 2900b57cec5SDimitry Andric 2910b57cec5SDimitry Andric bool __read_mode(); 2920b57cec5SDimitry Andric void __write_mode(); 2930b57cec5SDimitry Andric}; 2940b57cec5SDimitry Andric 2950b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 2960b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::basic_filebuf() 297e8d8bef9SDimitry Andric : __extbuf_(nullptr), 298e8d8bef9SDimitry Andric __extbufnext_(nullptr), 299e8d8bef9SDimitry Andric __extbufend_(nullptr), 3000b57cec5SDimitry Andric __ebs_(0), 301e8d8bef9SDimitry Andric __intbuf_(nullptr), 3020b57cec5SDimitry Andric __ibs_(0), 303e8d8bef9SDimitry Andric __file_(nullptr), 3040b57cec5SDimitry Andric __cv_(nullptr), 3050b57cec5SDimitry Andric __st_(), 3060b57cec5SDimitry Andric __st_last_(), 3070b57cec5SDimitry Andric __om_(0), 3080b57cec5SDimitry Andric __cm_(0), 3090b57cec5SDimitry Andric __owns_eb_(false), 3100b57cec5SDimitry Andric __owns_ib_(false), 3110b57cec5SDimitry Andric __always_noconv_(false) 3120b57cec5SDimitry Andric{ 3130b57cec5SDimitry Andric if (has_facet<codecvt<char_type, char, state_type> >(this->getloc())) 3140b57cec5SDimitry Andric { 3150b57cec5SDimitry Andric __cv_ = &use_facet<codecvt<char_type, char, state_type> >(this->getloc()); 3160b57cec5SDimitry Andric __always_noconv_ = __cv_->always_noconv(); 3170b57cec5SDimitry Andric } 318e8d8bef9SDimitry Andric setbuf(nullptr, 4096); 3190b57cec5SDimitry Andric} 3200b57cec5SDimitry Andric 3210b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 3220b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs) 3230b57cec5SDimitry Andric : basic_streambuf<_CharT, _Traits>(__rhs) 3240b57cec5SDimitry Andric{ 3250b57cec5SDimitry Andric if (__rhs.__extbuf_ == __rhs.__extbuf_min_) 3260b57cec5SDimitry Andric { 3270b57cec5SDimitry Andric __extbuf_ = __extbuf_min_; 3280b57cec5SDimitry Andric __extbufnext_ = __extbuf_ + (__rhs.__extbufnext_ - __rhs.__extbuf_); 3290b57cec5SDimitry Andric __extbufend_ = __extbuf_ + (__rhs.__extbufend_ - __rhs.__extbuf_); 3300b57cec5SDimitry Andric } 3310b57cec5SDimitry Andric else 3320b57cec5SDimitry Andric { 3330b57cec5SDimitry Andric __extbuf_ = __rhs.__extbuf_; 3340b57cec5SDimitry Andric __extbufnext_ = __rhs.__extbufnext_; 3350b57cec5SDimitry Andric __extbufend_ = __rhs.__extbufend_; 3360b57cec5SDimitry Andric } 3370b57cec5SDimitry Andric __ebs_ = __rhs.__ebs_; 3380b57cec5SDimitry Andric __intbuf_ = __rhs.__intbuf_; 3390b57cec5SDimitry Andric __ibs_ = __rhs.__ibs_; 3400b57cec5SDimitry Andric __file_ = __rhs.__file_; 3410b57cec5SDimitry Andric __cv_ = __rhs.__cv_; 3420b57cec5SDimitry Andric __st_ = __rhs.__st_; 3430b57cec5SDimitry Andric __st_last_ = __rhs.__st_last_; 3440b57cec5SDimitry Andric __om_ = __rhs.__om_; 3450b57cec5SDimitry Andric __cm_ = __rhs.__cm_; 3460b57cec5SDimitry Andric __owns_eb_ = __rhs.__owns_eb_; 3470b57cec5SDimitry Andric __owns_ib_ = __rhs.__owns_ib_; 3480b57cec5SDimitry Andric __always_noconv_ = __rhs.__always_noconv_; 3490b57cec5SDimitry Andric if (__rhs.pbase()) 3500b57cec5SDimitry Andric { 3510b57cec5SDimitry Andric if (__rhs.pbase() == __rhs.__intbuf_) 3520b57cec5SDimitry Andric this->setp(__intbuf_, __intbuf_ + (__rhs. epptr() - __rhs.pbase())); 3530b57cec5SDimitry Andric else 3540b57cec5SDimitry Andric this->setp((char_type*)__extbuf_, 3550b57cec5SDimitry Andric (char_type*)__extbuf_ + (__rhs. epptr() - __rhs.pbase())); 3560b57cec5SDimitry Andric this->__pbump(__rhs. pptr() - __rhs.pbase()); 3570b57cec5SDimitry Andric } 3580b57cec5SDimitry Andric else if (__rhs.eback()) 3590b57cec5SDimitry Andric { 3600b57cec5SDimitry Andric if (__rhs.eback() == __rhs.__intbuf_) 3610b57cec5SDimitry Andric this->setg(__intbuf_, __intbuf_ + (__rhs.gptr() - __rhs.eback()), 3620b57cec5SDimitry Andric __intbuf_ + (__rhs.egptr() - __rhs.eback())); 3630b57cec5SDimitry Andric else 3640b57cec5SDimitry Andric this->setg((char_type*)__extbuf_, 3650b57cec5SDimitry Andric (char_type*)__extbuf_ + (__rhs.gptr() - __rhs.eback()), 3660b57cec5SDimitry Andric (char_type*)__extbuf_ + (__rhs.egptr() - __rhs.eback())); 3670b57cec5SDimitry Andric } 368e8d8bef9SDimitry Andric __rhs.__extbuf_ = nullptr; 369e8d8bef9SDimitry Andric __rhs.__extbufnext_ = nullptr; 370e8d8bef9SDimitry Andric __rhs.__extbufend_ = nullptr; 3710b57cec5SDimitry Andric __rhs.__ebs_ = 0; 3720b57cec5SDimitry Andric __rhs.__intbuf_ = 0; 3730b57cec5SDimitry Andric __rhs.__ibs_ = 0; 374e8d8bef9SDimitry Andric __rhs.__file_ = nullptr; 3750b57cec5SDimitry Andric __rhs.__st_ = state_type(); 3760b57cec5SDimitry Andric __rhs.__st_last_ = state_type(); 3770b57cec5SDimitry Andric __rhs.__om_ = 0; 3780b57cec5SDimitry Andric __rhs.__cm_ = 0; 3790b57cec5SDimitry Andric __rhs.__owns_eb_ = false; 3800b57cec5SDimitry Andric __rhs.__owns_ib_ = false; 3810b57cec5SDimitry Andric __rhs.setg(0, 0, 0); 3820b57cec5SDimitry Andric __rhs.setp(0, 0); 3830b57cec5SDimitry Andric} 3840b57cec5SDimitry Andric 3850b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 3860b57cec5SDimitry Andricinline 3870b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>& 3880b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::operator=(basic_filebuf&& __rhs) 3890b57cec5SDimitry Andric{ 3900b57cec5SDimitry Andric close(); 3910b57cec5SDimitry Andric swap(__rhs); 3920b57cec5SDimitry Andric return *this; 3930b57cec5SDimitry Andric} 3940b57cec5SDimitry Andric 3950b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 3960b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::~basic_filebuf() 3970b57cec5SDimitry Andric{ 3980b57cec5SDimitry Andric#ifndef _LIBCPP_NO_EXCEPTIONS 3990b57cec5SDimitry Andric try 4000b57cec5SDimitry Andric { 4010b57cec5SDimitry Andric#endif // _LIBCPP_NO_EXCEPTIONS 4020b57cec5SDimitry Andric close(); 4030b57cec5SDimitry Andric#ifndef _LIBCPP_NO_EXCEPTIONS 4040b57cec5SDimitry Andric } 4050b57cec5SDimitry Andric catch (...) 4060b57cec5SDimitry Andric { 4070b57cec5SDimitry Andric } 4080b57cec5SDimitry Andric#endif // _LIBCPP_NO_EXCEPTIONS 4090b57cec5SDimitry Andric if (__owns_eb_) 4100b57cec5SDimitry Andric delete [] __extbuf_; 4110b57cec5SDimitry Andric if (__owns_ib_) 4120b57cec5SDimitry Andric delete [] __intbuf_; 4130b57cec5SDimitry Andric} 4140b57cec5SDimitry Andric 4150b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 4160b57cec5SDimitry Andricvoid 4170b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::swap(basic_filebuf& __rhs) 4180b57cec5SDimitry Andric{ 4190b57cec5SDimitry Andric basic_streambuf<char_type, traits_type>::swap(__rhs); 4200b57cec5SDimitry Andric if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_) 4210b57cec5SDimitry Andric { 422*81ad6265SDimitry Andric // Neither *this nor __rhs uses the small buffer, so we can simply swap the pointers. 423*81ad6265SDimitry Andric std::swap(__extbuf_, __rhs.__extbuf_); 424*81ad6265SDimitry Andric std::swap(__extbufnext_, __rhs.__extbufnext_); 425*81ad6265SDimitry Andric std::swap(__extbufend_, __rhs.__extbufend_); 4260b57cec5SDimitry Andric } 4270b57cec5SDimitry Andric else 4280b57cec5SDimitry Andric { 429*81ad6265SDimitry Andric ptrdiff_t __ln = __extbufnext_ ? __extbufnext_ - __extbuf_ : 0; 430*81ad6265SDimitry Andric ptrdiff_t __le = __extbufend_ ? __extbufend_ - __extbuf_ : 0; 431*81ad6265SDimitry Andric ptrdiff_t __rn = __rhs.__extbufnext_ ? __rhs.__extbufnext_ - __rhs.__extbuf_ : 0; 432*81ad6265SDimitry Andric ptrdiff_t __re = __rhs.__extbufend_ ? __rhs.__extbufend_ - __rhs.__extbuf_ : 0; 4330b57cec5SDimitry Andric if (__extbuf_ == __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_) 4340b57cec5SDimitry Andric { 435*81ad6265SDimitry Andric // *this uses the small buffer, but __rhs doesn't. 4360b57cec5SDimitry Andric __extbuf_ = __rhs.__extbuf_; 4370b57cec5SDimitry Andric __rhs.__extbuf_ = __rhs.__extbuf_min_; 438*81ad6265SDimitry Andric std::memmove(__rhs.__extbuf_min_, __extbuf_min_, sizeof(__extbuf_min_)); 4390b57cec5SDimitry Andric } 4400b57cec5SDimitry Andric else if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ == __rhs.__extbuf_min_) 4410b57cec5SDimitry Andric { 442*81ad6265SDimitry Andric // *this doesn't use the small buffer, but __rhs does. 4430b57cec5SDimitry Andric __rhs.__extbuf_ = __extbuf_; 4440b57cec5SDimitry Andric __extbuf_ = __extbuf_min_; 445*81ad6265SDimitry Andric std::memmove(__extbuf_min_, __rhs.__extbuf_min_, sizeof(__extbuf_min_)); 446*81ad6265SDimitry Andric } 447*81ad6265SDimitry Andric else 448*81ad6265SDimitry Andric { 449*81ad6265SDimitry Andric // Both *this and __rhs use the small buffer. 450*81ad6265SDimitry Andric char __tmp[sizeof(__extbuf_min_)]; 451*81ad6265SDimitry Andric std::memmove(__tmp, __extbuf_min_, sizeof(__extbuf_min_)); 452*81ad6265SDimitry Andric std::memmove(__extbuf_min_, __rhs.__extbuf_min_, sizeof(__extbuf_min_)); 453*81ad6265SDimitry Andric std::memmove(__rhs.__extbuf_min_, __tmp, sizeof(__extbuf_min_)); 4540b57cec5SDimitry Andric } 4550b57cec5SDimitry Andric __extbufnext_ = __extbuf_ + __rn; 4560b57cec5SDimitry Andric __extbufend_ = __extbuf_ + __re; 4570b57cec5SDimitry Andric __rhs.__extbufnext_ = __rhs.__extbuf_ + __ln; 4580b57cec5SDimitry Andric __rhs.__extbufend_ = __rhs.__extbuf_ + __le; 4590b57cec5SDimitry Andric } 4600b57cec5SDimitry Andric _VSTD::swap(__ebs_, __rhs.__ebs_); 4610b57cec5SDimitry Andric _VSTD::swap(__intbuf_, __rhs.__intbuf_); 4620b57cec5SDimitry Andric _VSTD::swap(__ibs_, __rhs.__ibs_); 4630b57cec5SDimitry Andric _VSTD::swap(__file_, __rhs.__file_); 4640b57cec5SDimitry Andric _VSTD::swap(__cv_, __rhs.__cv_); 4650b57cec5SDimitry Andric _VSTD::swap(__st_, __rhs.__st_); 4660b57cec5SDimitry Andric _VSTD::swap(__st_last_, __rhs.__st_last_); 4670b57cec5SDimitry Andric _VSTD::swap(__om_, __rhs.__om_); 4680b57cec5SDimitry Andric _VSTD::swap(__cm_, __rhs.__cm_); 4690b57cec5SDimitry Andric _VSTD::swap(__owns_eb_, __rhs.__owns_eb_); 4700b57cec5SDimitry Andric _VSTD::swap(__owns_ib_, __rhs.__owns_ib_); 4710b57cec5SDimitry Andric _VSTD::swap(__always_noconv_, __rhs.__always_noconv_); 4720b57cec5SDimitry Andric if (this->eback() == (char_type*)__rhs.__extbuf_min_) 4730b57cec5SDimitry Andric { 4740b57cec5SDimitry Andric ptrdiff_t __n = this->gptr() - this->eback(); 4750b57cec5SDimitry Andric ptrdiff_t __e = this->egptr() - this->eback(); 4760b57cec5SDimitry Andric this->setg((char_type*)__extbuf_min_, 4770b57cec5SDimitry Andric (char_type*)__extbuf_min_ + __n, 4780b57cec5SDimitry Andric (char_type*)__extbuf_min_ + __e); 4790b57cec5SDimitry Andric } 4800b57cec5SDimitry Andric else if (this->pbase() == (char_type*)__rhs.__extbuf_min_) 4810b57cec5SDimitry Andric { 4820b57cec5SDimitry Andric ptrdiff_t __n = this->pptr() - this->pbase(); 4830b57cec5SDimitry Andric ptrdiff_t __e = this->epptr() - this->pbase(); 4840b57cec5SDimitry Andric this->setp((char_type*)__extbuf_min_, 4850b57cec5SDimitry Andric (char_type*)__extbuf_min_ + __e); 4860b57cec5SDimitry Andric this->__pbump(__n); 4870b57cec5SDimitry Andric } 4880b57cec5SDimitry Andric if (__rhs.eback() == (char_type*)__extbuf_min_) 4890b57cec5SDimitry Andric { 4900b57cec5SDimitry Andric ptrdiff_t __n = __rhs.gptr() - __rhs.eback(); 4910b57cec5SDimitry Andric ptrdiff_t __e = __rhs.egptr() - __rhs.eback(); 4920b57cec5SDimitry Andric __rhs.setg((char_type*)__rhs.__extbuf_min_, 4930b57cec5SDimitry Andric (char_type*)__rhs.__extbuf_min_ + __n, 4940b57cec5SDimitry Andric (char_type*)__rhs.__extbuf_min_ + __e); 4950b57cec5SDimitry Andric } 4960b57cec5SDimitry Andric else if (__rhs.pbase() == (char_type*)__extbuf_min_) 4970b57cec5SDimitry Andric { 4980b57cec5SDimitry Andric ptrdiff_t __n = __rhs.pptr() - __rhs.pbase(); 4990b57cec5SDimitry Andric ptrdiff_t __e = __rhs.epptr() - __rhs.pbase(); 5000b57cec5SDimitry Andric __rhs.setp((char_type*)__rhs.__extbuf_min_, 5010b57cec5SDimitry Andric (char_type*)__rhs.__extbuf_min_ + __e); 5020b57cec5SDimitry Andric __rhs.__pbump(__n); 5030b57cec5SDimitry Andric } 5040b57cec5SDimitry Andric} 5050b57cec5SDimitry Andric 5060b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 5070b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 5080b57cec5SDimitry Andricvoid 5090b57cec5SDimitry Andricswap(basic_filebuf<_CharT, _Traits>& __x, basic_filebuf<_CharT, _Traits>& __y) 5100b57cec5SDimitry Andric{ 5110b57cec5SDimitry Andric __x.swap(__y); 5120b57cec5SDimitry Andric} 5130b57cec5SDimitry Andric 5140b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 5150b57cec5SDimitry Andricinline 5160b57cec5SDimitry Andricbool 5170b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::is_open() const 5180b57cec5SDimitry Andric{ 519e8d8bef9SDimitry Andric return __file_ != nullptr; 5200b57cec5SDimitry Andric} 5210b57cec5SDimitry Andric 5220b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 5230b57cec5SDimitry Andricconst char* basic_filebuf<_CharT, _Traits>::__make_mdstring( 5240b57cec5SDimitry Andric ios_base::openmode __mode) _NOEXCEPT { 5250b57cec5SDimitry Andric switch (__mode & ~ios_base::ate) { 5260b57cec5SDimitry Andric case ios_base::out: 5270b57cec5SDimitry Andric case ios_base::out | ios_base::trunc: 528e40139ffSDimitry Andric return "w" _LIBCPP_FOPEN_CLOEXEC_MODE; 5290b57cec5SDimitry Andric case ios_base::out | ios_base::app: 5300b57cec5SDimitry Andric case ios_base::app: 531e40139ffSDimitry Andric return "a" _LIBCPP_FOPEN_CLOEXEC_MODE; 5320b57cec5SDimitry Andric case ios_base::in: 533e40139ffSDimitry Andric return "r" _LIBCPP_FOPEN_CLOEXEC_MODE; 5340b57cec5SDimitry Andric case ios_base::in | ios_base::out: 535e40139ffSDimitry Andric return "r+" _LIBCPP_FOPEN_CLOEXEC_MODE; 5360b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::trunc: 537e40139ffSDimitry Andric return "w+" _LIBCPP_FOPEN_CLOEXEC_MODE; 5380b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::app: 5390b57cec5SDimitry Andric case ios_base::in | ios_base::app: 540e40139ffSDimitry Andric return "a+" _LIBCPP_FOPEN_CLOEXEC_MODE; 5410b57cec5SDimitry Andric case ios_base::out | ios_base::binary: 5420b57cec5SDimitry Andric case ios_base::out | ios_base::trunc | ios_base::binary: 543e40139ffSDimitry Andric return "wb" _LIBCPP_FOPEN_CLOEXEC_MODE; 5440b57cec5SDimitry Andric case ios_base::out | ios_base::app | ios_base::binary: 5450b57cec5SDimitry Andric case ios_base::app | ios_base::binary: 546e40139ffSDimitry Andric return "ab" _LIBCPP_FOPEN_CLOEXEC_MODE; 5470b57cec5SDimitry Andric case ios_base::in | ios_base::binary: 548e40139ffSDimitry Andric return "rb" _LIBCPP_FOPEN_CLOEXEC_MODE; 5490b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::binary: 550e40139ffSDimitry Andric return "r+b" _LIBCPP_FOPEN_CLOEXEC_MODE; 5510b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary: 552e40139ffSDimitry Andric return "w+b" _LIBCPP_FOPEN_CLOEXEC_MODE; 5530b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::app | ios_base::binary: 5540b57cec5SDimitry Andric case ios_base::in | ios_base::app | ios_base::binary: 555e40139ffSDimitry Andric return "a+b" _LIBCPP_FOPEN_CLOEXEC_MODE; 5560b57cec5SDimitry Andric default: 5570b57cec5SDimitry Andric return nullptr; 5580b57cec5SDimitry Andric } 559*81ad6265SDimitry Andric __libcpp_unreachable(); 5600b57cec5SDimitry Andric} 5610b57cec5SDimitry Andric 5620b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 5630b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 5640b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) 5650b57cec5SDimitry Andric{ 566e8d8bef9SDimitry Andric basic_filebuf<_CharT, _Traits>* __rt = nullptr; 567e8d8bef9SDimitry Andric if (__file_ == nullptr) 5680b57cec5SDimitry Andric { 5690b57cec5SDimitry Andric if (const char* __mdstr = __make_mdstring(__mode)) { 5700b57cec5SDimitry Andric __rt = this; 5710b57cec5SDimitry Andric __file_ = fopen(__s, __mdstr); 5720b57cec5SDimitry Andric if (__file_) { 5730b57cec5SDimitry Andric __om_ = __mode; 5740b57cec5SDimitry Andric if (__mode & ios_base::ate) { 5750b57cec5SDimitry Andric if (fseek(__file_, 0, SEEK_END)) { 5760b57cec5SDimitry Andric fclose(__file_); 577e8d8bef9SDimitry Andric __file_ = nullptr; 578e8d8bef9SDimitry Andric __rt = nullptr; 5790b57cec5SDimitry Andric } 5800b57cec5SDimitry Andric } 5810b57cec5SDimitry Andric } else 582e8d8bef9SDimitry Andric __rt = nullptr; 5830b57cec5SDimitry Andric } 5840b57cec5SDimitry Andric } 5850b57cec5SDimitry Andric return __rt; 5860b57cec5SDimitry Andric} 5870b57cec5SDimitry Andric 5880b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 589d099db25SDimitry Andricinline 590e8d8bef9SDimitry Andricbasic_filebuf<_CharT, _Traits>* 5910b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::__open(int __fd, ios_base::openmode __mode) { 592e8d8bef9SDimitry Andric basic_filebuf<_CharT, _Traits>* __rt = nullptr; 593e8d8bef9SDimitry Andric if (__file_ == nullptr) { 5940b57cec5SDimitry Andric if (const char* __mdstr = __make_mdstring(__mode)) { 5950b57cec5SDimitry Andric __rt = this; 5960b57cec5SDimitry Andric __file_ = fdopen(__fd, __mdstr); 5970b57cec5SDimitry Andric if (__file_) { 5980b57cec5SDimitry Andric __om_ = __mode; 5990b57cec5SDimitry Andric if (__mode & ios_base::ate) { 6000b57cec5SDimitry Andric if (fseek(__file_, 0, SEEK_END)) { 6010b57cec5SDimitry Andric fclose(__file_); 602e8d8bef9SDimitry Andric __file_ = nullptr; 603e8d8bef9SDimitry Andric __rt = nullptr; 6040b57cec5SDimitry Andric } 6050b57cec5SDimitry Andric } 6060b57cec5SDimitry Andric } else 607e8d8bef9SDimitry Andric __rt = nullptr; 6080b57cec5SDimitry Andric } 6090b57cec5SDimitry Andric } 6100b57cec5SDimitry Andric return __rt; 6110b57cec5SDimitry Andric} 6120b57cec5SDimitry Andric 6130b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 6140b57cec5SDimitry Andric// This is basically the same as the char* overload except that it uses _wfopen 6150b57cec5SDimitry Andric// and long mode strings. 6160b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 6170b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 6180b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) 6190b57cec5SDimitry Andric{ 620e8d8bef9SDimitry Andric basic_filebuf<_CharT, _Traits>* __rt = nullptr; 621e8d8bef9SDimitry Andric if (__file_ == nullptr) 6220b57cec5SDimitry Andric { 6230b57cec5SDimitry Andric __rt = this; 6240b57cec5SDimitry Andric const wchar_t* __mdstr; 6250b57cec5SDimitry Andric switch (__mode & ~ios_base::ate) 6260b57cec5SDimitry Andric { 6270b57cec5SDimitry Andric case ios_base::out: 6280b57cec5SDimitry Andric case ios_base::out | ios_base::trunc: 6290b57cec5SDimitry Andric __mdstr = L"w"; 6300b57cec5SDimitry Andric break; 6310b57cec5SDimitry Andric case ios_base::out | ios_base::app: 6320b57cec5SDimitry Andric case ios_base::app: 6330b57cec5SDimitry Andric __mdstr = L"a"; 6340b57cec5SDimitry Andric break; 6350b57cec5SDimitry Andric case ios_base::in: 6360b57cec5SDimitry Andric __mdstr = L"r"; 6370b57cec5SDimitry Andric break; 6380b57cec5SDimitry Andric case ios_base::in | ios_base::out: 6390b57cec5SDimitry Andric __mdstr = L"r+"; 6400b57cec5SDimitry Andric break; 6410b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::trunc: 6420b57cec5SDimitry Andric __mdstr = L"w+"; 6430b57cec5SDimitry Andric break; 6440b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::app: 6450b57cec5SDimitry Andric case ios_base::in | ios_base::app: 6460b57cec5SDimitry Andric __mdstr = L"a+"; 6470b57cec5SDimitry Andric break; 6480b57cec5SDimitry Andric case ios_base::out | ios_base::binary: 6490b57cec5SDimitry Andric case ios_base::out | ios_base::trunc | ios_base::binary: 6500b57cec5SDimitry Andric __mdstr = L"wb"; 6510b57cec5SDimitry Andric break; 6520b57cec5SDimitry Andric case ios_base::out | ios_base::app | ios_base::binary: 6530b57cec5SDimitry Andric case ios_base::app | ios_base::binary: 6540b57cec5SDimitry Andric __mdstr = L"ab"; 6550b57cec5SDimitry Andric break; 6560b57cec5SDimitry Andric case ios_base::in | ios_base::binary: 6570b57cec5SDimitry Andric __mdstr = L"rb"; 6580b57cec5SDimitry Andric break; 6590b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::binary: 6600b57cec5SDimitry Andric __mdstr = L"r+b"; 6610b57cec5SDimitry Andric break; 6620b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary: 6630b57cec5SDimitry Andric __mdstr = L"w+b"; 6640b57cec5SDimitry Andric break; 6650b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::app | ios_base::binary: 6660b57cec5SDimitry Andric case ios_base::in | ios_base::app | ios_base::binary: 6670b57cec5SDimitry Andric __mdstr = L"a+b"; 6680b57cec5SDimitry Andric break; 6690b57cec5SDimitry Andric default: 670e8d8bef9SDimitry Andric __rt = nullptr; 6710b57cec5SDimitry Andric break; 6720b57cec5SDimitry Andric } 6730b57cec5SDimitry Andric if (__rt) 6740b57cec5SDimitry Andric { 6750b57cec5SDimitry Andric __file_ = _wfopen(__s, __mdstr); 6760b57cec5SDimitry Andric if (__file_) 6770b57cec5SDimitry Andric { 6780b57cec5SDimitry Andric __om_ = __mode; 6790b57cec5SDimitry Andric if (__mode & ios_base::ate) 6800b57cec5SDimitry Andric { 6810b57cec5SDimitry Andric if (fseek(__file_, 0, SEEK_END)) 6820b57cec5SDimitry Andric { 6830b57cec5SDimitry Andric fclose(__file_); 684e8d8bef9SDimitry Andric __file_ = nullptr; 685e8d8bef9SDimitry Andric __rt = nullptr; 6860b57cec5SDimitry Andric } 6870b57cec5SDimitry Andric } 6880b57cec5SDimitry Andric } 6890b57cec5SDimitry Andric else 690e8d8bef9SDimitry Andric __rt = nullptr; 6910b57cec5SDimitry Andric } 6920b57cec5SDimitry Andric } 6930b57cec5SDimitry Andric return __rt; 6940b57cec5SDimitry Andric} 6950b57cec5SDimitry Andric#endif 6960b57cec5SDimitry Andric 6970b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 6980b57cec5SDimitry Andricinline 6990b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 7000b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) 7010b57cec5SDimitry Andric{ 7020b57cec5SDimitry Andric return open(__s.c_str(), __mode); 7030b57cec5SDimitry Andric} 7040b57cec5SDimitry Andric 7050b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 7060b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 7070b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::close() 7080b57cec5SDimitry Andric{ 709e8d8bef9SDimitry Andric basic_filebuf<_CharT, _Traits>* __rt = nullptr; 7100b57cec5SDimitry Andric if (__file_) 7110b57cec5SDimitry Andric { 7120b57cec5SDimitry Andric __rt = this; 7130b57cec5SDimitry Andric unique_ptr<FILE, int(*)(FILE*)> __h(__file_, fclose); 7140b57cec5SDimitry Andric if (sync()) 715e8d8bef9SDimitry Andric __rt = nullptr; 716e40139ffSDimitry Andric if (fclose(__h.release())) 717e8d8bef9SDimitry Andric __rt = nullptr; 718e8d8bef9SDimitry Andric __file_ = nullptr; 7190b57cec5SDimitry Andric setbuf(0, 0); 7200b57cec5SDimitry Andric } 7210b57cec5SDimitry Andric return __rt; 7220b57cec5SDimitry Andric} 7230b57cec5SDimitry Andric 7240b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 7250b57cec5SDimitry Andrictypename basic_filebuf<_CharT, _Traits>::int_type 7260b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::underflow() 7270b57cec5SDimitry Andric{ 728e8d8bef9SDimitry Andric if (__file_ == nullptr) 7290b57cec5SDimitry Andric return traits_type::eof(); 7300b57cec5SDimitry Andric bool __initial = __read_mode(); 7310b57cec5SDimitry Andric char_type __1buf; 732e8d8bef9SDimitry Andric if (this->gptr() == nullptr) 7330b57cec5SDimitry Andric this->setg(&__1buf, &__1buf+1, &__1buf+1); 7340b57cec5SDimitry Andric const size_t __unget_sz = __initial ? 0 : min<size_t>((this->egptr() - this->eback()) / 2, 4); 7350b57cec5SDimitry Andric int_type __c = traits_type::eof(); 7360b57cec5SDimitry Andric if (this->gptr() == this->egptr()) 7370b57cec5SDimitry Andric { 738e8d8bef9SDimitry Andric _VSTD::memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz * sizeof(char_type)); 7390b57cec5SDimitry Andric if (__always_noconv_) 7400b57cec5SDimitry Andric { 7410b57cec5SDimitry Andric size_t __nmemb = static_cast<size_t>(this->egptr() - this->eback() - __unget_sz); 7420b57cec5SDimitry Andric __nmemb = fread(this->eback() + __unget_sz, 1, __nmemb, __file_); 7430b57cec5SDimitry Andric if (__nmemb != 0) 7440b57cec5SDimitry Andric { 7450b57cec5SDimitry Andric this->setg(this->eback(), 7460b57cec5SDimitry Andric this->eback() + __unget_sz, 7470b57cec5SDimitry Andric this->eback() + __unget_sz + __nmemb); 7480b57cec5SDimitry Andric __c = traits_type::to_int_type(*this->gptr()); 7490b57cec5SDimitry Andric } 7500b57cec5SDimitry Andric } 7510b57cec5SDimitry Andric else 7520b57cec5SDimitry Andric { 7530b57cec5SDimitry Andric _LIBCPP_ASSERT ( !(__extbufnext_ == NULL && (__extbufend_ != __extbufnext_)), "underflow moving from NULL" ); 7540b57cec5SDimitry Andric if (__extbufend_ != __extbufnext_) 755e8d8bef9SDimitry Andric _VSTD::memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_); 7560b57cec5SDimitry Andric __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_); 7570b57cec5SDimitry Andric __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_); 7580b57cec5SDimitry Andric size_t __nmemb = _VSTD::min(static_cast<size_t>(__ibs_ - __unget_sz), 7590b57cec5SDimitry Andric static_cast<size_t>(__extbufend_ - __extbufnext_)); 7600b57cec5SDimitry Andric codecvt_base::result __r; 7610b57cec5SDimitry Andric __st_last_ = __st_; 7620b57cec5SDimitry Andric size_t __nr = fread((void*) const_cast<char *>(__extbufnext_), 1, __nmemb, __file_); 7630b57cec5SDimitry Andric if (__nr != 0) 7640b57cec5SDimitry Andric { 7650b57cec5SDimitry Andric if (!__cv_) 7660b57cec5SDimitry Andric __throw_bad_cast(); 7670b57cec5SDimitry Andric 7680b57cec5SDimitry Andric __extbufend_ = __extbufnext_ + __nr; 7690b57cec5SDimitry Andric char_type* __inext; 7700b57cec5SDimitry Andric __r = __cv_->in(__st_, __extbuf_, __extbufend_, __extbufnext_, 7710b57cec5SDimitry Andric this->eback() + __unget_sz, 7720b57cec5SDimitry Andric this->eback() + __ibs_, __inext); 7730b57cec5SDimitry Andric if (__r == codecvt_base::noconv) 7740b57cec5SDimitry Andric { 7750b57cec5SDimitry Andric this->setg((char_type*)__extbuf_, (char_type*)__extbuf_, 7760b57cec5SDimitry Andric (char_type*)const_cast<char *>(__extbufend_)); 7770b57cec5SDimitry Andric __c = traits_type::to_int_type(*this->gptr()); 7780b57cec5SDimitry Andric } 7790b57cec5SDimitry Andric else if (__inext != this->eback() + __unget_sz) 7800b57cec5SDimitry Andric { 7810b57cec5SDimitry Andric this->setg(this->eback(), this->eback() + __unget_sz, __inext); 7820b57cec5SDimitry Andric __c = traits_type::to_int_type(*this->gptr()); 7830b57cec5SDimitry Andric } 7840b57cec5SDimitry Andric } 7850b57cec5SDimitry Andric } 7860b57cec5SDimitry Andric } 7870b57cec5SDimitry Andric else 7880b57cec5SDimitry Andric __c = traits_type::to_int_type(*this->gptr()); 7890b57cec5SDimitry Andric if (this->eback() == &__1buf) 790e8d8bef9SDimitry Andric this->setg(nullptr, nullptr, nullptr); 7910b57cec5SDimitry Andric return __c; 7920b57cec5SDimitry Andric} 7930b57cec5SDimitry Andric 7940b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 7950b57cec5SDimitry Andrictypename basic_filebuf<_CharT, _Traits>::int_type 7960b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::pbackfail(int_type __c) 7970b57cec5SDimitry Andric{ 7980b57cec5SDimitry Andric if (__file_ && this->eback() < this->gptr()) 7990b57cec5SDimitry Andric { 8000b57cec5SDimitry Andric if (traits_type::eq_int_type(__c, traits_type::eof())) 8010b57cec5SDimitry Andric { 8020b57cec5SDimitry Andric this->gbump(-1); 8030b57cec5SDimitry Andric return traits_type::not_eof(__c); 8040b57cec5SDimitry Andric } 8050b57cec5SDimitry Andric if ((__om_ & ios_base::out) || 8060b57cec5SDimitry Andric traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1])) 8070b57cec5SDimitry Andric { 8080b57cec5SDimitry Andric this->gbump(-1); 8090b57cec5SDimitry Andric *this->gptr() = traits_type::to_char_type(__c); 8100b57cec5SDimitry Andric return __c; 8110b57cec5SDimitry Andric } 8120b57cec5SDimitry Andric } 8130b57cec5SDimitry Andric return traits_type::eof(); 8140b57cec5SDimitry Andric} 8150b57cec5SDimitry Andric 8160b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 8170b57cec5SDimitry Andrictypename basic_filebuf<_CharT, _Traits>::int_type 8180b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::overflow(int_type __c) 8190b57cec5SDimitry Andric{ 820e8d8bef9SDimitry Andric if (__file_ == nullptr) 8210b57cec5SDimitry Andric return traits_type::eof(); 8220b57cec5SDimitry Andric __write_mode(); 8230b57cec5SDimitry Andric char_type __1buf; 8240b57cec5SDimitry Andric char_type* __pb_save = this->pbase(); 8250b57cec5SDimitry Andric char_type* __epb_save = this->epptr(); 8260b57cec5SDimitry Andric if (!traits_type::eq_int_type(__c, traits_type::eof())) 8270b57cec5SDimitry Andric { 828e8d8bef9SDimitry Andric if (this->pptr() == nullptr) 8290b57cec5SDimitry Andric this->setp(&__1buf, &__1buf+1); 8300b57cec5SDimitry Andric *this->pptr() = traits_type::to_char_type(__c); 8310b57cec5SDimitry Andric this->pbump(1); 8320b57cec5SDimitry Andric } 8330b57cec5SDimitry Andric if (this->pptr() != this->pbase()) 8340b57cec5SDimitry Andric { 8350b57cec5SDimitry Andric if (__always_noconv_) 8360b57cec5SDimitry Andric { 8370b57cec5SDimitry Andric size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase()); 8380b57cec5SDimitry Andric if (fwrite(this->pbase(), sizeof(char_type), __nmemb, __file_) != __nmemb) 8390b57cec5SDimitry Andric return traits_type::eof(); 8400b57cec5SDimitry Andric } 8410b57cec5SDimitry Andric else 8420b57cec5SDimitry Andric { 8430b57cec5SDimitry Andric char* __extbe = __extbuf_; 8440b57cec5SDimitry Andric codecvt_base::result __r; 8450b57cec5SDimitry Andric do 8460b57cec5SDimitry Andric { 8470b57cec5SDimitry Andric if (!__cv_) 8480b57cec5SDimitry Andric __throw_bad_cast(); 8490b57cec5SDimitry Andric 8500b57cec5SDimitry Andric const char_type* __e; 8510b57cec5SDimitry Andric __r = __cv_->out(__st_, this->pbase(), this->pptr(), __e, 8520b57cec5SDimitry Andric __extbuf_, __extbuf_ + __ebs_, __extbe); 8530b57cec5SDimitry Andric if (__e == this->pbase()) 8540b57cec5SDimitry Andric return traits_type::eof(); 8550b57cec5SDimitry Andric if (__r == codecvt_base::noconv) 8560b57cec5SDimitry Andric { 8570b57cec5SDimitry Andric size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase()); 8580b57cec5SDimitry Andric if (fwrite(this->pbase(), 1, __nmemb, __file_) != __nmemb) 8590b57cec5SDimitry Andric return traits_type::eof(); 8600b57cec5SDimitry Andric } 8610b57cec5SDimitry Andric else if (__r == codecvt_base::ok || __r == codecvt_base::partial) 8620b57cec5SDimitry Andric { 8630b57cec5SDimitry Andric size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_); 8640b57cec5SDimitry Andric if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb) 8650b57cec5SDimitry Andric return traits_type::eof(); 8660b57cec5SDimitry Andric if (__r == codecvt_base::partial) 8670b57cec5SDimitry Andric { 8680b57cec5SDimitry Andric this->setp(const_cast<char_type*>(__e), this->pptr()); 8690b57cec5SDimitry Andric this->__pbump(this->epptr() - this->pbase()); 8700b57cec5SDimitry Andric } 8710b57cec5SDimitry Andric } 8720b57cec5SDimitry Andric else 8730b57cec5SDimitry Andric return traits_type::eof(); 8740b57cec5SDimitry Andric } while (__r == codecvt_base::partial); 8750b57cec5SDimitry Andric } 8760b57cec5SDimitry Andric this->setp(__pb_save, __epb_save); 8770b57cec5SDimitry Andric } 8780b57cec5SDimitry Andric return traits_type::not_eof(__c); 8790b57cec5SDimitry Andric} 8800b57cec5SDimitry Andric 8810b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 8820b57cec5SDimitry Andricbasic_streambuf<_CharT, _Traits>* 8830b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::setbuf(char_type* __s, streamsize __n) 8840b57cec5SDimitry Andric{ 885e8d8bef9SDimitry Andric this->setg(nullptr, nullptr, nullptr); 886e8d8bef9SDimitry Andric this->setp(nullptr, nullptr); 8870b57cec5SDimitry Andric if (__owns_eb_) 8880b57cec5SDimitry Andric delete [] __extbuf_; 8890b57cec5SDimitry Andric if (__owns_ib_) 8900b57cec5SDimitry Andric delete [] __intbuf_; 8910b57cec5SDimitry Andric __ebs_ = __n; 8920b57cec5SDimitry Andric if (__ebs_ > sizeof(__extbuf_min_)) 8930b57cec5SDimitry Andric { 8940b57cec5SDimitry Andric if (__always_noconv_ && __s) 8950b57cec5SDimitry Andric { 8960b57cec5SDimitry Andric __extbuf_ = (char*)__s; 8970b57cec5SDimitry Andric __owns_eb_ = false; 8980b57cec5SDimitry Andric } 8990b57cec5SDimitry Andric else 9000b57cec5SDimitry Andric { 9010b57cec5SDimitry Andric __extbuf_ = new char[__ebs_]; 9020b57cec5SDimitry Andric __owns_eb_ = true; 9030b57cec5SDimitry Andric } 9040b57cec5SDimitry Andric } 9050b57cec5SDimitry Andric else 9060b57cec5SDimitry Andric { 9070b57cec5SDimitry Andric __extbuf_ = __extbuf_min_; 9080b57cec5SDimitry Andric __ebs_ = sizeof(__extbuf_min_); 9090b57cec5SDimitry Andric __owns_eb_ = false; 9100b57cec5SDimitry Andric } 9110b57cec5SDimitry Andric if (!__always_noconv_) 9120b57cec5SDimitry Andric { 9130b57cec5SDimitry Andric __ibs_ = max<streamsize>(__n, sizeof(__extbuf_min_)); 9140b57cec5SDimitry Andric if (__s && __ibs_ >= sizeof(__extbuf_min_)) 9150b57cec5SDimitry Andric { 9160b57cec5SDimitry Andric __intbuf_ = __s; 9170b57cec5SDimitry Andric __owns_ib_ = false; 9180b57cec5SDimitry Andric } 9190b57cec5SDimitry Andric else 9200b57cec5SDimitry Andric { 9210b57cec5SDimitry Andric __intbuf_ = new char_type[__ibs_]; 9220b57cec5SDimitry Andric __owns_ib_ = true; 9230b57cec5SDimitry Andric } 9240b57cec5SDimitry Andric } 9250b57cec5SDimitry Andric else 9260b57cec5SDimitry Andric { 9270b57cec5SDimitry Andric __ibs_ = 0; 928e8d8bef9SDimitry Andric __intbuf_ = nullptr; 9290b57cec5SDimitry Andric __owns_ib_ = false; 9300b57cec5SDimitry Andric } 9310b57cec5SDimitry Andric return this; 9320b57cec5SDimitry Andric} 9330b57cec5SDimitry Andric 9340b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 9350b57cec5SDimitry Andrictypename basic_filebuf<_CharT, _Traits>::pos_type 9360b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way, 9370b57cec5SDimitry Andric ios_base::openmode) 9380b57cec5SDimitry Andric{ 9390b57cec5SDimitry Andric if (!__cv_) 9400b57cec5SDimitry Andric __throw_bad_cast(); 9410b57cec5SDimitry Andric 9420b57cec5SDimitry Andric int __width = __cv_->encoding(); 943e8d8bef9SDimitry Andric if (__file_ == nullptr || (__width <= 0 && __off != 0) || sync()) 9440b57cec5SDimitry Andric return pos_type(off_type(-1)); 9450b57cec5SDimitry Andric // __width > 0 || __off == 0 9460b57cec5SDimitry Andric int __whence; 9470b57cec5SDimitry Andric switch (__way) 9480b57cec5SDimitry Andric { 9490b57cec5SDimitry Andric case ios_base::beg: 9500b57cec5SDimitry Andric __whence = SEEK_SET; 9510b57cec5SDimitry Andric break; 9520b57cec5SDimitry Andric case ios_base::cur: 9530b57cec5SDimitry Andric __whence = SEEK_CUR; 9540b57cec5SDimitry Andric break; 9550b57cec5SDimitry Andric case ios_base::end: 9560b57cec5SDimitry Andric __whence = SEEK_END; 9570b57cec5SDimitry Andric break; 9580b57cec5SDimitry Andric default: 9590b57cec5SDimitry Andric return pos_type(off_type(-1)); 9600b57cec5SDimitry Andric } 9610b57cec5SDimitry Andric#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS) 9620b57cec5SDimitry Andric if (fseek(__file_, __width > 0 ? __width * __off : 0, __whence)) 9630b57cec5SDimitry Andric return pos_type(off_type(-1)); 9640b57cec5SDimitry Andric pos_type __r = ftell(__file_); 9650b57cec5SDimitry Andric#else 9660b57cec5SDimitry Andric if (fseeko(__file_, __width > 0 ? __width * __off : 0, __whence)) 9670b57cec5SDimitry Andric return pos_type(off_type(-1)); 9680b57cec5SDimitry Andric pos_type __r = ftello(__file_); 9690b57cec5SDimitry Andric#endif 9700b57cec5SDimitry Andric __r.state(__st_); 9710b57cec5SDimitry Andric return __r; 9720b57cec5SDimitry Andric} 9730b57cec5SDimitry Andric 9740b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 9750b57cec5SDimitry Andrictypename basic_filebuf<_CharT, _Traits>::pos_type 9760b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode) 9770b57cec5SDimitry Andric{ 978e8d8bef9SDimitry Andric if (__file_ == nullptr || sync()) 9790b57cec5SDimitry Andric return pos_type(off_type(-1)); 9800b57cec5SDimitry Andric#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS) 9810b57cec5SDimitry Andric if (fseek(__file_, __sp, SEEK_SET)) 9820b57cec5SDimitry Andric return pos_type(off_type(-1)); 9830b57cec5SDimitry Andric#else 9840b57cec5SDimitry Andric if (fseeko(__file_, __sp, SEEK_SET)) 9850b57cec5SDimitry Andric return pos_type(off_type(-1)); 9860b57cec5SDimitry Andric#endif 9870b57cec5SDimitry Andric __st_ = __sp.state(); 9880b57cec5SDimitry Andric return __sp; 9890b57cec5SDimitry Andric} 9900b57cec5SDimitry Andric 9910b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 9920b57cec5SDimitry Andricint 9930b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::sync() 9940b57cec5SDimitry Andric{ 995e8d8bef9SDimitry Andric if (__file_ == nullptr) 9960b57cec5SDimitry Andric return 0; 9970b57cec5SDimitry Andric if (!__cv_) 9980b57cec5SDimitry Andric __throw_bad_cast(); 9990b57cec5SDimitry Andric 10000b57cec5SDimitry Andric if (__cm_ & ios_base::out) 10010b57cec5SDimitry Andric { 10020b57cec5SDimitry Andric if (this->pptr() != this->pbase()) 10030b57cec5SDimitry Andric if (overflow() == traits_type::eof()) 10040b57cec5SDimitry Andric return -1; 10050b57cec5SDimitry Andric codecvt_base::result __r; 10060b57cec5SDimitry Andric do 10070b57cec5SDimitry Andric { 10080b57cec5SDimitry Andric char* __extbe; 10090b57cec5SDimitry Andric __r = __cv_->unshift(__st_, __extbuf_, __extbuf_ + __ebs_, __extbe); 10100b57cec5SDimitry Andric size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_); 10110b57cec5SDimitry Andric if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb) 10120b57cec5SDimitry Andric return -1; 10130b57cec5SDimitry Andric } while (__r == codecvt_base::partial); 10140b57cec5SDimitry Andric if (__r == codecvt_base::error) 10150b57cec5SDimitry Andric return -1; 10160b57cec5SDimitry Andric if (fflush(__file_)) 10170b57cec5SDimitry Andric return -1; 10180b57cec5SDimitry Andric } 10190b57cec5SDimitry Andric else if (__cm_ & ios_base::in) 10200b57cec5SDimitry Andric { 10210b57cec5SDimitry Andric off_type __c; 10220b57cec5SDimitry Andric state_type __state = __st_last_; 10230b57cec5SDimitry Andric bool __update_st = false; 10240b57cec5SDimitry Andric if (__always_noconv_) 10250b57cec5SDimitry Andric __c = this->egptr() - this->gptr(); 10260b57cec5SDimitry Andric else 10270b57cec5SDimitry Andric { 10280b57cec5SDimitry Andric int __width = __cv_->encoding(); 10290b57cec5SDimitry Andric __c = __extbufend_ - __extbufnext_; 10300b57cec5SDimitry Andric if (__width > 0) 10310b57cec5SDimitry Andric __c += __width * (this->egptr() - this->gptr()); 10320b57cec5SDimitry Andric else 10330b57cec5SDimitry Andric { 10340b57cec5SDimitry Andric if (this->gptr() != this->egptr()) 10350b57cec5SDimitry Andric { 10360b57cec5SDimitry Andric const int __off = __cv_->length(__state, __extbuf_, 10370b57cec5SDimitry Andric __extbufnext_, 10380b57cec5SDimitry Andric this->gptr() - this->eback()); 10390b57cec5SDimitry Andric __c += __extbufnext_ - __extbuf_ - __off; 10400b57cec5SDimitry Andric __update_st = true; 10410b57cec5SDimitry Andric } 10420b57cec5SDimitry Andric } 10430b57cec5SDimitry Andric } 10440b57cec5SDimitry Andric#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS) 10450b57cec5SDimitry Andric if (fseek(__file_, -__c, SEEK_CUR)) 10460b57cec5SDimitry Andric return -1; 10470b57cec5SDimitry Andric#else 10480b57cec5SDimitry Andric if (fseeko(__file_, -__c, SEEK_CUR)) 10490b57cec5SDimitry Andric return -1; 10500b57cec5SDimitry Andric#endif 10510b57cec5SDimitry Andric if (__update_st) 10520b57cec5SDimitry Andric __st_ = __state; 10530b57cec5SDimitry Andric __extbufnext_ = __extbufend_ = __extbuf_; 1054e8d8bef9SDimitry Andric this->setg(nullptr, nullptr, nullptr); 10550b57cec5SDimitry Andric __cm_ = 0; 10560b57cec5SDimitry Andric } 10570b57cec5SDimitry Andric return 0; 10580b57cec5SDimitry Andric} 10590b57cec5SDimitry Andric 10600b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 10610b57cec5SDimitry Andricvoid 10620b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::imbue(const locale& __loc) 10630b57cec5SDimitry Andric{ 10640b57cec5SDimitry Andric sync(); 10650b57cec5SDimitry Andric __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc); 10660b57cec5SDimitry Andric bool __old_anc = __always_noconv_; 10670b57cec5SDimitry Andric __always_noconv_ = __cv_->always_noconv(); 10680b57cec5SDimitry Andric if (__old_anc != __always_noconv_) 10690b57cec5SDimitry Andric { 1070e8d8bef9SDimitry Andric this->setg(nullptr, nullptr, nullptr); 1071e8d8bef9SDimitry Andric this->setp(nullptr, nullptr); 10720b57cec5SDimitry Andric // invariant, char_type is char, else we couldn't get here 10730b57cec5SDimitry Andric if (__always_noconv_) // need to dump __intbuf_ 10740b57cec5SDimitry Andric { 10750b57cec5SDimitry Andric if (__owns_eb_) 10760b57cec5SDimitry Andric delete [] __extbuf_; 10770b57cec5SDimitry Andric __owns_eb_ = __owns_ib_; 10780b57cec5SDimitry Andric __ebs_ = __ibs_; 10790b57cec5SDimitry Andric __extbuf_ = (char*)__intbuf_; 10800b57cec5SDimitry Andric __ibs_ = 0; 1081e8d8bef9SDimitry Andric __intbuf_ = nullptr; 10820b57cec5SDimitry Andric __owns_ib_ = false; 10830b57cec5SDimitry Andric } 10840b57cec5SDimitry Andric else // need to obtain an __intbuf_. 10850b57cec5SDimitry Andric { // If __extbuf_ is user-supplied, use it, else new __intbuf_ 10860b57cec5SDimitry Andric if (!__owns_eb_ && __extbuf_ != __extbuf_min_) 10870b57cec5SDimitry Andric { 10880b57cec5SDimitry Andric __ibs_ = __ebs_; 10890b57cec5SDimitry Andric __intbuf_ = (char_type*)__extbuf_; 10900b57cec5SDimitry Andric __owns_ib_ = false; 10910b57cec5SDimitry Andric __extbuf_ = new char[__ebs_]; 10920b57cec5SDimitry Andric __owns_eb_ = true; 10930b57cec5SDimitry Andric } 10940b57cec5SDimitry Andric else 10950b57cec5SDimitry Andric { 10960b57cec5SDimitry Andric __ibs_ = __ebs_; 10970b57cec5SDimitry Andric __intbuf_ = new char_type[__ibs_]; 10980b57cec5SDimitry Andric __owns_ib_ = true; 10990b57cec5SDimitry Andric } 11000b57cec5SDimitry Andric } 11010b57cec5SDimitry Andric } 11020b57cec5SDimitry Andric} 11030b57cec5SDimitry Andric 11040b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 11050b57cec5SDimitry Andricbool 11060b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::__read_mode() 11070b57cec5SDimitry Andric{ 11080b57cec5SDimitry Andric if (!(__cm_ & ios_base::in)) 11090b57cec5SDimitry Andric { 1110e8d8bef9SDimitry Andric this->setp(nullptr, nullptr); 11110b57cec5SDimitry Andric if (__always_noconv_) 11120b57cec5SDimitry Andric this->setg((char_type*)__extbuf_, 11130b57cec5SDimitry Andric (char_type*)__extbuf_ + __ebs_, 11140b57cec5SDimitry Andric (char_type*)__extbuf_ + __ebs_); 11150b57cec5SDimitry Andric else 11160b57cec5SDimitry Andric this->setg(__intbuf_, __intbuf_ + __ibs_, __intbuf_ + __ibs_); 11170b57cec5SDimitry Andric __cm_ = ios_base::in; 11180b57cec5SDimitry Andric return true; 11190b57cec5SDimitry Andric } 11200b57cec5SDimitry Andric return false; 11210b57cec5SDimitry Andric} 11220b57cec5SDimitry Andric 11230b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 11240b57cec5SDimitry Andricvoid 11250b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::__write_mode() 11260b57cec5SDimitry Andric{ 11270b57cec5SDimitry Andric if (!(__cm_ & ios_base::out)) 11280b57cec5SDimitry Andric { 1129e8d8bef9SDimitry Andric this->setg(nullptr, nullptr, nullptr); 11300b57cec5SDimitry Andric if (__ebs_ > sizeof(__extbuf_min_)) 11310b57cec5SDimitry Andric { 11320b57cec5SDimitry Andric if (__always_noconv_) 11330b57cec5SDimitry Andric this->setp((char_type*)__extbuf_, 11340b57cec5SDimitry Andric (char_type*)__extbuf_ + (__ebs_ - 1)); 11350b57cec5SDimitry Andric else 11360b57cec5SDimitry Andric this->setp(__intbuf_, __intbuf_ + (__ibs_ - 1)); 11370b57cec5SDimitry Andric } 11380b57cec5SDimitry Andric else 1139e8d8bef9SDimitry Andric this->setp(nullptr, nullptr); 11400b57cec5SDimitry Andric __cm_ = ios_base::out; 11410b57cec5SDimitry Andric } 11420b57cec5SDimitry Andric} 11430b57cec5SDimitry Andric 11440b57cec5SDimitry Andric// basic_ifstream 11450b57cec5SDimitry Andric 11460b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 11470b57cec5SDimitry Andricclass _LIBCPP_TEMPLATE_VIS basic_ifstream 11480b57cec5SDimitry Andric : public basic_istream<_CharT, _Traits> 11490b57cec5SDimitry Andric{ 11500b57cec5SDimitry Andricpublic: 11510b57cec5SDimitry Andric typedef _CharT char_type; 11520b57cec5SDimitry Andric typedef _Traits traits_type; 11530b57cec5SDimitry Andric typedef typename traits_type::int_type int_type; 11540b57cec5SDimitry Andric typedef typename traits_type::pos_type pos_type; 11550b57cec5SDimitry Andric typedef typename traits_type::off_type off_type; 11560b57cec5SDimitry Andric 11570b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11580b57cec5SDimitry Andric basic_ifstream(); 11590b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11600b57cec5SDimitry Andric explicit basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in); 11610b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 11620b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11630b57cec5SDimitry Andric explicit basic_ifstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in); 11640b57cec5SDimitry Andric#endif 11650b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11660b57cec5SDimitry Andric explicit basic_ifstream(const string& __s, ios_base::openmode __mode = ios_base::in); 1167e8d8bef9SDimitry Andric#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) 11680b57cec5SDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY 11690b57cec5SDimitry Andric explicit basic_ifstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in) 11700b57cec5SDimitry Andric : basic_ifstream(__p.c_str(), __mode) {} 11710b57cec5SDimitry Andric#endif // _LIBCPP_STD_VER >= 17 11720b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11730b57cec5SDimitry Andric basic_ifstream(basic_ifstream&& __rhs); 11740b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11750b57cec5SDimitry Andric basic_ifstream& operator=(basic_ifstream&& __rhs); 11760b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11770b57cec5SDimitry Andric void swap(basic_ifstream& __rhs); 11780b57cec5SDimitry Andric 11790b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11800b57cec5SDimitry Andric basic_filebuf<char_type, traits_type>* rdbuf() const; 11810b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11820b57cec5SDimitry Andric bool is_open() const; 11830b57cec5SDimitry Andric void open(const char* __s, ios_base::openmode __mode = ios_base::in); 11840b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 11850b57cec5SDimitry Andric void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in); 11860b57cec5SDimitry Andric#endif 11870b57cec5SDimitry Andric void open(const string& __s, ios_base::openmode __mode = ios_base::in); 1188e8d8bef9SDimitry Andric#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) 11890b57cec5SDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY 11900b57cec5SDimitry Andric void open(const filesystem::path& __p, 11910b57cec5SDimitry Andric ios_base::openmode __mode = ios_base::in) { 11920b57cec5SDimitry Andric return open(__p.c_str(), __mode); 11930b57cec5SDimitry Andric } 11940b57cec5SDimitry Andric#endif // _LIBCPP_STD_VER >= 17 11950b57cec5SDimitry Andric 11960b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11970b57cec5SDimitry Andric void __open(int __fd, ios_base::openmode __mode); 11980b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11990b57cec5SDimitry Andric void close(); 12000b57cec5SDimitry Andric 12010b57cec5SDimitry Andricprivate: 12020b57cec5SDimitry Andric basic_filebuf<char_type, traits_type> __sb_; 12030b57cec5SDimitry Andric}; 12040b57cec5SDimitry Andric 12050b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12060b57cec5SDimitry Andricinline 12070b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::basic_ifstream() 12080b57cec5SDimitry Andric : basic_istream<char_type, traits_type>(&__sb_) 12090b57cec5SDimitry Andric{ 12100b57cec5SDimitry Andric} 12110b57cec5SDimitry Andric 12120b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12130b57cec5SDimitry Andricinline 12140b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::basic_ifstream(const char* __s, ios_base::openmode __mode) 12150b57cec5SDimitry Andric : basic_istream<char_type, traits_type>(&__sb_) 12160b57cec5SDimitry Andric{ 1217e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode | ios_base::in) == nullptr) 12180b57cec5SDimitry Andric this->setstate(ios_base::failbit); 12190b57cec5SDimitry Andric} 12200b57cec5SDimitry Andric 12210b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 12220b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12230b57cec5SDimitry Andricinline 12240b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::basic_ifstream(const wchar_t* __s, ios_base::openmode __mode) 12250b57cec5SDimitry Andric : basic_istream<char_type, traits_type>(&__sb_) 12260b57cec5SDimitry Andric{ 1227e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode | ios_base::in) == nullptr) 12280b57cec5SDimitry Andric this->setstate(ios_base::failbit); 12290b57cec5SDimitry Andric} 12300b57cec5SDimitry Andric#endif 12310b57cec5SDimitry Andric 12320b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12330b57cec5SDimitry Andricinline 12340b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::openmode __mode) 12350b57cec5SDimitry Andric : basic_istream<char_type, traits_type>(&__sb_) 12360b57cec5SDimitry Andric{ 1237e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode | ios_base::in) == nullptr) 12380b57cec5SDimitry Andric this->setstate(ios_base::failbit); 12390b57cec5SDimitry Andric} 12400b57cec5SDimitry Andric 12410b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12420b57cec5SDimitry Andricinline 12430b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::basic_ifstream(basic_ifstream&& __rhs) 12440b57cec5SDimitry Andric : basic_istream<char_type, traits_type>(_VSTD::move(__rhs)), 12450b57cec5SDimitry Andric __sb_(_VSTD::move(__rhs.__sb_)) 12460b57cec5SDimitry Andric{ 12470b57cec5SDimitry Andric this->set_rdbuf(&__sb_); 12480b57cec5SDimitry Andric} 12490b57cec5SDimitry Andric 12500b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12510b57cec5SDimitry Andricinline 12520b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>& 12530b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs) 12540b57cec5SDimitry Andric{ 12550b57cec5SDimitry Andric basic_istream<char_type, traits_type>::operator=(_VSTD::move(__rhs)); 12560b57cec5SDimitry Andric __sb_ = _VSTD::move(__rhs.__sb_); 12570b57cec5SDimitry Andric return *this; 12580b57cec5SDimitry Andric} 12590b57cec5SDimitry Andric 12600b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12610b57cec5SDimitry Andricinline 12620b57cec5SDimitry Andricvoid 12630b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::swap(basic_ifstream& __rhs) 12640b57cec5SDimitry Andric{ 12650b57cec5SDimitry Andric basic_istream<char_type, traits_type>::swap(__rhs); 12660b57cec5SDimitry Andric __sb_.swap(__rhs.__sb_); 12670b57cec5SDimitry Andric} 12680b57cec5SDimitry Andric 12690b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12700b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 12710b57cec5SDimitry Andricvoid 12720b57cec5SDimitry Andricswap(basic_ifstream<_CharT, _Traits>& __x, basic_ifstream<_CharT, _Traits>& __y) 12730b57cec5SDimitry Andric{ 12740b57cec5SDimitry Andric __x.swap(__y); 12750b57cec5SDimitry Andric} 12760b57cec5SDimitry Andric 12770b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12780b57cec5SDimitry Andricinline 12790b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 12800b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::rdbuf() const 12810b57cec5SDimitry Andric{ 12820b57cec5SDimitry Andric return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_); 12830b57cec5SDimitry Andric} 12840b57cec5SDimitry Andric 12850b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12860b57cec5SDimitry Andricinline 12870b57cec5SDimitry Andricbool 12880b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::is_open() const 12890b57cec5SDimitry Andric{ 12900b57cec5SDimitry Andric return __sb_.is_open(); 12910b57cec5SDimitry Andric} 12920b57cec5SDimitry Andric 12930b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12940b57cec5SDimitry Andricvoid 12950b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) 12960b57cec5SDimitry Andric{ 12970b57cec5SDimitry Andric if (__sb_.open(__s, __mode | ios_base::in)) 12980b57cec5SDimitry Andric this->clear(); 12990b57cec5SDimitry Andric else 13000b57cec5SDimitry Andric this->setstate(ios_base::failbit); 13010b57cec5SDimitry Andric} 13020b57cec5SDimitry Andric 13030b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 13040b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 13050b57cec5SDimitry Andricvoid 13060b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) 13070b57cec5SDimitry Andric{ 13080b57cec5SDimitry Andric if (__sb_.open(__s, __mode | ios_base::in)) 13090b57cec5SDimitry Andric this->clear(); 13100b57cec5SDimitry Andric else 13110b57cec5SDimitry Andric this->setstate(ios_base::failbit); 13120b57cec5SDimitry Andric} 13130b57cec5SDimitry Andric#endif 13140b57cec5SDimitry Andric 13150b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 13160b57cec5SDimitry Andricvoid 13170b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) 13180b57cec5SDimitry Andric{ 13190b57cec5SDimitry Andric if (__sb_.open(__s, __mode | ios_base::in)) 13200b57cec5SDimitry Andric this->clear(); 13210b57cec5SDimitry Andric else 13220b57cec5SDimitry Andric this->setstate(ios_base::failbit); 13230b57cec5SDimitry Andric} 13240b57cec5SDimitry Andric 13250b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 1326d099db25SDimitry Andricinline 13270b57cec5SDimitry Andricvoid basic_ifstream<_CharT, _Traits>::__open(int __fd, 13280b57cec5SDimitry Andric ios_base::openmode __mode) { 13290b57cec5SDimitry Andric if (__sb_.__open(__fd, __mode | ios_base::in)) 13300b57cec5SDimitry Andric this->clear(); 13310b57cec5SDimitry Andric else 13320b57cec5SDimitry Andric this->setstate(ios_base::failbit); 13330b57cec5SDimitry Andric} 13340b57cec5SDimitry Andric 13350b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 13360b57cec5SDimitry Andricinline 13370b57cec5SDimitry Andricvoid 13380b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::close() 13390b57cec5SDimitry Andric{ 13400b57cec5SDimitry Andric if (__sb_.close() == 0) 13410b57cec5SDimitry Andric this->setstate(ios_base::failbit); 13420b57cec5SDimitry Andric} 13430b57cec5SDimitry Andric 13440b57cec5SDimitry Andric// basic_ofstream 13450b57cec5SDimitry Andric 13460b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 13470b57cec5SDimitry Andricclass _LIBCPP_TEMPLATE_VIS basic_ofstream 13480b57cec5SDimitry Andric : public basic_ostream<_CharT, _Traits> 13490b57cec5SDimitry Andric{ 13500b57cec5SDimitry Andricpublic: 13510b57cec5SDimitry Andric typedef _CharT char_type; 13520b57cec5SDimitry Andric typedef _Traits traits_type; 13530b57cec5SDimitry Andric typedef typename traits_type::int_type int_type; 13540b57cec5SDimitry Andric typedef typename traits_type::pos_type pos_type; 13550b57cec5SDimitry Andric typedef typename traits_type::off_type off_type; 13560b57cec5SDimitry Andric 13570b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13580b57cec5SDimitry Andric basic_ofstream(); 13590b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13600b57cec5SDimitry Andric explicit basic_ofstream(const char* __s, ios_base::openmode __mode = ios_base::out); 13610b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 13620b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13630b57cec5SDimitry Andric explicit basic_ofstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::out); 13640b57cec5SDimitry Andric#endif 13650b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13660b57cec5SDimitry Andric explicit basic_ofstream(const string& __s, ios_base::openmode __mode = ios_base::out); 13670b57cec5SDimitry Andric 1368e8d8bef9SDimitry Andric#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) 13690b57cec5SDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY 13700b57cec5SDimitry Andric explicit basic_ofstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out) 13710b57cec5SDimitry Andric : basic_ofstream(__p.c_str(), __mode) {} 13720b57cec5SDimitry Andric#endif // _LIBCPP_STD_VER >= 17 13730b57cec5SDimitry Andric 13740b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13750b57cec5SDimitry Andric basic_ofstream(basic_ofstream&& __rhs); 13760b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13770b57cec5SDimitry Andric basic_ofstream& operator=(basic_ofstream&& __rhs); 13780b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13790b57cec5SDimitry Andric void swap(basic_ofstream& __rhs); 13800b57cec5SDimitry Andric 13810b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13820b57cec5SDimitry Andric basic_filebuf<char_type, traits_type>* rdbuf() const; 13830b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13840b57cec5SDimitry Andric bool is_open() const; 13850b57cec5SDimitry Andric void open(const char* __s, ios_base::openmode __mode = ios_base::out); 13860b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 13870b57cec5SDimitry Andric void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::out); 13880b57cec5SDimitry Andric#endif 13890b57cec5SDimitry Andric void open(const string& __s, ios_base::openmode __mode = ios_base::out); 13900b57cec5SDimitry Andric 1391e8d8bef9SDimitry Andric#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) 13920b57cec5SDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY 13930b57cec5SDimitry Andric void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out) 13940b57cec5SDimitry Andric { return open(__p.c_str(), __mode); } 13950b57cec5SDimitry Andric#endif // _LIBCPP_STD_VER >= 17 13960b57cec5SDimitry Andric 13970b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13980b57cec5SDimitry Andric void __open(int __fd, ios_base::openmode __mode); 13990b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 14000b57cec5SDimitry Andric void close(); 14010b57cec5SDimitry Andric 14020b57cec5SDimitry Andricprivate: 14030b57cec5SDimitry Andric basic_filebuf<char_type, traits_type> __sb_; 14040b57cec5SDimitry Andric}; 14050b57cec5SDimitry Andric 14060b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14070b57cec5SDimitry Andricinline 14080b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::basic_ofstream() 14090b57cec5SDimitry Andric : basic_ostream<char_type, traits_type>(&__sb_) 14100b57cec5SDimitry Andric{ 14110b57cec5SDimitry Andric} 14120b57cec5SDimitry Andric 14130b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14140b57cec5SDimitry Andricinline 14150b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::basic_ofstream(const char* __s, ios_base::openmode __mode) 14160b57cec5SDimitry Andric : basic_ostream<char_type, traits_type>(&__sb_) 14170b57cec5SDimitry Andric{ 1418e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode | ios_base::out) == nullptr) 14190b57cec5SDimitry Andric this->setstate(ios_base::failbit); 14200b57cec5SDimitry Andric} 14210b57cec5SDimitry Andric 14220b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 14230b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14240b57cec5SDimitry Andricinline 14250b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::basic_ofstream(const wchar_t* __s, ios_base::openmode __mode) 14260b57cec5SDimitry Andric : basic_ostream<char_type, traits_type>(&__sb_) 14270b57cec5SDimitry Andric{ 1428e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode | ios_base::out) == nullptr) 14290b57cec5SDimitry Andric this->setstate(ios_base::failbit); 14300b57cec5SDimitry Andric} 14310b57cec5SDimitry Andric#endif 14320b57cec5SDimitry Andric 14330b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14340b57cec5SDimitry Andricinline 14350b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::openmode __mode) 14360b57cec5SDimitry Andric : basic_ostream<char_type, traits_type>(&__sb_) 14370b57cec5SDimitry Andric{ 1438e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode | ios_base::out) == nullptr) 14390b57cec5SDimitry Andric this->setstate(ios_base::failbit); 14400b57cec5SDimitry Andric} 14410b57cec5SDimitry Andric 14420b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14430b57cec5SDimitry Andricinline 14440b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::basic_ofstream(basic_ofstream&& __rhs) 14450b57cec5SDimitry Andric : basic_ostream<char_type, traits_type>(_VSTD::move(__rhs)), 14460b57cec5SDimitry Andric __sb_(_VSTD::move(__rhs.__sb_)) 14470b57cec5SDimitry Andric{ 14480b57cec5SDimitry Andric this->set_rdbuf(&__sb_); 14490b57cec5SDimitry Andric} 14500b57cec5SDimitry Andric 14510b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14520b57cec5SDimitry Andricinline 14530b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>& 14540b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs) 14550b57cec5SDimitry Andric{ 14560b57cec5SDimitry Andric basic_ostream<char_type, traits_type>::operator=(_VSTD::move(__rhs)); 14570b57cec5SDimitry Andric __sb_ = _VSTD::move(__rhs.__sb_); 14580b57cec5SDimitry Andric return *this; 14590b57cec5SDimitry Andric} 14600b57cec5SDimitry Andric 14610b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14620b57cec5SDimitry Andricinline 14630b57cec5SDimitry Andricvoid 14640b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::swap(basic_ofstream& __rhs) 14650b57cec5SDimitry Andric{ 14660b57cec5SDimitry Andric basic_ostream<char_type, traits_type>::swap(__rhs); 14670b57cec5SDimitry Andric __sb_.swap(__rhs.__sb_); 14680b57cec5SDimitry Andric} 14690b57cec5SDimitry Andric 14700b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14710b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 14720b57cec5SDimitry Andricvoid 14730b57cec5SDimitry Andricswap(basic_ofstream<_CharT, _Traits>& __x, basic_ofstream<_CharT, _Traits>& __y) 14740b57cec5SDimitry Andric{ 14750b57cec5SDimitry Andric __x.swap(__y); 14760b57cec5SDimitry Andric} 14770b57cec5SDimitry Andric 14780b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14790b57cec5SDimitry Andricinline 14800b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 14810b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::rdbuf() const 14820b57cec5SDimitry Andric{ 14830b57cec5SDimitry Andric return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_); 14840b57cec5SDimitry Andric} 14850b57cec5SDimitry Andric 14860b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14870b57cec5SDimitry Andricinline 14880b57cec5SDimitry Andricbool 14890b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::is_open() const 14900b57cec5SDimitry Andric{ 14910b57cec5SDimitry Andric return __sb_.is_open(); 14920b57cec5SDimitry Andric} 14930b57cec5SDimitry Andric 14940b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14950b57cec5SDimitry Andricvoid 14960b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) 14970b57cec5SDimitry Andric{ 14980b57cec5SDimitry Andric if (__sb_.open(__s, __mode | ios_base::out)) 14990b57cec5SDimitry Andric this->clear(); 15000b57cec5SDimitry Andric else 15010b57cec5SDimitry Andric this->setstate(ios_base::failbit); 15020b57cec5SDimitry Andric} 15030b57cec5SDimitry Andric 15040b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 15050b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 15060b57cec5SDimitry Andricvoid 15070b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) 15080b57cec5SDimitry Andric{ 15090b57cec5SDimitry Andric if (__sb_.open(__s, __mode | ios_base::out)) 15100b57cec5SDimitry Andric this->clear(); 15110b57cec5SDimitry Andric else 15120b57cec5SDimitry Andric this->setstate(ios_base::failbit); 15130b57cec5SDimitry Andric} 15140b57cec5SDimitry Andric#endif 15150b57cec5SDimitry Andric 15160b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 15170b57cec5SDimitry Andricvoid 15180b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) 15190b57cec5SDimitry Andric{ 15200b57cec5SDimitry Andric if (__sb_.open(__s, __mode | ios_base::out)) 15210b57cec5SDimitry Andric this->clear(); 15220b57cec5SDimitry Andric else 15230b57cec5SDimitry Andric this->setstate(ios_base::failbit); 15240b57cec5SDimitry Andric} 15250b57cec5SDimitry Andric 15260b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 1527d099db25SDimitry Andricinline 15280b57cec5SDimitry Andricvoid basic_ofstream<_CharT, _Traits>::__open(int __fd, 15290b57cec5SDimitry Andric ios_base::openmode __mode) { 15300b57cec5SDimitry Andric if (__sb_.__open(__fd, __mode | ios_base::out)) 15310b57cec5SDimitry Andric this->clear(); 15320b57cec5SDimitry Andric else 15330b57cec5SDimitry Andric this->setstate(ios_base::failbit); 15340b57cec5SDimitry Andric} 15350b57cec5SDimitry Andric 15360b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 15370b57cec5SDimitry Andricinline 15380b57cec5SDimitry Andricvoid 15390b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::close() 15400b57cec5SDimitry Andric{ 1541e8d8bef9SDimitry Andric if (__sb_.close() == nullptr) 15420b57cec5SDimitry Andric this->setstate(ios_base::failbit); 15430b57cec5SDimitry Andric} 15440b57cec5SDimitry Andric 15450b57cec5SDimitry Andric// basic_fstream 15460b57cec5SDimitry Andric 15470b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 15480b57cec5SDimitry Andricclass _LIBCPP_TEMPLATE_VIS basic_fstream 15490b57cec5SDimitry Andric : public basic_iostream<_CharT, _Traits> 15500b57cec5SDimitry Andric{ 15510b57cec5SDimitry Andricpublic: 15520b57cec5SDimitry Andric typedef _CharT char_type; 15530b57cec5SDimitry Andric typedef _Traits traits_type; 15540b57cec5SDimitry Andric typedef typename traits_type::int_type int_type; 15550b57cec5SDimitry Andric typedef typename traits_type::pos_type pos_type; 15560b57cec5SDimitry Andric typedef typename traits_type::off_type off_type; 15570b57cec5SDimitry Andric 15580b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15590b57cec5SDimitry Andric basic_fstream(); 15600b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15610b57cec5SDimitry Andric explicit basic_fstream(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 15620b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 15630b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15640b57cec5SDimitry Andric explicit basic_fstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 15650b57cec5SDimitry Andric#endif 15660b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15670b57cec5SDimitry Andric explicit basic_fstream(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 15680b57cec5SDimitry Andric 1569e8d8bef9SDimitry Andric#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) 15700b57cec5SDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY 15710b57cec5SDimitry Andric explicit basic_fstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in | ios_base::out) 15720b57cec5SDimitry Andric : basic_fstream(__p.c_str(), __mode) {} 15730b57cec5SDimitry Andric#endif // _LIBCPP_STD_VER >= 17 15740b57cec5SDimitry Andric 15750b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15760b57cec5SDimitry Andric basic_fstream(basic_fstream&& __rhs); 15770b57cec5SDimitry Andric 15780b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15790b57cec5SDimitry Andric basic_fstream& operator=(basic_fstream&& __rhs); 1580fe6060f1SDimitry Andric 15810b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15820b57cec5SDimitry Andric void swap(basic_fstream& __rhs); 15830b57cec5SDimitry Andric 15840b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15850b57cec5SDimitry Andric basic_filebuf<char_type, traits_type>* rdbuf() const; 15860b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15870b57cec5SDimitry Andric bool is_open() const; 15880b57cec5SDimitry Andric void open(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 15890b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 15900b57cec5SDimitry Andric void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 15910b57cec5SDimitry Andric#endif 15920b57cec5SDimitry Andric void open(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 15930b57cec5SDimitry Andric 1594e8d8bef9SDimitry Andric#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) 15950b57cec5SDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY 15960b57cec5SDimitry Andric void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in|ios_base::out) 15970b57cec5SDimitry Andric { return open(__p.c_str(), __mode); } 15980b57cec5SDimitry Andric#endif // _LIBCPP_STD_VER >= 17 15990b57cec5SDimitry Andric 16000b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 16010b57cec5SDimitry Andric void close(); 16020b57cec5SDimitry Andric 16030b57cec5SDimitry Andricprivate: 16040b57cec5SDimitry Andric basic_filebuf<char_type, traits_type> __sb_; 16050b57cec5SDimitry Andric}; 16060b57cec5SDimitry Andric 16070b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16080b57cec5SDimitry Andricinline 16090b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::basic_fstream() 16100b57cec5SDimitry Andric : basic_iostream<char_type, traits_type>(&__sb_) 16110b57cec5SDimitry Andric{ 16120b57cec5SDimitry Andric} 16130b57cec5SDimitry Andric 16140b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16150b57cec5SDimitry Andricinline 16160b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::basic_fstream(const char* __s, ios_base::openmode __mode) 16170b57cec5SDimitry Andric : basic_iostream<char_type, traits_type>(&__sb_) 16180b57cec5SDimitry Andric{ 1619e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode) == nullptr) 16200b57cec5SDimitry Andric this->setstate(ios_base::failbit); 16210b57cec5SDimitry Andric} 16220b57cec5SDimitry Andric 16230b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 16240b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16250b57cec5SDimitry Andricinline 16260b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::basic_fstream(const wchar_t* __s, ios_base::openmode __mode) 16270b57cec5SDimitry Andric : basic_iostream<char_type, traits_type>(&__sb_) 16280b57cec5SDimitry Andric{ 1629e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode) == nullptr) 16300b57cec5SDimitry Andric this->setstate(ios_base::failbit); 16310b57cec5SDimitry Andric} 16320b57cec5SDimitry Andric#endif 16330b57cec5SDimitry Andric 16340b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16350b57cec5SDimitry Andricinline 16360b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openmode __mode) 16370b57cec5SDimitry Andric : basic_iostream<char_type, traits_type>(&__sb_) 16380b57cec5SDimitry Andric{ 1639e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode) == nullptr) 16400b57cec5SDimitry Andric this->setstate(ios_base::failbit); 16410b57cec5SDimitry Andric} 16420b57cec5SDimitry Andric 16430b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16440b57cec5SDimitry Andricinline 16450b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::basic_fstream(basic_fstream&& __rhs) 16460b57cec5SDimitry Andric : basic_iostream<char_type, traits_type>(_VSTD::move(__rhs)), 16470b57cec5SDimitry Andric __sb_(_VSTD::move(__rhs.__sb_)) 16480b57cec5SDimitry Andric{ 16490b57cec5SDimitry Andric this->set_rdbuf(&__sb_); 16500b57cec5SDimitry Andric} 16510b57cec5SDimitry Andric 16520b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16530b57cec5SDimitry Andricinline 16540b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>& 16550b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs) 16560b57cec5SDimitry Andric{ 16570b57cec5SDimitry Andric basic_iostream<char_type, traits_type>::operator=(_VSTD::move(__rhs)); 16580b57cec5SDimitry Andric __sb_ = _VSTD::move(__rhs.__sb_); 16590b57cec5SDimitry Andric return *this; 16600b57cec5SDimitry Andric} 16610b57cec5SDimitry Andric 16620b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16630b57cec5SDimitry Andricinline 16640b57cec5SDimitry Andricvoid 16650b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::swap(basic_fstream& __rhs) 16660b57cec5SDimitry Andric{ 16670b57cec5SDimitry Andric basic_iostream<char_type, traits_type>::swap(__rhs); 16680b57cec5SDimitry Andric __sb_.swap(__rhs.__sb_); 16690b57cec5SDimitry Andric} 16700b57cec5SDimitry Andric 16710b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16720b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 16730b57cec5SDimitry Andricvoid 16740b57cec5SDimitry Andricswap(basic_fstream<_CharT, _Traits>& __x, basic_fstream<_CharT, _Traits>& __y) 16750b57cec5SDimitry Andric{ 16760b57cec5SDimitry Andric __x.swap(__y); 16770b57cec5SDimitry Andric} 16780b57cec5SDimitry Andric 16790b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16800b57cec5SDimitry Andricinline 16810b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 16820b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::rdbuf() const 16830b57cec5SDimitry Andric{ 16840b57cec5SDimitry Andric return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_); 16850b57cec5SDimitry Andric} 16860b57cec5SDimitry Andric 16870b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16880b57cec5SDimitry Andricinline 16890b57cec5SDimitry Andricbool 16900b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::is_open() const 16910b57cec5SDimitry Andric{ 16920b57cec5SDimitry Andric return __sb_.is_open(); 16930b57cec5SDimitry Andric} 16940b57cec5SDimitry Andric 16950b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16960b57cec5SDimitry Andricvoid 16970b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) 16980b57cec5SDimitry Andric{ 16990b57cec5SDimitry Andric if (__sb_.open(__s, __mode)) 17000b57cec5SDimitry Andric this->clear(); 17010b57cec5SDimitry Andric else 17020b57cec5SDimitry Andric this->setstate(ios_base::failbit); 17030b57cec5SDimitry Andric} 17040b57cec5SDimitry Andric 17050b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 17060b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 17070b57cec5SDimitry Andricvoid 17080b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) 17090b57cec5SDimitry Andric{ 17100b57cec5SDimitry Andric if (__sb_.open(__s, __mode)) 17110b57cec5SDimitry Andric this->clear(); 17120b57cec5SDimitry Andric else 17130b57cec5SDimitry Andric this->setstate(ios_base::failbit); 17140b57cec5SDimitry Andric} 17150b57cec5SDimitry Andric#endif 17160b57cec5SDimitry Andric 17170b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 17180b57cec5SDimitry Andricvoid 17190b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) 17200b57cec5SDimitry Andric{ 17210b57cec5SDimitry Andric if (__sb_.open(__s, __mode)) 17220b57cec5SDimitry Andric this->clear(); 17230b57cec5SDimitry Andric else 17240b57cec5SDimitry Andric this->setstate(ios_base::failbit); 17250b57cec5SDimitry Andric} 17260b57cec5SDimitry Andric 17270b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 17280b57cec5SDimitry Andricinline 17290b57cec5SDimitry Andricvoid 17300b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::close() 17310b57cec5SDimitry Andric{ 1732e8d8bef9SDimitry Andric if (__sb_.close() == nullptr) 17330b57cec5SDimitry Andric this->setstate(ios_base::failbit); 17340b57cec5SDimitry Andric} 17350b57cec5SDimitry Andric 1736e8d8bef9SDimitry Andric#if defined(_LIBCPP_ABI_ENABLE_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1) 1737*81ad6265SDimitry Andricextern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ifstream<char>; 1738*81ad6265SDimitry Andricextern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ofstream<char>; 1739*81ad6265SDimitry Andricextern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_filebuf<char>; 1740e8d8bef9SDimitry Andric#endif 1741e8d8bef9SDimitry Andric 17420b57cec5SDimitry Andric_LIBCPP_END_NAMESPACE_STD 17430b57cec5SDimitry Andric 17440b57cec5SDimitry Andric_LIBCPP_POP_MACROS 17450b57cec5SDimitry Andric 17460b57cec5SDimitry Andric#endif // _LIBCPP_FSTREAM 1747