Home | History | Annotate | Download | only in v1
      1 // -*- C++ -*-
      2 //===-------------------------- exception ---------------------------------===//
      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_EXCEPTION
     12 #define _LIBCPP_EXCEPTION
     13 
     14 /*
     15     exception synopsis
     16 
     17 namespace std
     18 {
     19 
     20 class exception
     21 {
     22 public:
     23     exception() noexcept;
     24     exception(const exception&) noexcept;
     25     exception& operator=(const exception&) noexcept;
     26     virtual ~exception() noexcept;
     27     virtual const char* what() const noexcept;
     28 };
     29 
     30 class bad_exception
     31     : public exception
     32 {
     33 public:
     34     bad_exception() noexcept;
     35     bad_exception(const bad_exception&) noexcept;
     36     bad_exception& operator=(const bad_exception&) noexcept;
     37     virtual ~bad_exception() noexcept;
     38     virtual const char* what() const noexcept;
     39 };
     40 
     41 typedef void (*unexpected_handler)();
     42 unexpected_handler set_unexpected(unexpected_handler  f ) noexcept;
     43 unexpected_handler get_unexpected() noexcept;
     44 [[noreturn]] void unexpected();
     45 
     46 typedef void (*terminate_handler)();
     47 terminate_handler set_terminate(terminate_handler  f ) noexcept;
     48 terminate_handler get_terminate() noexcept;
     49 [[noreturn]] void terminate() noexcept;
     50 
     51 bool uncaught_exception()  noexcept;
     52 int  uncaught_exceptions() noexcept;  // C++17
     53 
     54 typedef unspecified exception_ptr;
     55 
     56 exception_ptr current_exception() noexcept;
     57 void rethrow_exception [[noreturn]] (exception_ptr p);
     58 template<class E> exception_ptr make_exception_ptr(E e) noexcept;
     59 
     60 class nested_exception
     61 {
     62 public:
     63     nested_exception() noexcept;
     64     nested_exception(const nested_exception&) noexcept = default;
     65     nested_exception& operator=(const nested_exception&) noexcept = default;
     66     virtual ~nested_exception() = default;
     67 
     68     // access functions
     69     [[noreturn]] void rethrow_nested() const;
     70     exception_ptr nested_ptr() const noexcept;
     71 };
     72 
     73 template <class T> [[noreturn]] void throw_with_nested(T&& t);
     74 template <class E> void rethrow_if_nested(const E& e);
     75 
     76 }  // std
     77 
     78 */
     79 
     80 #include <__config>
     81 #include <cstddef>
     82 #include <cstdlib>
     83 #include <type_traits>
     84 
     85 #if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_NO_VCRUNTIME)
     86 #include <vcruntime_exception.h>
     87 #endif
     88 
     89 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
     90 #pragma GCC system_header
     91 #endif
     92 
     93 namespace std  // purposefully not using versioning namespace
     94 {
     95 
     96 #if !defined(_LIBCPP_ABI_MICROSOFT) || defined(_LIBCPP_NO_VCRUNTIME)
     97 class _LIBCPP_EXCEPTION_ABI exception
     98 {
     99 public:
    100     _LIBCPP_INLINE_VISIBILITY exception() _NOEXCEPT {}
    101     virtual ~exception() _NOEXCEPT;
    102     virtual const char* what() const _NOEXCEPT;
    103 };
    104 
    105 class _LIBCPP_EXCEPTION_ABI bad_exception
    106     : public exception
    107 {
    108 public:
    109     _LIBCPP_INLINE_VISIBILITY bad_exception() _NOEXCEPT {}
    110     virtual ~bad_exception() _NOEXCEPT;
    111     virtual const char* what() const _NOEXCEPT;
    112 };
    113 #endif // !_LIBCPP_ABI_MICROSOFT || _LIBCPP_NO_VCRUNTIME
    114 
    115 #if _LIBCPP_STD_VER <= 14 \
    116     || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS) \
    117     || defined(_LIBCPP_BUILDING_LIBRARY)
    118 typedef void (*unexpected_handler)();
    119 _LIBCPP_FUNC_VIS unexpected_handler set_unexpected(unexpected_handler) _NOEXCEPT;
    120 _LIBCPP_FUNC_VIS unexpected_handler get_unexpected() _NOEXCEPT;
    121 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void unexpected();
    122 #endif
    123 
    124 typedef void (*terminate_handler)();
    125 _LIBCPP_FUNC_VIS terminate_handler set_terminate(terminate_handler) _NOEXCEPT;
    126 _LIBCPP_FUNC_VIS terminate_handler get_terminate() _NOEXCEPT;
    127 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void terminate() _NOEXCEPT;
    128 
    129 _LIBCPP_FUNC_VIS bool uncaught_exception() _NOEXCEPT;
    130 _LIBCPP_FUNC_VIS _LIBCPP_AVAILABILITY_UNCAUGHT_EXCEPTIONS int uncaught_exceptions() _NOEXCEPT;
    131 
    132 class _LIBCPP_TYPE_VIS exception_ptr;
    133 
    134 _LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
    135 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
    136 
    137 #ifndef _LIBCPP_ABI_MICROSOFT
    138 
    139 class _LIBCPP_TYPE_VIS exception_ptr
    140 {
    141     void* __ptr_;
    142 public:
    143     _LIBCPP_INLINE_VISIBILITY exception_ptr() _NOEXCEPT : __ptr_() {}
    144     _LIBCPP_INLINE_VISIBILITY exception_ptr(nullptr_t) _NOEXCEPT : __ptr_() {}
    145 
    146     exception_ptr(const exception_ptr&) _NOEXCEPT;
    147     exception_ptr& operator=(const exception_ptr&) _NOEXCEPT;
    148     ~exception_ptr() _NOEXCEPT;
    149 
    150     _LIBCPP_INLINE_VISIBILITY _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT
    151     {return __ptr_ != nullptr;}
    152 
    153     friend _LIBCPP_INLINE_VISIBILITY
    154     bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
    155         {return __x.__ptr_ == __y.__ptr_;}
    156 
    157     friend _LIBCPP_INLINE_VISIBILITY
    158     bool operator!=(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
    159         {return !(__x == __y);}
    160 
    161     friend _LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
    162     friend _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
    163 };
    164 
    165 template<class _Ep>
    166 exception_ptr
    167 make_exception_ptr(_Ep __e) _NOEXCEPT
    168 {
    169 #ifndef _LIBCPP_NO_EXCEPTIONS
    170     try
    171     {
    172         throw __e;
    173     }
    174     catch (...)
    175     {
    176         return current_exception();
    177     }
    178 #else
    179     ((void)__e);
    180     _VSTD::abort();
    181 #endif
    182 }
    183 
    184 #else // _LIBCPP_ABI_MICROSOFT
    185 
    186 class _LIBCPP_TYPE_VIS exception_ptr
    187 {
    188 #if defined(__clang__)
    189 #pragma clang diagnostic push
    190 #pragma clang diagnostic ignored "-Wunused-private-field"
    191 #endif
    192     void* __ptr1_;
    193     void* __ptr2_;
    194 #if defined(__clang__)
    195 #pragma clang diagnostic pop
    196 #endif
    197 public:
    198     exception_ptr() _NOEXCEPT;
    199     exception_ptr(nullptr_t) _NOEXCEPT;
    200     exception_ptr(const exception_ptr& __other) _NOEXCEPT;
    201     exception_ptr& operator=(const exception_ptr& __other) _NOEXCEPT;
    202     exception_ptr& operator=(nullptr_t) _NOEXCEPT;
    203     ~exception_ptr() _NOEXCEPT;
    204     _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT;
    205 };
    206 
    207 _LIBCPP_FUNC_VIS
    208 bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT;
    209 
    210 inline _LIBCPP_INLINE_VISIBILITY
    211 bool operator!=(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
    212     {return !(__x == __y);}
    213 
    214 _LIBCPP_FUNC_VIS void swap(exception_ptr&, exception_ptr&) _NOEXCEPT;
    215 
    216 _LIBCPP_FUNC_VIS exception_ptr __copy_exception_ptr(void *__except, const void* __ptr);
    217 _LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
    218 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr p);
    219 
    220 // This is a built-in template function which automagically extracts the required
    221 // information.
    222 template <class _E> void *__GetExceptionInfo(_E);
    223 
    224 template<class _Ep>
    225 exception_ptr
    226 make_exception_ptr(_Ep __e) _NOEXCEPT
    227 {
    228   return __copy_exception_ptr(_VSTD::addressof(__e), __GetExceptionInfo(__e));
    229 }
    230 
    231 #endif // _LIBCPP_ABI_MICROSOFT
    232 // nested_exception
    233 
    234 class _LIBCPP_EXCEPTION_ABI nested_exception
    235 {
    236     exception_ptr __ptr_;
    237 public:
    238     nested_exception() _NOEXCEPT;
    239 //     nested_exception(const nested_exception&) noexcept = default;
    240 //     nested_exception& operator=(const nested_exception&) noexcept = default;
    241     virtual ~nested_exception() _NOEXCEPT;
    242 
    243     // access functions
    244     _LIBCPP_NORETURN void rethrow_nested() const;
    245     _LIBCPP_INLINE_VISIBILITY exception_ptr nested_ptr() const _NOEXCEPT {return __ptr_;}
    246 };
    247 
    248 template <class _Tp>
    249 struct __nested
    250     : public _Tp,
    251       public nested_exception
    252 {
    253     _LIBCPP_INLINE_VISIBILITY explicit __nested(const _Tp& __t) : _Tp(__t) {}
    254 };
    255 
    256 #ifndef _LIBCPP_NO_EXCEPTIONS
    257 template <class _Tp, class _Up, bool>
    258 struct __throw_with_nested;
    259 
    260 template <class _Tp, class _Up>
    261 struct __throw_with_nested<_Tp, _Up, true> {
    262     _LIBCPP_NORETURN static inline _LIBCPP_ALWAYS_INLINE void
    263 #ifndef _LIBCPP_CXX03_LANG
    264     __do_throw(_Tp&& __t)
    265 #else
    266     __do_throw (_Tp& __t)
    267 #endif  // _LIBCPP_CXX03_LANG
    268     {
    269         throw __nested<_Up>(_VSTD::forward<_Tp>(__t));
    270     }
    271 };
    272 
    273 template <class _Tp, class _Up>
    274 struct __throw_with_nested<_Tp, _Up, false> {
    275     _LIBCPP_NORETURN static inline _LIBCPP_ALWAYS_INLINE void
    276 #ifndef _LIBCPP_CXX03_LANG
    277     __do_throw(_Tp&& __t)
    278 #else
    279     __do_throw (_Tp& __t)
    280 #endif  // _LIBCPP_CXX03_LANG
    281     {
    282         throw _VSTD::forward<_Tp>(__t);
    283     }
    284 };
    285 #endif
    286 
    287 template <class _Tp>
    288 _LIBCPP_NORETURN
    289 void
    290 #ifndef _LIBCPP_CXX03_LANG
    291 throw_with_nested(_Tp&& __t)
    292 #else
    293 throw_with_nested (_Tp& __t)
    294 #endif // _LIBCPP_CXX03_LANG
    295 {
    296 #ifndef _LIBCPP_NO_EXCEPTIONS
    297     typedef typename decay<_Tp>::type _Up;
    298     static_assert( is_copy_constructible<_Up>::value, "type thrown must be CopyConstructible");
    299     __throw_with_nested<_Tp, _Up,
    300         is_class<_Up>::value &&
    301         !is_base_of<nested_exception, _Up>::value &&
    302         !__libcpp_is_final<_Up>::value>::
    303             __do_throw(_VSTD::forward<_Tp>(__t));
    304 #else
    305     ((void)__t);
    306     // FIXME: Make this abort
    307 #endif
    308 }
    309 
    310 template <class _From, class _To>
    311 struct __can_dynamic_cast : public _LIBCPP_BOOL_CONSTANT(
    312               is_polymorphic<_From>::value &&
    313                  (!is_base_of<_To, _From>::value ||
    314                    is_convertible<const _From*, const _To*>::value)) {};
    315 
    316 template <class _Ep>
    317 inline _LIBCPP_INLINE_VISIBILITY
    318 void
    319 rethrow_if_nested(const _Ep& __e,
    320                   typename enable_if< __can_dynamic_cast<_Ep, nested_exception>::value>::type* = 0)
    321 {
    322     const nested_exception* __nep = dynamic_cast<const nested_exception*>(_VSTD::addressof(__e));
    323     if (__nep)
    324         __nep->rethrow_nested();
    325 }
    326 
    327 template <class _Ep>
    328 inline _LIBCPP_INLINE_VISIBILITY
    329 void
    330 rethrow_if_nested(const _Ep&,
    331                   typename enable_if<!__can_dynamic_cast<_Ep, nested_exception>::value>::type* = 0)
    332 {
    333 }
    334 
    335 }  // std
    336 
    337 #endif  // _LIBCPP_EXCEPTION
    338