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