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 18281ad6265SDimitry Andric#include <__algorithm/max.h> 18381ad6265SDimitry Andric#include <__assert> // all public C++ headers provide the assertion handler 184e8d8bef9SDimitry Andric#include <__availability> 185fe6060f1SDimitry Andric#include <__config> 18606c3fb27SDimitry Andric#include <__fwd/fstream.h> 1870b57cec5SDimitry Andric#include <__locale> 18881ad6265SDimitry Andric#include <__utility/move.h> 18981ad6265SDimitry Andric#include <__utility/swap.h> 19081ad6265SDimitry Andric#include <__utility/unreachable.h> 1910b57cec5SDimitry Andric#include <cstdio> 19206c3fb27SDimitry Andric#include <filesystem> 193fe6060f1SDimitry Andric#include <istream> 194fe6060f1SDimitry Andric#include <ostream> 195bdd1243dSDimitry Andric#include <typeinfo> 19604eeddc0SDimitry Andric#include <version> 197e8d8bef9SDimitry Andric 1980b57cec5SDimitry Andric#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 1990b57cec5SDimitry Andric# pragma GCC system_header 2000b57cec5SDimitry Andric#endif 2010b57cec5SDimitry Andric 2020b57cec5SDimitry Andric_LIBCPP_PUSH_MACROS 2030b57cec5SDimitry Andric#include <__undef_macros> 2040b57cec5SDimitry Andric 205fe6060f1SDimitry Andric#if defined(_LIBCPP_MSVCRT) || defined(_NEWLIB_VERSION) 206fe6060f1SDimitry Andric# define _LIBCPP_HAS_NO_OFF_T_FUNCTIONS 207fe6060f1SDimitry Andric#endif 2080b57cec5SDimitry Andric 20906c3fb27SDimitry Andric#if !defined(_LIBCPP_HAS_NO_FILESYSTEM) 210bdd1243dSDimitry Andric 2110b57cec5SDimitry Andric_LIBCPP_BEGIN_NAMESPACE_STD 2120b57cec5SDimitry Andric 2130b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 2140b57cec5SDimitry Andricclass _LIBCPP_TEMPLATE_VIS basic_filebuf 2150b57cec5SDimitry Andric : public basic_streambuf<_CharT, _Traits> 2160b57cec5SDimitry Andric{ 2170b57cec5SDimitry Andricpublic: 2180b57cec5SDimitry Andric typedef _CharT char_type; 2190b57cec5SDimitry Andric typedef _Traits traits_type; 2200b57cec5SDimitry Andric typedef typename traits_type::int_type int_type; 2210b57cec5SDimitry Andric typedef typename traits_type::pos_type pos_type; 2220b57cec5SDimitry Andric typedef typename traits_type::off_type off_type; 2230b57cec5SDimitry Andric typedef typename traits_type::state_type state_type; 2240b57cec5SDimitry Andric 2250b57cec5SDimitry Andric // 27.9.1.2 Constructors/destructor: 2260b57cec5SDimitry Andric basic_filebuf(); 2270b57cec5SDimitry Andric basic_filebuf(basic_filebuf&& __rhs); 228bdd1243dSDimitry Andric ~basic_filebuf() override; 2290b57cec5SDimitry Andric 2300b57cec5SDimitry Andric // 27.9.1.3 Assign/swap: 231*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 2320b57cec5SDimitry Andric basic_filebuf& operator=(basic_filebuf&& __rhs); 2330b57cec5SDimitry Andric void swap(basic_filebuf& __rhs); 2340b57cec5SDimitry Andric 2350b57cec5SDimitry Andric // 27.9.1.4 Members: 236*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 2370b57cec5SDimitry Andric bool is_open() const; 2380b57cec5SDimitry Andric basic_filebuf* open(const char* __s, ios_base::openmode __mode); 2390b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 2400b57cec5SDimitry Andric basic_filebuf* open(const wchar_t* __s, ios_base::openmode __mode); 2410b57cec5SDimitry Andric#endif 242*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 2430b57cec5SDimitry Andric basic_filebuf* open(const string& __s, ios_base::openmode __mode); 2440b57cec5SDimitry Andric 24506c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 17 246*5f757f3fSDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_HIDE_FROM_ABI 247*5f757f3fSDimitry Andric basic_filebuf* open(const filesystem::path& __p, ios_base::openmode __mode) { 2480b57cec5SDimitry Andric return open(__p.c_str(), __mode); 2490b57cec5SDimitry Andric } 2500b57cec5SDimitry Andric#endif 251*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 2520b57cec5SDimitry Andric basic_filebuf* __open(int __fd, ios_base::openmode __mode); 2530b57cec5SDimitry Andric basic_filebuf* close(); 2540b57cec5SDimitry Andric 255*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 2560b57cec5SDimitry Andric inline static const char* 2570b57cec5SDimitry Andric __make_mdstring(ios_base::openmode __mode) _NOEXCEPT; 2580b57cec5SDimitry Andric 2590b57cec5SDimitry Andric protected: 2600b57cec5SDimitry Andric // 27.9.1.5 Overridden virtual functions: 261bdd1243dSDimitry Andric int_type underflow() override; 262bdd1243dSDimitry Andric int_type pbackfail(int_type __c = traits_type::eof()) override; 263bdd1243dSDimitry Andric int_type overflow (int_type __c = traits_type::eof()) override; 264bdd1243dSDimitry Andric basic_streambuf<char_type, traits_type>* setbuf(char_type* __s, streamsize __n) override; 265bdd1243dSDimitry Andric pos_type seekoff(off_type __off, ios_base::seekdir __way, 266bdd1243dSDimitry Andric ios_base::openmode __wch = ios_base::in | ios_base::out) override; 267bdd1243dSDimitry Andric pos_type seekpos(pos_type __sp, 268bdd1243dSDimitry Andric ios_base::openmode __wch = ios_base::in | ios_base::out) override; 269bdd1243dSDimitry Andric int sync() override; 270bdd1243dSDimitry Andric void imbue(const locale& __loc) override; 2710b57cec5SDimitry Andric 2720b57cec5SDimitry Andricprivate: 2730b57cec5SDimitry Andric char* __extbuf_; 2740b57cec5SDimitry Andric const char* __extbufnext_; 2750b57cec5SDimitry Andric const char* __extbufend_; 2760b57cec5SDimitry Andric char __extbuf_min_[8]; 2770b57cec5SDimitry Andric size_t __ebs_; 2780b57cec5SDimitry Andric char_type* __intbuf_; 2790b57cec5SDimitry Andric size_t __ibs_; 2800b57cec5SDimitry Andric FILE* __file_; 2810b57cec5SDimitry Andric const codecvt<char_type, char, state_type>* __cv_; 2820b57cec5SDimitry Andric state_type __st_; 2830b57cec5SDimitry Andric state_type __st_last_; 2840b57cec5SDimitry Andric ios_base::openmode __om_; 2850b57cec5SDimitry Andric ios_base::openmode __cm_; 2860b57cec5SDimitry Andric bool __owns_eb_; 2870b57cec5SDimitry Andric bool __owns_ib_; 2880b57cec5SDimitry Andric bool __always_noconv_; 2890b57cec5SDimitry Andric 2900b57cec5SDimitry Andric bool __read_mode(); 2910b57cec5SDimitry Andric void __write_mode(); 2920b57cec5SDimitry Andric}; 2930b57cec5SDimitry Andric 2940b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 2950b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::basic_filebuf() 296e8d8bef9SDimitry Andric : __extbuf_(nullptr), 297e8d8bef9SDimitry Andric __extbufnext_(nullptr), 298e8d8bef9SDimitry Andric __extbufend_(nullptr), 2990b57cec5SDimitry Andric __ebs_(0), 300e8d8bef9SDimitry Andric __intbuf_(nullptr), 3010b57cec5SDimitry Andric __ibs_(0), 302e8d8bef9SDimitry Andric __file_(nullptr), 3030b57cec5SDimitry Andric __cv_(nullptr), 3040b57cec5SDimitry Andric __st_(), 3050b57cec5SDimitry Andric __st_last_(), 3060b57cec5SDimitry Andric __om_(0), 3070b57cec5SDimitry Andric __cm_(0), 3080b57cec5SDimitry Andric __owns_eb_(false), 3090b57cec5SDimitry Andric __owns_ib_(false), 3100b57cec5SDimitry Andric __always_noconv_(false) 3110b57cec5SDimitry Andric{ 312bdd1243dSDimitry Andric if (std::has_facet<codecvt<char_type, char, state_type> >(this->getloc())) 3130b57cec5SDimitry Andric { 314bdd1243dSDimitry Andric __cv_ = &std::use_facet<codecvt<char_type, char, state_type> >(this->getloc()); 3150b57cec5SDimitry Andric __always_noconv_ = __cv_->always_noconv(); 3160b57cec5SDimitry Andric } 317e8d8bef9SDimitry Andric setbuf(nullptr, 4096); 3180b57cec5SDimitry Andric} 3190b57cec5SDimitry Andric 3200b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 3210b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs) 3220b57cec5SDimitry Andric : basic_streambuf<_CharT, _Traits>(__rhs) 3230b57cec5SDimitry Andric{ 3240b57cec5SDimitry Andric if (__rhs.__extbuf_ == __rhs.__extbuf_min_) 3250b57cec5SDimitry Andric { 3260b57cec5SDimitry Andric __extbuf_ = __extbuf_min_; 3270b57cec5SDimitry Andric __extbufnext_ = __extbuf_ + (__rhs.__extbufnext_ - __rhs.__extbuf_); 3280b57cec5SDimitry Andric __extbufend_ = __extbuf_ + (__rhs.__extbufend_ - __rhs.__extbuf_); 3290b57cec5SDimitry Andric } 3300b57cec5SDimitry Andric else 3310b57cec5SDimitry Andric { 3320b57cec5SDimitry Andric __extbuf_ = __rhs.__extbuf_; 3330b57cec5SDimitry Andric __extbufnext_ = __rhs.__extbufnext_; 3340b57cec5SDimitry Andric __extbufend_ = __rhs.__extbufend_; 3350b57cec5SDimitry Andric } 3360b57cec5SDimitry Andric __ebs_ = __rhs.__ebs_; 3370b57cec5SDimitry Andric __intbuf_ = __rhs.__intbuf_; 3380b57cec5SDimitry Andric __ibs_ = __rhs.__ibs_; 3390b57cec5SDimitry Andric __file_ = __rhs.__file_; 3400b57cec5SDimitry Andric __cv_ = __rhs.__cv_; 3410b57cec5SDimitry Andric __st_ = __rhs.__st_; 3420b57cec5SDimitry Andric __st_last_ = __rhs.__st_last_; 3430b57cec5SDimitry Andric __om_ = __rhs.__om_; 3440b57cec5SDimitry Andric __cm_ = __rhs.__cm_; 3450b57cec5SDimitry Andric __owns_eb_ = __rhs.__owns_eb_; 3460b57cec5SDimitry Andric __owns_ib_ = __rhs.__owns_ib_; 3470b57cec5SDimitry Andric __always_noconv_ = __rhs.__always_noconv_; 3480b57cec5SDimitry Andric if (__rhs.pbase()) 3490b57cec5SDimitry Andric { 3500b57cec5SDimitry Andric if (__rhs.pbase() == __rhs.__intbuf_) 3510b57cec5SDimitry Andric this->setp(__intbuf_, __intbuf_ + (__rhs. epptr() - __rhs.pbase())); 3520b57cec5SDimitry Andric else 3530b57cec5SDimitry Andric this->setp((char_type*)__extbuf_, 3540b57cec5SDimitry Andric (char_type*)__extbuf_ + (__rhs. epptr() - __rhs.pbase())); 3550b57cec5SDimitry Andric this->__pbump(__rhs. pptr() - __rhs.pbase()); 3560b57cec5SDimitry Andric } 3570b57cec5SDimitry Andric else if (__rhs.eback()) 3580b57cec5SDimitry Andric { 3590b57cec5SDimitry Andric if (__rhs.eback() == __rhs.__intbuf_) 3600b57cec5SDimitry Andric this->setg(__intbuf_, __intbuf_ + (__rhs.gptr() - __rhs.eback()), 3610b57cec5SDimitry Andric __intbuf_ + (__rhs.egptr() - __rhs.eback())); 3620b57cec5SDimitry Andric else 3630b57cec5SDimitry Andric this->setg((char_type*)__extbuf_, 3640b57cec5SDimitry Andric (char_type*)__extbuf_ + (__rhs.gptr() - __rhs.eback()), 3650b57cec5SDimitry Andric (char_type*)__extbuf_ + (__rhs.egptr() - __rhs.eback())); 3660b57cec5SDimitry Andric } 367e8d8bef9SDimitry Andric __rhs.__extbuf_ = nullptr; 368e8d8bef9SDimitry Andric __rhs.__extbufnext_ = nullptr; 369e8d8bef9SDimitry Andric __rhs.__extbufend_ = nullptr; 3700b57cec5SDimitry Andric __rhs.__ebs_ = 0; 3710b57cec5SDimitry Andric __rhs.__intbuf_ = 0; 3720b57cec5SDimitry Andric __rhs.__ibs_ = 0; 373e8d8bef9SDimitry Andric __rhs.__file_ = nullptr; 3740b57cec5SDimitry Andric __rhs.__st_ = state_type(); 3750b57cec5SDimitry Andric __rhs.__st_last_ = state_type(); 3760b57cec5SDimitry Andric __rhs.__om_ = 0; 3770b57cec5SDimitry Andric __rhs.__cm_ = 0; 3780b57cec5SDimitry Andric __rhs.__owns_eb_ = false; 3790b57cec5SDimitry Andric __rhs.__owns_ib_ = false; 3800b57cec5SDimitry Andric __rhs.setg(0, 0, 0); 3810b57cec5SDimitry Andric __rhs.setp(0, 0); 3820b57cec5SDimitry Andric} 3830b57cec5SDimitry Andric 3840b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 3850b57cec5SDimitry Andricinline 3860b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>& 3870b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::operator=(basic_filebuf&& __rhs) 3880b57cec5SDimitry Andric{ 3890b57cec5SDimitry Andric close(); 3900b57cec5SDimitry Andric swap(__rhs); 3910b57cec5SDimitry Andric return *this; 3920b57cec5SDimitry Andric} 3930b57cec5SDimitry Andric 3940b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 3950b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::~basic_filebuf() 3960b57cec5SDimitry Andric{ 39706c3fb27SDimitry Andric#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 3980b57cec5SDimitry Andric try 3990b57cec5SDimitry Andric { 40006c3fb27SDimitry Andric#endif // _LIBCPP_HAS_NO_EXCEPTIONS 4010b57cec5SDimitry Andric close(); 40206c3fb27SDimitry Andric#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 4030b57cec5SDimitry Andric } 4040b57cec5SDimitry Andric catch (...) 4050b57cec5SDimitry Andric { 4060b57cec5SDimitry Andric } 40706c3fb27SDimitry Andric#endif // _LIBCPP_HAS_NO_EXCEPTIONS 4080b57cec5SDimitry Andric if (__owns_eb_) 4090b57cec5SDimitry Andric delete [] __extbuf_; 4100b57cec5SDimitry Andric if (__owns_ib_) 4110b57cec5SDimitry Andric delete [] __intbuf_; 4120b57cec5SDimitry Andric} 4130b57cec5SDimitry Andric 4140b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 4150b57cec5SDimitry Andricvoid 4160b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::swap(basic_filebuf& __rhs) 4170b57cec5SDimitry Andric{ 4180b57cec5SDimitry Andric basic_streambuf<char_type, traits_type>::swap(__rhs); 4190b57cec5SDimitry Andric if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_) 4200b57cec5SDimitry Andric { 42181ad6265SDimitry Andric // Neither *this nor __rhs uses the small buffer, so we can simply swap the pointers. 42281ad6265SDimitry Andric std::swap(__extbuf_, __rhs.__extbuf_); 42381ad6265SDimitry Andric std::swap(__extbufnext_, __rhs.__extbufnext_); 42481ad6265SDimitry Andric std::swap(__extbufend_, __rhs.__extbufend_); 4250b57cec5SDimitry Andric } 4260b57cec5SDimitry Andric else 4270b57cec5SDimitry Andric { 42881ad6265SDimitry Andric ptrdiff_t __ln = __extbufnext_ ? __extbufnext_ - __extbuf_ : 0; 42981ad6265SDimitry Andric ptrdiff_t __le = __extbufend_ ? __extbufend_ - __extbuf_ : 0; 43081ad6265SDimitry Andric ptrdiff_t __rn = __rhs.__extbufnext_ ? __rhs.__extbufnext_ - __rhs.__extbuf_ : 0; 43181ad6265SDimitry Andric ptrdiff_t __re = __rhs.__extbufend_ ? __rhs.__extbufend_ - __rhs.__extbuf_ : 0; 4320b57cec5SDimitry Andric if (__extbuf_ == __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_) 4330b57cec5SDimitry Andric { 43481ad6265SDimitry Andric // *this uses the small buffer, but __rhs doesn't. 4350b57cec5SDimitry Andric __extbuf_ = __rhs.__extbuf_; 4360b57cec5SDimitry Andric __rhs.__extbuf_ = __rhs.__extbuf_min_; 43781ad6265SDimitry Andric std::memmove(__rhs.__extbuf_min_, __extbuf_min_, sizeof(__extbuf_min_)); 4380b57cec5SDimitry Andric } 4390b57cec5SDimitry Andric else if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ == __rhs.__extbuf_min_) 4400b57cec5SDimitry Andric { 44181ad6265SDimitry Andric // *this doesn't use the small buffer, but __rhs does. 4420b57cec5SDimitry Andric __rhs.__extbuf_ = __extbuf_; 4430b57cec5SDimitry Andric __extbuf_ = __extbuf_min_; 44481ad6265SDimitry Andric std::memmove(__extbuf_min_, __rhs.__extbuf_min_, sizeof(__extbuf_min_)); 44581ad6265SDimitry Andric } 44681ad6265SDimitry Andric else 44781ad6265SDimitry Andric { 44881ad6265SDimitry Andric // Both *this and __rhs use the small buffer. 44981ad6265SDimitry Andric char __tmp[sizeof(__extbuf_min_)]; 45081ad6265SDimitry Andric std::memmove(__tmp, __extbuf_min_, sizeof(__extbuf_min_)); 45181ad6265SDimitry Andric std::memmove(__extbuf_min_, __rhs.__extbuf_min_, sizeof(__extbuf_min_)); 45281ad6265SDimitry Andric std::memmove(__rhs.__extbuf_min_, __tmp, sizeof(__extbuf_min_)); 4530b57cec5SDimitry Andric } 4540b57cec5SDimitry Andric __extbufnext_ = __extbuf_ + __rn; 4550b57cec5SDimitry Andric __extbufend_ = __extbuf_ + __re; 4560b57cec5SDimitry Andric __rhs.__extbufnext_ = __rhs.__extbuf_ + __ln; 4570b57cec5SDimitry Andric __rhs.__extbufend_ = __rhs.__extbuf_ + __le; 4580b57cec5SDimitry Andric } 459*5f757f3fSDimitry Andric std::swap(__ebs_, __rhs.__ebs_); 460*5f757f3fSDimitry Andric std::swap(__intbuf_, __rhs.__intbuf_); 461*5f757f3fSDimitry Andric std::swap(__ibs_, __rhs.__ibs_); 462*5f757f3fSDimitry Andric std::swap(__file_, __rhs.__file_); 463*5f757f3fSDimitry Andric std::swap(__cv_, __rhs.__cv_); 464*5f757f3fSDimitry Andric std::swap(__st_, __rhs.__st_); 465*5f757f3fSDimitry Andric std::swap(__st_last_, __rhs.__st_last_); 466*5f757f3fSDimitry Andric std::swap(__om_, __rhs.__om_); 467*5f757f3fSDimitry Andric std::swap(__cm_, __rhs.__cm_); 468*5f757f3fSDimitry Andric std::swap(__owns_eb_, __rhs.__owns_eb_); 469*5f757f3fSDimitry Andric std::swap(__owns_ib_, __rhs.__owns_ib_); 470*5f757f3fSDimitry Andric std::swap(__always_noconv_, __rhs.__always_noconv_); 4710b57cec5SDimitry Andric if (this->eback() == (char_type*)__rhs.__extbuf_min_) 4720b57cec5SDimitry Andric { 4730b57cec5SDimitry Andric ptrdiff_t __n = this->gptr() - this->eback(); 4740b57cec5SDimitry Andric ptrdiff_t __e = this->egptr() - this->eback(); 4750b57cec5SDimitry Andric this->setg((char_type*)__extbuf_min_, 4760b57cec5SDimitry Andric (char_type*)__extbuf_min_ + __n, 4770b57cec5SDimitry Andric (char_type*)__extbuf_min_ + __e); 4780b57cec5SDimitry Andric } 4790b57cec5SDimitry Andric else if (this->pbase() == (char_type*)__rhs.__extbuf_min_) 4800b57cec5SDimitry Andric { 4810b57cec5SDimitry Andric ptrdiff_t __n = this->pptr() - this->pbase(); 4820b57cec5SDimitry Andric ptrdiff_t __e = this->epptr() - this->pbase(); 4830b57cec5SDimitry Andric this->setp((char_type*)__extbuf_min_, 4840b57cec5SDimitry Andric (char_type*)__extbuf_min_ + __e); 4850b57cec5SDimitry Andric this->__pbump(__n); 4860b57cec5SDimitry Andric } 4870b57cec5SDimitry Andric if (__rhs.eback() == (char_type*)__extbuf_min_) 4880b57cec5SDimitry Andric { 4890b57cec5SDimitry Andric ptrdiff_t __n = __rhs.gptr() - __rhs.eback(); 4900b57cec5SDimitry Andric ptrdiff_t __e = __rhs.egptr() - __rhs.eback(); 4910b57cec5SDimitry Andric __rhs.setg((char_type*)__rhs.__extbuf_min_, 4920b57cec5SDimitry Andric (char_type*)__rhs.__extbuf_min_ + __n, 4930b57cec5SDimitry Andric (char_type*)__rhs.__extbuf_min_ + __e); 4940b57cec5SDimitry Andric } 4950b57cec5SDimitry Andric else if (__rhs.pbase() == (char_type*)__extbuf_min_) 4960b57cec5SDimitry Andric { 4970b57cec5SDimitry Andric ptrdiff_t __n = __rhs.pptr() - __rhs.pbase(); 4980b57cec5SDimitry Andric ptrdiff_t __e = __rhs.epptr() - __rhs.pbase(); 4990b57cec5SDimitry Andric __rhs.setp((char_type*)__rhs.__extbuf_min_, 5000b57cec5SDimitry Andric (char_type*)__rhs.__extbuf_min_ + __e); 5010b57cec5SDimitry Andric __rhs.__pbump(__n); 5020b57cec5SDimitry Andric } 5030b57cec5SDimitry Andric} 5040b57cec5SDimitry Andric 5050b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 506*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 5070b57cec5SDimitry Andricvoid 5080b57cec5SDimitry Andricswap(basic_filebuf<_CharT, _Traits>& __x, basic_filebuf<_CharT, _Traits>& __y) 5090b57cec5SDimitry Andric{ 5100b57cec5SDimitry Andric __x.swap(__y); 5110b57cec5SDimitry Andric} 5120b57cec5SDimitry Andric 5130b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 5140b57cec5SDimitry Andricinline 5150b57cec5SDimitry Andricbool 5160b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::is_open() const 5170b57cec5SDimitry Andric{ 518e8d8bef9SDimitry Andric return __file_ != nullptr; 5190b57cec5SDimitry Andric} 5200b57cec5SDimitry Andric 5210b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 5220b57cec5SDimitry Andricconst char* basic_filebuf<_CharT, _Traits>::__make_mdstring( 5230b57cec5SDimitry Andric ios_base::openmode __mode) _NOEXCEPT { 5240b57cec5SDimitry Andric switch (__mode & ~ios_base::ate) { 5250b57cec5SDimitry Andric case ios_base::out: 5260b57cec5SDimitry Andric case ios_base::out | ios_base::trunc: 527e40139ffSDimitry Andric return "w" _LIBCPP_FOPEN_CLOEXEC_MODE; 5280b57cec5SDimitry Andric case ios_base::out | ios_base::app: 5290b57cec5SDimitry Andric case ios_base::app: 530e40139ffSDimitry Andric return "a" _LIBCPP_FOPEN_CLOEXEC_MODE; 5310b57cec5SDimitry Andric case ios_base::in: 532e40139ffSDimitry Andric return "r" _LIBCPP_FOPEN_CLOEXEC_MODE; 5330b57cec5SDimitry Andric case ios_base::in | ios_base::out: 534e40139ffSDimitry Andric return "r+" _LIBCPP_FOPEN_CLOEXEC_MODE; 5350b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::trunc: 536e40139ffSDimitry Andric return "w+" _LIBCPP_FOPEN_CLOEXEC_MODE; 5370b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::app: 5380b57cec5SDimitry Andric case ios_base::in | ios_base::app: 539e40139ffSDimitry Andric return "a+" _LIBCPP_FOPEN_CLOEXEC_MODE; 5400b57cec5SDimitry Andric case ios_base::out | ios_base::binary: 5410b57cec5SDimitry Andric case ios_base::out | ios_base::trunc | ios_base::binary: 542e40139ffSDimitry Andric return "wb" _LIBCPP_FOPEN_CLOEXEC_MODE; 5430b57cec5SDimitry Andric case ios_base::out | ios_base::app | ios_base::binary: 5440b57cec5SDimitry Andric case ios_base::app | ios_base::binary: 545e40139ffSDimitry Andric return "ab" _LIBCPP_FOPEN_CLOEXEC_MODE; 5460b57cec5SDimitry Andric case ios_base::in | ios_base::binary: 547e40139ffSDimitry Andric return "rb" _LIBCPP_FOPEN_CLOEXEC_MODE; 5480b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::binary: 549e40139ffSDimitry Andric return "r+b" _LIBCPP_FOPEN_CLOEXEC_MODE; 5500b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary: 551e40139ffSDimitry Andric return "w+b" _LIBCPP_FOPEN_CLOEXEC_MODE; 5520b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::app | ios_base::binary: 5530b57cec5SDimitry Andric case ios_base::in | ios_base::app | ios_base::binary: 554e40139ffSDimitry Andric return "a+b" _LIBCPP_FOPEN_CLOEXEC_MODE; 555*5f757f3fSDimitry Andric#if _LIBCPP_STD_VER >= 23 556*5f757f3fSDimitry Andric case ios_base::out | ios_base::noreplace: 557*5f757f3fSDimitry Andric case ios_base::out | ios_base::trunc | ios_base::noreplace: 558*5f757f3fSDimitry Andric return "wx" _LIBCPP_FOPEN_CLOEXEC_MODE; 559*5f757f3fSDimitry Andric case ios_base::in | ios_base::out | ios_base::trunc | ios_base::noreplace: 560*5f757f3fSDimitry Andric return "w+x" _LIBCPP_FOPEN_CLOEXEC_MODE; 561*5f757f3fSDimitry Andric case ios_base::out | ios_base::binary | ios_base::noreplace: 562*5f757f3fSDimitry Andric case ios_base::out | ios_base::trunc | ios_base::binary | ios_base::noreplace: 563*5f757f3fSDimitry Andric return "wbx" _LIBCPP_FOPEN_CLOEXEC_MODE; 564*5f757f3fSDimitry Andric case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary | ios_base::noreplace: 565*5f757f3fSDimitry Andric return "w+bx" _LIBCPP_FOPEN_CLOEXEC_MODE; 566*5f757f3fSDimitry Andric#endif // _LIBCPP_STD_VER >= 23 5670b57cec5SDimitry Andric default: 5680b57cec5SDimitry Andric return nullptr; 5690b57cec5SDimitry Andric } 57081ad6265SDimitry Andric __libcpp_unreachable(); 5710b57cec5SDimitry Andric} 5720b57cec5SDimitry Andric 5730b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 5740b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 5750b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) 5760b57cec5SDimitry Andric{ 577e8d8bef9SDimitry Andric basic_filebuf<_CharT, _Traits>* __rt = nullptr; 578e8d8bef9SDimitry Andric if (__file_ == nullptr) 5790b57cec5SDimitry Andric { 5800b57cec5SDimitry Andric if (const char* __mdstr = __make_mdstring(__mode)) { 5810b57cec5SDimitry Andric __rt = this; 5820b57cec5SDimitry Andric __file_ = fopen(__s, __mdstr); 5830b57cec5SDimitry Andric if (__file_) { 5840b57cec5SDimitry Andric __om_ = __mode; 5850b57cec5SDimitry Andric if (__mode & ios_base::ate) { 5860b57cec5SDimitry Andric if (fseek(__file_, 0, SEEK_END)) { 5870b57cec5SDimitry Andric fclose(__file_); 588e8d8bef9SDimitry Andric __file_ = nullptr; 589e8d8bef9SDimitry Andric __rt = nullptr; 5900b57cec5SDimitry Andric } 5910b57cec5SDimitry Andric } 5920b57cec5SDimitry Andric } else 593e8d8bef9SDimitry Andric __rt = nullptr; 5940b57cec5SDimitry Andric } 5950b57cec5SDimitry Andric } 5960b57cec5SDimitry Andric return __rt; 5970b57cec5SDimitry Andric} 5980b57cec5SDimitry Andric 5990b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 600d099db25SDimitry Andricinline 601e8d8bef9SDimitry Andricbasic_filebuf<_CharT, _Traits>* 6020b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::__open(int __fd, ios_base::openmode __mode) { 603e8d8bef9SDimitry Andric basic_filebuf<_CharT, _Traits>* __rt = nullptr; 604e8d8bef9SDimitry Andric if (__file_ == nullptr) { 6050b57cec5SDimitry Andric if (const char* __mdstr = __make_mdstring(__mode)) { 6060b57cec5SDimitry Andric __rt = this; 6070b57cec5SDimitry Andric __file_ = fdopen(__fd, __mdstr); 6080b57cec5SDimitry Andric if (__file_) { 6090b57cec5SDimitry Andric __om_ = __mode; 6100b57cec5SDimitry Andric if (__mode & ios_base::ate) { 6110b57cec5SDimitry Andric if (fseek(__file_, 0, SEEK_END)) { 6120b57cec5SDimitry Andric fclose(__file_); 613e8d8bef9SDimitry Andric __file_ = nullptr; 614e8d8bef9SDimitry Andric __rt = nullptr; 6150b57cec5SDimitry Andric } 6160b57cec5SDimitry Andric } 6170b57cec5SDimitry Andric } else 618e8d8bef9SDimitry Andric __rt = nullptr; 6190b57cec5SDimitry Andric } 6200b57cec5SDimitry Andric } 6210b57cec5SDimitry Andric return __rt; 6220b57cec5SDimitry Andric} 6230b57cec5SDimitry Andric 6240b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 6250b57cec5SDimitry Andric// This is basically the same as the char* overload except that it uses _wfopen 6260b57cec5SDimitry Andric// and long mode strings. 6270b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 6280b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 6290b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) 6300b57cec5SDimitry Andric{ 631e8d8bef9SDimitry Andric basic_filebuf<_CharT, _Traits>* __rt = nullptr; 632e8d8bef9SDimitry Andric if (__file_ == nullptr) 6330b57cec5SDimitry Andric { 6340b57cec5SDimitry Andric __rt = this; 6350b57cec5SDimitry Andric const wchar_t* __mdstr; 6360b57cec5SDimitry Andric switch (__mode & ~ios_base::ate) 6370b57cec5SDimitry Andric { 6380b57cec5SDimitry Andric case ios_base::out: 6390b57cec5SDimitry Andric case ios_base::out | ios_base::trunc: 6400b57cec5SDimitry Andric __mdstr = L"w"; 6410b57cec5SDimitry Andric break; 6420b57cec5SDimitry Andric case ios_base::out | ios_base::app: 6430b57cec5SDimitry Andric case ios_base::app: 6440b57cec5SDimitry Andric __mdstr = L"a"; 6450b57cec5SDimitry Andric break; 6460b57cec5SDimitry Andric case ios_base::in: 6470b57cec5SDimitry Andric __mdstr = L"r"; 6480b57cec5SDimitry Andric break; 6490b57cec5SDimitry Andric case ios_base::in | ios_base::out: 6500b57cec5SDimitry Andric __mdstr = L"r+"; 6510b57cec5SDimitry Andric break; 6520b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::trunc: 6530b57cec5SDimitry Andric __mdstr = L"w+"; 6540b57cec5SDimitry Andric break; 6550b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::app: 6560b57cec5SDimitry Andric case ios_base::in | ios_base::app: 6570b57cec5SDimitry Andric __mdstr = L"a+"; 6580b57cec5SDimitry Andric break; 6590b57cec5SDimitry Andric case ios_base::out | ios_base::binary: 6600b57cec5SDimitry Andric case ios_base::out | ios_base::trunc | ios_base::binary: 6610b57cec5SDimitry Andric __mdstr = L"wb"; 6620b57cec5SDimitry Andric break; 6630b57cec5SDimitry Andric case ios_base::out | ios_base::app | ios_base::binary: 6640b57cec5SDimitry Andric case ios_base::app | ios_base::binary: 6650b57cec5SDimitry Andric __mdstr = L"ab"; 6660b57cec5SDimitry Andric break; 6670b57cec5SDimitry Andric case ios_base::in | ios_base::binary: 6680b57cec5SDimitry Andric __mdstr = L"rb"; 6690b57cec5SDimitry Andric break; 6700b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::binary: 6710b57cec5SDimitry Andric __mdstr = L"r+b"; 6720b57cec5SDimitry Andric break; 6730b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary: 6740b57cec5SDimitry Andric __mdstr = L"w+b"; 6750b57cec5SDimitry Andric break; 6760b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::app | ios_base::binary: 6770b57cec5SDimitry Andric case ios_base::in | ios_base::app | ios_base::binary: 6780b57cec5SDimitry Andric __mdstr = L"a+b"; 6790b57cec5SDimitry Andric break; 680*5f757f3fSDimitry Andric# if _LIBCPP_STD_VER >= 23 681*5f757f3fSDimitry Andric case ios_base::out | ios_base::noreplace: 682*5f757f3fSDimitry Andric case ios_base::out | ios_base::trunc | ios_base::noreplace: 683*5f757f3fSDimitry Andric __mdstr = L"wx"; 684*5f757f3fSDimitry Andric break; 685*5f757f3fSDimitry Andric case ios_base::in | ios_base::out | ios_base::trunc | ios_base::noreplace: 686*5f757f3fSDimitry Andric __mdstr = L"w+x"; 687*5f757f3fSDimitry Andric break; 688*5f757f3fSDimitry Andric case ios_base::out | ios_base::binary | ios_base::noreplace: 689*5f757f3fSDimitry Andric case ios_base::out | ios_base::trunc | ios_base::binary | ios_base::noreplace: 690*5f757f3fSDimitry Andric __mdstr = L"wbx"; 691*5f757f3fSDimitry Andric break; 692*5f757f3fSDimitry Andric case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary | ios_base::noreplace: 693*5f757f3fSDimitry Andric __mdstr = L"w+bx"; 694*5f757f3fSDimitry Andric break; 695*5f757f3fSDimitry Andric# endif // _LIBCPP_STD_VER >= 23 6960b57cec5SDimitry Andric default: 697e8d8bef9SDimitry Andric __rt = nullptr; 6980b57cec5SDimitry Andric break; 6990b57cec5SDimitry Andric } 7000b57cec5SDimitry Andric if (__rt) 7010b57cec5SDimitry Andric { 7020b57cec5SDimitry Andric __file_ = _wfopen(__s, __mdstr); 7030b57cec5SDimitry Andric if (__file_) 7040b57cec5SDimitry Andric { 7050b57cec5SDimitry Andric __om_ = __mode; 7060b57cec5SDimitry Andric if (__mode & ios_base::ate) 7070b57cec5SDimitry Andric { 7080b57cec5SDimitry Andric if (fseek(__file_, 0, SEEK_END)) 7090b57cec5SDimitry Andric { 7100b57cec5SDimitry Andric fclose(__file_); 711e8d8bef9SDimitry Andric __file_ = nullptr; 712e8d8bef9SDimitry Andric __rt = nullptr; 7130b57cec5SDimitry Andric } 7140b57cec5SDimitry Andric } 7150b57cec5SDimitry Andric } 7160b57cec5SDimitry Andric else 717e8d8bef9SDimitry Andric __rt = nullptr; 7180b57cec5SDimitry Andric } 7190b57cec5SDimitry Andric } 7200b57cec5SDimitry Andric return __rt; 7210b57cec5SDimitry Andric} 7220b57cec5SDimitry Andric#endif 7230b57cec5SDimitry Andric 7240b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 7250b57cec5SDimitry Andricinline 7260b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 7270b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) 7280b57cec5SDimitry Andric{ 7290b57cec5SDimitry Andric return open(__s.c_str(), __mode); 7300b57cec5SDimitry Andric} 7310b57cec5SDimitry Andric 7320b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 7330b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 7340b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::close() 7350b57cec5SDimitry Andric{ 736e8d8bef9SDimitry Andric basic_filebuf<_CharT, _Traits>* __rt = nullptr; 7370b57cec5SDimitry Andric if (__file_) 7380b57cec5SDimitry Andric { 7390b57cec5SDimitry Andric __rt = this; 7400b57cec5SDimitry Andric unique_ptr<FILE, int(*)(FILE*)> __h(__file_, fclose); 7410b57cec5SDimitry Andric if (sync()) 742e8d8bef9SDimitry Andric __rt = nullptr; 743e40139ffSDimitry Andric if (fclose(__h.release())) 744e8d8bef9SDimitry Andric __rt = nullptr; 745e8d8bef9SDimitry Andric __file_ = nullptr; 7460b57cec5SDimitry Andric setbuf(0, 0); 7470b57cec5SDimitry Andric } 7480b57cec5SDimitry Andric return __rt; 7490b57cec5SDimitry Andric} 7500b57cec5SDimitry Andric 7510b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 7520b57cec5SDimitry Andrictypename basic_filebuf<_CharT, _Traits>::int_type 7530b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::underflow() 7540b57cec5SDimitry Andric{ 755e8d8bef9SDimitry Andric if (__file_ == nullptr) 7560b57cec5SDimitry Andric return traits_type::eof(); 7570b57cec5SDimitry Andric bool __initial = __read_mode(); 7580b57cec5SDimitry Andric char_type __1buf; 759e8d8bef9SDimitry Andric if (this->gptr() == nullptr) 7600b57cec5SDimitry Andric this->setg(&__1buf, &__1buf+1, &__1buf+1); 761bdd1243dSDimitry Andric const size_t __unget_sz = __initial ? 0 : std::min<size_t>((this->egptr() - this->eback()) / 2, 4); 7620b57cec5SDimitry Andric int_type __c = traits_type::eof(); 7630b57cec5SDimitry Andric if (this->gptr() == this->egptr()) 7640b57cec5SDimitry Andric { 765*5f757f3fSDimitry Andric std::memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz * sizeof(char_type)); 7660b57cec5SDimitry Andric if (__always_noconv_) 7670b57cec5SDimitry Andric { 7680b57cec5SDimitry Andric size_t __nmemb = static_cast<size_t>(this->egptr() - this->eback() - __unget_sz); 769bdd1243dSDimitry Andric __nmemb = ::fread(this->eback() + __unget_sz, 1, __nmemb, __file_); 7700b57cec5SDimitry Andric if (__nmemb != 0) 7710b57cec5SDimitry Andric { 7720b57cec5SDimitry Andric this->setg(this->eback(), 7730b57cec5SDimitry Andric this->eback() + __unget_sz, 7740b57cec5SDimitry Andric this->eback() + __unget_sz + __nmemb); 7750b57cec5SDimitry Andric __c = traits_type::to_int_type(*this->gptr()); 7760b57cec5SDimitry Andric } 7770b57cec5SDimitry Andric } 7780b57cec5SDimitry Andric else 7790b57cec5SDimitry Andric { 780bdd1243dSDimitry Andric if (__extbufend_ != __extbufnext_) { 781*5f757f3fSDimitry Andric _LIBCPP_ASSERT_NON_NULL(__extbufnext_ != nullptr, "underflow moving from nullptr"); 782*5f757f3fSDimitry Andric _LIBCPP_ASSERT_NON_NULL(__extbuf_ != nullptr, "underflow moving into nullptr"); 783*5f757f3fSDimitry Andric std::memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_); 784bdd1243dSDimitry Andric } 7850b57cec5SDimitry Andric __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_); 7860b57cec5SDimitry Andric __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_); 787*5f757f3fSDimitry Andric size_t __nmemb = std::min(static_cast<size_t>(__ibs_ - __unget_sz), 7880b57cec5SDimitry Andric static_cast<size_t>(__extbufend_ - __extbufnext_)); 7890b57cec5SDimitry Andric codecvt_base::result __r; 7900b57cec5SDimitry Andric __st_last_ = __st_; 7910b57cec5SDimitry Andric size_t __nr = fread((void*) const_cast<char *>(__extbufnext_), 1, __nmemb, __file_); 7920b57cec5SDimitry Andric if (__nr != 0) 7930b57cec5SDimitry Andric { 7940b57cec5SDimitry Andric if (!__cv_) 7950b57cec5SDimitry Andric __throw_bad_cast(); 7960b57cec5SDimitry Andric 7970b57cec5SDimitry Andric __extbufend_ = __extbufnext_ + __nr; 7980b57cec5SDimitry Andric char_type* __inext; 7990b57cec5SDimitry Andric __r = __cv_->in(__st_, __extbuf_, __extbufend_, __extbufnext_, 8000b57cec5SDimitry Andric this->eback() + __unget_sz, 8010b57cec5SDimitry Andric this->eback() + __ibs_, __inext); 8020b57cec5SDimitry Andric if (__r == codecvt_base::noconv) 8030b57cec5SDimitry Andric { 8040b57cec5SDimitry Andric this->setg((char_type*)__extbuf_, (char_type*)__extbuf_, 8050b57cec5SDimitry Andric (char_type*)const_cast<char *>(__extbufend_)); 8060b57cec5SDimitry Andric __c = traits_type::to_int_type(*this->gptr()); 8070b57cec5SDimitry Andric } 8080b57cec5SDimitry Andric else if (__inext != this->eback() + __unget_sz) 8090b57cec5SDimitry Andric { 8100b57cec5SDimitry Andric this->setg(this->eback(), this->eback() + __unget_sz, __inext); 8110b57cec5SDimitry Andric __c = traits_type::to_int_type(*this->gptr()); 8120b57cec5SDimitry Andric } 8130b57cec5SDimitry Andric } 8140b57cec5SDimitry Andric } 8150b57cec5SDimitry Andric } 8160b57cec5SDimitry Andric else 8170b57cec5SDimitry Andric __c = traits_type::to_int_type(*this->gptr()); 8180b57cec5SDimitry Andric if (this->eback() == &__1buf) 819e8d8bef9SDimitry Andric this->setg(nullptr, nullptr, nullptr); 8200b57cec5SDimitry Andric return __c; 8210b57cec5SDimitry Andric} 8220b57cec5SDimitry Andric 8230b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 8240b57cec5SDimitry Andrictypename basic_filebuf<_CharT, _Traits>::int_type 8250b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::pbackfail(int_type __c) 8260b57cec5SDimitry Andric{ 8270b57cec5SDimitry Andric if (__file_ && this->eback() < this->gptr()) 8280b57cec5SDimitry Andric { 8290b57cec5SDimitry Andric if (traits_type::eq_int_type(__c, traits_type::eof())) 8300b57cec5SDimitry Andric { 8310b57cec5SDimitry Andric this->gbump(-1); 8320b57cec5SDimitry Andric return traits_type::not_eof(__c); 8330b57cec5SDimitry Andric } 8340b57cec5SDimitry Andric if ((__om_ & ios_base::out) || 8350b57cec5SDimitry Andric traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1])) 8360b57cec5SDimitry Andric { 8370b57cec5SDimitry Andric this->gbump(-1); 8380b57cec5SDimitry Andric *this->gptr() = traits_type::to_char_type(__c); 8390b57cec5SDimitry Andric return __c; 8400b57cec5SDimitry Andric } 8410b57cec5SDimitry Andric } 8420b57cec5SDimitry Andric return traits_type::eof(); 8430b57cec5SDimitry Andric} 8440b57cec5SDimitry Andric 8450b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 8460b57cec5SDimitry Andrictypename basic_filebuf<_CharT, _Traits>::int_type 8470b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::overflow(int_type __c) 8480b57cec5SDimitry Andric{ 849e8d8bef9SDimitry Andric if (__file_ == nullptr) 8500b57cec5SDimitry Andric return traits_type::eof(); 8510b57cec5SDimitry Andric __write_mode(); 8520b57cec5SDimitry Andric char_type __1buf; 8530b57cec5SDimitry Andric char_type* __pb_save = this->pbase(); 8540b57cec5SDimitry Andric char_type* __epb_save = this->epptr(); 8550b57cec5SDimitry Andric if (!traits_type::eq_int_type(__c, traits_type::eof())) 8560b57cec5SDimitry Andric { 857e8d8bef9SDimitry Andric if (this->pptr() == nullptr) 8580b57cec5SDimitry Andric this->setp(&__1buf, &__1buf+1); 8590b57cec5SDimitry Andric *this->pptr() = traits_type::to_char_type(__c); 8600b57cec5SDimitry Andric this->pbump(1); 8610b57cec5SDimitry Andric } 8620b57cec5SDimitry Andric if (this->pptr() != this->pbase()) 8630b57cec5SDimitry Andric { 8640b57cec5SDimitry Andric if (__always_noconv_) 8650b57cec5SDimitry Andric { 8660b57cec5SDimitry Andric size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase()); 867bdd1243dSDimitry Andric if (std::fwrite(this->pbase(), sizeof(char_type), __nmemb, __file_) != __nmemb) 8680b57cec5SDimitry Andric return traits_type::eof(); 8690b57cec5SDimitry Andric } 8700b57cec5SDimitry Andric else 8710b57cec5SDimitry Andric { 8720b57cec5SDimitry Andric char* __extbe = __extbuf_; 8730b57cec5SDimitry Andric codecvt_base::result __r; 8740b57cec5SDimitry Andric do 8750b57cec5SDimitry Andric { 8760b57cec5SDimitry Andric if (!__cv_) 8770b57cec5SDimitry Andric __throw_bad_cast(); 8780b57cec5SDimitry Andric 8790b57cec5SDimitry Andric const char_type* __e; 8800b57cec5SDimitry Andric __r = __cv_->out(__st_, this->pbase(), this->pptr(), __e, 8810b57cec5SDimitry Andric __extbuf_, __extbuf_ + __ebs_, __extbe); 8820b57cec5SDimitry Andric if (__e == this->pbase()) 8830b57cec5SDimitry Andric return traits_type::eof(); 8840b57cec5SDimitry Andric if (__r == codecvt_base::noconv) 8850b57cec5SDimitry Andric { 8860b57cec5SDimitry Andric size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase()); 887bdd1243dSDimitry Andric if (std::fwrite(this->pbase(), 1, __nmemb, __file_) != __nmemb) 8880b57cec5SDimitry Andric return traits_type::eof(); 8890b57cec5SDimitry Andric } 8900b57cec5SDimitry Andric else if (__r == codecvt_base::ok || __r == codecvt_base::partial) 8910b57cec5SDimitry Andric { 8920b57cec5SDimitry Andric size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_); 8930b57cec5SDimitry Andric if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb) 8940b57cec5SDimitry Andric return traits_type::eof(); 8950b57cec5SDimitry Andric if (__r == codecvt_base::partial) 8960b57cec5SDimitry Andric { 8970b57cec5SDimitry Andric this->setp(const_cast<char_type*>(__e), this->pptr()); 8980b57cec5SDimitry Andric this->__pbump(this->epptr() - this->pbase()); 8990b57cec5SDimitry Andric } 9000b57cec5SDimitry Andric } 9010b57cec5SDimitry Andric else 9020b57cec5SDimitry Andric return traits_type::eof(); 9030b57cec5SDimitry Andric } while (__r == codecvt_base::partial); 9040b57cec5SDimitry Andric } 9050b57cec5SDimitry Andric this->setp(__pb_save, __epb_save); 9060b57cec5SDimitry Andric } 9070b57cec5SDimitry Andric return traits_type::not_eof(__c); 9080b57cec5SDimitry Andric} 9090b57cec5SDimitry Andric 9100b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 9110b57cec5SDimitry Andricbasic_streambuf<_CharT, _Traits>* 9120b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::setbuf(char_type* __s, streamsize __n) 9130b57cec5SDimitry Andric{ 914e8d8bef9SDimitry Andric this->setg(nullptr, nullptr, nullptr); 915e8d8bef9SDimitry Andric this->setp(nullptr, nullptr); 9160b57cec5SDimitry Andric if (__owns_eb_) 9170b57cec5SDimitry Andric delete [] __extbuf_; 9180b57cec5SDimitry Andric if (__owns_ib_) 9190b57cec5SDimitry Andric delete [] __intbuf_; 9200b57cec5SDimitry Andric __ebs_ = __n; 9210b57cec5SDimitry Andric if (__ebs_ > sizeof(__extbuf_min_)) 9220b57cec5SDimitry Andric { 9230b57cec5SDimitry Andric if (__always_noconv_ && __s) 9240b57cec5SDimitry Andric { 9250b57cec5SDimitry Andric __extbuf_ = (char*)__s; 9260b57cec5SDimitry Andric __owns_eb_ = false; 9270b57cec5SDimitry Andric } 9280b57cec5SDimitry Andric else 9290b57cec5SDimitry Andric { 9300b57cec5SDimitry Andric __extbuf_ = new char[__ebs_]; 9310b57cec5SDimitry Andric __owns_eb_ = true; 9320b57cec5SDimitry Andric } 9330b57cec5SDimitry Andric } 9340b57cec5SDimitry Andric else 9350b57cec5SDimitry Andric { 9360b57cec5SDimitry Andric __extbuf_ = __extbuf_min_; 9370b57cec5SDimitry Andric __ebs_ = sizeof(__extbuf_min_); 9380b57cec5SDimitry Andric __owns_eb_ = false; 9390b57cec5SDimitry Andric } 9400b57cec5SDimitry Andric if (!__always_noconv_) 9410b57cec5SDimitry Andric { 9420b57cec5SDimitry Andric __ibs_ = max<streamsize>(__n, sizeof(__extbuf_min_)); 943*5f757f3fSDimitry Andric if (__s && __ibs_ > sizeof(__extbuf_min_)) 9440b57cec5SDimitry Andric { 9450b57cec5SDimitry Andric __intbuf_ = __s; 9460b57cec5SDimitry Andric __owns_ib_ = false; 9470b57cec5SDimitry Andric } 9480b57cec5SDimitry Andric else 9490b57cec5SDimitry Andric { 9500b57cec5SDimitry Andric __intbuf_ = new char_type[__ibs_]; 9510b57cec5SDimitry Andric __owns_ib_ = true; 9520b57cec5SDimitry Andric } 9530b57cec5SDimitry Andric } 9540b57cec5SDimitry Andric else 9550b57cec5SDimitry Andric { 9560b57cec5SDimitry Andric __ibs_ = 0; 957e8d8bef9SDimitry Andric __intbuf_ = nullptr; 9580b57cec5SDimitry Andric __owns_ib_ = false; 9590b57cec5SDimitry Andric } 9600b57cec5SDimitry Andric return this; 9610b57cec5SDimitry Andric} 9620b57cec5SDimitry Andric 9630b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 9640b57cec5SDimitry Andrictypename basic_filebuf<_CharT, _Traits>::pos_type 9650b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way, 9660b57cec5SDimitry Andric ios_base::openmode) 9670b57cec5SDimitry Andric{ 9680b57cec5SDimitry Andric if (!__cv_) 9690b57cec5SDimitry Andric __throw_bad_cast(); 9700b57cec5SDimitry Andric 9710b57cec5SDimitry Andric int __width = __cv_->encoding(); 972e8d8bef9SDimitry Andric if (__file_ == nullptr || (__width <= 0 && __off != 0) || sync()) 9730b57cec5SDimitry Andric return pos_type(off_type(-1)); 9740b57cec5SDimitry Andric // __width > 0 || __off == 0 9750b57cec5SDimitry Andric int __whence; 9760b57cec5SDimitry Andric switch (__way) 9770b57cec5SDimitry Andric { 9780b57cec5SDimitry Andric case ios_base::beg: 9790b57cec5SDimitry Andric __whence = SEEK_SET; 9800b57cec5SDimitry Andric break; 9810b57cec5SDimitry Andric case ios_base::cur: 9820b57cec5SDimitry Andric __whence = SEEK_CUR; 9830b57cec5SDimitry Andric break; 9840b57cec5SDimitry Andric case ios_base::end: 9850b57cec5SDimitry Andric __whence = SEEK_END; 9860b57cec5SDimitry Andric break; 9870b57cec5SDimitry Andric default: 9880b57cec5SDimitry Andric return pos_type(off_type(-1)); 9890b57cec5SDimitry Andric } 9900b57cec5SDimitry Andric#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS) 9910b57cec5SDimitry Andric if (fseek(__file_, __width > 0 ? __width * __off : 0, __whence)) 9920b57cec5SDimitry Andric return pos_type(off_type(-1)); 9930b57cec5SDimitry Andric pos_type __r = ftell(__file_); 9940b57cec5SDimitry Andric#else 995bdd1243dSDimitry Andric if (::fseeko(__file_, __width > 0 ? __width * __off : 0, __whence)) 9960b57cec5SDimitry Andric return pos_type(off_type(-1)); 9970b57cec5SDimitry Andric pos_type __r = ftello(__file_); 9980b57cec5SDimitry Andric#endif 9990b57cec5SDimitry Andric __r.state(__st_); 10000b57cec5SDimitry Andric return __r; 10010b57cec5SDimitry Andric} 10020b57cec5SDimitry Andric 10030b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 10040b57cec5SDimitry Andrictypename basic_filebuf<_CharT, _Traits>::pos_type 10050b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode) 10060b57cec5SDimitry Andric{ 1007e8d8bef9SDimitry Andric if (__file_ == nullptr || sync()) 10080b57cec5SDimitry Andric return pos_type(off_type(-1)); 10090b57cec5SDimitry Andric#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS) 10100b57cec5SDimitry Andric if (fseek(__file_, __sp, SEEK_SET)) 10110b57cec5SDimitry Andric return pos_type(off_type(-1)); 10120b57cec5SDimitry Andric#else 1013bdd1243dSDimitry Andric if (::fseeko(__file_, __sp, SEEK_SET)) 10140b57cec5SDimitry Andric return pos_type(off_type(-1)); 10150b57cec5SDimitry Andric#endif 10160b57cec5SDimitry Andric __st_ = __sp.state(); 10170b57cec5SDimitry Andric return __sp; 10180b57cec5SDimitry Andric} 10190b57cec5SDimitry Andric 10200b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 10210b57cec5SDimitry Andricint 10220b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::sync() 10230b57cec5SDimitry Andric{ 1024e8d8bef9SDimitry Andric if (__file_ == nullptr) 10250b57cec5SDimitry Andric return 0; 10260b57cec5SDimitry Andric if (!__cv_) 10270b57cec5SDimitry Andric __throw_bad_cast(); 10280b57cec5SDimitry Andric 10290b57cec5SDimitry Andric if (__cm_ & ios_base::out) 10300b57cec5SDimitry Andric { 10310b57cec5SDimitry Andric if (this->pptr() != this->pbase()) 10320b57cec5SDimitry Andric if (overflow() == traits_type::eof()) 10330b57cec5SDimitry Andric return -1; 10340b57cec5SDimitry Andric codecvt_base::result __r; 10350b57cec5SDimitry Andric do 10360b57cec5SDimitry Andric { 10370b57cec5SDimitry Andric char* __extbe; 10380b57cec5SDimitry Andric __r = __cv_->unshift(__st_, __extbuf_, __extbuf_ + __ebs_, __extbe); 10390b57cec5SDimitry Andric size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_); 10400b57cec5SDimitry Andric if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb) 10410b57cec5SDimitry Andric return -1; 10420b57cec5SDimitry Andric } while (__r == codecvt_base::partial); 10430b57cec5SDimitry Andric if (__r == codecvt_base::error) 10440b57cec5SDimitry Andric return -1; 10450b57cec5SDimitry Andric if (fflush(__file_)) 10460b57cec5SDimitry Andric return -1; 10470b57cec5SDimitry Andric } 10480b57cec5SDimitry Andric else if (__cm_ & ios_base::in) 10490b57cec5SDimitry Andric { 10500b57cec5SDimitry Andric off_type __c; 10510b57cec5SDimitry Andric state_type __state = __st_last_; 10520b57cec5SDimitry Andric bool __update_st = false; 10530b57cec5SDimitry Andric if (__always_noconv_) 10540b57cec5SDimitry Andric __c = this->egptr() - this->gptr(); 10550b57cec5SDimitry Andric else 10560b57cec5SDimitry Andric { 10570b57cec5SDimitry Andric int __width = __cv_->encoding(); 10580b57cec5SDimitry Andric __c = __extbufend_ - __extbufnext_; 10590b57cec5SDimitry Andric if (__width > 0) 10600b57cec5SDimitry Andric __c += __width * (this->egptr() - this->gptr()); 10610b57cec5SDimitry Andric else 10620b57cec5SDimitry Andric { 10630b57cec5SDimitry Andric if (this->gptr() != this->egptr()) 10640b57cec5SDimitry Andric { 10650b57cec5SDimitry Andric const int __off = __cv_->length(__state, __extbuf_, 10660b57cec5SDimitry Andric __extbufnext_, 10670b57cec5SDimitry Andric this->gptr() - this->eback()); 10680b57cec5SDimitry Andric __c += __extbufnext_ - __extbuf_ - __off; 10690b57cec5SDimitry Andric __update_st = true; 10700b57cec5SDimitry Andric } 10710b57cec5SDimitry Andric } 10720b57cec5SDimitry Andric } 10730b57cec5SDimitry Andric#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS) 10740b57cec5SDimitry Andric if (fseek(__file_, -__c, SEEK_CUR)) 10750b57cec5SDimitry Andric return -1; 10760b57cec5SDimitry Andric#else 1077bdd1243dSDimitry Andric if (::fseeko(__file_, -__c, SEEK_CUR)) 10780b57cec5SDimitry Andric return -1; 10790b57cec5SDimitry Andric#endif 10800b57cec5SDimitry Andric if (__update_st) 10810b57cec5SDimitry Andric __st_ = __state; 10820b57cec5SDimitry Andric __extbufnext_ = __extbufend_ = __extbuf_; 1083e8d8bef9SDimitry Andric this->setg(nullptr, nullptr, nullptr); 10840b57cec5SDimitry Andric __cm_ = 0; 10850b57cec5SDimitry Andric } 10860b57cec5SDimitry Andric return 0; 10870b57cec5SDimitry Andric} 10880b57cec5SDimitry Andric 10890b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 10900b57cec5SDimitry Andricvoid 10910b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::imbue(const locale& __loc) 10920b57cec5SDimitry Andric{ 10930b57cec5SDimitry Andric sync(); 1094bdd1243dSDimitry Andric __cv_ = &std::use_facet<codecvt<char_type, char, state_type> >(__loc); 10950b57cec5SDimitry Andric bool __old_anc = __always_noconv_; 10960b57cec5SDimitry Andric __always_noconv_ = __cv_->always_noconv(); 10970b57cec5SDimitry Andric if (__old_anc != __always_noconv_) 10980b57cec5SDimitry Andric { 1099e8d8bef9SDimitry Andric this->setg(nullptr, nullptr, nullptr); 1100e8d8bef9SDimitry Andric this->setp(nullptr, nullptr); 11010b57cec5SDimitry Andric // invariant, char_type is char, else we couldn't get here 11020b57cec5SDimitry Andric if (__always_noconv_) // need to dump __intbuf_ 11030b57cec5SDimitry Andric { 11040b57cec5SDimitry Andric if (__owns_eb_) 11050b57cec5SDimitry Andric delete [] __extbuf_; 11060b57cec5SDimitry Andric __owns_eb_ = __owns_ib_; 11070b57cec5SDimitry Andric __ebs_ = __ibs_; 11080b57cec5SDimitry Andric __extbuf_ = (char*)__intbuf_; 11090b57cec5SDimitry Andric __ibs_ = 0; 1110e8d8bef9SDimitry Andric __intbuf_ = nullptr; 11110b57cec5SDimitry Andric __owns_ib_ = false; 11120b57cec5SDimitry Andric } 11130b57cec5SDimitry Andric else // need to obtain an __intbuf_. 11140b57cec5SDimitry Andric { // If __extbuf_ is user-supplied, use it, else new __intbuf_ 11150b57cec5SDimitry Andric if (!__owns_eb_ && __extbuf_ != __extbuf_min_) 11160b57cec5SDimitry Andric { 11170b57cec5SDimitry Andric __ibs_ = __ebs_; 11180b57cec5SDimitry Andric __intbuf_ = (char_type*)__extbuf_; 11190b57cec5SDimitry Andric __owns_ib_ = false; 11200b57cec5SDimitry Andric __extbuf_ = new char[__ebs_]; 11210b57cec5SDimitry Andric __owns_eb_ = true; 11220b57cec5SDimitry Andric } 11230b57cec5SDimitry Andric else 11240b57cec5SDimitry Andric { 11250b57cec5SDimitry Andric __ibs_ = __ebs_; 11260b57cec5SDimitry Andric __intbuf_ = new char_type[__ibs_]; 11270b57cec5SDimitry Andric __owns_ib_ = true; 11280b57cec5SDimitry Andric } 11290b57cec5SDimitry Andric } 11300b57cec5SDimitry Andric } 11310b57cec5SDimitry Andric} 11320b57cec5SDimitry Andric 11330b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 11340b57cec5SDimitry Andricbool 11350b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::__read_mode() 11360b57cec5SDimitry Andric{ 11370b57cec5SDimitry Andric if (!(__cm_ & ios_base::in)) 11380b57cec5SDimitry Andric { 1139e8d8bef9SDimitry Andric this->setp(nullptr, nullptr); 11400b57cec5SDimitry Andric if (__always_noconv_) 11410b57cec5SDimitry Andric this->setg((char_type*)__extbuf_, 11420b57cec5SDimitry Andric (char_type*)__extbuf_ + __ebs_, 11430b57cec5SDimitry Andric (char_type*)__extbuf_ + __ebs_); 11440b57cec5SDimitry Andric else 11450b57cec5SDimitry Andric this->setg(__intbuf_, __intbuf_ + __ibs_, __intbuf_ + __ibs_); 11460b57cec5SDimitry Andric __cm_ = ios_base::in; 11470b57cec5SDimitry Andric return true; 11480b57cec5SDimitry Andric } 11490b57cec5SDimitry Andric return false; 11500b57cec5SDimitry Andric} 11510b57cec5SDimitry Andric 11520b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 11530b57cec5SDimitry Andricvoid 11540b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::__write_mode() 11550b57cec5SDimitry Andric{ 11560b57cec5SDimitry Andric if (!(__cm_ & ios_base::out)) 11570b57cec5SDimitry Andric { 1158e8d8bef9SDimitry Andric this->setg(nullptr, nullptr, nullptr); 11590b57cec5SDimitry Andric if (__ebs_ > sizeof(__extbuf_min_)) 11600b57cec5SDimitry Andric { 11610b57cec5SDimitry Andric if (__always_noconv_) 11620b57cec5SDimitry Andric this->setp((char_type*)__extbuf_, 11630b57cec5SDimitry Andric (char_type*)__extbuf_ + (__ebs_ - 1)); 11640b57cec5SDimitry Andric else 11650b57cec5SDimitry Andric this->setp(__intbuf_, __intbuf_ + (__ibs_ - 1)); 11660b57cec5SDimitry Andric } 11670b57cec5SDimitry Andric else 1168e8d8bef9SDimitry Andric this->setp(nullptr, nullptr); 11690b57cec5SDimitry Andric __cm_ = ios_base::out; 11700b57cec5SDimitry Andric } 11710b57cec5SDimitry Andric} 11720b57cec5SDimitry Andric 11730b57cec5SDimitry Andric// basic_ifstream 11740b57cec5SDimitry Andric 11750b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 11760b57cec5SDimitry Andricclass _LIBCPP_TEMPLATE_VIS basic_ifstream 11770b57cec5SDimitry Andric : public basic_istream<_CharT, _Traits> 11780b57cec5SDimitry Andric{ 11790b57cec5SDimitry Andricpublic: 11800b57cec5SDimitry Andric typedef _CharT char_type; 11810b57cec5SDimitry Andric typedef _Traits traits_type; 11820b57cec5SDimitry Andric typedef typename traits_type::int_type int_type; 11830b57cec5SDimitry Andric typedef typename traits_type::pos_type pos_type; 11840b57cec5SDimitry Andric typedef typename traits_type::off_type off_type; 11850b57cec5SDimitry Andric 1186*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 11870b57cec5SDimitry Andric basic_ifstream(); 1188*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 11890b57cec5SDimitry Andric explicit basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in); 11900b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 1191*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 11920b57cec5SDimitry Andric explicit basic_ifstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in); 11930b57cec5SDimitry Andric#endif 1194*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 11950b57cec5SDimitry Andric explicit basic_ifstream(const string& __s, ios_base::openmode __mode = ios_base::in); 119606c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 17 1197*5f757f3fSDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_HIDE_FROM_ABI 11980b57cec5SDimitry Andric explicit basic_ifstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in) 11990b57cec5SDimitry Andric : basic_ifstream(__p.c_str(), __mode) {} 12000b57cec5SDimitry Andric#endif // _LIBCPP_STD_VER >= 17 1201*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 12020b57cec5SDimitry Andric basic_ifstream(basic_ifstream&& __rhs); 1203*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 12040b57cec5SDimitry Andric basic_ifstream& operator=(basic_ifstream&& __rhs); 1205*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 12060b57cec5SDimitry Andric void swap(basic_ifstream& __rhs); 12070b57cec5SDimitry Andric 1208*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 12090b57cec5SDimitry Andric basic_filebuf<char_type, traits_type>* rdbuf() const; 1210*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 12110b57cec5SDimitry Andric bool is_open() const; 12120b57cec5SDimitry Andric void open(const char* __s, ios_base::openmode __mode = ios_base::in); 12130b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 12140b57cec5SDimitry Andric void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in); 12150b57cec5SDimitry Andric#endif 12160b57cec5SDimitry Andric void open(const string& __s, ios_base::openmode __mode = ios_base::in); 121706c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 17 1218*5f757f3fSDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_HIDE_FROM_ABI 12190b57cec5SDimitry Andric void open(const filesystem::path& __p, 12200b57cec5SDimitry Andric ios_base::openmode __mode = ios_base::in) { 12210b57cec5SDimitry Andric return open(__p.c_str(), __mode); 12220b57cec5SDimitry Andric } 12230b57cec5SDimitry Andric#endif // _LIBCPP_STD_VER >= 17 12240b57cec5SDimitry Andric 1225*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 12260b57cec5SDimitry Andric void __open(int __fd, ios_base::openmode __mode); 1227*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 12280b57cec5SDimitry Andric void close(); 12290b57cec5SDimitry Andric 12300b57cec5SDimitry Andricprivate: 12310b57cec5SDimitry Andric basic_filebuf<char_type, traits_type> __sb_; 12320b57cec5SDimitry Andric}; 12330b57cec5SDimitry Andric 12340b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12350b57cec5SDimitry Andricinline 12360b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::basic_ifstream() 12370b57cec5SDimitry Andric : basic_istream<char_type, traits_type>(&__sb_) 12380b57cec5SDimitry Andric{ 12390b57cec5SDimitry Andric} 12400b57cec5SDimitry Andric 12410b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12420b57cec5SDimitry Andricinline 12430b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::basic_ifstream(const char* __s, ios_base::openmode __mode) 12440b57cec5SDimitry Andric : basic_istream<char_type, traits_type>(&__sb_) 12450b57cec5SDimitry Andric{ 1246e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode | ios_base::in) == nullptr) 12470b57cec5SDimitry Andric this->setstate(ios_base::failbit); 12480b57cec5SDimitry Andric} 12490b57cec5SDimitry Andric 12500b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 12510b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12520b57cec5SDimitry Andricinline 12530b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::basic_ifstream(const wchar_t* __s, ios_base::openmode __mode) 12540b57cec5SDimitry Andric : basic_istream<char_type, traits_type>(&__sb_) 12550b57cec5SDimitry Andric{ 1256e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode | ios_base::in) == nullptr) 12570b57cec5SDimitry Andric this->setstate(ios_base::failbit); 12580b57cec5SDimitry Andric} 12590b57cec5SDimitry Andric#endif 12600b57cec5SDimitry Andric 12610b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12620b57cec5SDimitry Andricinline 12630b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::openmode __mode) 12640b57cec5SDimitry Andric : basic_istream<char_type, traits_type>(&__sb_) 12650b57cec5SDimitry Andric{ 1266e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode | ios_base::in) == nullptr) 12670b57cec5SDimitry Andric this->setstate(ios_base::failbit); 12680b57cec5SDimitry Andric} 12690b57cec5SDimitry Andric 12700b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12710b57cec5SDimitry Andricinline 12720b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::basic_ifstream(basic_ifstream&& __rhs) 1273*5f757f3fSDimitry Andric : basic_istream<char_type, traits_type>(std::move(__rhs)), 1274*5f757f3fSDimitry Andric __sb_(std::move(__rhs.__sb_)) 12750b57cec5SDimitry Andric{ 12760b57cec5SDimitry Andric this->set_rdbuf(&__sb_); 12770b57cec5SDimitry Andric} 12780b57cec5SDimitry Andric 12790b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12800b57cec5SDimitry Andricinline 12810b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>& 12820b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs) 12830b57cec5SDimitry Andric{ 1284*5f757f3fSDimitry Andric basic_istream<char_type, traits_type>::operator=(std::move(__rhs)); 1285*5f757f3fSDimitry Andric __sb_ = std::move(__rhs.__sb_); 12860b57cec5SDimitry Andric return *this; 12870b57cec5SDimitry Andric} 12880b57cec5SDimitry Andric 12890b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12900b57cec5SDimitry Andricinline 12910b57cec5SDimitry Andricvoid 12920b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::swap(basic_ifstream& __rhs) 12930b57cec5SDimitry Andric{ 12940b57cec5SDimitry Andric basic_istream<char_type, traits_type>::swap(__rhs); 12950b57cec5SDimitry Andric __sb_.swap(__rhs.__sb_); 12960b57cec5SDimitry Andric} 12970b57cec5SDimitry Andric 12980b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 1299*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 13000b57cec5SDimitry Andricvoid 13010b57cec5SDimitry Andricswap(basic_ifstream<_CharT, _Traits>& __x, basic_ifstream<_CharT, _Traits>& __y) 13020b57cec5SDimitry Andric{ 13030b57cec5SDimitry Andric __x.swap(__y); 13040b57cec5SDimitry Andric} 13050b57cec5SDimitry Andric 13060b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 13070b57cec5SDimitry Andricinline 13080b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 13090b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::rdbuf() const 13100b57cec5SDimitry Andric{ 13110b57cec5SDimitry Andric return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_); 13120b57cec5SDimitry Andric} 13130b57cec5SDimitry Andric 13140b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 13150b57cec5SDimitry Andricinline 13160b57cec5SDimitry Andricbool 13170b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::is_open() const 13180b57cec5SDimitry Andric{ 13190b57cec5SDimitry Andric return __sb_.is_open(); 13200b57cec5SDimitry Andric} 13210b57cec5SDimitry Andric 13220b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 13230b57cec5SDimitry Andricvoid 13240b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) 13250b57cec5SDimitry Andric{ 13260b57cec5SDimitry Andric if (__sb_.open(__s, __mode | ios_base::in)) 13270b57cec5SDimitry Andric this->clear(); 13280b57cec5SDimitry Andric else 13290b57cec5SDimitry Andric this->setstate(ios_base::failbit); 13300b57cec5SDimitry Andric} 13310b57cec5SDimitry Andric 13320b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 13330b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 13340b57cec5SDimitry Andricvoid 13350b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) 13360b57cec5SDimitry Andric{ 13370b57cec5SDimitry Andric if (__sb_.open(__s, __mode | ios_base::in)) 13380b57cec5SDimitry Andric this->clear(); 13390b57cec5SDimitry Andric else 13400b57cec5SDimitry Andric this->setstate(ios_base::failbit); 13410b57cec5SDimitry Andric} 13420b57cec5SDimitry Andric#endif 13430b57cec5SDimitry Andric 13440b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 13450b57cec5SDimitry Andricvoid 13460b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) 13470b57cec5SDimitry Andric{ 13480b57cec5SDimitry Andric if (__sb_.open(__s, __mode | ios_base::in)) 13490b57cec5SDimitry Andric this->clear(); 13500b57cec5SDimitry Andric else 13510b57cec5SDimitry Andric this->setstate(ios_base::failbit); 13520b57cec5SDimitry Andric} 13530b57cec5SDimitry Andric 13540b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 1355d099db25SDimitry Andricinline 13560b57cec5SDimitry Andricvoid basic_ifstream<_CharT, _Traits>::__open(int __fd, 13570b57cec5SDimitry Andric ios_base::openmode __mode) { 13580b57cec5SDimitry Andric if (__sb_.__open(__fd, __mode | ios_base::in)) 13590b57cec5SDimitry Andric this->clear(); 13600b57cec5SDimitry Andric else 13610b57cec5SDimitry Andric this->setstate(ios_base::failbit); 13620b57cec5SDimitry Andric} 13630b57cec5SDimitry Andric 13640b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 13650b57cec5SDimitry Andricinline 13660b57cec5SDimitry Andricvoid 13670b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::close() 13680b57cec5SDimitry Andric{ 13690b57cec5SDimitry Andric if (__sb_.close() == 0) 13700b57cec5SDimitry Andric this->setstate(ios_base::failbit); 13710b57cec5SDimitry Andric} 13720b57cec5SDimitry Andric 13730b57cec5SDimitry Andric// basic_ofstream 13740b57cec5SDimitry Andric 13750b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 13760b57cec5SDimitry Andricclass _LIBCPP_TEMPLATE_VIS basic_ofstream 13770b57cec5SDimitry Andric : public basic_ostream<_CharT, _Traits> 13780b57cec5SDimitry Andric{ 13790b57cec5SDimitry Andricpublic: 13800b57cec5SDimitry Andric typedef _CharT char_type; 13810b57cec5SDimitry Andric typedef _Traits traits_type; 13820b57cec5SDimitry Andric typedef typename traits_type::int_type int_type; 13830b57cec5SDimitry Andric typedef typename traits_type::pos_type pos_type; 13840b57cec5SDimitry Andric typedef typename traits_type::off_type off_type; 13850b57cec5SDimitry Andric 1386*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 13870b57cec5SDimitry Andric basic_ofstream(); 1388*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 13890b57cec5SDimitry Andric explicit basic_ofstream(const char* __s, ios_base::openmode __mode = ios_base::out); 13900b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 1391*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 13920b57cec5SDimitry Andric explicit basic_ofstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::out); 13930b57cec5SDimitry Andric#endif 1394*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 13950b57cec5SDimitry Andric explicit basic_ofstream(const string& __s, ios_base::openmode __mode = ios_base::out); 13960b57cec5SDimitry Andric 139706c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 17 1398*5f757f3fSDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_HIDE_FROM_ABI 13990b57cec5SDimitry Andric explicit basic_ofstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out) 14000b57cec5SDimitry Andric : basic_ofstream(__p.c_str(), __mode) {} 14010b57cec5SDimitry Andric#endif // _LIBCPP_STD_VER >= 17 14020b57cec5SDimitry Andric 1403*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 14040b57cec5SDimitry Andric basic_ofstream(basic_ofstream&& __rhs); 1405*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 14060b57cec5SDimitry Andric basic_ofstream& operator=(basic_ofstream&& __rhs); 1407*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 14080b57cec5SDimitry Andric void swap(basic_ofstream& __rhs); 14090b57cec5SDimitry Andric 1410*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 14110b57cec5SDimitry Andric basic_filebuf<char_type, traits_type>* rdbuf() const; 1412*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 14130b57cec5SDimitry Andric bool is_open() const; 14140b57cec5SDimitry Andric void open(const char* __s, ios_base::openmode __mode = ios_base::out); 14150b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 14160b57cec5SDimitry Andric void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::out); 14170b57cec5SDimitry Andric#endif 14180b57cec5SDimitry Andric void open(const string& __s, ios_base::openmode __mode = ios_base::out); 14190b57cec5SDimitry Andric 142006c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 17 1421*5f757f3fSDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_HIDE_FROM_ABI 14220b57cec5SDimitry Andric void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out) 14230b57cec5SDimitry Andric { return open(__p.c_str(), __mode); } 14240b57cec5SDimitry Andric#endif // _LIBCPP_STD_VER >= 17 14250b57cec5SDimitry Andric 1426*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 14270b57cec5SDimitry Andric void __open(int __fd, ios_base::openmode __mode); 1428*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 14290b57cec5SDimitry Andric void close(); 14300b57cec5SDimitry Andric 14310b57cec5SDimitry Andricprivate: 14320b57cec5SDimitry Andric basic_filebuf<char_type, traits_type> __sb_; 14330b57cec5SDimitry Andric}; 14340b57cec5SDimitry Andric 14350b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14360b57cec5SDimitry Andricinline 14370b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::basic_ofstream() 14380b57cec5SDimitry Andric : basic_ostream<char_type, traits_type>(&__sb_) 14390b57cec5SDimitry Andric{ 14400b57cec5SDimitry Andric} 14410b57cec5SDimitry Andric 14420b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14430b57cec5SDimitry Andricinline 14440b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::basic_ofstream(const char* __s, ios_base::openmode __mode) 14450b57cec5SDimitry Andric : basic_ostream<char_type, traits_type>(&__sb_) 14460b57cec5SDimitry Andric{ 1447e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode | ios_base::out) == nullptr) 14480b57cec5SDimitry Andric this->setstate(ios_base::failbit); 14490b57cec5SDimitry Andric} 14500b57cec5SDimitry Andric 14510b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 14520b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14530b57cec5SDimitry Andricinline 14540b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::basic_ofstream(const wchar_t* __s, ios_base::openmode __mode) 14550b57cec5SDimitry Andric : basic_ostream<char_type, traits_type>(&__sb_) 14560b57cec5SDimitry Andric{ 1457e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode | ios_base::out) == nullptr) 14580b57cec5SDimitry Andric this->setstate(ios_base::failbit); 14590b57cec5SDimitry Andric} 14600b57cec5SDimitry Andric#endif 14610b57cec5SDimitry Andric 14620b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14630b57cec5SDimitry Andricinline 14640b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::openmode __mode) 14650b57cec5SDimitry Andric : basic_ostream<char_type, traits_type>(&__sb_) 14660b57cec5SDimitry Andric{ 1467e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode | ios_base::out) == nullptr) 14680b57cec5SDimitry Andric this->setstate(ios_base::failbit); 14690b57cec5SDimitry Andric} 14700b57cec5SDimitry Andric 14710b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14720b57cec5SDimitry Andricinline 14730b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::basic_ofstream(basic_ofstream&& __rhs) 1474*5f757f3fSDimitry Andric : basic_ostream<char_type, traits_type>(std::move(__rhs)), 1475*5f757f3fSDimitry Andric __sb_(std::move(__rhs.__sb_)) 14760b57cec5SDimitry Andric{ 14770b57cec5SDimitry Andric this->set_rdbuf(&__sb_); 14780b57cec5SDimitry Andric} 14790b57cec5SDimitry Andric 14800b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14810b57cec5SDimitry Andricinline 14820b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>& 14830b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs) 14840b57cec5SDimitry Andric{ 1485*5f757f3fSDimitry Andric basic_ostream<char_type, traits_type>::operator=(std::move(__rhs)); 1486*5f757f3fSDimitry Andric __sb_ = std::move(__rhs.__sb_); 14870b57cec5SDimitry Andric return *this; 14880b57cec5SDimitry Andric} 14890b57cec5SDimitry Andric 14900b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14910b57cec5SDimitry Andricinline 14920b57cec5SDimitry Andricvoid 14930b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::swap(basic_ofstream& __rhs) 14940b57cec5SDimitry Andric{ 14950b57cec5SDimitry Andric basic_ostream<char_type, traits_type>::swap(__rhs); 14960b57cec5SDimitry Andric __sb_.swap(__rhs.__sb_); 14970b57cec5SDimitry Andric} 14980b57cec5SDimitry Andric 14990b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 1500*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 15010b57cec5SDimitry Andricvoid 15020b57cec5SDimitry Andricswap(basic_ofstream<_CharT, _Traits>& __x, basic_ofstream<_CharT, _Traits>& __y) 15030b57cec5SDimitry Andric{ 15040b57cec5SDimitry Andric __x.swap(__y); 15050b57cec5SDimitry Andric} 15060b57cec5SDimitry Andric 15070b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 15080b57cec5SDimitry Andricinline 15090b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 15100b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::rdbuf() const 15110b57cec5SDimitry Andric{ 15120b57cec5SDimitry Andric return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_); 15130b57cec5SDimitry Andric} 15140b57cec5SDimitry Andric 15150b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 15160b57cec5SDimitry Andricinline 15170b57cec5SDimitry Andricbool 15180b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::is_open() const 15190b57cec5SDimitry Andric{ 15200b57cec5SDimitry Andric return __sb_.is_open(); 15210b57cec5SDimitry Andric} 15220b57cec5SDimitry Andric 15230b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 15240b57cec5SDimitry Andricvoid 15250b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) 15260b57cec5SDimitry Andric{ 15270b57cec5SDimitry Andric if (__sb_.open(__s, __mode | ios_base::out)) 15280b57cec5SDimitry Andric this->clear(); 15290b57cec5SDimitry Andric else 15300b57cec5SDimitry Andric this->setstate(ios_base::failbit); 15310b57cec5SDimitry Andric} 15320b57cec5SDimitry Andric 15330b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 15340b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 15350b57cec5SDimitry Andricvoid 15360b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) 15370b57cec5SDimitry Andric{ 15380b57cec5SDimitry Andric if (__sb_.open(__s, __mode | ios_base::out)) 15390b57cec5SDimitry Andric this->clear(); 15400b57cec5SDimitry Andric else 15410b57cec5SDimitry Andric this->setstate(ios_base::failbit); 15420b57cec5SDimitry Andric} 15430b57cec5SDimitry Andric#endif 15440b57cec5SDimitry Andric 15450b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 15460b57cec5SDimitry Andricvoid 15470b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) 15480b57cec5SDimitry Andric{ 15490b57cec5SDimitry Andric if (__sb_.open(__s, __mode | ios_base::out)) 15500b57cec5SDimitry Andric this->clear(); 15510b57cec5SDimitry Andric else 15520b57cec5SDimitry Andric this->setstate(ios_base::failbit); 15530b57cec5SDimitry Andric} 15540b57cec5SDimitry Andric 15550b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 1556d099db25SDimitry Andricinline 15570b57cec5SDimitry Andricvoid basic_ofstream<_CharT, _Traits>::__open(int __fd, 15580b57cec5SDimitry Andric ios_base::openmode __mode) { 15590b57cec5SDimitry Andric if (__sb_.__open(__fd, __mode | ios_base::out)) 15600b57cec5SDimitry Andric this->clear(); 15610b57cec5SDimitry Andric else 15620b57cec5SDimitry Andric this->setstate(ios_base::failbit); 15630b57cec5SDimitry Andric} 15640b57cec5SDimitry Andric 15650b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 15660b57cec5SDimitry Andricinline 15670b57cec5SDimitry Andricvoid 15680b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::close() 15690b57cec5SDimitry Andric{ 1570e8d8bef9SDimitry Andric if (__sb_.close() == nullptr) 15710b57cec5SDimitry Andric this->setstate(ios_base::failbit); 15720b57cec5SDimitry Andric} 15730b57cec5SDimitry Andric 15740b57cec5SDimitry Andric// basic_fstream 15750b57cec5SDimitry Andric 15760b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 15770b57cec5SDimitry Andricclass _LIBCPP_TEMPLATE_VIS basic_fstream 15780b57cec5SDimitry Andric : public basic_iostream<_CharT, _Traits> 15790b57cec5SDimitry Andric{ 15800b57cec5SDimitry Andricpublic: 15810b57cec5SDimitry Andric typedef _CharT char_type; 15820b57cec5SDimitry Andric typedef _Traits traits_type; 15830b57cec5SDimitry Andric typedef typename traits_type::int_type int_type; 15840b57cec5SDimitry Andric typedef typename traits_type::pos_type pos_type; 15850b57cec5SDimitry Andric typedef typename traits_type::off_type off_type; 15860b57cec5SDimitry Andric 1587*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 15880b57cec5SDimitry Andric basic_fstream(); 1589*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 15900b57cec5SDimitry Andric explicit basic_fstream(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 15910b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 1592*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 15930b57cec5SDimitry Andric explicit basic_fstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 15940b57cec5SDimitry Andric#endif 1595*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 15960b57cec5SDimitry Andric explicit basic_fstream(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 15970b57cec5SDimitry Andric 159806c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 17 1599*5f757f3fSDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_HIDE_FROM_ABI 16000b57cec5SDimitry Andric explicit basic_fstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in | ios_base::out) 16010b57cec5SDimitry Andric : basic_fstream(__p.c_str(), __mode) {} 16020b57cec5SDimitry Andric#endif // _LIBCPP_STD_VER >= 17 16030b57cec5SDimitry Andric 1604*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 16050b57cec5SDimitry Andric basic_fstream(basic_fstream&& __rhs); 16060b57cec5SDimitry Andric 1607*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 16080b57cec5SDimitry Andric basic_fstream& operator=(basic_fstream&& __rhs); 1609fe6060f1SDimitry Andric 1610*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 16110b57cec5SDimitry Andric void swap(basic_fstream& __rhs); 16120b57cec5SDimitry Andric 1613*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 16140b57cec5SDimitry Andric basic_filebuf<char_type, traits_type>* rdbuf() const; 1615*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 16160b57cec5SDimitry Andric bool is_open() const; 161706c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI void open(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 16180b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 16190b57cec5SDimitry Andric void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 16200b57cec5SDimitry Andric#endif 162106c3fb27SDimitry Andric _LIBCPP_HIDE_FROM_ABI void open(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 16220b57cec5SDimitry Andric 162306c3fb27SDimitry Andric#if _LIBCPP_STD_VER >= 17 1624*5f757f3fSDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_HIDE_FROM_ABI 16250b57cec5SDimitry Andric void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in|ios_base::out) 16260b57cec5SDimitry Andric { return open(__p.c_str(), __mode); } 16270b57cec5SDimitry Andric#endif // _LIBCPP_STD_VER >= 17 16280b57cec5SDimitry Andric 1629*5f757f3fSDimitry Andric _LIBCPP_HIDE_FROM_ABI 16300b57cec5SDimitry Andric void close(); 16310b57cec5SDimitry Andric 16320b57cec5SDimitry Andricprivate: 16330b57cec5SDimitry Andric basic_filebuf<char_type, traits_type> __sb_; 16340b57cec5SDimitry Andric}; 16350b57cec5SDimitry Andric 16360b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16370b57cec5SDimitry Andricinline 16380b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::basic_fstream() 16390b57cec5SDimitry Andric : basic_iostream<char_type, traits_type>(&__sb_) 16400b57cec5SDimitry Andric{ 16410b57cec5SDimitry Andric} 16420b57cec5SDimitry Andric 16430b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16440b57cec5SDimitry Andricinline 16450b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::basic_fstream(const char* __s, ios_base::openmode __mode) 16460b57cec5SDimitry Andric : basic_iostream<char_type, traits_type>(&__sb_) 16470b57cec5SDimitry Andric{ 1648e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode) == nullptr) 16490b57cec5SDimitry Andric this->setstate(ios_base::failbit); 16500b57cec5SDimitry Andric} 16510b57cec5SDimitry Andric 16520b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 16530b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16540b57cec5SDimitry Andricinline 16550b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::basic_fstream(const wchar_t* __s, ios_base::openmode __mode) 16560b57cec5SDimitry Andric : basic_iostream<char_type, traits_type>(&__sb_) 16570b57cec5SDimitry Andric{ 1658e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode) == nullptr) 16590b57cec5SDimitry Andric this->setstate(ios_base::failbit); 16600b57cec5SDimitry Andric} 16610b57cec5SDimitry Andric#endif 16620b57cec5SDimitry Andric 16630b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16640b57cec5SDimitry Andricinline 16650b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openmode __mode) 16660b57cec5SDimitry Andric : basic_iostream<char_type, traits_type>(&__sb_) 16670b57cec5SDimitry Andric{ 1668e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode) == nullptr) 16690b57cec5SDimitry Andric this->setstate(ios_base::failbit); 16700b57cec5SDimitry Andric} 16710b57cec5SDimitry Andric 16720b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16730b57cec5SDimitry Andricinline 16740b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::basic_fstream(basic_fstream&& __rhs) 1675*5f757f3fSDimitry Andric : basic_iostream<char_type, traits_type>(std::move(__rhs)), 1676*5f757f3fSDimitry Andric __sb_(std::move(__rhs.__sb_)) 16770b57cec5SDimitry Andric{ 16780b57cec5SDimitry Andric this->set_rdbuf(&__sb_); 16790b57cec5SDimitry Andric} 16800b57cec5SDimitry Andric 16810b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16820b57cec5SDimitry Andricinline 16830b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>& 16840b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs) 16850b57cec5SDimitry Andric{ 1686*5f757f3fSDimitry Andric basic_iostream<char_type, traits_type>::operator=(std::move(__rhs)); 1687*5f757f3fSDimitry Andric __sb_ = std::move(__rhs.__sb_); 16880b57cec5SDimitry Andric return *this; 16890b57cec5SDimitry Andric} 16900b57cec5SDimitry Andric 16910b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16920b57cec5SDimitry Andricinline 16930b57cec5SDimitry Andricvoid 16940b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::swap(basic_fstream& __rhs) 16950b57cec5SDimitry Andric{ 16960b57cec5SDimitry Andric basic_iostream<char_type, traits_type>::swap(__rhs); 16970b57cec5SDimitry Andric __sb_.swap(__rhs.__sb_); 16980b57cec5SDimitry Andric} 16990b57cec5SDimitry Andric 17000b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 1701*5f757f3fSDimitry Andricinline _LIBCPP_HIDE_FROM_ABI 17020b57cec5SDimitry Andricvoid 17030b57cec5SDimitry Andricswap(basic_fstream<_CharT, _Traits>& __x, basic_fstream<_CharT, _Traits>& __y) 17040b57cec5SDimitry Andric{ 17050b57cec5SDimitry Andric __x.swap(__y); 17060b57cec5SDimitry Andric} 17070b57cec5SDimitry Andric 17080b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 17090b57cec5SDimitry Andricinline 17100b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 17110b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::rdbuf() const 17120b57cec5SDimitry Andric{ 17130b57cec5SDimitry Andric return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_); 17140b57cec5SDimitry Andric} 17150b57cec5SDimitry Andric 17160b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 17170b57cec5SDimitry Andricinline 17180b57cec5SDimitry Andricbool 17190b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::is_open() const 17200b57cec5SDimitry Andric{ 17210b57cec5SDimitry Andric return __sb_.is_open(); 17220b57cec5SDimitry Andric} 17230b57cec5SDimitry Andric 17240b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 17250b57cec5SDimitry Andricvoid 17260b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) 17270b57cec5SDimitry Andric{ 17280b57cec5SDimitry Andric if (__sb_.open(__s, __mode)) 17290b57cec5SDimitry Andric this->clear(); 17300b57cec5SDimitry Andric else 17310b57cec5SDimitry Andric this->setstate(ios_base::failbit); 17320b57cec5SDimitry Andric} 17330b57cec5SDimitry Andric 17340b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 17350b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 17360b57cec5SDimitry Andricvoid 17370b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) 17380b57cec5SDimitry Andric{ 17390b57cec5SDimitry Andric if (__sb_.open(__s, __mode)) 17400b57cec5SDimitry Andric this->clear(); 17410b57cec5SDimitry Andric else 17420b57cec5SDimitry Andric this->setstate(ios_base::failbit); 17430b57cec5SDimitry Andric} 17440b57cec5SDimitry Andric#endif 17450b57cec5SDimitry Andric 17460b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 17470b57cec5SDimitry Andricvoid 17480b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) 17490b57cec5SDimitry Andric{ 17500b57cec5SDimitry Andric if (__sb_.open(__s, __mode)) 17510b57cec5SDimitry Andric this->clear(); 17520b57cec5SDimitry Andric else 17530b57cec5SDimitry Andric this->setstate(ios_base::failbit); 17540b57cec5SDimitry Andric} 17550b57cec5SDimitry Andric 17560b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 17570b57cec5SDimitry Andricinline 17580b57cec5SDimitry Andricvoid 17590b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::close() 17600b57cec5SDimitry Andric{ 1761e8d8bef9SDimitry Andric if (__sb_.close() == nullptr) 17620b57cec5SDimitry Andric this->setstate(ios_base::failbit); 17630b57cec5SDimitry Andric} 17640b57cec5SDimitry Andric 1765*5f757f3fSDimitry Andric#if _LIBCPP_AVAILABILITY_HAS_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1 176681ad6265SDimitry Andricextern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ifstream<char>; 176781ad6265SDimitry Andricextern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ofstream<char>; 176881ad6265SDimitry Andricextern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_filebuf<char>; 1769e8d8bef9SDimitry Andric#endif 1770e8d8bef9SDimitry Andric 17710b57cec5SDimitry Andric_LIBCPP_END_NAMESPACE_STD 17720b57cec5SDimitry Andric 177306c3fb27SDimitry Andric#endif // _LIBCPP_HAS_NO_FILESYSTEM 1774bdd1243dSDimitry Andric 17750b57cec5SDimitry Andric_LIBCPP_POP_MACROS 17760b57cec5SDimitry Andric 1777bdd1243dSDimitry Andric#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 1778bdd1243dSDimitry Andric# include <atomic> 1779bdd1243dSDimitry Andric# include <concepts> 178006c3fb27SDimitry Andric# include <cstdlib> 1781bdd1243dSDimitry Andric# include <iosfwd> 1782bdd1243dSDimitry Andric# include <limits> 1783*5f757f3fSDimitry Andric# include <mutex> 1784bdd1243dSDimitry Andric# include <new> 1785bdd1243dSDimitry Andric# include <stdexcept> 1786bdd1243dSDimitry Andric# include <type_traits> 1787bdd1243dSDimitry Andric#endif 1788bdd1243dSDimitry Andric 17890b57cec5SDimitry Andric#endif // _LIBCPP_FSTREAM 1790