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