11.2.0/bits/exception_ptr.h

// Exception Handling support header (exception_ptr class) for -*- C++ -*-

// Copyright (C) 2008-2021 Free Software Foundation, Inc.
//
// This file is part of GCC.
//
// GCC is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3, or (at your option)
// any later version.
// 
// GCC is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @file bits/exception_ptr.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{exception}
 */

#ifndef _EXCEPTION_PTR_H
#define _EXCEPTION_PTR_H

#pragma GCC visibility push(default)

#include <bits/c++config.h>
#include <bits/exception_defines.h>
#include <bits/cxxabi_init_exception.h>
#include <typeinfo>
#include <new>

#ifdef _GLIBCXX_EH_PTR_RELOPS_COMPAT
# define _GLIBCXX_EH_PTR_USED __attribute__((__used__))
#else
# define _GLIBCXX_EH_PTR_USED
#endif

extern "C++" {

namespace std 
{
  class type_info;

  /**
   * @addtogroup exceptions
   * @{
   */

  namespace __exception_ptr
  {
    class exception_ptr;
  }

  using __exception_ptr::exception_ptr;

  /** Obtain an exception_ptr to the currently handled exception. If there
   *  is none, or the currently handled exception is foreign, return the null
   *  value.
   */
  exception_ptr current_exception() _GLIBCXX_USE_NOEXCEPT;

  template<typename _Ex>
  exception_ptr make_exception_ptr(_Ex) _GLIBCXX_USE_NOEXCEPT;

  /// Throw the object pointed to by the exception_ptr.
  void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));

  namespace __exception_ptr
  {
    using std::rethrow_exception;

    /**
     *  @brief An opaque pointer to an arbitrary exception.
     *  @ingroup exceptions
     */
    class exception_ptr
    {
      void* _M_exception_object;

      explicit exception_ptr(void* __e) _GLIBCXX_USE_NOEXCEPT;

      void _M_addref() _GLIBCXX_USE_NOEXCEPT;
      void _M_release() _GLIBCXX_USE_NOEXCEPT;

      void *_M_get() const _GLIBCXX_NOEXCEPT __attribute__ ((__pure__));

      friend exception_ptr std::current_exception() _GLIBCXX_USE_NOEXCEPT;
      friend void std::rethrow_exception(exception_ptr);
      template<typename _Ex>
      friend exception_ptr std::make_exception_ptr(_Ex) _GLIBCXX_USE_NOEXCEPT;

    public:
      exception_ptr() _GLIBCXX_USE_NOEXCEPT;

      exception_ptr(const exception_ptr&) _GLIBCXX_USE_NOEXCEPT;

#if __cplusplus >= 201103L
      exception_ptr(nullptr_t) noexcept
      : _M_exception_object(nullptr)
      { }

      exception_ptr(exception_ptr&& __o) noexcept
      : _M_exception_object(__o._M_exception_object)
      { __o._M_exception_object = nullptr; }
#endif

#if (__cplusplus < 201103L) || defined (_GLIBCXX_EH_PTR_COMPAT)
      typedef void (exception_ptr::*__safe_bool)();

      // For construction from nullptr or 0.
      exception_ptr(__safe_bool) _GLIBCXX_USE_NOEXCEPT;
#endif

      exception_ptr& 
      operator=(const exception_ptr&) _GLIBCXX_USE_NOEXCEPT;

#if __cplusplus >= 201103L
      exception_ptr& 
      operator=(exception_ptr&& __o) noexcept
      {
        exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this);
        return *this;
      }
#endif

      ~exception_ptr() _GLIBCXX_USE_NOEXCEPT;

      void 
      swap(exception_ptr&) _GLIBCXX_USE_NOEXCEPT;

#ifdef _GLIBCXX_EH_PTR_COMPAT
      // Retained for compatibility with CXXABI_1.3.
      void _M_safe_bool_dummy() _GLIBCXX_USE_NOEXCEPT
        __attribute__ ((__const__));
      bool operator!() const _GLIBCXX_USE_NOEXCEPT
        __attribute__ ((__pure__));
      operator __safe_bool() const _GLIBCXX_USE_NOEXCEPT;
#endif

#if __cplusplus >= 201103L
      explicit operator bool() const noexcept
      { return _M_exception_object; }
#endif

#if __cpp_impl_three_way_comparison >= 201907L \
      && ! defined _GLIBCXX_EH_PTR_RELOPS_COMPAT
      friend bool
      operator==(const exception_ptr&, const exception_ptr&) noexcept = default;
#else
      friend _GLIBCXX_EH_PTR_USED bool
      operator==(const exception_ptr& __x, const exception_ptr& __y)
      _GLIBCXX_USE_NOEXCEPT
      { return __x._M_exception_object == __y._M_exception_object; }

      friend _GLIBCXX_EH_PTR_USED bool
      operator!=(const exception_ptr& __x, const exception_ptr& __y)
      _GLIBCXX_USE_NOEXCEPT
      { return __x._M_exception_object != __y._M_exception_object; }
#endif

      const class std::type_info*
      __cxa_exception_type() const _GLIBCXX_USE_NOEXCEPT
        __attribute__ ((__pure__));
    };

    _GLIBCXX_EH_PTR_USED
    inline
    exception_ptr::exception_ptr() _GLIBCXX_NOEXCEPT
    : _M_exception_object(0)
    { }

    _GLIBCXX_EH_PTR_USED
    inline
    exception_ptr::exception_ptr(const exception_ptr& __other) _GLIBCXX_NOEXCEPT
    : _M_exception_object(__other._M_exception_object)
    {
      if (_M_exception_object)
        _M_addref();
    }

    _GLIBCXX_EH_PTR_USED
    inline
    exception_ptr::~exception_ptr() _GLIBCXX_USE_NOEXCEPT
    {
      if (_M_exception_object)
        _M_release();
    }

    _GLIBCXX_EH_PTR_USED
    inline exception_ptr&
    exception_ptr::operator=(const exception_ptr& __other) _GLIBCXX_USE_NOEXCEPT
    {
      exception_ptr(__other).swap(*this);
      return *this;
    }

    _GLIBCXX_EH_PTR_USED
    inline void
    exception_ptr::swap(exception_ptr &__other) _GLIBCXX_USE_NOEXCEPT
    {
      void *__tmp = _M_exception_object;
      _M_exception_object = __other._M_exception_object;
      __other._M_exception_object = __tmp;
    }

    /// @relates exception_ptr
    inline void
    swap(exception_ptr& __lhs, exception_ptr& __rhs)
    { __lhs.swap(__rhs); }

    /// @cond undocumented
    template<typename _Ex>
      inline void
      __dest_thunk(void* __x)
      { static_cast<_Ex*>(__x)->~_Ex(); }
    /// @endcond

  } // namespace __exception_ptr

  /// Obtain an exception_ptr pointing to a copy of the supplied object.
  template<typename _Ex>
    exception_ptr 
    make_exception_ptr(_Ex __ex) _GLIBCXX_USE_NOEXCEPT
    {
#if __cpp_exceptions && __cpp_rtti && !_GLIBCXX_HAVE_CDTOR_CALLABI
      void* __e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex));
      (void) __cxxabiv1::__cxa_init_primary_exception(
          __e, const_cast<std::type_info*>(&typeid(__ex)),
          __exception_ptr::__dest_thunk<_Ex>);
      try
        {
          ::new (__e) _Ex(__ex);
          return exception_ptr(__e);
        }
      catch(...)
        {
          __cxxabiv1::__cxa_free_exception(__e);
          return current_exception();
        }
