1 //===-------------------------- ios.cpp -----------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #define _LIBCPP_EXTERN_TEMPLATE(...) extern template __VA_ARGS__;
23 _LIBCPP_BEGIN_NAMESPACE_STD
25 template class basic_ios<char>;
26 template class basic_ios<wchar_t>;
28 template class basic_streambuf<char>;
29 template class basic_streambuf<wchar_t>;
31 template class basic_istream<char>;
32 template class basic_istream<wchar_t>;
34 template class basic_ostream<char>;
35 template class basic_ostream<wchar_t>;
37 template class basic_iostream<char>;
39 class _LIBCPP_HIDDEN __iostream_category
43 virtual const char* name() const _NOEXCEPT;
44 virtual string message(int ev) const;
48 __iostream_category::name() const _NOEXCEPT
54 __iostream_category::message(int ev) const
56 if (ev != static_cast<int>(io_errc::stream)
61 return __do_message::message(ev);
62 return string("unspecified iostream_category error");
66 iostream_category() _NOEXCEPT
68 static __iostream_category s;
74 ios_base::failure::failure(const string& msg, const error_code& ec)
75 : system_error(ec, msg)
79 ios_base::failure::failure(const char* msg, const error_code& ec)
80 : system_error(ec, msg)
84 ios_base::failure::~failure() throw()
90 const ios_base::fmtflags ios_base::boolalpha;
91 const ios_base::fmtflags ios_base::dec;
92 const ios_base::fmtflags ios_base::fixed;
93 const ios_base::fmtflags ios_base::hex;
94 const ios_base::fmtflags ios_base::internal;
95 const ios_base::fmtflags ios_base::left;
96 const ios_base::fmtflags ios_base::oct;
97 const ios_base::fmtflags ios_base::right;
98 const ios_base::fmtflags ios_base::scientific;
99 const ios_base::fmtflags ios_base::showbase;
100 const ios_base::fmtflags ios_base::showpoint;
101 const ios_base::fmtflags ios_base::showpos;
102 const ios_base::fmtflags ios_base::skipws;
103 const ios_base::fmtflags ios_base::unitbuf;
104 const ios_base::fmtflags ios_base::uppercase;
105 const ios_base::fmtflags ios_base::adjustfield;
106 const ios_base::fmtflags ios_base::basefield;
107 const ios_base::fmtflags ios_base::floatfield;
109 const ios_base::iostate ios_base::badbit;
110 const ios_base::iostate ios_base::eofbit;
111 const ios_base::iostate ios_base::failbit;
112 const ios_base::iostate ios_base::goodbit;
114 const ios_base::openmode ios_base::app;
115 const ios_base::openmode ios_base::ate;
116 const ios_base::openmode ios_base::binary;
117 const ios_base::openmode ios_base::in;
118 const ios_base::openmode ios_base::out;
119 const ios_base::openmode ios_base::trunc;
122 ios_base::__call_callbacks(event ev)
124 for (size_t i = __event_size_; i;)
127 __fn_[i](ev, *this, __index_[i]);
134 ios_base::imbue(const locale& newloc)
136 static_assert(sizeof(locale) == sizeof(__loc_), "");
137 locale& loc_storage = *(locale*)&__loc_;
138 locale oldloc = loc_storage;
139 loc_storage = newloc;
140 __call_callbacks(imbue_event);
145 ios_base::getloc() const
147 const locale& loc_storage = *(locale*)&__loc_;
152 #if __has_feature(cxx_atomic)
153 atomic<int> ios_base::__xindex_ = ATOMIC_VAR_INIT(0);
155 int ios_base::__xindex_ = 0;
165 ios_base::iword(int index)
167 size_t req_size = static_cast<size_t>(index)+1;
168 if (req_size > __iarray_cap_)
171 const size_t mx = std::numeric_limits<size_t>::max();
173 newcap = _VSTD::max(2 * __iarray_cap_, req_size);
176 long* iarray = (long*)realloc(__iarray_, newcap * sizeof(long));
185 for (long* p = __iarray_ + __iarray_size_; __iarray_cap_ < newcap; ++__iarray_cap_, ++p)
188 __iarray_size_ = max<size_t>(__iarray_size_, req_size);
189 return __iarray_[index];
193 ios_base::pword(int index)
195 size_t req_size = static_cast<size_t>(index)+1;
196 if (req_size > __parray_cap_)
199 const size_t mx = std::numeric_limits<size_t>::max();
201 newcap = _VSTD::max(2 * __parray_cap_, req_size);
204 void** parray = (void**)realloc(__parray_, newcap * sizeof(void*));
213 for (void** p = __parray_ + __parray_size_; __parray_cap_ < newcap; ++__parray_cap_, ++p)
216 __parray_size_ = max<size_t>(__parray_size_, req_size);
217 return __parray_[index];
223 ios_base::register_callback(event_callback fn, int index)
225 size_t req_size = __event_size_ + 1;
226 if (req_size > __event_cap_)
229 const size_t mx = std::numeric_limits<size_t>::max();
231 newcap = _VSTD::max(2 * __event_cap_, req_size);
234 event_callback* fns = (event_callback*)realloc(__fn_, newcap * sizeof(event_callback));
238 int* indxs = (int*)realloc(__index_, newcap * sizeof(int));
243 __fn_[__event_size_] = fn;
244 __index_[__event_size_] = index;
248 ios_base::~ios_base()
250 __call_callbacks(erase_event);
251 locale& loc_storage = *(locale*)&__loc_;
252 loc_storage.~locale();
262 ios_base::clear(iostate state)
267 __rdstate_ = state | badbit;
268 #ifndef _LIBCPP_NO_EXCEPTIONS
269 if (((state | (__rdbuf_ ? goodbit : badbit)) & __exceptions_) != 0)
270 throw failure("ios_base::clear");
271 #endif // _LIBCPP_NO_EXCEPTIONS
277 ios_base::init(void* sb)
280 __rdstate_ = __rdbuf_ ? goodbit : badbit;
281 __exceptions_ = goodbit;
282 __fmtflags_ = skipws | dec;
295 ::new(&__loc_) locale;
299 ios_base::copyfmt(const ios_base& rhs)
301 // If we can't acquire the needed resources, throw bad_alloc (can't set badbit)
302 // Don't alter *this until all needed resources are aquired
303 unique_ptr<event_callback, void (*)(void*)> new_callbacks(0, free);
304 unique_ptr<int, void (*)(void*)> new_ints(0, free);
305 unique_ptr<long, void (*)(void*)> new_longs(0, free);
306 unique_ptr<void*, void (*)(void*)> new_pointers(0, free);
307 if (__event_cap_ < rhs.__event_size_)
309 new_callbacks.reset((event_callback*)malloc(sizeof(event_callback) * rhs.__event_size_));
310 #ifndef _LIBCPP_NO_EXCEPTIONS
313 #endif // _LIBCPP_NO_EXCEPTIONS
314 new_ints.reset((int*)malloc(sizeof(int) * rhs.__event_size_));
315 #ifndef _LIBCPP_NO_EXCEPTIONS
318 #endif // _LIBCPP_NO_EXCEPTIONS
320 if (__iarray_cap_ < rhs.__iarray_size_)
322 new_longs.reset((long*)malloc(sizeof(long) * rhs.__iarray_size_));
323 #ifndef _LIBCPP_NO_EXCEPTIONS
326 #endif // _LIBCPP_NO_EXCEPTIONS
328 if (__parray_cap_ < rhs.__parray_size_)
330 new_pointers.reset((void**)malloc(sizeof(void*) * rhs.__parray_size_));
331 #ifndef _LIBCPP_NO_EXCEPTIONS
334 #endif // _LIBCPP_NO_EXCEPTIONS
336 // Got everything we need. Copy everything but __rdstate_, __rdbuf_ and __exceptions_
337 __fmtflags_ = rhs.__fmtflags_;
338 __precision_ = rhs.__precision_;
339 __width_ = rhs.__width_;
340 locale& lhs_loc = *(locale*)&__loc_;
341 locale& rhs_loc = *(locale*)&rhs.__loc_;
343 if (__event_cap_ < rhs.__event_size_)
346 __fn_ = new_callbacks.release();
348 __index_ = new_ints.release();
349 __event_cap_ = rhs.__event_size_;
351 for (__event_size_ = 0; __event_size_ < rhs.__event_size_; ++__event_size_)
353 __fn_[__event_size_] = rhs.__fn_[__event_size_];
354 __index_[__event_size_] = rhs.__index_[__event_size_];
356 if (__iarray_cap_ < rhs.__iarray_size_)
359 __iarray_ = new_longs.release();
360 __iarray_cap_ = rhs.__iarray_size_;
362 for (__iarray_size_ = 0; __iarray_size_ < rhs.__iarray_size_; ++__iarray_size_)
363 __iarray_[__iarray_size_] = rhs.__iarray_[__iarray_size_];
364 if (__parray_cap_ < rhs.__parray_size_)
367 __parray_ = new_pointers.release();
368 __parray_cap_ = rhs.__parray_size_;
370 for (__parray_size_ = 0; __parray_size_ < rhs.__parray_size_; ++__parray_size_)
371 __parray_[__parray_size_] = rhs.__parray_[__parray_size_];
375 ios_base::move(ios_base& rhs)
377 // *this is uninitialized
378 __fmtflags_ = rhs.__fmtflags_;
379 __precision_ = rhs.__precision_;
380 __width_ = rhs.__width_;
381 __rdstate_ = rhs.__rdstate_;
382 __exceptions_ = rhs.__exceptions_;
384 locale& rhs_loc = *(locale*)&rhs.__loc_;
385 ::new(&__loc_) locale(rhs_loc);
388 __index_ = rhs.__index_;
390 __event_size_ = rhs.__event_size_;
391 rhs.__event_size_ = 0;
392 __event_cap_ = rhs.__event_cap_;
393 rhs.__event_cap_ = 0;
394 __iarray_ = rhs.__iarray_;
396 __iarray_size_ = rhs.__iarray_size_;
397 rhs.__iarray_size_ = 0;
398 __iarray_cap_ = rhs.__iarray_cap_;
399 rhs.__iarray_cap_ = 0;
400 __parray_ = rhs.__parray_;
402 __parray_size_ = rhs.__parray_size_;
403 rhs.__parray_size_ = 0;
404 __parray_cap_ = rhs.__parray_cap_;
405 rhs.__parray_cap_ = 0;
409 ios_base::swap(ios_base& rhs) _NOEXCEPT
411 _VSTD::swap(__fmtflags_, rhs.__fmtflags_);
412 _VSTD::swap(__precision_, rhs.__precision_);
413 _VSTD::swap(__width_, rhs.__width_);
414 _VSTD::swap(__rdstate_, rhs.__rdstate_);
415 _VSTD::swap(__exceptions_, rhs.__exceptions_);
416 locale& lhs_loc = *(locale*)&__loc_;
417 locale& rhs_loc = *(locale*)&rhs.__loc_;
418 _VSTD::swap(lhs_loc, rhs_loc);
419 _VSTD::swap(__fn_, rhs.__fn_);
420 _VSTD::swap(__index_, rhs.__index_);
421 _VSTD::swap(__event_size_, rhs.__event_size_);
422 _VSTD::swap(__event_cap_, rhs.__event_cap_);
423 _VSTD::swap(__iarray_, rhs.__iarray_);
424 _VSTD::swap(__iarray_size_, rhs.__iarray_size_);
425 _VSTD::swap(__iarray_cap_, rhs.__iarray_cap_);
426 _VSTD::swap(__parray_, rhs.__parray_);
427 _VSTD::swap(__parray_size_, rhs.__parray_size_);
428 _VSTD::swap(__parray_cap_, rhs.__parray_cap_);
432 ios_base::__set_badbit_and_consider_rethrow()
434 __rdstate_ |= badbit;
435 #ifndef _LIBCPP_NO_EXCEPTIONS
436 if (__exceptions_ & badbit)
438 #endif // _LIBCPP_NO_EXCEPTIONS
442 ios_base::__set_failbit_and_consider_rethrow()
444 __rdstate_ |= failbit;
445 #ifndef _LIBCPP_NO_EXCEPTIONS
446 if (__exceptions_ & failbit)
448 #endif // _LIBCPP_NO_EXCEPTIONS
452 ios_base::sync_with_stdio(bool sync)
454 static bool previous_state = true;
455 bool r = previous_state;
456 previous_state = sync;
460 _LIBCPP_END_NAMESPACE_STD