libcxx/include/stdexcept

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