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