1 // Nested Exception support header (nested_exception class) for -*- C++ -*-
2 
3 // Copyright (C) 2009-2019 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library.  This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /** @file bits/nested_exception.h
26  *  This is an internal header file, included by other library headers.
27  *  Do not attempt to use it directly. @headername{exception}
28  */
29 
30 #ifndef _GLIBCXX_NESTED_EXCEPTION_H
31 #define _GLIBCXX_NESTED_EXCEPTION_H 1
32 
33 #pragma GCC visibility push(default)
34 
35 #if __cplusplus < 201103L
36 # include <bits/c++0x_warning.h>
37 #else
38 
39 #include <bits/c++config.h>
40 #include <bits/move.h>
41 
42 extern "C++" {
43 
44 namespace std
45 {
46   /**
47    * @addtogroup exceptions
48    * @{
49    */
50 
51   /// Exception class with exception_ptr data member.
52   class nested_exception
53   {
54     exception_ptr _M_ptr;
55 
56   public:
nested_exception()57     nested_exception() noexcept : _M_ptr(current_exception()) { }
58 
59     nested_exception(const nested_exception&) noexcept = default;
60 
61     nested_exception& operator=(const nested_exception&) noexcept = default;
62 
63     virtual ~nested_exception() noexcept;
64 
65     [[noreturn]]
66     void
rethrow_nested()67     rethrow_nested() const
68     {
69       if (_M_ptr)
70 	rethrow_exception(_M_ptr);
71       std::terminate();
72     }
73 
74     exception_ptr
nested_ptr()75     nested_ptr() const noexcept
76     { return _M_ptr; }
77   };
78 
79   template<typename _Except>
80     struct _Nested_exception : public _Except, public nested_exception
81     {
_Nested_exception_Nested_exception82       explicit _Nested_exception(const _Except& __ex)
83       : _Except(__ex)
84       { }
85 
_Nested_exception_Nested_exception86       explicit _Nested_exception(_Except&& __ex)
87       : _Except(static_cast<_Except&&>(__ex))
88       { }
89     };
90 
91   // [except.nested]/8
92   // Throw an exception of unspecified type that is publicly derived from
93   // both remove_reference_t<_Tp> and nested_exception.
94   template<typename _Tp>
95     [[noreturn]]
96     inline void
__throw_with_nested_impl(_Tp && __t,true_type)97     __throw_with_nested_impl(_Tp&& __t, true_type)
98     {
99       using _Up = typename remove_reference<_Tp>::type;
100       throw _Nested_exception<_Up>{std::forward<_Tp>(__t)};
101     }
102 
103   template<typename _Tp>
104     [[noreturn]]
105     inline void
__throw_with_nested_impl(_Tp && __t,false_type)106     __throw_with_nested_impl(_Tp&& __t, false_type)
107     { throw std::forward<_Tp>(__t); }
108 
109   /// If @p __t is derived from nested_exception, throws @p __t.
110   /// Else, throws an implementation-defined object derived from both.
111   template<typename _Tp>
112     [[noreturn]]
113     inline void
throw_with_nested(_Tp && __t)114     throw_with_nested(_Tp&& __t)
115     {
116       using _Up = typename decay<_Tp>::type;
117       using _CopyConstructible
118 	= __and_<is_copy_constructible<_Up>, is_move_constructible<_Up>>;
119       static_assert(_CopyConstructible::value,
120 	  "throw_with_nested argument must be CopyConstructible");
121       using __nest = __and_<is_class<_Up>, __bool_constant<!__is_final(_Up)>,
122 			    __not_<is_base_of<nested_exception, _Up>>>;
123       std::__throw_with_nested_impl(std::forward<_Tp>(__t), __nest{});
124     }
125 
126   // Determine if dynamic_cast<const nested_exception&> would be well-formed.
127   template<typename _Tp>
128     using __rethrow_if_nested_cond = typename enable_if<
129       __and_<is_polymorphic<_Tp>,
130 	     __or_<__not_<is_base_of<nested_exception, _Tp>>,
131 		   is_convertible<_Tp*, nested_exception*>>>::value
132     >::type;
133 
134   // Attempt dynamic_cast to nested_exception and call rethrow_nested().
135   template<typename _Ex>
136     inline __rethrow_if_nested_cond<_Ex>
__rethrow_if_nested_impl(const _Ex * __ptr)137     __rethrow_if_nested_impl(const _Ex* __ptr)
138     {
139       if (auto __ne_ptr = dynamic_cast<const nested_exception*>(__ptr))
140 	__ne_ptr->rethrow_nested();
141     }
142 
143   // Otherwise, no effects.
144   inline void
__rethrow_if_nested_impl(const void *)145   __rethrow_if_nested_impl(const void*)
146   { }
147 
148   /// If @p __ex is derived from nested_exception, @p __ex.rethrow_nested().
149   template<typename _Ex>
150     inline void
rethrow_if_nested(const _Ex & __ex)151     rethrow_if_nested(const _Ex& __ex)
152     { std::__rethrow_if_nested_impl(std::__addressof(__ex)); }
153 
154   /// @} group exceptions
155 } // namespace std
156 
157 } // extern "C++"
158 
159 #endif // C++11
160 
161 #pragma GCC visibility pop
162 
163 #endif // _GLIBCXX_NESTED_EXCEPTION_H
164