contrib/libc++/src/ios.cpp

   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 "ios"
  11 #include "streambuf"
  12 #include "istream"
  13 #include "string"
  14 #include "__locale"
  15 #include "algorithm"
  16 #include "memory"
  17 #include "new"
  18 #include "limits"
  19 #include <stdlib.h>
  20
  21 _LIBCPP_BEGIN_NAMESPACE_STD
  22
  23 template class basic_ios<char>;
  24 template class basic_ios<wchar_t>;
  25
  26 template class basic_streambuf<char>;
  27 template class basic_streambuf<wchar_t>;
  28
  29 template class basic_istream<char>;
  30 template class basic_istream<wchar_t>;
  31
  32 template class basic_ostream<char>;
  33 template class basic_ostream<wchar_t>;
  34
  35 template class basic_iostream<char>;
  36
  37 class _LIBCPP_HIDDEN __iostream_category
  38     : public __do_message
  39 {
  40 public:
  41     virtual const char* name() const _NOEXCEPT;
  42     virtual string message(int ev) const;
  43 };
  44
  45 const char*
  46 __iostream_category::name() const _NOEXCEPT
  47 {
  48     return "iostream";
  49 }
  50
  51 string
  52 __iostream_category::message(int ev) const
  53 {
  54     if (ev != static_cast<int>(io_errc::stream)
  55 #ifdef ELAST
  56         && ev <= ELAST
  57 #endif
  58         )
  59         return __do_message::message(ev);
  60     return string("unspecified iostream_category error");
  61 }
  62
  63 const error_category&
  64 iostream_category()
  65 {
  66     static __iostream_category s;
  67     return s;
  68 }
  69
  70 // ios_base::failure
  71
  72 ios_base::failure::failure(const string& msg, const error_code& ec)
  73     : system_error(ec, msg)
  74 {
  75 }
  76
  77 ios_base::failure::failure(const char* msg, const error_code& ec)
  78     : system_error(ec, msg)
  79 {
  80 }
  81
  82 ios_base::failure::~failure() throw()
  83 {
  84 }
  85
  86 // ios_base locale
  87
  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;
 106
 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;
 111
 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;
 118
 119 void
 120 ios_base::__call_callbacks(event ev)
 121 {
 122     for (size_t i = __event_size_; i;)
 123     {
 124         --i;
 125         __fn_[i](ev, *this, __index_[i]);
 126     }
 127 }
 128
 129 // locale
 130
 131 locale
 132 ios_base::imbue(const locale& newloc)
 133 {
 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);
 139     return oldloc;
 140 }
 141
 142 locale
 143 ios_base::getloc() const
 144 {
 145     const locale& loc_storage = *(locale*)&__loc_;
 146     return loc_storage;
 147 }
 148
 149 // xalloc
 150
 151 int ios_base::__xindex_ = 0;
 152
 153 int
 154 ios_base::xalloc()
 155 {
 156     return __xindex_++;
 157 }
 158
 159 long&
 160 ios_base::iword(int index)
 161 {
 162     size_t req_size = static_cast<size_t>(index)+1;
 163     if (req_size > __iarray_cap_)
 164     {
 165         size_t newcap;
 166         const size_t mx = std::numeric_limits<size_t>::max();
 167         if (req_size < mx/2)
 168             newcap = _VSTD::max(2 * __iarray_cap_, req_size);
 169         else
 170             newcap = mx;
 171         long* iarray = (long*)realloc(__iarray_, newcap * sizeof(long));
 172         if (iarray == 0)
 173         {
 174             setstate(badbit);
 175             static long error;
 176             error = 0;
 177             return error;
 178         }
 179         __iarray_ = iarray;
 180         for (long* p = __iarray_ + __iarray_size_; __iarray_cap_ < newcap; ++__iarray_cap_, ++p)
 181             *p = 0;
 182     }
 183     __iarray_size_ = max<size_t>(__iarray_size_, req_size);
 184     return __iarray_[index];
 185 }
 186
 187 void*&
 188 ios_base::pword(int index)
 189 {
 190     size_t req_size = static_cast<size_t>(index)+1;
 191     if (req_size > __parray_cap_)
 192     {
 193         size_t newcap;
 194         const size_t mx = std::numeric_limits<size_t>::max();
 195         if (req_size < mx/2)
 196             newcap = _VSTD::max(2 * __parray_cap_, req_size);
 197         else
 198             newcap = mx;
 199         void** parray = (void**)realloc(__parray_, newcap * sizeof(void*));
 200         if (parray == 0)
 201         {
 202             setstate(badbit);
 203             static void* error;
 204             error = 0;
 205             return error;
 206         }
 207         __parray_ = parray;
 208         for (void** p = __parray_ + __parray_size_; __parray_cap_ < newcap; ++__parray_cap_, ++p)
 209             *p = 0;
 210     }
 211     __parray_size_ = max<size_t>(__parray_size_, req_size);
 212     return __parray_[index];
 213 }
 214
 215 // register_callback
 216
 217 void
 218 ios_base::register_callback(event_callback fn, int index)
 219 {
 220     size_t req_size = __event_size_ + 1;
 221     if (req_size > __event_cap_)
 222     {
 223         size_t newcap;
 224         const size_t mx = std::numeric_limits<size_t>::max();
 225         if (req_size < mx/2)
 226             newcap = _VSTD::max(2 * __event_cap_, req_size);
 227         else
 228             newcap = mx;
 229         event_callback* fns = (event_callback*)realloc(__fn_, newcap * sizeof(event_callback));
 230         if (fns == 0)
 231             setstate(badbit);
 232         __fn_ = fns;
 233         int* indxs = (int*)realloc(__index_, newcap * sizeof(int));
 234         if (indxs == 0)
 235             setstate(badbit);
 236         __index_ = indxs;
 237     }
 238     __fn_[__event_size_] = fn;
 239     __index_[__event_size_] = index;
 240     ++__event_size_;
 241 }
 242
 243 ios_base::~ios_base()
 244 {
 245     __call_callbacks(erase_event);
 246     locale& loc_storage = *(locale*)&__loc_;
 247     loc_storage.~locale();
 248     free(__fn_);
 249     free(__index_);
 250     free(__iarray_);
 251     free(__parray_);
 252 }
 253
 254 // iostate
 255
 256 void
 257 ios_base::clear(iostate state)
 258 {
 259     if (__rdbuf_)
 260         __rdstate_ = state;
 261     else
 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
 267 }
 268
 269 // init
 270
 271 void
 272 ios_base::init(void* sb)
 273 {
 274     __rdbuf_ = sb;
 275     __rdstate_ = __rdbuf_ ? goodbit : badbit;
 276     __exceptions_ = goodbit;
 277     __fmtflags_ = skipws | dec;
 278     __width_ = 0;
 279     __precision_ = 6;
 280     __fn_ = 0;
 281     __index_ = 0;
 282     __event_size_ = 0;
 283     __event_cap_ = 0;
 284     __iarray_ = 0;
 285     __iarray_size_ = 0;
 286     __iarray_cap_ = 0;
 287     __parray_ = 0;
 288     __parray_size_ = 0;
 289     __parray_cap_ = 0;
 290     ::new(&__loc_) locale;
 291 }
 292
 293 void
 294 ios_base::copyfmt(const ios_base& rhs)
 295 {
 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_)
 303     {
 304         new_callbacks.reset((event_callback*)malloc(sizeof(event_callback) * rhs.__event_size_));
 305 #ifndef _LIBCPP_NO_EXCEPTIONS
 306         if (!new_callbacks)
 307             throw bad_alloc();
 308 #endif  // _LIBCPP_NO_EXCEPTIONS
 309         new_ints.reset((int*)malloc(sizeof(int) * rhs.__event_size_));
 310 #ifndef _LIBCPP_NO_EXCEPTIONS
 311         if (!new_ints)
 312             throw bad_alloc();
 313 #endif  // _LIBCPP_NO_EXCEPTIONS
 314     }
 315     if (__iarray_cap_ < rhs.__iarray_size_)
 316     {
 317         new_longs.reset((long*)malloc(sizeof(long) * rhs.__iarray_size_));
 318 #ifndef _LIBCPP_NO_EXCEPTIONS
 319         if (!new_longs)
 320             throw bad_alloc();
 321 #endif  // _LIBCPP_NO_EXCEPTIONS
 322     }
 323     if (__parray_cap_ < rhs.__parray_size_)
 324     {
 325         new_pointers.reset((void**)malloc(sizeof(void*) * rhs.__parray_size_));
 326 #ifndef _LIBCPP_NO_EXCEPTIONS
 327         if (!new_pointers)
 328             throw bad_alloc();
 329 #endif  // _LIBCPP_NO_EXCEPTIONS
 330     }
 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_;
 337     lhs_loc = rhs_loc;
 338     if (__event_cap_ < rhs.__event_size_)
 339     {
 340         free(__fn_);
 341         __fn_ = new_callbacks.release();
 342         free(__index_);
 343         __index_ = new_ints.release();
 344         __event_cap_ = rhs.__event_size_;
 345     }
 346     for (__event_size_ = 0; __event_size_ < rhs.__event_size_; ++__event_size_)
 347     {
 348         __fn_[__event_size_] = rhs.__fn_[__event_size_];
 349         __index_[__event_size_] = rhs.__index_[__event_size_];
 350     }
 351     if (__iarray_cap_ < rhs.__iarray_size_)
 352     {
 353         free(__iarray_);
 354         __iarray_ = new_longs.release();
 355         __iarray_cap_ = rhs.__iarray_size_;
 356     }
 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_)
 360     {
 361         free(__parray_);
 362         __parray_ = new_pointers.release();
 363         __parray_cap_ = rhs.__parray_size_;
 364     }
 365     for (__parray_size_ = 0; __parray_size_ < rhs.__parray_size_; ++__parray_size_)
 366         __parray_[__parray_size_] = rhs.__parray_[__parray_size_];
 367 }
 368
 369 void
 370 ios_base::move(ios_base& rhs)
 371 {
 372     // *this is uninitialized
 373     __fmtflags_ = rhs.__fmtflags_;
 374     __precision_ = rhs.__precision_;
 375     __width_ = rhs.__width_;
 376     __rdstate_ = rhs.__rdstate_;
 377     __exceptions_ = rhs.__exceptions_;
 378     __rdbuf_ = 0;
 379     locale& rhs_loc = *(locale*)&rhs.__loc_;
 380     ::new(&__loc_) locale(rhs_loc);
 381     __fn_ = rhs.__fn_;
 382     rhs.__fn_ = 0;
 383     __index_ = rhs.__index_;
 384     rhs.__index_ = 0;
 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_;
 390     rhs.__iarray_ = 0;
 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_;
 396     rhs.__parray_ = 0;
 397     __parray_size_ = rhs.__parray_size_;
 398     rhs.__parray_size_ = 0;
 399     __parray_cap_ = rhs.__parray_cap_;
 400     rhs.__parray_cap_ = 0;
 401 }
 402
 403 void
 404 ios_base::swap(ios_base& rhs) _NOEXCEPT
 405 {
 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_);
 424 }
 425
 426 void
 427 ios_base::__set_badbit_and_consider_rethrow()
 428 {
 429     __rdstate_ |= badbit;
 430 #ifndef _LIBCPP_NO_EXCEPTIONS
 431     if (__exceptions_ & badbit)
 432         throw;
 433 #endif  // _LIBCPP_NO_EXCEPTIONS
 434 }
 435
 436 void
 437 ios_base::__set_failbit_and_consider_rethrow()
 438 {
 439     __rdstate_ |= failbit;
 440 #ifndef _LIBCPP_NO_EXCEPTIONS
 441     if (__exceptions_ & failbit)
 442         throw;
 443 #endif  // _LIBCPP_NO_EXCEPTIONS
 444 }
 445
 446 bool
 447 ios_base::sync_with_stdio(bool sync)
 448 {
 449     static bool previous_state = true;
 450     bool r = previous_state;
 451     previous_state = sync;
 452     return r;
 453 }
 454
 455 _LIBCPP_END_NAMESPACE_STD