150
|
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 basic_filebuf<_CharT, _Traits>::__open(int __fd, ios_base::openmode __mode) {
|
|
575 basic_filebuf<_CharT, _Traits>* __rt = 0;
|
|
576 if (__file_ == 0) {
|
|
577 if (const char* __mdstr = __make_mdstring(__mode)) {
|
|
578 __rt = this;
|
|
579 __file_ = fdopen(__fd, __mdstr);
|
|
580 if (__file_) {
|
|
581 __om_ = __mode;
|
|
582 if (__mode & ios_base::ate) {
|
|
583 if (fseek(__file_, 0, SEEK_END)) {
|
|
584 fclose(__file_);
|
|
585 __file_ = 0;
|
|
586 __rt = 0;
|
|
587 }
|
|
588 }
|
|
589 } else
|
|
590 __rt = 0;
|
|
591 }
|
|
592 }
|
|
593 return __rt;
|
|
594 }
|
|
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 {
|
|
782 if (__file_ && this->eback() < this->gptr())
|
|
783 {
|
|
784 if (traits_type::eq_int_type(__c, traits_type::eof()))
|
|
785 {
|
|
786 this->gbump(-1);
|
|
787 return traits_type::not_eof(__c);
|
|
788 }
|
|
789 if ((__om_ & ios_base::out) ||
|
|
790 traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1]))
|
|
791 {
|
|
792 this->gbump(-1);
|
|
793 *this->gptr() = traits_type::to_char_type(__c);
|
|
794 return __c;
|
|
795 }
|
|
796 }
|
|
797 return traits_type::eof();
|
|
798 }
|
|
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 {
|
|
923 if (!__cv_)
|
|
924 __throw_bad_cast();
|
|
925
|
|
926 int __width = __cv_->encoding();
|
|
927 if (__file_ == 0 || (__width <= 0 && __off != 0) || sync())
|
|
928 return pos_type(off_type(-1));
|
|
929 // __width > 0 || __off == 0
|
|
930 int __whence;
|
|
931 switch (__way)
|
|
932 {
|
|
933 case ios_base::beg:
|
|
934 __whence = SEEK_SET;
|
|
935 break;
|
|
936 case ios_base::cur:
|
|
937 __whence = SEEK_CUR;
|
|
938 break;
|
|
939 case ios_base::end:
|
|
940 __whence = SEEK_END;
|
|
941 break;
|
|
942 default:
|
|
943 return pos_type(off_type(-1));
|
|
944 }
|
|
945 #if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
|
|
946 if (fseek(__file_, __width > 0 ? __width * __off : 0, __whence))
|
|
947 return pos_type(off_type(-1));
|
|
948 pos_type __r = ftell(__file_);
|
|
949 #else
|
|
950 if (fseeko(__file_, __width > 0 ? __width * __off : 0, __whence))
|
|
951 return pos_type(off_type(-1));
|
|
952 pos_type __r = ftello(__file_);
|
|
953 #endif
|
|
954 __r.state(__st_);
|
|
955 return __r;
|
|
956 }
|
|
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 {
|
|
962 if (__file_ == 0 || sync())
|
|
963 return pos_type(off_type(-1));
|
|
964 #if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
|
|
965 if (fseek(__file_, __sp, SEEK_SET))
|
|
966 return pos_type(off_type(-1));
|
|
967 #else
|
|
968 if (fseeko(__file_, __sp, SEEK_SET))
|
|
969 return pos_type(off_type(-1));
|
|
970 #endif
|
|
971 __st_ = __sp.state();
|
|
972 return __sp;
|
|
973 }
|
|
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 {
|
|
1048 sync();
|
|
1049 __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);
|
|
1050 bool __old_anc = __always_noconv_;
|
|
1051 __always_noconv_ = __cv_->always_noconv();
|
|
1052 if (__old_anc != __always_noconv_)
|
|
1053 {
|
|
1054 this->setg(0, 0, 0);
|
|
1055 this->setp(0, 0);
|
|
1056 // invariant, char_type is char, else we couldn't get here
|
|
1057 if (__always_noconv_) // need to dump __intbuf_
|
|
1058 {
|
|
1059 if (__owns_eb_)
|
|
1060 delete [] __extbuf_;
|
|
1061 __owns_eb_ = __owns_ib_;
|
|
1062 __ebs_ = __ibs_;
|
|
1063 __extbuf_ = (char*)__intbuf_;
|
|
1064 __ibs_ = 0;
|
|
1065 __intbuf_ = 0;
|
|
1066 __owns_ib_ = false;
|
|
1067 }
|
|
1068 else // need to obtain an __intbuf_.
|
|
1069 { // If __extbuf_ is user-supplied, use it, else new __intbuf_
|
|
1070 if (!__owns_eb_ && __extbuf_ != __extbuf_min_)
|
|
1071 {
|
|
1072 __ibs_ = __ebs_;
|
|
1073 __intbuf_ = (char_type*)__extbuf_;
|
|
1074 __owns_ib_ = false;
|
|
1075 __extbuf_ = new char[__ebs_];
|
|
1076 __owns_eb_ = true;
|
|
1077 }
|
|
1078 else
|
|
1079 {
|
|
1080 __ibs_ = __ebs_;
|
|
1081 __intbuf_ = new char_type[__ibs_];
|
|
1082 __owns_ib_ = true;
|
|
1083 }
|
|
1084 }
|
|
1085 }
|
|
1086 }
|
|
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 ios_base::openmode __mode) {
|
|
1326 if (__sb_.__open(__fd, __mode | ios_base::in))
|
|
1327 this->clear();
|
|
1328 else
|
|
1329 this->setstate(ios_base::failbit);
|
|
1330 }
|
|
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 ios_base::openmode __mode) {
|
|
1539 if (__sb_.__open(__fd, __mode | ios_base::out))
|
|
1540 this->clear();
|
|
1541 else
|
|
1542 this->setstate(ios_base::failbit);
|
|
1543 }
|
|
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
|