xref: /netbsd-src/external/apache2/llvm/dist/libcxx/src/ios.cpp (revision 4d6fc14bc9b0c5bf3e30be318c143ee82cadd108)
1*4d6fc14bSjoerg //===-------------------------- ios.cpp -----------------------------------===//
2*4d6fc14bSjoerg //
3*4d6fc14bSjoerg // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4*4d6fc14bSjoerg // See https://llvm.org/LICENSE.txt for license information.
5*4d6fc14bSjoerg // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6*4d6fc14bSjoerg //
7*4d6fc14bSjoerg //===----------------------------------------------------------------------===//
8*4d6fc14bSjoerg 
9*4d6fc14bSjoerg #include "__config"
10*4d6fc14bSjoerg 
11*4d6fc14bSjoerg #include "ios"
12*4d6fc14bSjoerg 
13*4d6fc14bSjoerg #include <stdlib.h>
14*4d6fc14bSjoerg 
15*4d6fc14bSjoerg #include "__locale"
16*4d6fc14bSjoerg #include "algorithm"
17*4d6fc14bSjoerg #include "include/config_elast.h"
18*4d6fc14bSjoerg #include "limits"
19*4d6fc14bSjoerg #include "memory"
20*4d6fc14bSjoerg #include "new"
21*4d6fc14bSjoerg #include "string"
22*4d6fc14bSjoerg #include "__undef_macros"
23*4d6fc14bSjoerg 
24*4d6fc14bSjoerg _LIBCPP_BEGIN_NAMESPACE_STD
25*4d6fc14bSjoerg 
26*4d6fc14bSjoerg class _LIBCPP_HIDDEN __iostream_category
27*4d6fc14bSjoerg     : public __do_message
28*4d6fc14bSjoerg {
29*4d6fc14bSjoerg public:
30*4d6fc14bSjoerg     virtual const char* name() const noexcept;
31*4d6fc14bSjoerg     virtual string message(int ev) const;
32*4d6fc14bSjoerg };
33*4d6fc14bSjoerg 
34*4d6fc14bSjoerg const char*
name() const35*4d6fc14bSjoerg __iostream_category::name() const noexcept
36*4d6fc14bSjoerg {
37*4d6fc14bSjoerg     return "iostream";
38*4d6fc14bSjoerg }
39*4d6fc14bSjoerg 
40*4d6fc14bSjoerg string
message(int ev) const41*4d6fc14bSjoerg __iostream_category::message(int ev) const
42*4d6fc14bSjoerg {
43*4d6fc14bSjoerg     if (ev != static_cast<int>(io_errc::stream)
44*4d6fc14bSjoerg #ifdef _LIBCPP_ELAST
45*4d6fc14bSjoerg         && ev <= _LIBCPP_ELAST
46*4d6fc14bSjoerg #endif // _LIBCPP_ELAST
47*4d6fc14bSjoerg         )
48*4d6fc14bSjoerg         return __do_message::message(ev);
49*4d6fc14bSjoerg     return string("unspecified iostream_category error");
50*4d6fc14bSjoerg }
51*4d6fc14bSjoerg 
52*4d6fc14bSjoerg const error_category&
iostream_category()53*4d6fc14bSjoerg iostream_category() noexcept
54*4d6fc14bSjoerg {
55*4d6fc14bSjoerg     static __iostream_category s;
56*4d6fc14bSjoerg     return s;
57*4d6fc14bSjoerg }
58*4d6fc14bSjoerg 
59*4d6fc14bSjoerg // ios_base::failure
60*4d6fc14bSjoerg 
failure(const string & msg,const error_code & ec)61*4d6fc14bSjoerg ios_base::failure::failure(const string& msg, const error_code& ec)
62*4d6fc14bSjoerg     : system_error(ec, msg)
63*4d6fc14bSjoerg {
64*4d6fc14bSjoerg }
65*4d6fc14bSjoerg 
failure(const char * msg,const error_code & ec)66*4d6fc14bSjoerg ios_base::failure::failure(const char* msg, const error_code& ec)
67*4d6fc14bSjoerg     : system_error(ec, msg)
68*4d6fc14bSjoerg {
69*4d6fc14bSjoerg }
70*4d6fc14bSjoerg 
~failure()71*4d6fc14bSjoerg ios_base::failure::~failure() throw()
72*4d6fc14bSjoerg {
73*4d6fc14bSjoerg }
74*4d6fc14bSjoerg 
75*4d6fc14bSjoerg // ios_base locale
76*4d6fc14bSjoerg 
77*4d6fc14bSjoerg const ios_base::fmtflags ios_base::boolalpha;
78*4d6fc14bSjoerg const ios_base::fmtflags ios_base::dec;
79*4d6fc14bSjoerg const ios_base::fmtflags ios_base::fixed;
80*4d6fc14bSjoerg const ios_base::fmtflags ios_base::hex;
81*4d6fc14bSjoerg const ios_base::fmtflags ios_base::internal;
82*4d6fc14bSjoerg const ios_base::fmtflags ios_base::left;
83*4d6fc14bSjoerg const ios_base::fmtflags ios_base::oct;
84*4d6fc14bSjoerg const ios_base::fmtflags ios_base::right;
85*4d6fc14bSjoerg const ios_base::fmtflags ios_base::scientific;
86*4d6fc14bSjoerg const ios_base::fmtflags ios_base::showbase;
87*4d6fc14bSjoerg const ios_base::fmtflags ios_base::showpoint;
88*4d6fc14bSjoerg const ios_base::fmtflags ios_base::showpos;
89*4d6fc14bSjoerg const ios_base::fmtflags ios_base::skipws;
90*4d6fc14bSjoerg const ios_base::fmtflags ios_base::unitbuf;
91*4d6fc14bSjoerg const ios_base::fmtflags ios_base::uppercase;
92*4d6fc14bSjoerg const ios_base::fmtflags ios_base::adjustfield;
93*4d6fc14bSjoerg const ios_base::fmtflags ios_base::basefield;
94*4d6fc14bSjoerg const ios_base::fmtflags ios_base::floatfield;
95*4d6fc14bSjoerg 
96*4d6fc14bSjoerg const ios_base::iostate ios_base::badbit;
97*4d6fc14bSjoerg const ios_base::iostate ios_base::eofbit;
98*4d6fc14bSjoerg const ios_base::iostate ios_base::failbit;
99*4d6fc14bSjoerg const ios_base::iostate ios_base::goodbit;
100*4d6fc14bSjoerg 
101*4d6fc14bSjoerg const ios_base::openmode ios_base::app;
102*4d6fc14bSjoerg const ios_base::openmode ios_base::ate;
103*4d6fc14bSjoerg const ios_base::openmode ios_base::binary;
104*4d6fc14bSjoerg const ios_base::openmode ios_base::in;
105*4d6fc14bSjoerg const ios_base::openmode ios_base::out;
106*4d6fc14bSjoerg const ios_base::openmode ios_base::trunc;
107*4d6fc14bSjoerg 
108*4d6fc14bSjoerg void
__call_callbacks(event ev)109*4d6fc14bSjoerg ios_base::__call_callbacks(event ev)
110*4d6fc14bSjoerg {
111*4d6fc14bSjoerg     for (size_t i = __event_size_; i;)
112*4d6fc14bSjoerg     {
113*4d6fc14bSjoerg         --i;
114*4d6fc14bSjoerg         __fn_[i](ev, *this, __index_[i]);
115*4d6fc14bSjoerg     }
116*4d6fc14bSjoerg }
117*4d6fc14bSjoerg 
118*4d6fc14bSjoerg // locale
119*4d6fc14bSjoerg 
120*4d6fc14bSjoerg locale
imbue(const locale & newloc)121*4d6fc14bSjoerg ios_base::imbue(const locale& newloc)
122*4d6fc14bSjoerg {
123*4d6fc14bSjoerg     static_assert(sizeof(locale) == sizeof(__loc_), "");
124*4d6fc14bSjoerg     locale& loc_storage = *reinterpret_cast<locale*>(&__loc_);
125*4d6fc14bSjoerg     locale oldloc = loc_storage;
126*4d6fc14bSjoerg     loc_storage = newloc;
127*4d6fc14bSjoerg     __call_callbacks(imbue_event);
128*4d6fc14bSjoerg     return oldloc;
129*4d6fc14bSjoerg }
130*4d6fc14bSjoerg 
131*4d6fc14bSjoerg locale
getloc() const132*4d6fc14bSjoerg ios_base::getloc() const
133*4d6fc14bSjoerg {
134*4d6fc14bSjoerg     const locale& loc_storage = *reinterpret_cast<const locale*>(&__loc_);
135*4d6fc14bSjoerg     return loc_storage;
136*4d6fc14bSjoerg }
137*4d6fc14bSjoerg 
138*4d6fc14bSjoerg // xalloc
139*4d6fc14bSjoerg #if defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS)
140*4d6fc14bSjoerg atomic<int> ios_base::__xindex_ = ATOMIC_VAR_INIT(0);
141*4d6fc14bSjoerg #else
142*4d6fc14bSjoerg int ios_base::__xindex_ = 0;
143*4d6fc14bSjoerg #endif
144*4d6fc14bSjoerg 
145*4d6fc14bSjoerg template <typename _Tp>
__ios_new_cap(size_t __req_size,size_t __current_cap)146*4d6fc14bSjoerg static size_t __ios_new_cap(size_t __req_size, size_t __current_cap)
147*4d6fc14bSjoerg { // Precondition: __req_size > __current_cap
148*4d6fc14bSjoerg 	const size_t mx = std::numeric_limits<size_t>::max() / sizeof(_Tp);
149*4d6fc14bSjoerg 	if (__req_size < mx/2)
150*4d6fc14bSjoerg 		return _VSTD::max(2 * __current_cap, __req_size);
151*4d6fc14bSjoerg 	else
152*4d6fc14bSjoerg 		return mx;
153*4d6fc14bSjoerg }
154*4d6fc14bSjoerg 
155*4d6fc14bSjoerg int
xalloc()156*4d6fc14bSjoerg ios_base::xalloc()
157*4d6fc14bSjoerg {
158*4d6fc14bSjoerg     return __xindex_++;
159*4d6fc14bSjoerg }
160*4d6fc14bSjoerg 
161*4d6fc14bSjoerg long&
iword(int index)162*4d6fc14bSjoerg ios_base::iword(int index)
163*4d6fc14bSjoerg {
164*4d6fc14bSjoerg     size_t req_size = static_cast<size_t>(index)+1;
165*4d6fc14bSjoerg     if (req_size > __iarray_cap_)
166*4d6fc14bSjoerg     {
167*4d6fc14bSjoerg         size_t newcap = __ios_new_cap<long>(req_size, __iarray_cap_);
168*4d6fc14bSjoerg         long* iarray = static_cast<long*>(realloc(__iarray_, newcap * sizeof(long)));
169*4d6fc14bSjoerg         if (iarray == 0)
170*4d6fc14bSjoerg         {
171*4d6fc14bSjoerg             setstate(badbit);
172*4d6fc14bSjoerg             static long error;
173*4d6fc14bSjoerg             error = 0;
174*4d6fc14bSjoerg             return error;
175*4d6fc14bSjoerg         }
176*4d6fc14bSjoerg         __iarray_ = iarray;
177*4d6fc14bSjoerg         for (long* p = __iarray_ + __iarray_size_; p < __iarray_ + newcap; ++p)
178*4d6fc14bSjoerg             *p = 0;
179*4d6fc14bSjoerg         __iarray_cap_ = newcap;
180*4d6fc14bSjoerg     }
181*4d6fc14bSjoerg     __iarray_size_ = max<size_t>(__iarray_size_, req_size);
182*4d6fc14bSjoerg     return __iarray_[index];
183*4d6fc14bSjoerg }
184*4d6fc14bSjoerg 
185*4d6fc14bSjoerg void*&
pword(int index)186*4d6fc14bSjoerg ios_base::pword(int index)
187*4d6fc14bSjoerg {
188*4d6fc14bSjoerg     size_t req_size = static_cast<size_t>(index)+1;
189*4d6fc14bSjoerg     if (req_size > __parray_cap_)
190*4d6fc14bSjoerg     {
191*4d6fc14bSjoerg         size_t newcap = __ios_new_cap<void *>(req_size, __iarray_cap_);
192*4d6fc14bSjoerg         void** parray = static_cast<void**>(realloc(__parray_, newcap * sizeof(void *)));
193*4d6fc14bSjoerg         if (parray == 0)
194*4d6fc14bSjoerg         {
195*4d6fc14bSjoerg             setstate(badbit);
196*4d6fc14bSjoerg             static void* error;
197*4d6fc14bSjoerg             error = 0;
198*4d6fc14bSjoerg             return error;
199*4d6fc14bSjoerg         }
200*4d6fc14bSjoerg         __parray_ = parray;
201*4d6fc14bSjoerg         for (void** p = __parray_ + __parray_size_; p < __parray_ + newcap; ++p)
202*4d6fc14bSjoerg             *p = 0;
203*4d6fc14bSjoerg         __parray_cap_ = newcap;
204*4d6fc14bSjoerg     }
205*4d6fc14bSjoerg     __parray_size_ = max<size_t>(__parray_size_, req_size);
206*4d6fc14bSjoerg     return __parray_[index];
207*4d6fc14bSjoerg }
208*4d6fc14bSjoerg 
209*4d6fc14bSjoerg // register_callback
210*4d6fc14bSjoerg 
211*4d6fc14bSjoerg void
register_callback(event_callback fn,int index)212*4d6fc14bSjoerg ios_base::register_callback(event_callback fn, int index)
213*4d6fc14bSjoerg {
214*4d6fc14bSjoerg     size_t req_size = __event_size_ + 1;
215*4d6fc14bSjoerg     if (req_size > __event_cap_)
216*4d6fc14bSjoerg     {
217*4d6fc14bSjoerg         size_t newcap = __ios_new_cap<event_callback>(req_size, __event_cap_);
218*4d6fc14bSjoerg         event_callback* fns = static_cast<event_callback*>(realloc(__fn_, newcap * sizeof(event_callback)));
219*4d6fc14bSjoerg         if (fns == 0)
220*4d6fc14bSjoerg             setstate(badbit);
221*4d6fc14bSjoerg         __fn_ = fns;
222*4d6fc14bSjoerg         int* indxs = static_cast<int *>(realloc(__index_, newcap * sizeof(int)));
223*4d6fc14bSjoerg         if (indxs == 0)
224*4d6fc14bSjoerg             setstate(badbit);
225*4d6fc14bSjoerg         __index_ = indxs;
226*4d6fc14bSjoerg         __event_cap_ = newcap;
227*4d6fc14bSjoerg     }
228*4d6fc14bSjoerg     __fn_[__event_size_] = fn;
229*4d6fc14bSjoerg     __index_[__event_size_] = index;
230*4d6fc14bSjoerg     ++__event_size_;
231*4d6fc14bSjoerg }
232*4d6fc14bSjoerg 
~ios_base()233*4d6fc14bSjoerg ios_base::~ios_base()
234*4d6fc14bSjoerg {
235*4d6fc14bSjoerg     __call_callbacks(erase_event);
236*4d6fc14bSjoerg     locale& loc_storage = *reinterpret_cast<locale*>(&__loc_);
237*4d6fc14bSjoerg     loc_storage.~locale();
238*4d6fc14bSjoerg     free(__fn_);
239*4d6fc14bSjoerg     free(__index_);
240*4d6fc14bSjoerg     free(__iarray_);
241*4d6fc14bSjoerg     free(__parray_);
242*4d6fc14bSjoerg }
243*4d6fc14bSjoerg 
244*4d6fc14bSjoerg // iostate
245*4d6fc14bSjoerg 
246*4d6fc14bSjoerg void
clear(iostate state)247*4d6fc14bSjoerg ios_base::clear(iostate state)
248*4d6fc14bSjoerg {
249*4d6fc14bSjoerg     if (__rdbuf_)
250*4d6fc14bSjoerg         __rdstate_ = state;
251*4d6fc14bSjoerg     else
252*4d6fc14bSjoerg         __rdstate_ = state | badbit;
253*4d6fc14bSjoerg 
254*4d6fc14bSjoerg     if (((state | (__rdbuf_ ? goodbit : badbit)) & __exceptions_) != 0)
255*4d6fc14bSjoerg         __throw_failure("ios_base::clear");
256*4d6fc14bSjoerg }
257*4d6fc14bSjoerg 
258*4d6fc14bSjoerg // init
259*4d6fc14bSjoerg 
260*4d6fc14bSjoerg void
init(void * sb)261*4d6fc14bSjoerg ios_base::init(void* sb)
262*4d6fc14bSjoerg {
263*4d6fc14bSjoerg     __rdbuf_ = sb;
264*4d6fc14bSjoerg     __rdstate_ = __rdbuf_ ? goodbit : badbit;
265*4d6fc14bSjoerg     __exceptions_ = goodbit;
266*4d6fc14bSjoerg     __fmtflags_ = skipws | dec;
267*4d6fc14bSjoerg     __width_ = 0;
268*4d6fc14bSjoerg     __precision_ = 6;
269*4d6fc14bSjoerg     __fn_ = 0;
270*4d6fc14bSjoerg     __index_ = 0;
271*4d6fc14bSjoerg     __event_size_ = 0;
272*4d6fc14bSjoerg     __event_cap_ = 0;
273*4d6fc14bSjoerg     __iarray_ = 0;
274*4d6fc14bSjoerg     __iarray_size_ = 0;
275*4d6fc14bSjoerg     __iarray_cap_ = 0;
276*4d6fc14bSjoerg     __parray_ = 0;
277*4d6fc14bSjoerg     __parray_size_ = 0;
278*4d6fc14bSjoerg     __parray_cap_ = 0;
279*4d6fc14bSjoerg     ::new(&__loc_) locale;
280*4d6fc14bSjoerg }
281*4d6fc14bSjoerg 
282*4d6fc14bSjoerg void
copyfmt(const ios_base & rhs)283*4d6fc14bSjoerg ios_base::copyfmt(const ios_base& rhs)
284*4d6fc14bSjoerg {
285*4d6fc14bSjoerg     // If we can't acquire the needed resources, throw bad_alloc (can't set badbit)
286*4d6fc14bSjoerg     // Don't alter *this until all needed resources are acquired
287*4d6fc14bSjoerg     unique_ptr<event_callback, void (*)(void*)> new_callbacks(0, free);
288*4d6fc14bSjoerg     unique_ptr<int, void (*)(void*)> new_ints(0, free);
289*4d6fc14bSjoerg     unique_ptr<long, void (*)(void*)> new_longs(0, free);
290*4d6fc14bSjoerg     unique_ptr<void*, void (*)(void*)> new_pointers(0, free);
291*4d6fc14bSjoerg     if (__event_cap_ < rhs.__event_size_)
292*4d6fc14bSjoerg     {
293*4d6fc14bSjoerg         size_t newesize = sizeof(event_callback) * rhs.__event_size_;
294*4d6fc14bSjoerg         new_callbacks.reset(static_cast<event_callback*>(malloc(newesize)));
295*4d6fc14bSjoerg         if (!new_callbacks)
296*4d6fc14bSjoerg             __throw_bad_alloc();
297*4d6fc14bSjoerg 
298*4d6fc14bSjoerg         size_t newisize = sizeof(int) * rhs.__event_size_;
299*4d6fc14bSjoerg         new_ints.reset(static_cast<int *>(malloc(newisize)));
300*4d6fc14bSjoerg         if (!new_ints)
301*4d6fc14bSjoerg             __throw_bad_alloc();
302*4d6fc14bSjoerg     }
303*4d6fc14bSjoerg     if (__iarray_cap_ < rhs.__iarray_size_)
304*4d6fc14bSjoerg     {
305*4d6fc14bSjoerg         size_t newsize = sizeof(long) * rhs.__iarray_size_;
306*4d6fc14bSjoerg         new_longs.reset(static_cast<long*>(malloc(newsize)));
307*4d6fc14bSjoerg         if (!new_longs)
308*4d6fc14bSjoerg             __throw_bad_alloc();
309*4d6fc14bSjoerg     }
310*4d6fc14bSjoerg     if (__parray_cap_ < rhs.__parray_size_)
311*4d6fc14bSjoerg     {
312*4d6fc14bSjoerg         size_t newsize = sizeof(void*) * rhs.__parray_size_;
313*4d6fc14bSjoerg         new_pointers.reset(static_cast<void**>(malloc(newsize)));
314*4d6fc14bSjoerg         if (!new_pointers)
315*4d6fc14bSjoerg             __throw_bad_alloc();
316*4d6fc14bSjoerg     }
317*4d6fc14bSjoerg     // Got everything we need.  Copy everything but __rdstate_, __rdbuf_ and __exceptions_
318*4d6fc14bSjoerg     __fmtflags_ = rhs.__fmtflags_;
319*4d6fc14bSjoerg     __precision_ = rhs.__precision_;
320*4d6fc14bSjoerg     __width_ = rhs.__width_;
321*4d6fc14bSjoerg     locale& lhs_loc = *reinterpret_cast<locale*>(&__loc_);
322*4d6fc14bSjoerg     const locale& rhs_loc = *reinterpret_cast<const locale*>(&rhs.__loc_);
323*4d6fc14bSjoerg     lhs_loc = rhs_loc;
324*4d6fc14bSjoerg     if (__event_cap_ < rhs.__event_size_)
325*4d6fc14bSjoerg     {
326*4d6fc14bSjoerg         free(__fn_);
327*4d6fc14bSjoerg         __fn_ = new_callbacks.release();
328*4d6fc14bSjoerg         free(__index_);
329*4d6fc14bSjoerg         __index_ = new_ints.release();
330*4d6fc14bSjoerg         __event_cap_ = rhs.__event_size_;
331*4d6fc14bSjoerg     }
332*4d6fc14bSjoerg     for (__event_size_ = 0; __event_size_ < rhs.__event_size_; ++__event_size_)
333*4d6fc14bSjoerg     {
334*4d6fc14bSjoerg         __fn_[__event_size_] = rhs.__fn_[__event_size_];
335*4d6fc14bSjoerg         __index_[__event_size_] = rhs.__index_[__event_size_];
336*4d6fc14bSjoerg     }
337*4d6fc14bSjoerg     if (__iarray_cap_ < rhs.__iarray_size_)
338*4d6fc14bSjoerg     {
339*4d6fc14bSjoerg         free(__iarray_);
340*4d6fc14bSjoerg         __iarray_ = new_longs.release();
341*4d6fc14bSjoerg         __iarray_cap_ = rhs.__iarray_size_;
342*4d6fc14bSjoerg     }
343*4d6fc14bSjoerg     for (__iarray_size_ = 0; __iarray_size_ < rhs.__iarray_size_; ++__iarray_size_)
344*4d6fc14bSjoerg         __iarray_[__iarray_size_] = rhs.__iarray_[__iarray_size_];
345*4d6fc14bSjoerg     if (__parray_cap_ < rhs.__parray_size_)
346*4d6fc14bSjoerg     {
347*4d6fc14bSjoerg         free(__parray_);
348*4d6fc14bSjoerg         __parray_ = new_pointers.release();
349*4d6fc14bSjoerg         __parray_cap_ = rhs.__parray_size_;
350*4d6fc14bSjoerg     }
351*4d6fc14bSjoerg     for (__parray_size_ = 0; __parray_size_ < rhs.__parray_size_; ++__parray_size_)
352*4d6fc14bSjoerg         __parray_[__parray_size_] = rhs.__parray_[__parray_size_];
353*4d6fc14bSjoerg }
354*4d6fc14bSjoerg 
355*4d6fc14bSjoerg void
move(ios_base & rhs)356*4d6fc14bSjoerg ios_base::move(ios_base& rhs)
357*4d6fc14bSjoerg {
358*4d6fc14bSjoerg     // *this is uninitialized
359*4d6fc14bSjoerg     __fmtflags_ = rhs.__fmtflags_;
360*4d6fc14bSjoerg     __precision_ = rhs.__precision_;
361*4d6fc14bSjoerg     __width_ = rhs.__width_;
362*4d6fc14bSjoerg     __rdstate_ = rhs.__rdstate_;
363*4d6fc14bSjoerg     __exceptions_ = rhs.__exceptions_;
364*4d6fc14bSjoerg     __rdbuf_ = 0;
365*4d6fc14bSjoerg     locale& rhs_loc = *reinterpret_cast<locale*>(&rhs.__loc_);
366*4d6fc14bSjoerg     ::new(&__loc_) locale(rhs_loc);
367*4d6fc14bSjoerg     __fn_ = rhs.__fn_;
368*4d6fc14bSjoerg     rhs.__fn_ = 0;
369*4d6fc14bSjoerg     __index_ = rhs.__index_;
370*4d6fc14bSjoerg     rhs.__index_ = 0;
371*4d6fc14bSjoerg     __event_size_ = rhs.__event_size_;
372*4d6fc14bSjoerg     rhs.__event_size_ = 0;
373*4d6fc14bSjoerg     __event_cap_ = rhs.__event_cap_;
374*4d6fc14bSjoerg     rhs.__event_cap_ = 0;
375*4d6fc14bSjoerg     __iarray_ = rhs.__iarray_;
376*4d6fc14bSjoerg     rhs.__iarray_ = 0;
377*4d6fc14bSjoerg     __iarray_size_ = rhs.__iarray_size_;
378*4d6fc14bSjoerg     rhs.__iarray_size_ = 0;
379*4d6fc14bSjoerg     __iarray_cap_ = rhs.__iarray_cap_;
380*4d6fc14bSjoerg     rhs.__iarray_cap_ = 0;
381*4d6fc14bSjoerg     __parray_ = rhs.__parray_;
382*4d6fc14bSjoerg     rhs.__parray_ = 0;
383*4d6fc14bSjoerg     __parray_size_ = rhs.__parray_size_;
384*4d6fc14bSjoerg     rhs.__parray_size_ = 0;
385*4d6fc14bSjoerg     __parray_cap_ = rhs.__parray_cap_;
386*4d6fc14bSjoerg     rhs.__parray_cap_ = 0;
387*4d6fc14bSjoerg }
388*4d6fc14bSjoerg 
389*4d6fc14bSjoerg void
swap(ios_base & rhs)390*4d6fc14bSjoerg ios_base::swap(ios_base& rhs) noexcept
391*4d6fc14bSjoerg {
392*4d6fc14bSjoerg     _VSTD::swap(__fmtflags_, rhs.__fmtflags_);
393*4d6fc14bSjoerg     _VSTD::swap(__precision_, rhs.__precision_);
394*4d6fc14bSjoerg     _VSTD::swap(__width_, rhs.__width_);
395*4d6fc14bSjoerg     _VSTD::swap(__rdstate_, rhs.__rdstate_);
396*4d6fc14bSjoerg     _VSTD::swap(__exceptions_, rhs.__exceptions_);
397*4d6fc14bSjoerg     locale& lhs_loc = *reinterpret_cast<locale*>(&__loc_);
398*4d6fc14bSjoerg     locale& rhs_loc = *reinterpret_cast<locale*>(&rhs.__loc_);
399*4d6fc14bSjoerg     _VSTD::swap(lhs_loc, rhs_loc);
400*4d6fc14bSjoerg     _VSTD::swap(__fn_, rhs.__fn_);
401*4d6fc14bSjoerg     _VSTD::swap(__index_, rhs.__index_);
402*4d6fc14bSjoerg     _VSTD::swap(__event_size_, rhs.__event_size_);
403*4d6fc14bSjoerg     _VSTD::swap(__event_cap_, rhs.__event_cap_);
404*4d6fc14bSjoerg     _VSTD::swap(__iarray_, rhs.__iarray_);
405*4d6fc14bSjoerg     _VSTD::swap(__iarray_size_, rhs.__iarray_size_);
406*4d6fc14bSjoerg     _VSTD::swap(__iarray_cap_, rhs.__iarray_cap_);
407*4d6fc14bSjoerg     _VSTD::swap(__parray_, rhs.__parray_);
408*4d6fc14bSjoerg     _VSTD::swap(__parray_size_, rhs.__parray_size_);
409*4d6fc14bSjoerg     _VSTD::swap(__parray_cap_, rhs.__parray_cap_);
410*4d6fc14bSjoerg }
411*4d6fc14bSjoerg 
412*4d6fc14bSjoerg void
__set_badbit_and_consider_rethrow()413*4d6fc14bSjoerg ios_base::__set_badbit_and_consider_rethrow()
414*4d6fc14bSjoerg {
415*4d6fc14bSjoerg     __rdstate_ |= badbit;
416*4d6fc14bSjoerg #ifndef _LIBCPP_NO_EXCEPTIONS
417*4d6fc14bSjoerg     if (__exceptions_ & badbit)
418*4d6fc14bSjoerg         throw;
419*4d6fc14bSjoerg #endif // _LIBCPP_NO_EXCEPTIONS
420*4d6fc14bSjoerg }
421*4d6fc14bSjoerg 
422*4d6fc14bSjoerg void
__set_failbit_and_consider_rethrow()423*4d6fc14bSjoerg ios_base::__set_failbit_and_consider_rethrow()
424*4d6fc14bSjoerg {
425*4d6fc14bSjoerg     __rdstate_ |= failbit;
426*4d6fc14bSjoerg #ifndef _LIBCPP_NO_EXCEPTIONS
427*4d6fc14bSjoerg     if (__exceptions_ & failbit)
428*4d6fc14bSjoerg         throw;
429*4d6fc14bSjoerg #endif // _LIBCPP_NO_EXCEPTIONS
430*4d6fc14bSjoerg }
431*4d6fc14bSjoerg 
432*4d6fc14bSjoerg bool
sync_with_stdio(bool sync)433*4d6fc14bSjoerg ios_base::sync_with_stdio(bool sync)
434*4d6fc14bSjoerg {
435*4d6fc14bSjoerg     static bool previous_state = true;
436*4d6fc14bSjoerg     bool r = previous_state;
437*4d6fc14bSjoerg     previous_state = sync;
438*4d6fc14bSjoerg     return r;
439*4d6fc14bSjoerg }
440*4d6fc14bSjoerg 
441*4d6fc14bSjoerg _LIBCPP_END_NAMESPACE_STD
442