#elif __cpp_exceptions
      try
        {
          throw __ex;
        }
      catch(...)
        {
          return current_exception();
        }
#else // no RTTI and no exceptions
      return exception_ptr();
#endif
    }

#undef _GLIBCXX_EH_PTR_USED

  /// @} group exceptions
} // namespace std

} // extern "C++"

#pragma GCC visibility pop

#endif
Revision:	1166
Committed:	Tue Oct 26 14:22:36 2021 UTC (4 years ago) by rossy
Content type:	text/x-chdr
File size:	7465 byte(s)
Log Message:	Daodan: Replace MinGW build env with an up-to-date MSYS2 env
#	Content
1	// Exception Handling support header (exception_ptr class) for -- C++ --
2
3	// Copyright (C) 2008-2021 Free Software Foundation, Inc.
4	//
5	// This file is part of GCC.
6	//
7	// GCC is free software; you can redistribute it and/or modify
8	// it under the terms of the GNU General Public License as published by
9	// the Free Software Foundation; either version 3, or (at your option)
10	// any later version.
11	//
12	// GCC is distributed in the hope that it will be useful,
13	// but WITHOUT ANY WARRANTY; without even the implied warranty of
14	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	// GNU General Public License for more details.
16	//
17	// Under Section 7 of GPL version 3, you are granted additional
18	// permissions described in the GCC Runtime Library Exception, version
19	// 3.1, as published by the Free Software Foundation.
20
21	// You should have received a copy of the GNU General Public License and
22	// a copy of the GCC Runtime Library Exception along with this program;
23	// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24	// <http://www.gnu.org/licenses/>.
25
26	/** @file bits/exception_ptr.h
27	* This is an internal header file, included by other library headers.
28	* Do not attempt to use it directly. @headername{exception}
29	*/
30
31	#ifndef _EXCEPTION_PTR_H
32	#define _EXCEPTION_PTR_H
33
34	#pragma GCC visibility push(default)
35
36	#include <bits/c++config.h>
37	#include <bits/exception_defines.h>
38	#include <bits/cxxabi_init_exception.h>
39	#include <typeinfo>
40	#include <new>
41
42	#ifdef _GLIBCXX_EH_PTR_RELOPS_COMPAT
43	# define _GLIBCXX_EH_PTR_USED __attribute__((__used__))
44	#else
45	# define _GLIBCXX_EH_PTR_USED
46	#endif
47
48	extern "C++" {
49
50	namespace std
51	{
52	class type_info;
53
54	/**
55	* @addtogroup exceptions
56	* @{
57	*/
58
59	namespace __exception_ptr
60	{
61	class exception_ptr;
62	}
63
64	using __exception_ptr::exception_ptr;
65
66	/** Obtain an exception_ptr to the currently handled exception. If there
67	* is none, or the currently handled exception is foreign, return the null
68	* value.
69	*/
70	exception_ptr current_exception() _GLIBCXX_USE_NOEXCEPT;
71
72	template<typename _Ex>
73	exception_ptr make_exception_ptr(_Ex) _GLIBCXX_USE_NOEXCEPT;
74
75	/// Throw the object pointed to by the exception_ptr.
76	void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));
77
78	namespace __exception_ptr
79	{
80	using std::rethrow_exception;
81
82	/**
83	* @brief An opaque pointer to an arbitrary exception.
84	* @ingroup exceptions
85	*/
86	class exception_ptr
87	{
88	void* _M_exception_object;
89
90	explicit exception_ptr(void* __e) _GLIBCXX_USE_NOEXCEPT;
91
92	void _M_addref() _GLIBCXX_USE_NOEXCEPT;
93	void _M_release() _GLIBCXX_USE_NOEXCEPT;
94
95	void *_M_get() const _GLIBCXX_NOEXCEPT __attribute__ ((__pure__));
96
97	friend exception_ptr std::current_exception() _GLIBCXX_USE_NOEXCEPT;
98	friend void std::rethrow_exception(exception_ptr);
99	template<typename _Ex>
100	friend exception_ptr std::make_exception_ptr(_Ex) _GLIBCXX_USE_NOEXCEPT;
101
102	public:
103	exception_ptr() _GLIBCXX_USE_NOEXCEPT;
104
105	exception_ptr(const exception_ptr&) _GLIBCXX_USE_NOEXCEPT;
106
107	#if __cplusplus >= 201103L
108	exception_ptr(nullptr_t) noexcept
109	: _M_exception_object(nullptr)
110	{ }
111
112	exception_ptr(exception_ptr&& __o) noexcept
113	: _M_exception_object(__o._M_exception_object)
114	{ __o._M_exception_object = nullptr; }
115	#endif
116
117	#if (__cplusplus < 201103L) \|\| defined (_GLIBCXX_EH_PTR_COMPAT)
118	typedef void (exception_ptr::*__safe_bool)();
119
120	// For construction from nullptr or 0.
121	exception_ptr(__safe_bool) _GLIBCXX_USE_NOEXCEPT;
122	#endif
123
124	exception_ptr&
125	operator=(const exception_ptr&) _GLIBCXX_USE_NOEXCEPT;
126
127	#if __cplusplus >= 201103L
128	exception_ptr&
129	operator=(exception_ptr&& __o) noexcept
130	{
131	exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this);
132	return *this;
133	}
134	#endif
135
136	~exception_ptr() _GLIBCXX_USE_NOEXCEPT;
137
138	void
139	swap(exception_ptr&) _GLIBCXX_USE_NOEXCEPT;
140
141	#ifdef _GLIBCXX_EH_PTR_COMPAT
142	// Retained for compatibility with CXXABI_1.3.
143	void _M_safe_bool_dummy() _GLIBCXX_USE_NOEXCEPT
144	__attribute__ ((__const__));
145	bool operator!() const _GLIBCXX_USE_NOEXCEPT
146	__attribute__ ((__pure__));
147	operator __safe_bool() const _GLIBCXX_USE_NOEXCEPT;
148	#endif
149
150	#if __cplusplus >= 201103L
151	explicit operator bool() const noexcept
152	{ return _M_exception_object; }
153	#endif
154
155	#if __cpp_impl_three_way_comparison >= 201907L \
156	&& ! defined _GLIBCXX_EH_PTR_RELOPS_COMPAT
157	friend bool
158	operator==(const exception_ptr&, const exception_ptr&) noexcept = default;
159	#else
160	friend _GLIBCXX_EH_PTR_USED bool
161	operator==(const exception_ptr& __x, const exception_ptr& __y)
162	_GLIBCXX_USE_NOEXCEPT
163	{ return __x._M_exception_object == __y._M_exception_object; }
164
165	friend _GLIBCXX_EH_PTR_USED bool
166	operator!=(const exception_ptr& __x, const exception_ptr& __y)
167	_GLIBCXX_USE_NOEXCEPT
168	{ return __x._M_exception_object != __y._M_exception_object; }
169	#endif
170
171	const class std::type_info*
172	__cxa_exception_type() const _GLIBCXX_USE_NOEXCEPT
173	__attribute__ ((__pure__));
174	};
175
176	_GLIBCXX_EH_PTR_USED
177	inline
178	exception_ptr::exception_ptr() _GLIBCXX_NOEXCEPT
179	: _M_exception_object(0)
180	{ }
181
182	_GLIBCXX_EH_PTR_USED
183	inline
184	exception_ptr::exception_ptr(const exception_ptr& __other) _GLIBCXX_NOEXCEPT
185	: _M_exception_object(__other._M_exception_object)
186	{
187	if (_M_exception_object)
188	_M_addref();
189	}
190
191	_GLIBCXX_EH_PTR_USED
192	inline
193	exception_ptr::~exception_ptr() _GLIBCXX_USE_NOEXCEPT
194	{
195	if (_M_exception_object)
196	_M_release();
197	}
198
199	_GLIBCXX_EH_PTR_USED
200	inline exception_ptr&
201	exception_ptr::operator=(const exception_ptr& __other) _GLIBCXX_USE_NOEXCEPT
202	{
203	exception_ptr(__other).swap(*this);
204	return *this;
205	}
206
207	_GLIBCXX_EH_PTR_USED
208	inline void
209	exception_ptr::swap(exception_ptr &__other) _GLIBCXX_USE_NOEXCEPT
210	{
211	void *__tmp = _M_exception_object;
212	_M_exception_object = __other._M_exception_object;
213	__other._M_exception_object = __tmp;
214	}
215
216	/// @relates exception_ptr
217	inline void
218	swap(exception_ptr& __lhs, exception_ptr& __rhs)
219	{ __lhs.swap(__rhs); }
220
221	/// @cond undocumented
222	template<typename _Ex>
223	inline void
224	__dest_thunk(void* __x)
225	{ static_cast<_Ex*>(__x)->~_Ex(); }
226	/// @endcond
227
228	} // namespace __exception_ptr
229
230	/// Obtain an exception_ptr pointing to a copy of the supplied object.
231	template<typename _Ex>
232	exception_ptr
233	make_exception_ptr(_Ex __ex) _GLIBCXX_USE_NOEXCEPT
234	{
235	#if __cpp_exceptions && __cpp_rtti && !_GLIBCXX_HAVE_CDTOR_CALLABI
236	void* __e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex));
237	(void) __cxxabiv1::__cxa_init_primary_exception(
238	__e, const_cast<std::type_info*>(&typeid(__ex)),
239	__exception_ptr::__dest_thunk<_Ex>);
240	try
241	{
242	::new (__e) _Ex(__ex);
243	return exception_ptr(__e);
244	}
245	catch(...)
246	{
247	__cxxabiv1::__cxa_free_exception(__e);
248	return current_exception();
249	}
250	#elif __cpp_exceptions
251	try
252	{
253	throw __ex;
254	}
255	catch(...)
256	{
257	return current_exception();
258	}
259	#else // no RTTI and no exceptions
260	return exception_ptr();
261	#endif
262	}
263
264	#undef _GLIBCXX_EH_PTR_USED
265
266	/// @} group exceptions
267	} // namespace std
268
269	} // extern "C++"
270
271	#pragma GCC visibility pop
272
273	#endif