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