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> 1860b57cec5SDimitry Andric#include <__locale> 18781ad6265SDimitry Andric#include <__utility/move.h> 18881ad6265SDimitry Andric#include <__utility/swap.h> 18981ad6265SDimitry Andric#include <__utility/unreachable.h> 1900b57cec5SDimitry Andric#include <cstdio> 1910b57cec5SDimitry Andric#include <cstdlib> 19281ad6265SDimitry Andric#include <cstring> 193fe6060f1SDimitry Andric#include <istream> 194fe6060f1SDimitry Andric#include <ostream> 195*bdd1243dSDimitry Andric#include <typeinfo> 19604eeddc0SDimitry Andric#include <version> 197e8d8bef9SDimitry Andric 198e8d8bef9SDimitry Andric#if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) 1990b57cec5SDimitry Andric# include <filesystem> 200e8d8bef9SDimitry Andric#endif 2010b57cec5SDimitry Andric 2020b57cec5SDimitry Andric#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 2030b57cec5SDimitry Andric# pragma GCC system_header 2040b57cec5SDimitry Andric#endif 2050b57cec5SDimitry Andric 2060b57cec5SDimitry Andric_LIBCPP_PUSH_MACROS 2070b57cec5SDimitry Andric#include <__undef_macros> 2080b57cec5SDimitry Andric 209fe6060f1SDimitry Andric#if defined(_LIBCPP_MSVCRT) || defined(_NEWLIB_VERSION) 210fe6060f1SDimitry Andric# define _LIBCPP_HAS_NO_OFF_T_FUNCTIONS 211fe6060f1SDimitry Andric#endif 2120b57cec5SDimitry Andric 213*bdd1243dSDimitry Andric#if !defined(_LIBCPP_HAS_NO_FSTREAM) 214*bdd1243dSDimitry Andric 2150b57cec5SDimitry Andric_LIBCPP_BEGIN_NAMESPACE_STD 2160b57cec5SDimitry Andric 2170b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 2180b57cec5SDimitry Andricclass _LIBCPP_TEMPLATE_VIS basic_filebuf 2190b57cec5SDimitry Andric : public basic_streambuf<_CharT, _Traits> 2200b57cec5SDimitry Andric{ 2210b57cec5SDimitry Andricpublic: 2220b57cec5SDimitry Andric typedef _CharT char_type; 2230b57cec5SDimitry Andric typedef _Traits traits_type; 2240b57cec5SDimitry Andric typedef typename traits_type::int_type int_type; 2250b57cec5SDimitry Andric typedef typename traits_type::pos_type pos_type; 2260b57cec5SDimitry Andric typedef typename traits_type::off_type off_type; 2270b57cec5SDimitry Andric typedef typename traits_type::state_type state_type; 2280b57cec5SDimitry Andric 2290b57cec5SDimitry Andric // 27.9.1.2 Constructors/destructor: 2300b57cec5SDimitry Andric basic_filebuf(); 2310b57cec5SDimitry Andric basic_filebuf(basic_filebuf&& __rhs); 232*bdd1243dSDimitry Andric ~basic_filebuf() override; 2330b57cec5SDimitry Andric 2340b57cec5SDimitry Andric // 27.9.1.3 Assign/swap: 2350b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 2360b57cec5SDimitry Andric basic_filebuf& operator=(basic_filebuf&& __rhs); 2370b57cec5SDimitry Andric void swap(basic_filebuf& __rhs); 2380b57cec5SDimitry Andric 2390b57cec5SDimitry Andric // 27.9.1.4 Members: 2400b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 2410b57cec5SDimitry Andric bool is_open() const; 2420b57cec5SDimitry Andric basic_filebuf* open(const char* __s, ios_base::openmode __mode); 2430b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 2440b57cec5SDimitry Andric basic_filebuf* open(const wchar_t* __s, ios_base::openmode __mode); 2450b57cec5SDimitry Andric#endif 2460b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 2470b57cec5SDimitry Andric basic_filebuf* open(const string& __s, ios_base::openmode __mode); 2480b57cec5SDimitry Andric 249e8d8bef9SDimitry Andric#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) 2500b57cec5SDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY 2510b57cec5SDimitry Andric basic_filebuf* open(const _VSTD_FS::path& __p, ios_base::openmode __mode) { 2520b57cec5SDimitry Andric return open(__p.c_str(), __mode); 2530b57cec5SDimitry Andric } 2540b57cec5SDimitry Andric#endif 255d099db25SDimitry Andric _LIBCPP_INLINE_VISIBILITY 2560b57cec5SDimitry Andric basic_filebuf* __open(int __fd, ios_base::openmode __mode); 2570b57cec5SDimitry Andric basic_filebuf* close(); 2580b57cec5SDimitry Andric 2590b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 2600b57cec5SDimitry Andric inline static const char* 2610b57cec5SDimitry Andric __make_mdstring(ios_base::openmode __mode) _NOEXCEPT; 2620b57cec5SDimitry Andric 2630b57cec5SDimitry Andric protected: 2640b57cec5SDimitry Andric // 27.9.1.5 Overridden virtual functions: 265*bdd1243dSDimitry Andric int_type underflow() override; 266*bdd1243dSDimitry Andric int_type pbackfail(int_type __c = traits_type::eof()) override; 267*bdd1243dSDimitry Andric int_type overflow (int_type __c = traits_type::eof()) override; 268*bdd1243dSDimitry Andric basic_streambuf<char_type, traits_type>* setbuf(char_type* __s, streamsize __n) override; 269*bdd1243dSDimitry Andric pos_type seekoff(off_type __off, ios_base::seekdir __way, 270*bdd1243dSDimitry Andric ios_base::openmode __wch = ios_base::in | ios_base::out) override; 271*bdd1243dSDimitry Andric pos_type seekpos(pos_type __sp, 272*bdd1243dSDimitry Andric ios_base::openmode __wch = ios_base::in | ios_base::out) override; 273*bdd1243dSDimitry Andric int sync() override; 274*bdd1243dSDimitry Andric void imbue(const locale& __loc) override; 2750b57cec5SDimitry Andric 2760b57cec5SDimitry Andricprivate: 2770b57cec5SDimitry Andric char* __extbuf_; 2780b57cec5SDimitry Andric const char* __extbufnext_; 2790b57cec5SDimitry Andric const char* __extbufend_; 2800b57cec5SDimitry Andric char __extbuf_min_[8]; 2810b57cec5SDimitry Andric size_t __ebs_; 2820b57cec5SDimitry Andric char_type* __intbuf_; 2830b57cec5SDimitry Andric size_t __ibs_; 2840b57cec5SDimitry Andric FILE* __file_; 2850b57cec5SDimitry Andric const codecvt<char_type, char, state_type>* __cv_; 2860b57cec5SDimitry Andric state_type __st_; 2870b57cec5SDimitry Andric state_type __st_last_; 2880b57cec5SDimitry Andric ios_base::openmode __om_; 2890b57cec5SDimitry Andric ios_base::openmode __cm_; 2900b57cec5SDimitry Andric bool __owns_eb_; 2910b57cec5SDimitry Andric bool __owns_ib_; 2920b57cec5SDimitry Andric bool __always_noconv_; 2930b57cec5SDimitry Andric 2940b57cec5SDimitry Andric bool __read_mode(); 2950b57cec5SDimitry Andric void __write_mode(); 2960b57cec5SDimitry Andric}; 2970b57cec5SDimitry Andric 2980b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 2990b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::basic_filebuf() 300e8d8bef9SDimitry Andric : __extbuf_(nullptr), 301e8d8bef9SDimitry Andric __extbufnext_(nullptr), 302e8d8bef9SDimitry Andric __extbufend_(nullptr), 3030b57cec5SDimitry Andric __ebs_(0), 304e8d8bef9SDimitry Andric __intbuf_(nullptr), 3050b57cec5SDimitry Andric __ibs_(0), 306e8d8bef9SDimitry Andric __file_(nullptr), 3070b57cec5SDimitry Andric __cv_(nullptr), 3080b57cec5SDimitry Andric __st_(), 3090b57cec5SDimitry Andric __st_last_(), 3100b57cec5SDimitry Andric __om_(0), 3110b57cec5SDimitry Andric __cm_(0), 3120b57cec5SDimitry Andric __owns_eb_(false), 3130b57cec5SDimitry Andric __owns_ib_(false), 3140b57cec5SDimitry Andric __always_noconv_(false) 3150b57cec5SDimitry Andric{ 316*bdd1243dSDimitry Andric if (std::has_facet<codecvt<char_type, char, state_type> >(this->getloc())) 3170b57cec5SDimitry Andric { 318*bdd1243dSDimitry Andric __cv_ = &std::use_facet<codecvt<char_type, char, state_type> >(this->getloc()); 3190b57cec5SDimitry Andric __always_noconv_ = __cv_->always_noconv(); 3200b57cec5SDimitry Andric } 321e8d8bef9SDimitry Andric setbuf(nullptr, 4096); 3220b57cec5SDimitry Andric} 3230b57cec5SDimitry Andric 3240b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 3250b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs) 3260b57cec5SDimitry Andric : basic_streambuf<_CharT, _Traits>(__rhs) 3270b57cec5SDimitry Andric{ 3280b57cec5SDimitry Andric if (__rhs.__extbuf_ == __rhs.__extbuf_min_) 3290b57cec5SDimitry Andric { 3300b57cec5SDimitry Andric __extbuf_ = __extbuf_min_; 3310b57cec5SDimitry Andric __extbufnext_ = __extbuf_ + (__rhs.__extbufnext_ - __rhs.__extbuf_); 3320b57cec5SDimitry Andric __extbufend_ = __extbuf_ + (__rhs.__extbufend_ - __rhs.__extbuf_); 3330b57cec5SDimitry Andric } 3340b57cec5SDimitry Andric else 3350b57cec5SDimitry Andric { 3360b57cec5SDimitry Andric __extbuf_ = __rhs.__extbuf_; 3370b57cec5SDimitry Andric __extbufnext_ = __rhs.__extbufnext_; 3380b57cec5SDimitry Andric __extbufend_ = __rhs.__extbufend_; 3390b57cec5SDimitry Andric } 3400b57cec5SDimitry Andric __ebs_ = __rhs.__ebs_; 3410b57cec5SDimitry Andric __intbuf_ = __rhs.__intbuf_; 3420b57cec5SDimitry Andric __ibs_ = __rhs.__ibs_; 3430b57cec5SDimitry Andric __file_ = __rhs.__file_; 3440b57cec5SDimitry Andric __cv_ = __rhs.__cv_; 3450b57cec5SDimitry Andric __st_ = __rhs.__st_; 3460b57cec5SDimitry Andric __st_last_ = __rhs.__st_last_; 3470b57cec5SDimitry Andric __om_ = __rhs.__om_; 3480b57cec5SDimitry Andric __cm_ = __rhs.__cm_; 3490b57cec5SDimitry Andric __owns_eb_ = __rhs.__owns_eb_; 3500b57cec5SDimitry Andric __owns_ib_ = __rhs.__owns_ib_; 3510b57cec5SDimitry Andric __always_noconv_ = __rhs.__always_noconv_; 3520b57cec5SDimitry Andric if (__rhs.pbase()) 3530b57cec5SDimitry Andric { 3540b57cec5SDimitry Andric if (__rhs.pbase() == __rhs.__intbuf_) 3550b57cec5SDimitry Andric this->setp(__intbuf_, __intbuf_ + (__rhs. epptr() - __rhs.pbase())); 3560b57cec5SDimitry Andric else 3570b57cec5SDimitry Andric this->setp((char_type*)__extbuf_, 3580b57cec5SDimitry Andric (char_type*)__extbuf_ + (__rhs. epptr() - __rhs.pbase())); 3590b57cec5SDimitry Andric this->__pbump(__rhs. pptr() - __rhs.pbase()); 3600b57cec5SDimitry Andric } 3610b57cec5SDimitry Andric else if (__rhs.eback()) 3620b57cec5SDimitry Andric { 3630b57cec5SDimitry Andric if (__rhs.eback() == __rhs.__intbuf_) 3640b57cec5SDimitry Andric this->setg(__intbuf_, __intbuf_ + (__rhs.gptr() - __rhs.eback()), 3650b57cec5SDimitry Andric __intbuf_ + (__rhs.egptr() - __rhs.eback())); 3660b57cec5SDimitry Andric else 3670b57cec5SDimitry Andric this->setg((char_type*)__extbuf_, 3680b57cec5SDimitry Andric (char_type*)__extbuf_ + (__rhs.gptr() - __rhs.eback()), 3690b57cec5SDimitry Andric (char_type*)__extbuf_ + (__rhs.egptr() - __rhs.eback())); 3700b57cec5SDimitry Andric } 371e8d8bef9SDimitry Andric __rhs.__extbuf_ = nullptr; 372e8d8bef9SDimitry Andric __rhs.__extbufnext_ = nullptr; 373e8d8bef9SDimitry Andric __rhs.__extbufend_ = nullptr; 3740b57cec5SDimitry Andric __rhs.__ebs_ = 0; 3750b57cec5SDimitry Andric __rhs.__intbuf_ = 0; 3760b57cec5SDimitry Andric __rhs.__ibs_ = 0; 377e8d8bef9SDimitry Andric __rhs.__file_ = nullptr; 3780b57cec5SDimitry Andric __rhs.__st_ = state_type(); 3790b57cec5SDimitry Andric __rhs.__st_last_ = state_type(); 3800b57cec5SDimitry Andric __rhs.__om_ = 0; 3810b57cec5SDimitry Andric __rhs.__cm_ = 0; 3820b57cec5SDimitry Andric __rhs.__owns_eb_ = false; 3830b57cec5SDimitry Andric __rhs.__owns_ib_ = false; 3840b57cec5SDimitry Andric __rhs.setg(0, 0, 0); 3850b57cec5SDimitry Andric __rhs.setp(0, 0); 3860b57cec5SDimitry Andric} 3870b57cec5SDimitry Andric 3880b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 3890b57cec5SDimitry Andricinline 3900b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>& 3910b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::operator=(basic_filebuf&& __rhs) 3920b57cec5SDimitry Andric{ 3930b57cec5SDimitry Andric close(); 3940b57cec5SDimitry Andric swap(__rhs); 3950b57cec5SDimitry Andric return *this; 3960b57cec5SDimitry Andric} 3970b57cec5SDimitry Andric 3980b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 3990b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::~basic_filebuf() 4000b57cec5SDimitry Andric{ 4010b57cec5SDimitry Andric#ifndef _LIBCPP_NO_EXCEPTIONS 4020b57cec5SDimitry Andric try 4030b57cec5SDimitry Andric { 4040b57cec5SDimitry Andric#endif // _LIBCPP_NO_EXCEPTIONS 4050b57cec5SDimitry Andric close(); 4060b57cec5SDimitry Andric#ifndef _LIBCPP_NO_EXCEPTIONS 4070b57cec5SDimitry Andric } 4080b57cec5SDimitry Andric catch (...) 4090b57cec5SDimitry Andric { 4100b57cec5SDimitry Andric } 4110b57cec5SDimitry Andric#endif // _LIBCPP_NO_EXCEPTIONS 4120b57cec5SDimitry Andric if (__owns_eb_) 4130b57cec5SDimitry Andric delete [] __extbuf_; 4140b57cec5SDimitry Andric if (__owns_ib_) 4150b57cec5SDimitry Andric delete [] __intbuf_; 4160b57cec5SDimitry Andric} 4170b57cec5SDimitry Andric 4180b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 4190b57cec5SDimitry Andricvoid 4200b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::swap(basic_filebuf& __rhs) 4210b57cec5SDimitry Andric{ 4220b57cec5SDimitry Andric basic_streambuf<char_type, traits_type>::swap(__rhs); 4230b57cec5SDimitry Andric if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_) 4240b57cec5SDimitry Andric { 42581ad6265SDimitry Andric // Neither *this nor __rhs uses the small buffer, so we can simply swap the pointers. 42681ad6265SDimitry Andric std::swap(__extbuf_, __rhs.__extbuf_); 42781ad6265SDimitry Andric std::swap(__extbufnext_, __rhs.__extbufnext_); 42881ad6265SDimitry Andric std::swap(__extbufend_, __rhs.__extbufend_); 4290b57cec5SDimitry Andric } 4300b57cec5SDimitry Andric else 4310b57cec5SDimitry Andric { 43281ad6265SDimitry Andric ptrdiff_t __ln = __extbufnext_ ? __extbufnext_ - __extbuf_ : 0; 43381ad6265SDimitry Andric ptrdiff_t __le = __extbufend_ ? __extbufend_ - __extbuf_ : 0; 43481ad6265SDimitry Andric ptrdiff_t __rn = __rhs.__extbufnext_ ? __rhs.__extbufnext_ - __rhs.__extbuf_ : 0; 43581ad6265SDimitry Andric ptrdiff_t __re = __rhs.__extbufend_ ? __rhs.__extbufend_ - __rhs.__extbuf_ : 0; 4360b57cec5SDimitry Andric if (__extbuf_ == __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_) 4370b57cec5SDimitry Andric { 43881ad6265SDimitry Andric // *this uses the small buffer, but __rhs doesn't. 4390b57cec5SDimitry Andric __extbuf_ = __rhs.__extbuf_; 4400b57cec5SDimitry Andric __rhs.__extbuf_ = __rhs.__extbuf_min_; 44181ad6265SDimitry Andric std::memmove(__rhs.__extbuf_min_, __extbuf_min_, sizeof(__extbuf_min_)); 4420b57cec5SDimitry Andric } 4430b57cec5SDimitry Andric else if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ == __rhs.__extbuf_min_) 4440b57cec5SDimitry Andric { 44581ad6265SDimitry Andric // *this doesn't use the small buffer, but __rhs does. 4460b57cec5SDimitry Andric __rhs.__extbuf_ = __extbuf_; 4470b57cec5SDimitry Andric __extbuf_ = __extbuf_min_; 44881ad6265SDimitry Andric std::memmove(__extbuf_min_, __rhs.__extbuf_min_, sizeof(__extbuf_min_)); 44981ad6265SDimitry Andric } 45081ad6265SDimitry Andric else 45181ad6265SDimitry Andric { 45281ad6265SDimitry Andric // Both *this and __rhs use the small buffer. 45381ad6265SDimitry Andric char __tmp[sizeof(__extbuf_min_)]; 45481ad6265SDimitry Andric std::memmove(__tmp, __extbuf_min_, sizeof(__extbuf_min_)); 45581ad6265SDimitry Andric std::memmove(__extbuf_min_, __rhs.__extbuf_min_, sizeof(__extbuf_min_)); 45681ad6265SDimitry Andric std::memmove(__rhs.__extbuf_min_, __tmp, sizeof(__extbuf_min_)); 4570b57cec5SDimitry Andric } 4580b57cec5SDimitry Andric __extbufnext_ = __extbuf_ + __rn; 4590b57cec5SDimitry Andric __extbufend_ = __extbuf_ + __re; 4600b57cec5SDimitry Andric __rhs.__extbufnext_ = __rhs.__extbuf_ + __ln; 4610b57cec5SDimitry Andric __rhs.__extbufend_ = __rhs.__extbuf_ + __le; 4620b57cec5SDimitry Andric } 4630b57cec5SDimitry Andric _VSTD::swap(__ebs_, __rhs.__ebs_); 4640b57cec5SDimitry Andric _VSTD::swap(__intbuf_, __rhs.__intbuf_); 4650b57cec5SDimitry Andric _VSTD::swap(__ibs_, __rhs.__ibs_); 4660b57cec5SDimitry Andric _VSTD::swap(__file_, __rhs.__file_); 4670b57cec5SDimitry Andric _VSTD::swap(__cv_, __rhs.__cv_); 4680b57cec5SDimitry Andric _VSTD::swap(__st_, __rhs.__st_); 4690b57cec5SDimitry Andric _VSTD::swap(__st_last_, __rhs.__st_last_); 4700b57cec5SDimitry Andric _VSTD::swap(__om_, __rhs.__om_); 4710b57cec5SDimitry Andric _VSTD::swap(__cm_, __rhs.__cm_); 4720b57cec5SDimitry Andric _VSTD::swap(__owns_eb_, __rhs.__owns_eb_); 4730b57cec5SDimitry Andric _VSTD::swap(__owns_ib_, __rhs.__owns_ib_); 4740b57cec5SDimitry Andric _VSTD::swap(__always_noconv_, __rhs.__always_noconv_); 4750b57cec5SDimitry Andric if (this->eback() == (char_type*)__rhs.__extbuf_min_) 4760b57cec5SDimitry Andric { 4770b57cec5SDimitry Andric ptrdiff_t __n = this->gptr() - this->eback(); 4780b57cec5SDimitry Andric ptrdiff_t __e = this->egptr() - this->eback(); 4790b57cec5SDimitry Andric this->setg((char_type*)__extbuf_min_, 4800b57cec5SDimitry Andric (char_type*)__extbuf_min_ + __n, 4810b57cec5SDimitry Andric (char_type*)__extbuf_min_ + __e); 4820b57cec5SDimitry Andric } 4830b57cec5SDimitry Andric else if (this->pbase() == (char_type*)__rhs.__extbuf_min_) 4840b57cec5SDimitry Andric { 4850b57cec5SDimitry Andric ptrdiff_t __n = this->pptr() - this->pbase(); 4860b57cec5SDimitry Andric ptrdiff_t __e = this->epptr() - this->pbase(); 4870b57cec5SDimitry Andric this->setp((char_type*)__extbuf_min_, 4880b57cec5SDimitry Andric (char_type*)__extbuf_min_ + __e); 4890b57cec5SDimitry Andric this->__pbump(__n); 4900b57cec5SDimitry Andric } 4910b57cec5SDimitry Andric if (__rhs.eback() == (char_type*)__extbuf_min_) 4920b57cec5SDimitry Andric { 4930b57cec5SDimitry Andric ptrdiff_t __n = __rhs.gptr() - __rhs.eback(); 4940b57cec5SDimitry Andric ptrdiff_t __e = __rhs.egptr() - __rhs.eback(); 4950b57cec5SDimitry Andric __rhs.setg((char_type*)__rhs.__extbuf_min_, 4960b57cec5SDimitry Andric (char_type*)__rhs.__extbuf_min_ + __n, 4970b57cec5SDimitry Andric (char_type*)__rhs.__extbuf_min_ + __e); 4980b57cec5SDimitry Andric } 4990b57cec5SDimitry Andric else if (__rhs.pbase() == (char_type*)__extbuf_min_) 5000b57cec5SDimitry Andric { 5010b57cec5SDimitry Andric ptrdiff_t __n = __rhs.pptr() - __rhs.pbase(); 5020b57cec5SDimitry Andric ptrdiff_t __e = __rhs.epptr() - __rhs.pbase(); 5030b57cec5SDimitry Andric __rhs.setp((char_type*)__rhs.__extbuf_min_, 5040b57cec5SDimitry Andric (char_type*)__rhs.__extbuf_min_ + __e); 5050b57cec5SDimitry Andric __rhs.__pbump(__n); 5060b57cec5SDimitry Andric } 5070b57cec5SDimitry Andric} 5080b57cec5SDimitry Andric 5090b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 5100b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 5110b57cec5SDimitry Andricvoid 5120b57cec5SDimitry Andricswap(basic_filebuf<_CharT, _Traits>& __x, basic_filebuf<_CharT, _Traits>& __y) 5130b57cec5SDimitry Andric{ 5140b57cec5SDimitry Andric __x.swap(__y); 5150b57cec5SDimitry Andric} 5160b57cec5SDimitry Andric 5170b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 5180b57cec5SDimitry Andricinline 5190b57cec5SDimitry Andricbool 5200b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::is_open() const 5210b57cec5SDimitry Andric{ 522e8d8bef9SDimitry Andric return __file_ != nullptr; 5230b57cec5SDimitry Andric} 5240b57cec5SDimitry Andric 5250b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 5260b57cec5SDimitry Andricconst char* basic_filebuf<_CharT, _Traits>::__make_mdstring( 5270b57cec5SDimitry Andric ios_base::openmode __mode) _NOEXCEPT { 5280b57cec5SDimitry Andric switch (__mode & ~ios_base::ate) { 5290b57cec5SDimitry Andric case ios_base::out: 5300b57cec5SDimitry Andric case ios_base::out | ios_base::trunc: 531e40139ffSDimitry Andric return "w" _LIBCPP_FOPEN_CLOEXEC_MODE; 5320b57cec5SDimitry Andric case ios_base::out | ios_base::app: 5330b57cec5SDimitry Andric case ios_base::app: 534e40139ffSDimitry Andric return "a" _LIBCPP_FOPEN_CLOEXEC_MODE; 5350b57cec5SDimitry Andric case ios_base::in: 536e40139ffSDimitry Andric return "r" _LIBCPP_FOPEN_CLOEXEC_MODE; 5370b57cec5SDimitry Andric case ios_base::in | ios_base::out: 538e40139ffSDimitry Andric return "r+" _LIBCPP_FOPEN_CLOEXEC_MODE; 5390b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::trunc: 540e40139ffSDimitry Andric return "w+" _LIBCPP_FOPEN_CLOEXEC_MODE; 5410b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::app: 5420b57cec5SDimitry Andric case ios_base::in | ios_base::app: 543e40139ffSDimitry Andric return "a+" _LIBCPP_FOPEN_CLOEXEC_MODE; 5440b57cec5SDimitry Andric case ios_base::out | ios_base::binary: 5450b57cec5SDimitry Andric case ios_base::out | ios_base::trunc | ios_base::binary: 546e40139ffSDimitry Andric return "wb" _LIBCPP_FOPEN_CLOEXEC_MODE; 5470b57cec5SDimitry Andric case ios_base::out | ios_base::app | ios_base::binary: 5480b57cec5SDimitry Andric case ios_base::app | ios_base::binary: 549e40139ffSDimitry Andric return "ab" _LIBCPP_FOPEN_CLOEXEC_MODE; 5500b57cec5SDimitry Andric case ios_base::in | ios_base::binary: 551e40139ffSDimitry Andric return "rb" _LIBCPP_FOPEN_CLOEXEC_MODE; 5520b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::binary: 553e40139ffSDimitry Andric return "r+b" _LIBCPP_FOPEN_CLOEXEC_MODE; 5540b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary: 555e40139ffSDimitry Andric return "w+b" _LIBCPP_FOPEN_CLOEXEC_MODE; 5560b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::app | ios_base::binary: 5570b57cec5SDimitry Andric case ios_base::in | ios_base::app | ios_base::binary: 558e40139ffSDimitry Andric return "a+b" _LIBCPP_FOPEN_CLOEXEC_MODE; 5590b57cec5SDimitry Andric default: 5600b57cec5SDimitry Andric return nullptr; 5610b57cec5SDimitry Andric } 56281ad6265SDimitry Andric __libcpp_unreachable(); 5630b57cec5SDimitry Andric} 5640b57cec5SDimitry Andric 5650b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 5660b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 5670b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) 5680b57cec5SDimitry Andric{ 569e8d8bef9SDimitry Andric basic_filebuf<_CharT, _Traits>* __rt = nullptr; 570e8d8bef9SDimitry Andric if (__file_ == nullptr) 5710b57cec5SDimitry Andric { 5720b57cec5SDimitry Andric if (const char* __mdstr = __make_mdstring(__mode)) { 5730b57cec5SDimitry Andric __rt = this; 5740b57cec5SDimitry Andric __file_ = fopen(__s, __mdstr); 5750b57cec5SDimitry Andric if (__file_) { 5760b57cec5SDimitry Andric __om_ = __mode; 5770b57cec5SDimitry Andric if (__mode & ios_base::ate) { 5780b57cec5SDimitry Andric if (fseek(__file_, 0, SEEK_END)) { 5790b57cec5SDimitry Andric fclose(__file_); 580e8d8bef9SDimitry Andric __file_ = nullptr; 581e8d8bef9SDimitry Andric __rt = nullptr; 5820b57cec5SDimitry Andric } 5830b57cec5SDimitry Andric } 5840b57cec5SDimitry Andric } else 585e8d8bef9SDimitry Andric __rt = nullptr; 5860b57cec5SDimitry Andric } 5870b57cec5SDimitry Andric } 5880b57cec5SDimitry Andric return __rt; 5890b57cec5SDimitry Andric} 5900b57cec5SDimitry Andric 5910b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 592d099db25SDimitry Andricinline 593e8d8bef9SDimitry Andricbasic_filebuf<_CharT, _Traits>* 5940b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::__open(int __fd, ios_base::openmode __mode) { 595e8d8bef9SDimitry Andric basic_filebuf<_CharT, _Traits>* __rt = nullptr; 596e8d8bef9SDimitry Andric if (__file_ == nullptr) { 5970b57cec5SDimitry Andric if (const char* __mdstr = __make_mdstring(__mode)) { 5980b57cec5SDimitry Andric __rt = this; 5990b57cec5SDimitry Andric __file_ = fdopen(__fd, __mdstr); 6000b57cec5SDimitry Andric if (__file_) { 6010b57cec5SDimitry Andric __om_ = __mode; 6020b57cec5SDimitry Andric if (__mode & ios_base::ate) { 6030b57cec5SDimitry Andric if (fseek(__file_, 0, SEEK_END)) { 6040b57cec5SDimitry Andric fclose(__file_); 605e8d8bef9SDimitry Andric __file_ = nullptr; 606e8d8bef9SDimitry Andric __rt = nullptr; 6070b57cec5SDimitry Andric } 6080b57cec5SDimitry Andric } 6090b57cec5SDimitry Andric } else 610e8d8bef9SDimitry Andric __rt = nullptr; 6110b57cec5SDimitry Andric } 6120b57cec5SDimitry Andric } 6130b57cec5SDimitry Andric return __rt; 6140b57cec5SDimitry Andric} 6150b57cec5SDimitry Andric 6160b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 6170b57cec5SDimitry Andric// This is basically the same as the char* overload except that it uses _wfopen 6180b57cec5SDimitry Andric// and long mode strings. 6190b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 6200b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 6210b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) 6220b57cec5SDimitry Andric{ 623e8d8bef9SDimitry Andric basic_filebuf<_CharT, _Traits>* __rt = nullptr; 624e8d8bef9SDimitry Andric if (__file_ == nullptr) 6250b57cec5SDimitry Andric { 6260b57cec5SDimitry Andric __rt = this; 6270b57cec5SDimitry Andric const wchar_t* __mdstr; 6280b57cec5SDimitry Andric switch (__mode & ~ios_base::ate) 6290b57cec5SDimitry Andric { 6300b57cec5SDimitry Andric case ios_base::out: 6310b57cec5SDimitry Andric case ios_base::out | ios_base::trunc: 6320b57cec5SDimitry Andric __mdstr = L"w"; 6330b57cec5SDimitry Andric break; 6340b57cec5SDimitry Andric case ios_base::out | ios_base::app: 6350b57cec5SDimitry Andric case ios_base::app: 6360b57cec5SDimitry Andric __mdstr = L"a"; 6370b57cec5SDimitry Andric break; 6380b57cec5SDimitry Andric case ios_base::in: 6390b57cec5SDimitry Andric __mdstr = L"r"; 6400b57cec5SDimitry Andric break; 6410b57cec5SDimitry Andric case ios_base::in | ios_base::out: 6420b57cec5SDimitry Andric __mdstr = L"r+"; 6430b57cec5SDimitry Andric break; 6440b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::trunc: 6450b57cec5SDimitry Andric __mdstr = L"w+"; 6460b57cec5SDimitry Andric break; 6470b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::app: 6480b57cec5SDimitry Andric case ios_base::in | ios_base::app: 6490b57cec5SDimitry Andric __mdstr = L"a+"; 6500b57cec5SDimitry Andric break; 6510b57cec5SDimitry Andric case ios_base::out | ios_base::binary: 6520b57cec5SDimitry Andric case ios_base::out | ios_base::trunc | ios_base::binary: 6530b57cec5SDimitry Andric __mdstr = L"wb"; 6540b57cec5SDimitry Andric break; 6550b57cec5SDimitry Andric case ios_base::out | ios_base::app | ios_base::binary: 6560b57cec5SDimitry Andric case ios_base::app | ios_base::binary: 6570b57cec5SDimitry Andric __mdstr = L"ab"; 6580b57cec5SDimitry Andric break; 6590b57cec5SDimitry Andric case ios_base::in | ios_base::binary: 6600b57cec5SDimitry Andric __mdstr = L"rb"; 6610b57cec5SDimitry Andric break; 6620b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::binary: 6630b57cec5SDimitry Andric __mdstr = L"r+b"; 6640b57cec5SDimitry Andric break; 6650b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary: 6660b57cec5SDimitry Andric __mdstr = L"w+b"; 6670b57cec5SDimitry Andric break; 6680b57cec5SDimitry Andric case ios_base::in | ios_base::out | ios_base::app | ios_base::binary: 6690b57cec5SDimitry Andric case ios_base::in | ios_base::app | ios_base::binary: 6700b57cec5SDimitry Andric __mdstr = L"a+b"; 6710b57cec5SDimitry Andric break; 6720b57cec5SDimitry Andric default: 673e8d8bef9SDimitry Andric __rt = nullptr; 6740b57cec5SDimitry Andric break; 6750b57cec5SDimitry Andric } 6760b57cec5SDimitry Andric if (__rt) 6770b57cec5SDimitry Andric { 6780b57cec5SDimitry Andric __file_ = _wfopen(__s, __mdstr); 6790b57cec5SDimitry Andric if (__file_) 6800b57cec5SDimitry Andric { 6810b57cec5SDimitry Andric __om_ = __mode; 6820b57cec5SDimitry Andric if (__mode & ios_base::ate) 6830b57cec5SDimitry Andric { 6840b57cec5SDimitry Andric if (fseek(__file_, 0, SEEK_END)) 6850b57cec5SDimitry Andric { 6860b57cec5SDimitry Andric fclose(__file_); 687e8d8bef9SDimitry Andric __file_ = nullptr; 688e8d8bef9SDimitry Andric __rt = nullptr; 6890b57cec5SDimitry Andric } 6900b57cec5SDimitry Andric } 6910b57cec5SDimitry Andric } 6920b57cec5SDimitry Andric else 693e8d8bef9SDimitry Andric __rt = nullptr; 6940b57cec5SDimitry Andric } 6950b57cec5SDimitry Andric } 6960b57cec5SDimitry Andric return __rt; 6970b57cec5SDimitry Andric} 6980b57cec5SDimitry Andric#endif 6990b57cec5SDimitry Andric 7000b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 7010b57cec5SDimitry Andricinline 7020b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 7030b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) 7040b57cec5SDimitry Andric{ 7050b57cec5SDimitry Andric return open(__s.c_str(), __mode); 7060b57cec5SDimitry Andric} 7070b57cec5SDimitry Andric 7080b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 7090b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 7100b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::close() 7110b57cec5SDimitry Andric{ 712e8d8bef9SDimitry Andric basic_filebuf<_CharT, _Traits>* __rt = nullptr; 7130b57cec5SDimitry Andric if (__file_) 7140b57cec5SDimitry Andric { 7150b57cec5SDimitry Andric __rt = this; 7160b57cec5SDimitry Andric unique_ptr<FILE, int(*)(FILE*)> __h(__file_, fclose); 7170b57cec5SDimitry Andric if (sync()) 718e8d8bef9SDimitry Andric __rt = nullptr; 719e40139ffSDimitry Andric if (fclose(__h.release())) 720e8d8bef9SDimitry Andric __rt = nullptr; 721e8d8bef9SDimitry Andric __file_ = nullptr; 7220b57cec5SDimitry Andric setbuf(0, 0); 7230b57cec5SDimitry Andric } 7240b57cec5SDimitry Andric return __rt; 7250b57cec5SDimitry Andric} 7260b57cec5SDimitry Andric 7270b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 7280b57cec5SDimitry Andrictypename basic_filebuf<_CharT, _Traits>::int_type 7290b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::underflow() 7300b57cec5SDimitry Andric{ 731e8d8bef9SDimitry Andric if (__file_ == nullptr) 7320b57cec5SDimitry Andric return traits_type::eof(); 7330b57cec5SDimitry Andric bool __initial = __read_mode(); 7340b57cec5SDimitry Andric char_type __1buf; 735e8d8bef9SDimitry Andric if (this->gptr() == nullptr) 7360b57cec5SDimitry Andric this->setg(&__1buf, &__1buf+1, &__1buf+1); 737*bdd1243dSDimitry Andric const size_t __unget_sz = __initial ? 0 : std::min<size_t>((this->egptr() - this->eback()) / 2, 4); 7380b57cec5SDimitry Andric int_type __c = traits_type::eof(); 7390b57cec5SDimitry Andric if (this->gptr() == this->egptr()) 7400b57cec5SDimitry Andric { 741e8d8bef9SDimitry Andric _VSTD::memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz * sizeof(char_type)); 7420b57cec5SDimitry Andric if (__always_noconv_) 7430b57cec5SDimitry Andric { 7440b57cec5SDimitry Andric size_t __nmemb = static_cast<size_t>(this->egptr() - this->eback() - __unget_sz); 745*bdd1243dSDimitry Andric __nmemb = ::fread(this->eback() + __unget_sz, 1, __nmemb, __file_); 7460b57cec5SDimitry Andric if (__nmemb != 0) 7470b57cec5SDimitry Andric { 7480b57cec5SDimitry Andric this->setg(this->eback(), 7490b57cec5SDimitry Andric this->eback() + __unget_sz, 7500b57cec5SDimitry Andric this->eback() + __unget_sz + __nmemb); 7510b57cec5SDimitry Andric __c = traits_type::to_int_type(*this->gptr()); 7520b57cec5SDimitry Andric } 7530b57cec5SDimitry Andric } 7540b57cec5SDimitry Andric else 7550b57cec5SDimitry Andric { 756*bdd1243dSDimitry Andric if (__extbufend_ != __extbufnext_) { 757*bdd1243dSDimitry Andric _LIBCPP_ASSERT(__extbufnext_ != nullptr, "underflow moving from nullptr"); 758*bdd1243dSDimitry Andric _LIBCPP_ASSERT(__extbuf_ != nullptr, "underflow moving into nullptr"); 759e8d8bef9SDimitry Andric _VSTD::memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_); 760*bdd1243dSDimitry Andric } 7610b57cec5SDimitry Andric __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_); 7620b57cec5SDimitry Andric __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_); 7630b57cec5SDimitry Andric size_t __nmemb = _VSTD::min(static_cast<size_t>(__ibs_ - __unget_sz), 7640b57cec5SDimitry Andric static_cast<size_t>(__extbufend_ - __extbufnext_)); 7650b57cec5SDimitry Andric codecvt_base::result __r; 7660b57cec5SDimitry Andric __st_last_ = __st_; 7670b57cec5SDimitry Andric size_t __nr = fread((void*) const_cast<char *>(__extbufnext_), 1, __nmemb, __file_); 7680b57cec5SDimitry Andric if (__nr != 0) 7690b57cec5SDimitry Andric { 7700b57cec5SDimitry Andric if (!__cv_) 7710b57cec5SDimitry Andric __throw_bad_cast(); 7720b57cec5SDimitry Andric 7730b57cec5SDimitry Andric __extbufend_ = __extbufnext_ + __nr; 7740b57cec5SDimitry Andric char_type* __inext; 7750b57cec5SDimitry Andric __r = __cv_->in(__st_, __extbuf_, __extbufend_, __extbufnext_, 7760b57cec5SDimitry Andric this->eback() + __unget_sz, 7770b57cec5SDimitry Andric this->eback() + __ibs_, __inext); 7780b57cec5SDimitry Andric if (__r == codecvt_base::noconv) 7790b57cec5SDimitry Andric { 7800b57cec5SDimitry Andric this->setg((char_type*)__extbuf_, (char_type*)__extbuf_, 7810b57cec5SDimitry Andric (char_type*)const_cast<char *>(__extbufend_)); 7820b57cec5SDimitry Andric __c = traits_type::to_int_type(*this->gptr()); 7830b57cec5SDimitry Andric } 7840b57cec5SDimitry Andric else if (__inext != this->eback() + __unget_sz) 7850b57cec5SDimitry Andric { 7860b57cec5SDimitry Andric this->setg(this->eback(), this->eback() + __unget_sz, __inext); 7870b57cec5SDimitry Andric __c = traits_type::to_int_type(*this->gptr()); 7880b57cec5SDimitry Andric } 7890b57cec5SDimitry Andric } 7900b57cec5SDimitry Andric } 7910b57cec5SDimitry Andric } 7920b57cec5SDimitry Andric else 7930b57cec5SDimitry Andric __c = traits_type::to_int_type(*this->gptr()); 7940b57cec5SDimitry Andric if (this->eback() == &__1buf) 795e8d8bef9SDimitry Andric this->setg(nullptr, nullptr, nullptr); 7960b57cec5SDimitry Andric return __c; 7970b57cec5SDimitry Andric} 7980b57cec5SDimitry Andric 7990b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 8000b57cec5SDimitry Andrictypename basic_filebuf<_CharT, _Traits>::int_type 8010b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::pbackfail(int_type __c) 8020b57cec5SDimitry Andric{ 8030b57cec5SDimitry Andric if (__file_ && this->eback() < this->gptr()) 8040b57cec5SDimitry Andric { 8050b57cec5SDimitry Andric if (traits_type::eq_int_type(__c, traits_type::eof())) 8060b57cec5SDimitry Andric { 8070b57cec5SDimitry Andric this->gbump(-1); 8080b57cec5SDimitry Andric return traits_type::not_eof(__c); 8090b57cec5SDimitry Andric } 8100b57cec5SDimitry Andric if ((__om_ & ios_base::out) || 8110b57cec5SDimitry Andric traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1])) 8120b57cec5SDimitry Andric { 8130b57cec5SDimitry Andric this->gbump(-1); 8140b57cec5SDimitry Andric *this->gptr() = traits_type::to_char_type(__c); 8150b57cec5SDimitry Andric return __c; 8160b57cec5SDimitry Andric } 8170b57cec5SDimitry Andric } 8180b57cec5SDimitry Andric return traits_type::eof(); 8190b57cec5SDimitry Andric} 8200b57cec5SDimitry Andric 8210b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 8220b57cec5SDimitry Andrictypename basic_filebuf<_CharT, _Traits>::int_type 8230b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::overflow(int_type __c) 8240b57cec5SDimitry Andric{ 825e8d8bef9SDimitry Andric if (__file_ == nullptr) 8260b57cec5SDimitry Andric return traits_type::eof(); 8270b57cec5SDimitry Andric __write_mode(); 8280b57cec5SDimitry Andric char_type __1buf; 8290b57cec5SDimitry Andric char_type* __pb_save = this->pbase(); 8300b57cec5SDimitry Andric char_type* __epb_save = this->epptr(); 8310b57cec5SDimitry Andric if (!traits_type::eq_int_type(__c, traits_type::eof())) 8320b57cec5SDimitry Andric { 833e8d8bef9SDimitry Andric if (this->pptr() == nullptr) 8340b57cec5SDimitry Andric this->setp(&__1buf, &__1buf+1); 8350b57cec5SDimitry Andric *this->pptr() = traits_type::to_char_type(__c); 8360b57cec5SDimitry Andric this->pbump(1); 8370b57cec5SDimitry Andric } 8380b57cec5SDimitry Andric if (this->pptr() != this->pbase()) 8390b57cec5SDimitry Andric { 8400b57cec5SDimitry Andric if (__always_noconv_) 8410b57cec5SDimitry Andric { 8420b57cec5SDimitry Andric size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase()); 843*bdd1243dSDimitry Andric if (std::fwrite(this->pbase(), sizeof(char_type), __nmemb, __file_) != __nmemb) 8440b57cec5SDimitry Andric return traits_type::eof(); 8450b57cec5SDimitry Andric } 8460b57cec5SDimitry Andric else 8470b57cec5SDimitry Andric { 8480b57cec5SDimitry Andric char* __extbe = __extbuf_; 8490b57cec5SDimitry Andric codecvt_base::result __r; 8500b57cec5SDimitry Andric do 8510b57cec5SDimitry Andric { 8520b57cec5SDimitry Andric if (!__cv_) 8530b57cec5SDimitry Andric __throw_bad_cast(); 8540b57cec5SDimitry Andric 8550b57cec5SDimitry Andric const char_type* __e; 8560b57cec5SDimitry Andric __r = __cv_->out(__st_, this->pbase(), this->pptr(), __e, 8570b57cec5SDimitry Andric __extbuf_, __extbuf_ + __ebs_, __extbe); 8580b57cec5SDimitry Andric if (__e == this->pbase()) 8590b57cec5SDimitry Andric return traits_type::eof(); 8600b57cec5SDimitry Andric if (__r == codecvt_base::noconv) 8610b57cec5SDimitry Andric { 8620b57cec5SDimitry Andric size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase()); 863*bdd1243dSDimitry Andric if (std::fwrite(this->pbase(), 1, __nmemb, __file_) != __nmemb) 8640b57cec5SDimitry Andric return traits_type::eof(); 8650b57cec5SDimitry Andric } 8660b57cec5SDimitry Andric else if (__r == codecvt_base::ok || __r == codecvt_base::partial) 8670b57cec5SDimitry Andric { 8680b57cec5SDimitry Andric size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_); 8690b57cec5SDimitry Andric if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb) 8700b57cec5SDimitry Andric return traits_type::eof(); 8710b57cec5SDimitry Andric if (__r == codecvt_base::partial) 8720b57cec5SDimitry Andric { 8730b57cec5SDimitry Andric this->setp(const_cast<char_type*>(__e), this->pptr()); 8740b57cec5SDimitry Andric this->__pbump(this->epptr() - this->pbase()); 8750b57cec5SDimitry Andric } 8760b57cec5SDimitry Andric } 8770b57cec5SDimitry Andric else 8780b57cec5SDimitry Andric return traits_type::eof(); 8790b57cec5SDimitry Andric } while (__r == codecvt_base::partial); 8800b57cec5SDimitry Andric } 8810b57cec5SDimitry Andric this->setp(__pb_save, __epb_save); 8820b57cec5SDimitry Andric } 8830b57cec5SDimitry Andric return traits_type::not_eof(__c); 8840b57cec5SDimitry Andric} 8850b57cec5SDimitry Andric 8860b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 8870b57cec5SDimitry Andricbasic_streambuf<_CharT, _Traits>* 8880b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::setbuf(char_type* __s, streamsize __n) 8890b57cec5SDimitry Andric{ 890e8d8bef9SDimitry Andric this->setg(nullptr, nullptr, nullptr); 891e8d8bef9SDimitry Andric this->setp(nullptr, nullptr); 8920b57cec5SDimitry Andric if (__owns_eb_) 8930b57cec5SDimitry Andric delete [] __extbuf_; 8940b57cec5SDimitry Andric if (__owns_ib_) 8950b57cec5SDimitry Andric delete [] __intbuf_; 8960b57cec5SDimitry Andric __ebs_ = __n; 8970b57cec5SDimitry Andric if (__ebs_ > sizeof(__extbuf_min_)) 8980b57cec5SDimitry Andric { 8990b57cec5SDimitry Andric if (__always_noconv_ && __s) 9000b57cec5SDimitry Andric { 9010b57cec5SDimitry Andric __extbuf_ = (char*)__s; 9020b57cec5SDimitry Andric __owns_eb_ = false; 9030b57cec5SDimitry Andric } 9040b57cec5SDimitry Andric else 9050b57cec5SDimitry Andric { 9060b57cec5SDimitry Andric __extbuf_ = new char[__ebs_]; 9070b57cec5SDimitry Andric __owns_eb_ = true; 9080b57cec5SDimitry Andric } 9090b57cec5SDimitry Andric } 9100b57cec5SDimitry Andric else 9110b57cec5SDimitry Andric { 9120b57cec5SDimitry Andric __extbuf_ = __extbuf_min_; 9130b57cec5SDimitry Andric __ebs_ = sizeof(__extbuf_min_); 9140b57cec5SDimitry Andric __owns_eb_ = false; 9150b57cec5SDimitry Andric } 9160b57cec5SDimitry Andric if (!__always_noconv_) 9170b57cec5SDimitry Andric { 9180b57cec5SDimitry Andric __ibs_ = max<streamsize>(__n, sizeof(__extbuf_min_)); 9190b57cec5SDimitry Andric if (__s && __ibs_ >= sizeof(__extbuf_min_)) 9200b57cec5SDimitry Andric { 9210b57cec5SDimitry Andric __intbuf_ = __s; 9220b57cec5SDimitry Andric __owns_ib_ = false; 9230b57cec5SDimitry Andric } 9240b57cec5SDimitry Andric else 9250b57cec5SDimitry Andric { 9260b57cec5SDimitry Andric __intbuf_ = new char_type[__ibs_]; 9270b57cec5SDimitry Andric __owns_ib_ = true; 9280b57cec5SDimitry Andric } 9290b57cec5SDimitry Andric } 9300b57cec5SDimitry Andric else 9310b57cec5SDimitry Andric { 9320b57cec5SDimitry Andric __ibs_ = 0; 933e8d8bef9SDimitry Andric __intbuf_ = nullptr; 9340b57cec5SDimitry Andric __owns_ib_ = false; 9350b57cec5SDimitry Andric } 9360b57cec5SDimitry Andric return this; 9370b57cec5SDimitry Andric} 9380b57cec5SDimitry Andric 9390b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 9400b57cec5SDimitry Andrictypename basic_filebuf<_CharT, _Traits>::pos_type 9410b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way, 9420b57cec5SDimitry Andric ios_base::openmode) 9430b57cec5SDimitry Andric{ 9440b57cec5SDimitry Andric if (!__cv_) 9450b57cec5SDimitry Andric __throw_bad_cast(); 9460b57cec5SDimitry Andric 9470b57cec5SDimitry Andric int __width = __cv_->encoding(); 948e8d8bef9SDimitry Andric if (__file_ == nullptr || (__width <= 0 && __off != 0) || sync()) 9490b57cec5SDimitry Andric return pos_type(off_type(-1)); 9500b57cec5SDimitry Andric // __width > 0 || __off == 0 9510b57cec5SDimitry Andric int __whence; 9520b57cec5SDimitry Andric switch (__way) 9530b57cec5SDimitry Andric { 9540b57cec5SDimitry Andric case ios_base::beg: 9550b57cec5SDimitry Andric __whence = SEEK_SET; 9560b57cec5SDimitry Andric break; 9570b57cec5SDimitry Andric case ios_base::cur: 9580b57cec5SDimitry Andric __whence = SEEK_CUR; 9590b57cec5SDimitry Andric break; 9600b57cec5SDimitry Andric case ios_base::end: 9610b57cec5SDimitry Andric __whence = SEEK_END; 9620b57cec5SDimitry Andric break; 9630b57cec5SDimitry Andric default: 9640b57cec5SDimitry Andric return pos_type(off_type(-1)); 9650b57cec5SDimitry Andric } 9660b57cec5SDimitry Andric#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS) 9670b57cec5SDimitry Andric if (fseek(__file_, __width > 0 ? __width * __off : 0, __whence)) 9680b57cec5SDimitry Andric return pos_type(off_type(-1)); 9690b57cec5SDimitry Andric pos_type __r = ftell(__file_); 9700b57cec5SDimitry Andric#else 971*bdd1243dSDimitry Andric if (::fseeko(__file_, __width > 0 ? __width * __off : 0, __whence)) 9720b57cec5SDimitry Andric return pos_type(off_type(-1)); 9730b57cec5SDimitry Andric pos_type __r = ftello(__file_); 9740b57cec5SDimitry Andric#endif 9750b57cec5SDimitry Andric __r.state(__st_); 9760b57cec5SDimitry Andric return __r; 9770b57cec5SDimitry Andric} 9780b57cec5SDimitry Andric 9790b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 9800b57cec5SDimitry Andrictypename basic_filebuf<_CharT, _Traits>::pos_type 9810b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode) 9820b57cec5SDimitry Andric{ 983e8d8bef9SDimitry Andric if (__file_ == nullptr || sync()) 9840b57cec5SDimitry Andric return pos_type(off_type(-1)); 9850b57cec5SDimitry Andric#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS) 9860b57cec5SDimitry Andric if (fseek(__file_, __sp, SEEK_SET)) 9870b57cec5SDimitry Andric return pos_type(off_type(-1)); 9880b57cec5SDimitry Andric#else 989*bdd1243dSDimitry Andric if (::fseeko(__file_, __sp, SEEK_SET)) 9900b57cec5SDimitry Andric return pos_type(off_type(-1)); 9910b57cec5SDimitry Andric#endif 9920b57cec5SDimitry Andric __st_ = __sp.state(); 9930b57cec5SDimitry Andric return __sp; 9940b57cec5SDimitry Andric} 9950b57cec5SDimitry Andric 9960b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 9970b57cec5SDimitry Andricint 9980b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::sync() 9990b57cec5SDimitry Andric{ 1000e8d8bef9SDimitry Andric if (__file_ == nullptr) 10010b57cec5SDimitry Andric return 0; 10020b57cec5SDimitry Andric if (!__cv_) 10030b57cec5SDimitry Andric __throw_bad_cast(); 10040b57cec5SDimitry Andric 10050b57cec5SDimitry Andric if (__cm_ & ios_base::out) 10060b57cec5SDimitry Andric { 10070b57cec5SDimitry Andric if (this->pptr() != this->pbase()) 10080b57cec5SDimitry Andric if (overflow() == traits_type::eof()) 10090b57cec5SDimitry Andric return -1; 10100b57cec5SDimitry Andric codecvt_base::result __r; 10110b57cec5SDimitry Andric do 10120b57cec5SDimitry Andric { 10130b57cec5SDimitry Andric char* __extbe; 10140b57cec5SDimitry Andric __r = __cv_->unshift(__st_, __extbuf_, __extbuf_ + __ebs_, __extbe); 10150b57cec5SDimitry Andric size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_); 10160b57cec5SDimitry Andric if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb) 10170b57cec5SDimitry Andric return -1; 10180b57cec5SDimitry Andric } while (__r == codecvt_base::partial); 10190b57cec5SDimitry Andric if (__r == codecvt_base::error) 10200b57cec5SDimitry Andric return -1; 10210b57cec5SDimitry Andric if (fflush(__file_)) 10220b57cec5SDimitry Andric return -1; 10230b57cec5SDimitry Andric } 10240b57cec5SDimitry Andric else if (__cm_ & ios_base::in) 10250b57cec5SDimitry Andric { 10260b57cec5SDimitry Andric off_type __c; 10270b57cec5SDimitry Andric state_type __state = __st_last_; 10280b57cec5SDimitry Andric bool __update_st = false; 10290b57cec5SDimitry Andric if (__always_noconv_) 10300b57cec5SDimitry Andric __c = this->egptr() - this->gptr(); 10310b57cec5SDimitry Andric else 10320b57cec5SDimitry Andric { 10330b57cec5SDimitry Andric int __width = __cv_->encoding(); 10340b57cec5SDimitry Andric __c = __extbufend_ - __extbufnext_; 10350b57cec5SDimitry Andric if (__width > 0) 10360b57cec5SDimitry Andric __c += __width * (this->egptr() - this->gptr()); 10370b57cec5SDimitry Andric else 10380b57cec5SDimitry Andric { 10390b57cec5SDimitry Andric if (this->gptr() != this->egptr()) 10400b57cec5SDimitry Andric { 10410b57cec5SDimitry Andric const int __off = __cv_->length(__state, __extbuf_, 10420b57cec5SDimitry Andric __extbufnext_, 10430b57cec5SDimitry Andric this->gptr() - this->eback()); 10440b57cec5SDimitry Andric __c += __extbufnext_ - __extbuf_ - __off; 10450b57cec5SDimitry Andric __update_st = true; 10460b57cec5SDimitry Andric } 10470b57cec5SDimitry Andric } 10480b57cec5SDimitry Andric } 10490b57cec5SDimitry Andric#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS) 10500b57cec5SDimitry Andric if (fseek(__file_, -__c, SEEK_CUR)) 10510b57cec5SDimitry Andric return -1; 10520b57cec5SDimitry Andric#else 1053*bdd1243dSDimitry Andric if (::fseeko(__file_, -__c, SEEK_CUR)) 10540b57cec5SDimitry Andric return -1; 10550b57cec5SDimitry Andric#endif 10560b57cec5SDimitry Andric if (__update_st) 10570b57cec5SDimitry Andric __st_ = __state; 10580b57cec5SDimitry Andric __extbufnext_ = __extbufend_ = __extbuf_; 1059e8d8bef9SDimitry Andric this->setg(nullptr, nullptr, nullptr); 10600b57cec5SDimitry Andric __cm_ = 0; 10610b57cec5SDimitry Andric } 10620b57cec5SDimitry Andric return 0; 10630b57cec5SDimitry Andric} 10640b57cec5SDimitry Andric 10650b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 10660b57cec5SDimitry Andricvoid 10670b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::imbue(const locale& __loc) 10680b57cec5SDimitry Andric{ 10690b57cec5SDimitry Andric sync(); 1070*bdd1243dSDimitry Andric __cv_ = &std::use_facet<codecvt<char_type, char, state_type> >(__loc); 10710b57cec5SDimitry Andric bool __old_anc = __always_noconv_; 10720b57cec5SDimitry Andric __always_noconv_ = __cv_->always_noconv(); 10730b57cec5SDimitry Andric if (__old_anc != __always_noconv_) 10740b57cec5SDimitry Andric { 1075e8d8bef9SDimitry Andric this->setg(nullptr, nullptr, nullptr); 1076e8d8bef9SDimitry Andric this->setp(nullptr, nullptr); 10770b57cec5SDimitry Andric // invariant, char_type is char, else we couldn't get here 10780b57cec5SDimitry Andric if (__always_noconv_) // need to dump __intbuf_ 10790b57cec5SDimitry Andric { 10800b57cec5SDimitry Andric if (__owns_eb_) 10810b57cec5SDimitry Andric delete [] __extbuf_; 10820b57cec5SDimitry Andric __owns_eb_ = __owns_ib_; 10830b57cec5SDimitry Andric __ebs_ = __ibs_; 10840b57cec5SDimitry Andric __extbuf_ = (char*)__intbuf_; 10850b57cec5SDimitry Andric __ibs_ = 0; 1086e8d8bef9SDimitry Andric __intbuf_ = nullptr; 10870b57cec5SDimitry Andric __owns_ib_ = false; 10880b57cec5SDimitry Andric } 10890b57cec5SDimitry Andric else // need to obtain an __intbuf_. 10900b57cec5SDimitry Andric { // If __extbuf_ is user-supplied, use it, else new __intbuf_ 10910b57cec5SDimitry Andric if (!__owns_eb_ && __extbuf_ != __extbuf_min_) 10920b57cec5SDimitry Andric { 10930b57cec5SDimitry Andric __ibs_ = __ebs_; 10940b57cec5SDimitry Andric __intbuf_ = (char_type*)__extbuf_; 10950b57cec5SDimitry Andric __owns_ib_ = false; 10960b57cec5SDimitry Andric __extbuf_ = new char[__ebs_]; 10970b57cec5SDimitry Andric __owns_eb_ = true; 10980b57cec5SDimitry Andric } 10990b57cec5SDimitry Andric else 11000b57cec5SDimitry Andric { 11010b57cec5SDimitry Andric __ibs_ = __ebs_; 11020b57cec5SDimitry Andric __intbuf_ = new char_type[__ibs_]; 11030b57cec5SDimitry Andric __owns_ib_ = true; 11040b57cec5SDimitry Andric } 11050b57cec5SDimitry Andric } 11060b57cec5SDimitry Andric } 11070b57cec5SDimitry Andric} 11080b57cec5SDimitry Andric 11090b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 11100b57cec5SDimitry Andricbool 11110b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::__read_mode() 11120b57cec5SDimitry Andric{ 11130b57cec5SDimitry Andric if (!(__cm_ & ios_base::in)) 11140b57cec5SDimitry Andric { 1115e8d8bef9SDimitry Andric this->setp(nullptr, nullptr); 11160b57cec5SDimitry Andric if (__always_noconv_) 11170b57cec5SDimitry Andric this->setg((char_type*)__extbuf_, 11180b57cec5SDimitry Andric (char_type*)__extbuf_ + __ebs_, 11190b57cec5SDimitry Andric (char_type*)__extbuf_ + __ebs_); 11200b57cec5SDimitry Andric else 11210b57cec5SDimitry Andric this->setg(__intbuf_, __intbuf_ + __ibs_, __intbuf_ + __ibs_); 11220b57cec5SDimitry Andric __cm_ = ios_base::in; 11230b57cec5SDimitry Andric return true; 11240b57cec5SDimitry Andric } 11250b57cec5SDimitry Andric return false; 11260b57cec5SDimitry Andric} 11270b57cec5SDimitry Andric 11280b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 11290b57cec5SDimitry Andricvoid 11300b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>::__write_mode() 11310b57cec5SDimitry Andric{ 11320b57cec5SDimitry Andric if (!(__cm_ & ios_base::out)) 11330b57cec5SDimitry Andric { 1134e8d8bef9SDimitry Andric this->setg(nullptr, nullptr, nullptr); 11350b57cec5SDimitry Andric if (__ebs_ > sizeof(__extbuf_min_)) 11360b57cec5SDimitry Andric { 11370b57cec5SDimitry Andric if (__always_noconv_) 11380b57cec5SDimitry Andric this->setp((char_type*)__extbuf_, 11390b57cec5SDimitry Andric (char_type*)__extbuf_ + (__ebs_ - 1)); 11400b57cec5SDimitry Andric else 11410b57cec5SDimitry Andric this->setp(__intbuf_, __intbuf_ + (__ibs_ - 1)); 11420b57cec5SDimitry Andric } 11430b57cec5SDimitry Andric else 1144e8d8bef9SDimitry Andric this->setp(nullptr, nullptr); 11450b57cec5SDimitry Andric __cm_ = ios_base::out; 11460b57cec5SDimitry Andric } 11470b57cec5SDimitry Andric} 11480b57cec5SDimitry Andric 11490b57cec5SDimitry Andric// basic_ifstream 11500b57cec5SDimitry Andric 11510b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 11520b57cec5SDimitry Andricclass _LIBCPP_TEMPLATE_VIS basic_ifstream 11530b57cec5SDimitry Andric : public basic_istream<_CharT, _Traits> 11540b57cec5SDimitry Andric{ 11550b57cec5SDimitry Andricpublic: 11560b57cec5SDimitry Andric typedef _CharT char_type; 11570b57cec5SDimitry Andric typedef _Traits traits_type; 11580b57cec5SDimitry Andric typedef typename traits_type::int_type int_type; 11590b57cec5SDimitry Andric typedef typename traits_type::pos_type pos_type; 11600b57cec5SDimitry Andric typedef typename traits_type::off_type off_type; 11610b57cec5SDimitry Andric 11620b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11630b57cec5SDimitry Andric basic_ifstream(); 11640b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11650b57cec5SDimitry Andric explicit basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in); 11660b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 11670b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11680b57cec5SDimitry Andric explicit basic_ifstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in); 11690b57cec5SDimitry Andric#endif 11700b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11710b57cec5SDimitry Andric explicit basic_ifstream(const string& __s, ios_base::openmode __mode = ios_base::in); 1172e8d8bef9SDimitry Andric#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) 11730b57cec5SDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY 11740b57cec5SDimitry Andric explicit basic_ifstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in) 11750b57cec5SDimitry Andric : basic_ifstream(__p.c_str(), __mode) {} 11760b57cec5SDimitry Andric#endif // _LIBCPP_STD_VER >= 17 11770b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11780b57cec5SDimitry Andric basic_ifstream(basic_ifstream&& __rhs); 11790b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11800b57cec5SDimitry Andric basic_ifstream& operator=(basic_ifstream&& __rhs); 11810b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11820b57cec5SDimitry Andric void swap(basic_ifstream& __rhs); 11830b57cec5SDimitry Andric 11840b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11850b57cec5SDimitry Andric basic_filebuf<char_type, traits_type>* rdbuf() const; 11860b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11870b57cec5SDimitry Andric bool is_open() const; 11880b57cec5SDimitry Andric void open(const char* __s, ios_base::openmode __mode = ios_base::in); 11890b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 11900b57cec5SDimitry Andric void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in); 11910b57cec5SDimitry Andric#endif 11920b57cec5SDimitry Andric void open(const string& __s, ios_base::openmode __mode = ios_base::in); 1193e8d8bef9SDimitry Andric#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) 11940b57cec5SDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY 11950b57cec5SDimitry Andric void open(const filesystem::path& __p, 11960b57cec5SDimitry Andric ios_base::openmode __mode = ios_base::in) { 11970b57cec5SDimitry Andric return open(__p.c_str(), __mode); 11980b57cec5SDimitry Andric } 11990b57cec5SDimitry Andric#endif // _LIBCPP_STD_VER >= 17 12000b57cec5SDimitry Andric 12010b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 12020b57cec5SDimitry Andric void __open(int __fd, ios_base::openmode __mode); 12030b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 12040b57cec5SDimitry Andric void close(); 12050b57cec5SDimitry Andric 12060b57cec5SDimitry Andricprivate: 12070b57cec5SDimitry Andric basic_filebuf<char_type, traits_type> __sb_; 12080b57cec5SDimitry Andric}; 12090b57cec5SDimitry Andric 12100b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12110b57cec5SDimitry Andricinline 12120b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::basic_ifstream() 12130b57cec5SDimitry Andric : basic_istream<char_type, traits_type>(&__sb_) 12140b57cec5SDimitry Andric{ 12150b57cec5SDimitry Andric} 12160b57cec5SDimitry Andric 12170b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12180b57cec5SDimitry Andricinline 12190b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::basic_ifstream(const char* __s, ios_base::openmode __mode) 12200b57cec5SDimitry Andric : basic_istream<char_type, traits_type>(&__sb_) 12210b57cec5SDimitry Andric{ 1222e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode | ios_base::in) == nullptr) 12230b57cec5SDimitry Andric this->setstate(ios_base::failbit); 12240b57cec5SDimitry Andric} 12250b57cec5SDimitry Andric 12260b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 12270b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12280b57cec5SDimitry Andricinline 12290b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::basic_ifstream(const wchar_t* __s, ios_base::openmode __mode) 12300b57cec5SDimitry Andric : basic_istream<char_type, traits_type>(&__sb_) 12310b57cec5SDimitry Andric{ 1232e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode | ios_base::in) == nullptr) 12330b57cec5SDimitry Andric this->setstate(ios_base::failbit); 12340b57cec5SDimitry Andric} 12350b57cec5SDimitry Andric#endif 12360b57cec5SDimitry Andric 12370b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12380b57cec5SDimitry Andricinline 12390b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::openmode __mode) 12400b57cec5SDimitry Andric : basic_istream<char_type, traits_type>(&__sb_) 12410b57cec5SDimitry Andric{ 1242e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode | ios_base::in) == nullptr) 12430b57cec5SDimitry Andric this->setstate(ios_base::failbit); 12440b57cec5SDimitry Andric} 12450b57cec5SDimitry Andric 12460b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12470b57cec5SDimitry Andricinline 12480b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::basic_ifstream(basic_ifstream&& __rhs) 12490b57cec5SDimitry Andric : basic_istream<char_type, traits_type>(_VSTD::move(__rhs)), 12500b57cec5SDimitry Andric __sb_(_VSTD::move(__rhs.__sb_)) 12510b57cec5SDimitry Andric{ 12520b57cec5SDimitry Andric this->set_rdbuf(&__sb_); 12530b57cec5SDimitry Andric} 12540b57cec5SDimitry Andric 12550b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12560b57cec5SDimitry Andricinline 12570b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>& 12580b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs) 12590b57cec5SDimitry Andric{ 12600b57cec5SDimitry Andric basic_istream<char_type, traits_type>::operator=(_VSTD::move(__rhs)); 12610b57cec5SDimitry Andric __sb_ = _VSTD::move(__rhs.__sb_); 12620b57cec5SDimitry Andric return *this; 12630b57cec5SDimitry Andric} 12640b57cec5SDimitry Andric 12650b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12660b57cec5SDimitry Andricinline 12670b57cec5SDimitry Andricvoid 12680b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::swap(basic_ifstream& __rhs) 12690b57cec5SDimitry Andric{ 12700b57cec5SDimitry Andric basic_istream<char_type, traits_type>::swap(__rhs); 12710b57cec5SDimitry Andric __sb_.swap(__rhs.__sb_); 12720b57cec5SDimitry Andric} 12730b57cec5SDimitry Andric 12740b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12750b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 12760b57cec5SDimitry Andricvoid 12770b57cec5SDimitry Andricswap(basic_ifstream<_CharT, _Traits>& __x, basic_ifstream<_CharT, _Traits>& __y) 12780b57cec5SDimitry Andric{ 12790b57cec5SDimitry Andric __x.swap(__y); 12800b57cec5SDimitry Andric} 12810b57cec5SDimitry Andric 12820b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12830b57cec5SDimitry Andricinline 12840b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 12850b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::rdbuf() const 12860b57cec5SDimitry Andric{ 12870b57cec5SDimitry Andric return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_); 12880b57cec5SDimitry Andric} 12890b57cec5SDimitry Andric 12900b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12910b57cec5SDimitry Andricinline 12920b57cec5SDimitry Andricbool 12930b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::is_open() const 12940b57cec5SDimitry Andric{ 12950b57cec5SDimitry Andric return __sb_.is_open(); 12960b57cec5SDimitry Andric} 12970b57cec5SDimitry Andric 12980b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 12990b57cec5SDimitry Andricvoid 13000b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) 13010b57cec5SDimitry Andric{ 13020b57cec5SDimitry Andric if (__sb_.open(__s, __mode | ios_base::in)) 13030b57cec5SDimitry Andric this->clear(); 13040b57cec5SDimitry Andric else 13050b57cec5SDimitry Andric this->setstate(ios_base::failbit); 13060b57cec5SDimitry Andric} 13070b57cec5SDimitry Andric 13080b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 13090b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 13100b57cec5SDimitry Andricvoid 13110b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) 13120b57cec5SDimitry Andric{ 13130b57cec5SDimitry Andric if (__sb_.open(__s, __mode | ios_base::in)) 13140b57cec5SDimitry Andric this->clear(); 13150b57cec5SDimitry Andric else 13160b57cec5SDimitry Andric this->setstate(ios_base::failbit); 13170b57cec5SDimitry Andric} 13180b57cec5SDimitry Andric#endif 13190b57cec5SDimitry Andric 13200b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 13210b57cec5SDimitry Andricvoid 13220b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) 13230b57cec5SDimitry Andric{ 13240b57cec5SDimitry Andric if (__sb_.open(__s, __mode | ios_base::in)) 13250b57cec5SDimitry Andric this->clear(); 13260b57cec5SDimitry Andric else 13270b57cec5SDimitry Andric this->setstate(ios_base::failbit); 13280b57cec5SDimitry Andric} 13290b57cec5SDimitry Andric 13300b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 1331d099db25SDimitry Andricinline 13320b57cec5SDimitry Andricvoid basic_ifstream<_CharT, _Traits>::__open(int __fd, 13330b57cec5SDimitry Andric ios_base::openmode __mode) { 13340b57cec5SDimitry Andric if (__sb_.__open(__fd, __mode | ios_base::in)) 13350b57cec5SDimitry Andric this->clear(); 13360b57cec5SDimitry Andric else 13370b57cec5SDimitry Andric this->setstate(ios_base::failbit); 13380b57cec5SDimitry Andric} 13390b57cec5SDimitry Andric 13400b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 13410b57cec5SDimitry Andricinline 13420b57cec5SDimitry Andricvoid 13430b57cec5SDimitry Andricbasic_ifstream<_CharT, _Traits>::close() 13440b57cec5SDimitry Andric{ 13450b57cec5SDimitry Andric if (__sb_.close() == 0) 13460b57cec5SDimitry Andric this->setstate(ios_base::failbit); 13470b57cec5SDimitry Andric} 13480b57cec5SDimitry Andric 13490b57cec5SDimitry Andric// basic_ofstream 13500b57cec5SDimitry Andric 13510b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 13520b57cec5SDimitry Andricclass _LIBCPP_TEMPLATE_VIS basic_ofstream 13530b57cec5SDimitry Andric : public basic_ostream<_CharT, _Traits> 13540b57cec5SDimitry Andric{ 13550b57cec5SDimitry Andricpublic: 13560b57cec5SDimitry Andric typedef _CharT char_type; 13570b57cec5SDimitry Andric typedef _Traits traits_type; 13580b57cec5SDimitry Andric typedef typename traits_type::int_type int_type; 13590b57cec5SDimitry Andric typedef typename traits_type::pos_type pos_type; 13600b57cec5SDimitry Andric typedef typename traits_type::off_type off_type; 13610b57cec5SDimitry Andric 13620b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13630b57cec5SDimitry Andric basic_ofstream(); 13640b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13650b57cec5SDimitry Andric explicit basic_ofstream(const char* __s, ios_base::openmode __mode = ios_base::out); 13660b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 13670b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13680b57cec5SDimitry Andric explicit basic_ofstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::out); 13690b57cec5SDimitry Andric#endif 13700b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13710b57cec5SDimitry Andric explicit basic_ofstream(const string& __s, ios_base::openmode __mode = ios_base::out); 13720b57cec5SDimitry Andric 1373e8d8bef9SDimitry Andric#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) 13740b57cec5SDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY 13750b57cec5SDimitry Andric explicit basic_ofstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out) 13760b57cec5SDimitry Andric : basic_ofstream(__p.c_str(), __mode) {} 13770b57cec5SDimitry Andric#endif // _LIBCPP_STD_VER >= 17 13780b57cec5SDimitry Andric 13790b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13800b57cec5SDimitry Andric basic_ofstream(basic_ofstream&& __rhs); 13810b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13820b57cec5SDimitry Andric basic_ofstream& operator=(basic_ofstream&& __rhs); 13830b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13840b57cec5SDimitry Andric void swap(basic_ofstream& __rhs); 13850b57cec5SDimitry Andric 13860b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13870b57cec5SDimitry Andric basic_filebuf<char_type, traits_type>* rdbuf() const; 13880b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13890b57cec5SDimitry Andric bool is_open() const; 13900b57cec5SDimitry Andric void open(const char* __s, ios_base::openmode __mode = ios_base::out); 13910b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 13920b57cec5SDimitry Andric void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::out); 13930b57cec5SDimitry Andric#endif 13940b57cec5SDimitry Andric void open(const string& __s, ios_base::openmode __mode = ios_base::out); 13950b57cec5SDimitry Andric 1396e8d8bef9SDimitry Andric#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) 13970b57cec5SDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY 13980b57cec5SDimitry Andric void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out) 13990b57cec5SDimitry Andric { return open(__p.c_str(), __mode); } 14000b57cec5SDimitry Andric#endif // _LIBCPP_STD_VER >= 17 14010b57cec5SDimitry Andric 14020b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 14030b57cec5SDimitry Andric void __open(int __fd, ios_base::openmode __mode); 14040b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 14050b57cec5SDimitry Andric void close(); 14060b57cec5SDimitry Andric 14070b57cec5SDimitry Andricprivate: 14080b57cec5SDimitry Andric basic_filebuf<char_type, traits_type> __sb_; 14090b57cec5SDimitry Andric}; 14100b57cec5SDimitry Andric 14110b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14120b57cec5SDimitry Andricinline 14130b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::basic_ofstream() 14140b57cec5SDimitry Andric : basic_ostream<char_type, traits_type>(&__sb_) 14150b57cec5SDimitry Andric{ 14160b57cec5SDimitry Andric} 14170b57cec5SDimitry Andric 14180b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14190b57cec5SDimitry Andricinline 14200b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::basic_ofstream(const char* __s, ios_base::openmode __mode) 14210b57cec5SDimitry Andric : basic_ostream<char_type, traits_type>(&__sb_) 14220b57cec5SDimitry Andric{ 1423e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode | ios_base::out) == nullptr) 14240b57cec5SDimitry Andric this->setstate(ios_base::failbit); 14250b57cec5SDimitry Andric} 14260b57cec5SDimitry Andric 14270b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 14280b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14290b57cec5SDimitry Andricinline 14300b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::basic_ofstream(const wchar_t* __s, ios_base::openmode __mode) 14310b57cec5SDimitry Andric : basic_ostream<char_type, traits_type>(&__sb_) 14320b57cec5SDimitry Andric{ 1433e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode | ios_base::out) == nullptr) 14340b57cec5SDimitry Andric this->setstate(ios_base::failbit); 14350b57cec5SDimitry Andric} 14360b57cec5SDimitry Andric#endif 14370b57cec5SDimitry Andric 14380b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14390b57cec5SDimitry Andricinline 14400b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::openmode __mode) 14410b57cec5SDimitry Andric : basic_ostream<char_type, traits_type>(&__sb_) 14420b57cec5SDimitry Andric{ 1443e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode | ios_base::out) == nullptr) 14440b57cec5SDimitry Andric this->setstate(ios_base::failbit); 14450b57cec5SDimitry Andric} 14460b57cec5SDimitry Andric 14470b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14480b57cec5SDimitry Andricinline 14490b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::basic_ofstream(basic_ofstream&& __rhs) 14500b57cec5SDimitry Andric : basic_ostream<char_type, traits_type>(_VSTD::move(__rhs)), 14510b57cec5SDimitry Andric __sb_(_VSTD::move(__rhs.__sb_)) 14520b57cec5SDimitry Andric{ 14530b57cec5SDimitry Andric this->set_rdbuf(&__sb_); 14540b57cec5SDimitry Andric} 14550b57cec5SDimitry Andric 14560b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14570b57cec5SDimitry Andricinline 14580b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>& 14590b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs) 14600b57cec5SDimitry Andric{ 14610b57cec5SDimitry Andric basic_ostream<char_type, traits_type>::operator=(_VSTD::move(__rhs)); 14620b57cec5SDimitry Andric __sb_ = _VSTD::move(__rhs.__sb_); 14630b57cec5SDimitry Andric return *this; 14640b57cec5SDimitry Andric} 14650b57cec5SDimitry Andric 14660b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14670b57cec5SDimitry Andricinline 14680b57cec5SDimitry Andricvoid 14690b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::swap(basic_ofstream& __rhs) 14700b57cec5SDimitry Andric{ 14710b57cec5SDimitry Andric basic_ostream<char_type, traits_type>::swap(__rhs); 14720b57cec5SDimitry Andric __sb_.swap(__rhs.__sb_); 14730b57cec5SDimitry Andric} 14740b57cec5SDimitry Andric 14750b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14760b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 14770b57cec5SDimitry Andricvoid 14780b57cec5SDimitry Andricswap(basic_ofstream<_CharT, _Traits>& __x, basic_ofstream<_CharT, _Traits>& __y) 14790b57cec5SDimitry Andric{ 14800b57cec5SDimitry Andric __x.swap(__y); 14810b57cec5SDimitry Andric} 14820b57cec5SDimitry Andric 14830b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14840b57cec5SDimitry Andricinline 14850b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 14860b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::rdbuf() const 14870b57cec5SDimitry Andric{ 14880b57cec5SDimitry Andric return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_); 14890b57cec5SDimitry Andric} 14900b57cec5SDimitry Andric 14910b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 14920b57cec5SDimitry Andricinline 14930b57cec5SDimitry Andricbool 14940b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::is_open() const 14950b57cec5SDimitry Andric{ 14960b57cec5SDimitry Andric return __sb_.is_open(); 14970b57cec5SDimitry Andric} 14980b57cec5SDimitry Andric 14990b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 15000b57cec5SDimitry Andricvoid 15010b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) 15020b57cec5SDimitry Andric{ 15030b57cec5SDimitry Andric if (__sb_.open(__s, __mode | ios_base::out)) 15040b57cec5SDimitry Andric this->clear(); 15050b57cec5SDimitry Andric else 15060b57cec5SDimitry Andric this->setstate(ios_base::failbit); 15070b57cec5SDimitry Andric} 15080b57cec5SDimitry Andric 15090b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 15100b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 15110b57cec5SDimitry Andricvoid 15120b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) 15130b57cec5SDimitry Andric{ 15140b57cec5SDimitry Andric if (__sb_.open(__s, __mode | ios_base::out)) 15150b57cec5SDimitry Andric this->clear(); 15160b57cec5SDimitry Andric else 15170b57cec5SDimitry Andric this->setstate(ios_base::failbit); 15180b57cec5SDimitry Andric} 15190b57cec5SDimitry Andric#endif 15200b57cec5SDimitry Andric 15210b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 15220b57cec5SDimitry Andricvoid 15230b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) 15240b57cec5SDimitry Andric{ 15250b57cec5SDimitry Andric if (__sb_.open(__s, __mode | ios_base::out)) 15260b57cec5SDimitry Andric this->clear(); 15270b57cec5SDimitry Andric else 15280b57cec5SDimitry Andric this->setstate(ios_base::failbit); 15290b57cec5SDimitry Andric} 15300b57cec5SDimitry Andric 15310b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 1532d099db25SDimitry Andricinline 15330b57cec5SDimitry Andricvoid basic_ofstream<_CharT, _Traits>::__open(int __fd, 15340b57cec5SDimitry Andric ios_base::openmode __mode) { 15350b57cec5SDimitry Andric if (__sb_.__open(__fd, __mode | ios_base::out)) 15360b57cec5SDimitry Andric this->clear(); 15370b57cec5SDimitry Andric else 15380b57cec5SDimitry Andric this->setstate(ios_base::failbit); 15390b57cec5SDimitry Andric} 15400b57cec5SDimitry Andric 15410b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 15420b57cec5SDimitry Andricinline 15430b57cec5SDimitry Andricvoid 15440b57cec5SDimitry Andricbasic_ofstream<_CharT, _Traits>::close() 15450b57cec5SDimitry Andric{ 1546e8d8bef9SDimitry Andric if (__sb_.close() == nullptr) 15470b57cec5SDimitry Andric this->setstate(ios_base::failbit); 15480b57cec5SDimitry Andric} 15490b57cec5SDimitry Andric 15500b57cec5SDimitry Andric// basic_fstream 15510b57cec5SDimitry Andric 15520b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 15530b57cec5SDimitry Andricclass _LIBCPP_TEMPLATE_VIS basic_fstream 15540b57cec5SDimitry Andric : public basic_iostream<_CharT, _Traits> 15550b57cec5SDimitry Andric{ 15560b57cec5SDimitry Andricpublic: 15570b57cec5SDimitry Andric typedef _CharT char_type; 15580b57cec5SDimitry Andric typedef _Traits traits_type; 15590b57cec5SDimitry Andric typedef typename traits_type::int_type int_type; 15600b57cec5SDimitry Andric typedef typename traits_type::pos_type pos_type; 15610b57cec5SDimitry Andric typedef typename traits_type::off_type off_type; 15620b57cec5SDimitry Andric 15630b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15640b57cec5SDimitry Andric basic_fstream(); 15650b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15660b57cec5SDimitry Andric explicit basic_fstream(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 15670b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 15680b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15690b57cec5SDimitry Andric explicit basic_fstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 15700b57cec5SDimitry Andric#endif 15710b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15720b57cec5SDimitry Andric explicit basic_fstream(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 15730b57cec5SDimitry Andric 1574e8d8bef9SDimitry Andric#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) 15750b57cec5SDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY 15760b57cec5SDimitry Andric explicit basic_fstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in | ios_base::out) 15770b57cec5SDimitry Andric : basic_fstream(__p.c_str(), __mode) {} 15780b57cec5SDimitry Andric#endif // _LIBCPP_STD_VER >= 17 15790b57cec5SDimitry Andric 15800b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15810b57cec5SDimitry Andric basic_fstream(basic_fstream&& __rhs); 15820b57cec5SDimitry Andric 15830b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15840b57cec5SDimitry Andric basic_fstream& operator=(basic_fstream&& __rhs); 1585fe6060f1SDimitry Andric 15860b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15870b57cec5SDimitry Andric void swap(basic_fstream& __rhs); 15880b57cec5SDimitry Andric 15890b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15900b57cec5SDimitry Andric basic_filebuf<char_type, traits_type>* rdbuf() const; 15910b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15920b57cec5SDimitry Andric bool is_open() const; 15930b57cec5SDimitry Andric void open(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 15940b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 15950b57cec5SDimitry Andric void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 15960b57cec5SDimitry Andric#endif 15970b57cec5SDimitry Andric void open(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out); 15980b57cec5SDimitry Andric 1599e8d8bef9SDimitry Andric#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) 16000b57cec5SDimitry Andric _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY 16010b57cec5SDimitry Andric void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in|ios_base::out) 16020b57cec5SDimitry Andric { return open(__p.c_str(), __mode); } 16030b57cec5SDimitry Andric#endif // _LIBCPP_STD_VER >= 17 16040b57cec5SDimitry Andric 16050b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 16060b57cec5SDimitry Andric void close(); 16070b57cec5SDimitry Andric 16080b57cec5SDimitry Andricprivate: 16090b57cec5SDimitry Andric basic_filebuf<char_type, traits_type> __sb_; 16100b57cec5SDimitry Andric}; 16110b57cec5SDimitry Andric 16120b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16130b57cec5SDimitry Andricinline 16140b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::basic_fstream() 16150b57cec5SDimitry Andric : basic_iostream<char_type, traits_type>(&__sb_) 16160b57cec5SDimitry Andric{ 16170b57cec5SDimitry Andric} 16180b57cec5SDimitry Andric 16190b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16200b57cec5SDimitry Andricinline 16210b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::basic_fstream(const char* __s, ios_base::openmode __mode) 16220b57cec5SDimitry Andric : basic_iostream<char_type, traits_type>(&__sb_) 16230b57cec5SDimitry Andric{ 1624e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode) == nullptr) 16250b57cec5SDimitry Andric this->setstate(ios_base::failbit); 16260b57cec5SDimitry Andric} 16270b57cec5SDimitry Andric 16280b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 16290b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16300b57cec5SDimitry Andricinline 16310b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::basic_fstream(const wchar_t* __s, ios_base::openmode __mode) 16320b57cec5SDimitry Andric : basic_iostream<char_type, traits_type>(&__sb_) 16330b57cec5SDimitry Andric{ 1634e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode) == nullptr) 16350b57cec5SDimitry Andric this->setstate(ios_base::failbit); 16360b57cec5SDimitry Andric} 16370b57cec5SDimitry Andric#endif 16380b57cec5SDimitry Andric 16390b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16400b57cec5SDimitry Andricinline 16410b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openmode __mode) 16420b57cec5SDimitry Andric : basic_iostream<char_type, traits_type>(&__sb_) 16430b57cec5SDimitry Andric{ 1644e8d8bef9SDimitry Andric if (__sb_.open(__s, __mode) == nullptr) 16450b57cec5SDimitry Andric this->setstate(ios_base::failbit); 16460b57cec5SDimitry Andric} 16470b57cec5SDimitry Andric 16480b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16490b57cec5SDimitry Andricinline 16500b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::basic_fstream(basic_fstream&& __rhs) 16510b57cec5SDimitry Andric : basic_iostream<char_type, traits_type>(_VSTD::move(__rhs)), 16520b57cec5SDimitry Andric __sb_(_VSTD::move(__rhs.__sb_)) 16530b57cec5SDimitry Andric{ 16540b57cec5SDimitry Andric this->set_rdbuf(&__sb_); 16550b57cec5SDimitry Andric} 16560b57cec5SDimitry Andric 16570b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16580b57cec5SDimitry Andricinline 16590b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>& 16600b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs) 16610b57cec5SDimitry Andric{ 16620b57cec5SDimitry Andric basic_iostream<char_type, traits_type>::operator=(_VSTD::move(__rhs)); 16630b57cec5SDimitry Andric __sb_ = _VSTD::move(__rhs.__sb_); 16640b57cec5SDimitry Andric return *this; 16650b57cec5SDimitry Andric} 16660b57cec5SDimitry Andric 16670b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16680b57cec5SDimitry Andricinline 16690b57cec5SDimitry Andricvoid 16700b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::swap(basic_fstream& __rhs) 16710b57cec5SDimitry Andric{ 16720b57cec5SDimitry Andric basic_iostream<char_type, traits_type>::swap(__rhs); 16730b57cec5SDimitry Andric __sb_.swap(__rhs.__sb_); 16740b57cec5SDimitry Andric} 16750b57cec5SDimitry Andric 16760b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16770b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 16780b57cec5SDimitry Andricvoid 16790b57cec5SDimitry Andricswap(basic_fstream<_CharT, _Traits>& __x, basic_fstream<_CharT, _Traits>& __y) 16800b57cec5SDimitry Andric{ 16810b57cec5SDimitry Andric __x.swap(__y); 16820b57cec5SDimitry Andric} 16830b57cec5SDimitry Andric 16840b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16850b57cec5SDimitry Andricinline 16860b57cec5SDimitry Andricbasic_filebuf<_CharT, _Traits>* 16870b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::rdbuf() const 16880b57cec5SDimitry Andric{ 16890b57cec5SDimitry Andric return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_); 16900b57cec5SDimitry Andric} 16910b57cec5SDimitry Andric 16920b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 16930b57cec5SDimitry Andricinline 16940b57cec5SDimitry Andricbool 16950b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::is_open() const 16960b57cec5SDimitry Andric{ 16970b57cec5SDimitry Andric return __sb_.is_open(); 16980b57cec5SDimitry Andric} 16990b57cec5SDimitry Andric 17000b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 17010b57cec5SDimitry Andricvoid 17020b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) 17030b57cec5SDimitry Andric{ 17040b57cec5SDimitry Andric if (__sb_.open(__s, __mode)) 17050b57cec5SDimitry Andric this->clear(); 17060b57cec5SDimitry Andric else 17070b57cec5SDimitry Andric this->setstate(ios_base::failbit); 17080b57cec5SDimitry Andric} 17090b57cec5SDimitry Andric 17100b57cec5SDimitry Andric#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR 17110b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 17120b57cec5SDimitry Andricvoid 17130b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) 17140b57cec5SDimitry Andric{ 17150b57cec5SDimitry Andric if (__sb_.open(__s, __mode)) 17160b57cec5SDimitry Andric this->clear(); 17170b57cec5SDimitry Andric else 17180b57cec5SDimitry Andric this->setstate(ios_base::failbit); 17190b57cec5SDimitry Andric} 17200b57cec5SDimitry Andric#endif 17210b57cec5SDimitry Andric 17220b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 17230b57cec5SDimitry Andricvoid 17240b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) 17250b57cec5SDimitry Andric{ 17260b57cec5SDimitry Andric if (__sb_.open(__s, __mode)) 17270b57cec5SDimitry Andric this->clear(); 17280b57cec5SDimitry Andric else 17290b57cec5SDimitry Andric this->setstate(ios_base::failbit); 17300b57cec5SDimitry Andric} 17310b57cec5SDimitry Andric 17320b57cec5SDimitry Andrictemplate <class _CharT, class _Traits> 17330b57cec5SDimitry Andricinline 17340b57cec5SDimitry Andricvoid 17350b57cec5SDimitry Andricbasic_fstream<_CharT, _Traits>::close() 17360b57cec5SDimitry Andric{ 1737e8d8bef9SDimitry Andric if (__sb_.close() == nullptr) 17380b57cec5SDimitry Andric this->setstate(ios_base::failbit); 17390b57cec5SDimitry Andric} 17400b57cec5SDimitry Andric 1741e8d8bef9SDimitry Andric#if defined(_LIBCPP_ABI_ENABLE_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1) 174281ad6265SDimitry Andricextern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ifstream<char>; 174381ad6265SDimitry Andricextern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ofstream<char>; 174481ad6265SDimitry Andricextern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_filebuf<char>; 1745e8d8bef9SDimitry Andric#endif 1746e8d8bef9SDimitry Andric 17470b57cec5SDimitry Andric_LIBCPP_END_NAMESPACE_STD 17480b57cec5SDimitry Andric 1749*bdd1243dSDimitry Andric#endif // _LIBCPP_HAS_NO_FSTREAM 1750*bdd1243dSDimitry Andric 17510b57cec5SDimitry Andric_LIBCPP_POP_MACROS 17520b57cec5SDimitry Andric 1753*bdd1243dSDimitry Andric#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 1754*bdd1243dSDimitry Andric# include <atomic> 1755*bdd1243dSDimitry Andric# include <concepts> 1756*bdd1243dSDimitry Andric# include <iosfwd> 1757*bdd1243dSDimitry Andric# include <limits> 1758*bdd1243dSDimitry Andric# include <new> 1759*bdd1243dSDimitry Andric# include <stdexcept> 1760*bdd1243dSDimitry Andric# include <type_traits> 1761*bdd1243dSDimitry Andric#endif 1762*bdd1243dSDimitry Andric 17630b57cec5SDimitry Andric#endif // _LIBCPP_FSTREAM 1764