Home | History | Annotate | Download | only in v1
      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