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 //===----------------------------------------------------------------------===//
21 _LIBCPP_BEGIN_NAMESPACE_STD
23 template class basic_ios<char>;
24 template class basic_ios<wchar_t>;
26 template class basic_streambuf<char>;
27 template class basic_streambuf<wchar_t>;
29 template class basic_istream<char>;
30 template class basic_istream<wchar_t>;
32 template class basic_ostream<char>;
33 template class basic_ostream<wchar_t>;
35 template class basic_iostream<char>;
37 class _LIBCPP_HIDDEN __iostream_category
41 virtual const char* name() const _NOEXCEPT;
42 virtual string message(int ev) const;
46 __iostream_category::name() const _NOEXCEPT
52 __iostream_category::message(int ev) const
54 if (ev != static_cast<int>(io_errc::stream)
59 return __do_message::message(ev);
60 return string("unspecified iostream_category error");
66 static __iostream_category s;
72 ios_base::failure::failure(const string& msg, const error_code& ec)
73 : system_error(ec, msg)
77 ios_base::failure::failure(const char* msg, const error_code& ec)
78 : system_error(ec, msg)
82 ios_base::failure::~failure() throw()
88 const ios_base::fmtflags ios_base::boolalpha;
89 const ios_base::fmtflags ios_base::dec;
90 const ios_base::fmtflags ios_base::fixed;
91 const ios_base::fmtflags ios_base::hex;
92 const ios_base::fmtflags ios_base::internal;
93 const ios_base::fmtflags ios_base::left;
94 const ios_base::fmtflags ios_base::oct;
95 const ios_base::fmtflags ios_base::right;
96 const ios_base::fmtflags ios_base::scientific;
97 const ios_base::fmtflags ios_base::showbase;
98 const ios_base::fmtflags ios_base::showpoint;
99 const ios_base::fmtflags ios_base::showpos;
100 const ios_base::fmtflags ios_base::skipws;
101 const ios_base::fmtflags ios_base::unitbuf;
102 const ios_base::fmtflags ios_base::uppercase;
103 const ios_base::fmtflags ios_base::adjustfield;
104 const ios_base::fmtflags ios_base::basefield;
105 const ios_base::fmtflags ios_base::floatfield;
107 const ios_base::iostate ios_base::badbit;
108 const ios_base::iostate ios_base::eofbit;
109 const ios_base::iostate ios_base::failbit;
110 const ios_base::iostate ios_base::goodbit;
112 const ios_base::openmode ios_base::app;
113 const ios_base::openmode ios_base::ate;
114 const ios_base::openmode ios_base::binary;
115 const ios_base::openmode ios_base::in;
116 const ios_base::openmode ios_base::out;
117 const ios_base::openmode ios_base::trunc;
120 ios_base::__call_callbacks(event ev)
122 for (size_t i = __event_size_; i;)
125 __fn_[i](ev, *this, __index_[i]);
132 ios_base::imbue(const locale& newloc)
134 static_assert(sizeof(locale) == sizeof(__loc_), "");
135 locale& loc_storage = *(locale*)&__loc_;
136 locale oldloc = loc_storage;
137 loc_storage = newloc;
138 __call_callbacks(imbue_event);
143 ios_base::getloc() const
145 const locale& loc_storage = *(locale*)&__loc_;
151 int ios_base::__xindex_ = 0;
160 ios_base::iword(int index)
162 size_t req_size = static_cast<size_t>(index)+1;
163 if (req_size > __iarray_cap_)
166 const size_t mx = std::numeric_limits<size_t>::max();
168 newcap = _VSTD::max(2 * __iarray_cap_, req_size);
171 long* iarray = (long*)realloc(__iarray_, newcap * sizeof(long));
180 for (long* p = __iarray_ + __iarray_size_; __iarray_cap_ < newcap; ++__iarray_cap_, ++p)
183 __iarray_size_ = max<size_t>(__iarray_size_, req_size);
184 return __iarray_[index];
188 ios_base::pword(int index)
190 size_t req_size = static_cast<size_t>(index)+1;
191 if (req_size > __parray_cap_)
194 const size_t mx = std::numeric_limits<size_t>::max();
196 newcap = _VSTD::max(2 * __parray_cap_, req_size);
199 void** parray = (void**)realloc(__parray_, newcap * sizeof(void*));
208 for (void** p = __parray_ + __parray_size_; __parray_cap_ < newcap; ++__parray_cap_, ++p)
211 __parray_size_ = max<size_t>(__parray_size_, req_size);
212 return __parray_[index];
218 ios_base::register_callback(event_callback fn, int index)
220 size_t req_size = __event_size_ + 1;
221 if (req_size > __event_cap_)
224 const size_t mx = std::numeric_limits<size_t>::max();
226 newcap = _VSTD::max(2 * __event_cap_, req_size);
229 event_callback* fns = (event_callback*)realloc(__fn_, newcap * sizeof(event_callback));
233 int* indxs = (int*)realloc(__index_, newcap * sizeof(int));
238 __fn_[__event_size_] = fn;
239 __index_[__event_size_] = index;
243 ios_base::~ios_base()
245 __call_callbacks(erase_event);
246 locale& loc_storage = *(locale*)&__loc_;
247 loc_storage.~locale();
257 ios_base::clear(iostate state)
262 __rdstate_ = state | badbit;
263 #ifndef _LIBCPP_NO_EXCEPTIONS
264 if (((state | (__rdbuf_ ? goodbit : badbit)) & __exceptions_) != 0)
265 throw failure("ios_base::clear");
266 #endif // _LIBCPP_NO_EXCEPTIONS
272 ios_base::init(void* sb)
275 __rdstate_ = __rdbuf_ ? goodbit : badbit;
276 __exceptions_ = goodbit;
277 __fmtflags_ = skipws | dec;
290 ::new(&__loc_) locale;
294 ios_base::copyfmt(const ios_base& rhs)
296 // If we can't acquire the needed resources, throw bad_alloc (can't set badbit)
297 // Don't alter *this until all needed resources are aquired
298 unique_ptr<event_callback, void (*)(void*)> new_callbacks(0, free);
299 unique_ptr<int, void (*)(void*)> new_ints(0, free);
300 unique_ptr<long, void (*)(void*)> new_longs(0, free);
301 unique_ptr<void*, void (*)(void*)> new_pointers(0, free);
302 if (__event_cap_ < rhs.__event_size_)
304 new_callbacks.reset((event_callback*)malloc(sizeof(event_callback) * rhs.__event_size_));
305 #ifndef _LIBCPP_NO_EXCEPTIONS
308 #endif // _LIBCPP_NO_EXCEPTIONS
309 new_ints.reset((int*)malloc(sizeof(int) * rhs.__event_size_));
310 #ifndef _LIBCPP_NO_EXCEPTIONS
313 #endif // _LIBCPP_NO_EXCEPTIONS
315 if (__iarray_cap_ < rhs.__iarray_size_)
317 new_longs.reset((long*)malloc(sizeof(long) * rhs.__iarray_size_));
318 #ifndef _LIBCPP_NO_EXCEPTIONS
321 #endif // _LIBCPP_NO_EXCEPTIONS
323 if (__parray_cap_ < rhs.__parray_size_)
325 new_pointers.reset((void**)malloc(sizeof(void*) * rhs.__parray_size_));
326 #ifndef _LIBCPP_NO_EXCEPTIONS
329 #endif // _LIBCPP_NO_EXCEPTIONS
331 // Got everything we need. Copy everything but __rdstate_, __rdbuf_ and __exceptions_
332 __fmtflags_ = rhs.__fmtflags_;
333 __precision_ = rhs.__precision_;
334 __width_ = rhs.__width_;
335 locale& lhs_loc = *(locale*)&__loc_;
336 locale& rhs_loc = *(locale*)&rhs.__loc_;
338 if (__event_cap_ < rhs.__event_size_)
341 __fn_ = new_callbacks.release();
343 __index_ = new_ints.release();
344 __event_cap_ = rhs.__event_size_;
346 for (__event_size_ = 0; __event_size_ < rhs.__event_size_; ++__event_size_)
348 __fn_[__event_size_] = rhs.__fn_[__event_size_];
349 __index_[__event_size_] = rhs.__index_[__event_size_];
351 if (__iarray_cap_ < rhs.__iarray_size_)
354 __iarray_ = new_longs.release();
355 __iarray_cap_ = rhs.__iarray_size_;
357 for (__iarray_size_ = 0; __iarray_size_ < rhs.__iarray_size_; ++__iarray_size_)
358 __iarray_[__iarray_size_] = rhs.__iarray_[__iarray_size_];
359 if (__parray_cap_ < rhs.__parray_size_)
362 __parray_ = new_pointers.release();
363 __parray_cap_ = rhs.__parray_size_;
365 for (__parray_size_ = 0; __parray_size_ < rhs.__parray_size_; ++__parray_size_)
366 __parray_[__parray_size_] = rhs.__parray_[__parray_size_];
370 ios_base::move(ios_base& rhs)
372 // *this is uninitialized
373 __fmtflags_ = rhs.__fmtflags_;
374 __precision_ = rhs.__precision_;
375 __width_ = rhs.__width_;
376 __rdstate_ = rhs.__rdstate_;
377 __exceptions_ = rhs.__exceptions_;
379 locale& rhs_loc = *(locale*)&rhs.__loc_;
380 ::new(&__loc_) locale(rhs_loc);
383 __index_ = rhs.__index_;
385 __event_size_ = rhs.__event_size_;
386 rhs.__event_size_ = 0;
387 __event_cap_ = rhs.__event_cap_;
388 rhs.__event_cap_ = 0;
389 __iarray_ = rhs.__iarray_;
391 __iarray_size_ = rhs.__iarray_size_;
392 rhs.__iarray_size_ = 0;
393 __iarray_cap_ = rhs.__iarray_cap_;
394 rhs.__iarray_cap_ = 0;
395 __parray_ = rhs.__parray_;
397 __parray_size_ = rhs.__parray_size_;
398 rhs.__parray_size_ = 0;
399 __parray_cap_ = rhs.__parray_cap_;
400 rhs.__parray_cap_ = 0;
404 ios_base::swap(ios_base& rhs)
406 _VSTD::swap(__fmtflags_, rhs.__fmtflags_);
407 _VSTD::swap(__precision_, rhs.__precision_);
408 _VSTD::swap(__width_, rhs.__width_);
409 _VSTD::swap(__rdstate_, rhs.__rdstate_);
410 _VSTD::swap(__exceptions_, rhs.__exceptions_);
411 locale& lhs_loc = *(locale*)&__loc_;
412 locale& rhs_loc = *(locale*)&rhs.__loc_;
413 _VSTD::swap(lhs_loc, rhs_loc);
414 _VSTD::swap(__fn_, rhs.__fn_);
415 _VSTD::swap(__index_, rhs.__index_);
416 _VSTD::swap(__event_size_, rhs.__event_size_);
417 _VSTD::swap(__event_cap_, rhs.__event_cap_);
418 _VSTD::swap(__iarray_, rhs.__iarray_);
419 _VSTD::swap(__iarray_size_, rhs.__iarray_size_);
420 _VSTD::swap(__iarray_cap_, rhs.__iarray_cap_);
421 _VSTD::swap(__parray_, rhs.__parray_);
422 _VSTD::swap(__parray_size_, rhs.__parray_size_);
423 _VSTD::swap(__parray_cap_, rhs.__parray_cap_);
427 ios_base::__set_badbit_and_consider_rethrow()
429 __rdstate_ |= badbit;
430 #ifndef _LIBCPP_NO_EXCEPTIONS
431 if (__exceptions_ & badbit)
433 #endif // _LIBCPP_NO_EXCEPTIONS
437 ios_base::__set_failbit_and_consider_rethrow()
439 __rdstate_ |= failbit;
440 #ifndef _LIBCPP_NO_EXCEPTIONS
441 if (__exceptions_ & failbit)
443 #endif // _LIBCPP_NO_EXCEPTIONS
447 ios_base::sync_with_stdio(bool sync)
449 static bool previous_state = true;
450 bool r = previous_state;
451 previous_state = sync;
455 _LIBCPP_END_NAMESPACE_STD