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