src/third_party/libc++/trunk/src/stdexcept.cpp

   1 //===------------------------ stdexcept.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 "stdexcept"
  11 #include "new"
  12 #include "string"
  13 #include <cstdlib>
  14 #include <cstring>
  15 #include <cstdint>
  16 #include <cstddef>
  17 #include "system_error"
  18
  19 #ifndef __has_include
  20 #define __has_include(inc) 0
  21 #endif
  22
  23 #ifdef __APPLE__
  24 #include <cxxabi.h>
  25 #elif defined(LIBCXXRT) || __has_include(<cxxabi.h>)
  26 #include <cxxabi.h>
  27 #endif
  28
  29 // Note:  optimize for size
  30
  31 #if ! defined(_LIBCPP_MSVC)
  32 #pragma GCC visibility push(hidden)
  33 #endif
  34
  35 namespace
  36 {
  37
  38 class __libcpp_nmstr
  39 {
  40 private:
  41     const char* str_;
  42
  43     typedef std::size_t unused_t;
  44     typedef std::ptrdiff_t count_t;
  45
  46     static const std::ptrdiff_t offset = static_cast<std::ptrdiff_t>(2*sizeof(unused_t) +
  47                                                                        sizeof(count_t));
  48
  49     count_t& count() const _NOEXCEPT {return *const_cast<count_t *>(reinterpret_cast<const count_t *>(str_ - sizeof(count_t)));}
  50 public:
  51     explicit __libcpp_nmstr(const char* msg);
  52     __libcpp_nmstr(const __libcpp_nmstr& s) _NOEXCEPT;
  53     __libcpp_nmstr& operator=(const __libcpp_nmstr& s) _NOEXCEPT;
  54     ~__libcpp_nmstr();
  55     const char* c_str() const _NOEXCEPT {return str_;}
  56 };
  57
  58 __libcpp_nmstr::__libcpp_nmstr(const char* msg)
  59 {
  60     std::size_t len = strlen(msg);
  61     str_ = new char[len + 1 + offset];
  62     unused_t* c = reinterpret_cast<unused_t*>(const_cast<char *>(str_));
  63     c[0] = c[1] = len;
  64     str_ += offset;
  65     count() = 0;
  66     std::memcpy(const_cast<char*>(c_str()), msg, len + 1);
  67 }
  68
  69 inline
  70 __libcpp_nmstr::__libcpp_nmstr(const __libcpp_nmstr& s) _NOEXCEPT
  71     : str_(s.str_)
  72 {
  73     __sync_add_and_fetch(&count(), 1);
  74 }
  75
  76 __libcpp_nmstr&
  77 __libcpp_nmstr::operator=(const __libcpp_nmstr& s) _NOEXCEPT
  78 {
  79     const char* p = str_;
  80     str_ = s.str_;
  81     __sync_add_and_fetch(&count(), 1);
  82     if (__sync_add_and_fetch(reinterpret_cast<count_t*>(const_cast<char*>(p)-sizeof(count_t)), count_t(-1)) < 0)
  83         delete [] (p-offset);
  84     return *this;
  85 }
  86
  87 inline
  88 __libcpp_nmstr::~__libcpp_nmstr()
  89 {
  90     if (__sync_add_and_fetch(&count(), count_t(-1)) < 0)
  91         delete [] (str_ - offset);
  92 }
  93
  94 }
  95
  96 #if ! defined(_LIBCPP_MSVC)
  97 #pragma GCC visibility pop
  98 #endif
  99
 100 namespace std  // purposefully not using versioning namespace
 101 {
 102
 103 logic_error::logic_error(const string& msg)
 104 {
 105     __libcpp_nmstr *s = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
 106     ::new(s) __libcpp_nmstr(msg.c_str());
 107 }
 108
 109 logic_error::logic_error(const char* msg)
 110 {
 111     __libcpp_nmstr *s = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
 112     ::new(s) __libcpp_nmstr(msg);
 113 }
 114
 115 logic_error::logic_error(const logic_error& le) _NOEXCEPT
 116 {
 117     __libcpp_nmstr *s = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
 118     const __libcpp_nmstr *s2 = reinterpret_cast<const __libcpp_nmstr *>(&le.__imp_);
 119     ::new(s) __libcpp_nmstr(*s2);
 120 }
 121
 122 logic_error&
 123 logic_error::operator=(const logic_error& le) _NOEXCEPT
 124 {
 125     __libcpp_nmstr *s1 = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
 126     const __libcpp_nmstr *s2 = reinterpret_cast<const __libcpp_nmstr *>(&le.__imp_);
 127     *s1 = *s2;
 128     return *this;
 129 }
 130
 131 #if !defined(_LIBCPPABI_VERSION) && !defined(LIBSTDCXX)
 132
 133 logic_error::~logic_error() _NOEXCEPT
 134 {
 135     __libcpp_nmstr *s = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
 136     s->~__libcpp_nmstr();
 137 }
 138
 139 const char*
 140 logic_error::what() const _NOEXCEPT
 141 {
 142     const __libcpp_nmstr *s = reinterpret_cast<const __libcpp_nmstr *>(&__imp_);
 143     return s->c_str();
 144 }
 145
 146 #endif
 147
 148 runtime_error::runtime_error(const string& msg)
 149 {
 150     __libcpp_nmstr *s = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
 151     ::new(s) __libcpp_nmstr(msg.c_str());
 152 }
 153
 154 runtime_error::runtime_error(const char* msg)
 155 {
 156     __libcpp_nmstr *s = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
 157     ::new(s) __libcpp_nmstr(msg);
 158 }
 159
 160 runtime_error::runtime_error(const runtime_error& le) _NOEXCEPT
 161 {
 162     __libcpp_nmstr *s = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
 163     const __libcpp_nmstr *s2 = reinterpret_cast<const __libcpp_nmstr *>(&le.__imp_);
 164     ::new(s) __libcpp_nmstr(*s2);
 165 }
 166
 167 runtime_error&
 168 runtime_error::operator=(const runtime_error& le) _NOEXCEPT
 169 {
 170     __libcpp_nmstr *s1 = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
 171     const __libcpp_nmstr *s2 = reinterpret_cast<const __libcpp_nmstr *>(&le.__imp_);
 172     *s1 = *s2;
 173     return *this;
 174 }
 175
 176 #if !defined(_LIBCPPABI_VERSION) && !defined(LIBSTDCXX)
 177
 178 runtime_error::~runtime_error() _NOEXCEPT
 179 {
 180     __libcpp_nmstr *s = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
 181     s->~__libcpp_nmstr();
 182 }
 183
 184 const char*
 185 runtime_error::what() const _NOEXCEPT
 186 {
 187     const __libcpp_nmstr *s = reinterpret_cast<const __libcpp_nmstr *>(&__imp_);
 188     return s->c_str();
 189 }
 190
 191 domain_error::~domain_error() _NOEXCEPT {}
 192 invalid_argument::~invalid_argument() _NOEXCEPT {}
 193 length_error::~length_error() _NOEXCEPT {}
 194 out_of_range::~out_of_range() _NOEXCEPT {}
 195
 196 range_error::~range_error() _NOEXCEPT {}
 197 overflow_error::~overflow_error() _NOEXCEPT {}
 198 underflow_error::~underflow_error() _NOEXCEPT {}
 199
 200 #endif
 201
 202 }  // std