Coverage Report

Created: 2020-02-25 14:32

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