1 // -*- C++ -*- 2 //===--------------------------- stdexcept --------------------------------===// 3 // 4 // The LLVM Compiler Infrastructure 5 // 6 // This file is dual licensed under the MIT and the University of Illinois Open 7 // Source Licenses. See LICENSE.TXT for details. 8 // 9 //===----------------------------------------------------------------------===// 10 11 #ifndef _LIBCPP_STDEXCEPT 12 #define _LIBCPP_STDEXCEPT 13 14 /* 15 stdexcept synopsis 16 17 namespace std 18 { 19 20 class logic_error; 21 class domain_error; 22 class invalid_argument; 23 class length_error; 24 class out_of_range; 25 class runtime_error; 26 class range_error; 27 class overflow_error; 28 class underflow_error; 29 30 for each class xxx_error: 31 32 class xxx_error : public exception // at least indirectly 33 { 34 public: 35 explicit xxx_error(const string& what_arg); 36 explicit xxx_error(const char* what_arg); 37 38 virtual const char* what() const noexcept // returns what_arg 39 }; 40 41 } // std 42 43 */ 44 45 #include <__config> 46 #include <exception> 47 #include <iosfwd> // for string forward decl 48 #ifdef _LIBCPP_NO_EXCEPTIONS 49 #include <cstdlib> 50 #endif 51 52 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 53 #pragma GCC system_header 54 #endif 55 56 _LIBCPP_BEGIN_NAMESPACE_STD 57 58 class _LIBCPP_HIDDEN __libcpp_refstring 59 { 60 const char* __imp_; 61 62 bool __uses_refcount() const; 63 public: 64 explicit __libcpp_refstring(const char* __msg); 65 __libcpp_refstring(const __libcpp_refstring& __s) _NOEXCEPT; 66 __libcpp_refstring& operator=(const __libcpp_refstring& __s) _NOEXCEPT; 67 ~__libcpp_refstring(); 68 69 const char* c_str() const _NOEXCEPT {return __imp_;} 70 }; 71 72 _LIBCPP_END_NAMESPACE_STD 73 74 namespace std // purposefully not using versioning namespace 75 { 76 77 class _LIBCPP_EXCEPTION_ABI logic_error 78 : public exception 79 { 80 private: 81 _VSTD::__libcpp_refstring __imp_; 82 public: 83 explicit logic_error(const string&); 84 explicit logic_error(const char*); 85 86 logic_error(const logic_error&) _NOEXCEPT; 87 logic_error& operator=(const logic_error&) _NOEXCEPT; 88 89 virtual ~logic_error() _NOEXCEPT; 90 91 virtual const char* what() const _NOEXCEPT; 92 }; 93 94 class _LIBCPP_EXCEPTION_ABI runtime_error 95 : public exception 96 { 97 private: 98 _VSTD::__libcpp_refstring __imp_; 99 public: 100 explicit runtime_error(const string&); 101 explicit runtime_error(const char*); 102 103 runtime_error(const runtime_error&) _NOEXCEPT; 104 runtime_error& operator=(const runtime_error&) _NOEXCEPT; 105 106 virtual ~runtime_error() _NOEXCEPT; 107 108 virtual const char* what() const _NOEXCEPT; 109 }; 110 111 class _LIBCPP_EXCEPTION_ABI domain_error 112 : public logic_error 113 { 114 public: 115 _LIBCPP_INLINE_VISIBILITY explicit domain_error(const string& __s) : logic_error(__s) {} 116 _LIBCPP_INLINE_VISIBILITY explicit domain_error(const char* __s) : logic_error(__s) {} 117 118 virtual ~domain_error() _NOEXCEPT; 119 }; 120 121 class _LIBCPP_EXCEPTION_ABI invalid_argument 122 : public logic_error 123 { 124 public: 125 _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const string& __s) : logic_error(__s) {} 126 _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const char* __s) : logic_error(__s) {} 127 128 virtual ~invalid_argument() _NOEXCEPT; 129 }; 130 131 class _LIBCPP_EXCEPTION_ABI length_error 132 : public logic_error 133 { 134 public: 135 _LIBCPP_INLINE_VISIBILITY explicit length_error(const string& __s) : logic_error(__s) {} 136 _LIBCPP_INLINE_VISIBILITY explicit length_error(const char* __s) : logic_error(__s) {} 137 138 virtual ~length_error() _NOEXCEPT; 139 }; 140 141 class _LIBCPP_EXCEPTION_ABI out_of_range 142 : public logic_error 143 { 144 public: 145 _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const string& __s) : logic_error(__s) {} 146 _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const char* __s) : logic_error(__s) {} 147 148 virtual ~out_of_range() _NOEXCEPT; 149 }; 150 151 class _LIBCPP_EXCEPTION_ABI range_error 152 : public runtime_error 153 { 154 public: 155 _LIBCPP_INLINE_VISIBILITY explicit range_error(const string& __s) : runtime_error(__s) {} 156 _LIBCPP_INLINE_VISIBILITY explicit range_error(const char* __s) : runtime_error(__s) {} 157 158 virtual ~range_error() _NOEXCEPT; 159 }; 160 161 class _LIBCPP_EXCEPTION_ABI overflow_error 162 : public runtime_error 163 { 164 public: 165 _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const string& __s) : runtime_error(__s) {} 166 _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const char* __s) : runtime_error(__s) {} 167 168 virtual ~overflow_error() _NOEXCEPT; 169 }; 170 171 class _LIBCPP_EXCEPTION_ABI underflow_error 172 : public runtime_error 173 { 174 public: 175 _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const string& __s) : runtime_error(__s) {} 176 _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const char* __s) : runtime_error(__s) {} 177 178 virtual ~underflow_error() _NOEXCEPT; 179 }; 180 181 } // std 182 183 _LIBCPP_BEGIN_NAMESPACE_STD 184 185 // in the dylib 186 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*); 187 188 _LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE 189 void __throw_logic_error(const char*__msg) 190 { 191 #ifndef _LIBCPP_NO_EXCEPTIONS 192 throw logic_error(__msg); 193 #else 194 ((void)__msg); 195 _VSTD::abort(); 196 #endif 197 } 198 199 _LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE 200 void __throw_domain_error(const char*__msg) 201 { 202 #ifndef _LIBCPP_NO_EXCEPTIONS 203 throw domain_error(__msg); 204 #else 205 ((void)__msg); 206 _VSTD::abort(); 207 #endif 208 } 209 210 _LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE 211 void __throw_invalid_argument(const char*__msg) 212 { 213 #ifndef _LIBCPP_NO_EXCEPTIONS 214 throw invalid_argument(__msg); 215 #else 216 ((void)__msg); 217 _VSTD::abort(); 218 #endif 219 } 220 221 _LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE 222 void __throw_length_error(const char*__msg) 223 { 224 #ifndef _LIBCPP_NO_EXCEPTIONS 225 throw length_error(__msg); 226 #else 227 ((void)__msg); 228 _VSTD::abort(); 229 #endif 230 } 231 232 _LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE 233 void __throw_out_of_range(const char*__msg) 234 { 235 #ifndef _LIBCPP_NO_EXCEPTIONS 236 throw out_of_range(__msg); 237 #else 238 ((void)__msg); 239 _VSTD::abort(); 240 #endif 241 } 242 243 _LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE 244 void __throw_range_error(const char*__msg) 245 { 246 #ifndef _LIBCPP_NO_EXCEPTIONS 247 throw range_error(__msg); 248 #else 249 ((void)__msg); 250 _VSTD::abort(); 251 #endif 252 } 253 254 _LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE 255 void __throw_overflow_error(const char*__msg) 256 { 257 #ifndef _LIBCPP_NO_EXCEPTIONS 258 throw overflow_error(__msg); 259 #else 260 ((void)__msg); 261 _VSTD::abort(); 262 #endif 263 } 264 265 _LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE 266 void __throw_underflow_error(const char*__msg) 267 { 268 #ifndef _LIBCPP_NO_EXCEPTIONS 269 throw underflow_error(__msg); 270 #else 271 ((void)__msg); 272 _VSTD::abort(); 273 #endif 274 } 275 276 _LIBCPP_END_NAMESPACE_STD 277 278 #endif // _LIBCPP_STDEXCEPT 279
