diff options
author | Jonathan Wakely <jwakely@redhat.com> | 2021-11-09 12:56:43 +0000 |
---|---|---|
committer | Jonathan Wakely <jwakely@redhat.com> | 2021-12-12 22:51:12 +0000 |
commit | b8f7ff76d6f0b7fdffc314a19425423606b5e296 (patch) | |
tree | f19438f2a2a95503d4336e9c74de3912f6c896c4 | |
parent | 0b52083ea2c2dd9897031fdc3802a68fd4aa45ef (diff) | |
download | gcc-b8f7ff76d6f0b7fdffc314a19425423606b5e296.zip gcc-b8f7ff76d6f0b7fdffc314a19425423606b5e296.tar.gz gcc-b8f7ff76d6f0b7fdffc314a19425423606b5e296.tar.bz2 |
Replace gnu::unique_ptr with std::unique_ptr
Now that GCC is compiled as C++11 there is no need to keep the C++03
implementation of gnu::unique_ptr.
This removes the unique-ptr.h header and replaces it with <memory> in
system.h, and changes the INCLUDE_UNIQUE_PTR macro to INCLUDE_MEMORY.
Uses of gnu::unique_ptr and gnu::move can be replaced with
std::unique_ptr and std::move. There are no uses of unique_xmalloc_ptr
or xmalloc_deleter in GCC.
gcc/analyzer/ChangeLog:
* engine.cc: Define INCLUDE_MEMORY instead of INCLUDE_UNIQUE_PTR.
gcc/c-family/ChangeLog:
* known-headers.cc: Define INCLUDE_MEMORY instead of
INCLUDE_UNIQUE_PTR.
* name-hint.h: Likewise.
(class name_hint): Use std::unique_ptr instead of gnu::unique_ptr.
gcc/c/ChangeLog:
* c-decl.c: Define INCLUDE_MEMORY instead of INCLUDE_UNIQUE_PTR.
* c-parser.c: Likewise.
gcc/cp/ChangeLog:
* error.c: Define INCLUDE_MEMORY instead of
INCLUDE_UNIQUE_PTR.
* lex.c: Likewise.
* name-lookup.c: Likewise.
(class namespace_limit_reached): Use std::unique_ptr instead of
gnu::unique_ptr.
(suggest_alternatives_for): Use std::move instead of gnu::move.
(suggest_alternatives_in_other_namespaces): Likewise.
* parser.c: Define INCLUDE_MEMORY instead of INCLUDE_UNIQUE_PTR.
gcc/ChangeLog:
* Makefile.in: Remove unique-ptr-tests.o.
* selftest-run-tests.c (selftest::run_tests): Remove
unique_ptr_tests_cc_tests.
* selftest.h (unique_ptr_tests_cc_tests): Remove.
* system.h: Check INCLUDE_MEMORY instead of INCLUDE_UNIQUE_PTR
and include <memory> instead of "unique-ptr.h".
* unique-ptr-tests.cc: Removed.
include/ChangeLog:
* unique-ptr.h: Removed.
-rw-r--r-- | gcc/Makefile.in | 1 | ||||
-rw-r--r-- | gcc/analyzer/engine.cc | 2 | ||||
-rw-r--r-- | gcc/c-family/known-headers.cc | 2 | ||||
-rw-r--r-- | gcc/c-family/name-hint.h | 12 | ||||
-rw-r--r-- | gcc/c/c-decl.c | 2 | ||||
-rw-r--r-- | gcc/c/c-parser.c | 2 | ||||
-rw-r--r-- | gcc/cp/error.c | 2 | ||||
-rw-r--r-- | gcc/cp/lex.c | 2 | ||||
-rw-r--r-- | gcc/cp/name-lookup.c | 10 | ||||
-rw-r--r-- | gcc/cp/parser.c | 2 | ||||
-rw-r--r-- | gcc/selftest-run-tests.c | 1 | ||||
-rw-r--r-- | gcc/selftest.h | 1 | ||||
-rw-r--r-- | gcc/system.h | 8 | ||||
-rw-r--r-- | gcc/unique-ptr-tests.cc | 236 | ||||
-rw-r--r-- | include/unique-ptr.h | 405 |
15 files changed, 21 insertions, 667 deletions
diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 41949f0..3e0cb4794 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -1699,7 +1699,6 @@ OBJS = \ tree.o \ tristate.o \ typed-splay-tree.o \ - unique-ptr-tests.o \ valtrack.o \ value-pointer-equiv.o \ value-query.o \ diff --git a/gcc/analyzer/engine.cc b/gcc/analyzer/engine.cc index e8a7cca..4aa246c 100644 --- a/gcc/analyzer/engine.cc +++ b/gcc/analyzer/engine.cc @@ -19,7 +19,7 @@ along with GCC; see the file COPYING3. If not see <http://www.gnu.org/licenses/>. */ #include "config.h" -#define INCLUDE_UNIQUE_PTR +#define INCLUDE_MEMORY #include "system.h" #include "coretypes.h" #include "tree.h" diff --git a/gcc/c-family/known-headers.cc b/gcc/c-family/known-headers.cc index a391246..572cca1 100644 --- a/gcc/c-family/known-headers.cc +++ b/gcc/c-family/known-headers.cc @@ -18,7 +18,7 @@ along with GCC; see the file COPYING3. If not see <http://www.gnu.org/licenses/>. */ #include "config.h" -#define INCLUDE_UNIQUE_PTR +#define INCLUDE_MEMORY #include "system.h" #include "coretypes.h" #include "c-family/c-common.h" diff --git a/gcc/c-family/name-hint.h b/gcc/c-family/name-hint.h index ea43324..3141552 100644 --- a/gcc/c-family/name-hint.h +++ b/gcc/c-family/name-hint.h @@ -20,12 +20,12 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_NAME_HINT_H #define GCC_NAME_HINT_H -/* This header uses gnu::unique_ptr, but unique-ptr.h can't be directly +/* This header uses std::unique_ptr, but <memory> can't be directly included due to issues with macros. Hence it must be included from - system.h by defining INCLUDE_UNIQUE_PTR in any source file using it. */ + system.h by defining INCLUDE_MEMORY in any source file using it. */ -#ifndef GNU_UNIQUE_PTR_H -# error "You must define INCLUDE_UNIQUE_PTR before including system.h to use name-hint.h" +#ifndef INCLUDE_MEMORY +# error "You must define INCLUDE_MEMORY before including system.h to use name-hint.h" #endif enum lookup_name_fuzzy_kind { @@ -106,7 +106,7 @@ public: /* Take ownership of this name_hint's deferred_diagnostic, for use in chaining up deferred diagnostics. */ - gnu::unique_ptr<deferred_diagnostic> take_deferred () { return move (m_deferred); } + std::unique_ptr<deferred_diagnostic> take_deferred () { return move (m_deferred); } /* Call this on a name_hint if the corresponding warning was not emitted, in which case we should also not emit the deferred_diagnostic. */ @@ -119,7 +119,7 @@ public: private: const char *m_suggestion; - gnu::unique_ptr<deferred_diagnostic> m_deferred; + std::unique_ptr<deferred_diagnostic> m_deferred; }; extern name_hint lookup_name_fuzzy (tree, enum lookup_name_fuzzy_kind, diff --git a/gcc/c/c-decl.c b/gcc/c/c-decl.c index 9e45798..4b5481c 100644 --- a/gcc/c/c-decl.c +++ b/gcc/c/c-decl.c @@ -26,7 +26,7 @@ along with GCC; see the file COPYING3. If not see #include "config.h" #define INCLUDE_STRING -#define INCLUDE_UNIQUE_PTR +#define INCLUDE_MEMORY #include "system.h" #include "coretypes.h" #include "target.h" diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c index e99c847..e25df4f 100644 --- a/gcc/c/c-parser.c +++ b/gcc/c/c-parser.c @@ -36,7 +36,7 @@ along with GCC; see the file COPYING3. If not see location rather than implicitly using input_location. */ #include "config.h" -#define INCLUDE_UNIQUE_PTR +#define INCLUDE_MEMORY #include "system.h" #include "coretypes.h" #include "target.h" diff --git a/gcc/cp/error.c b/gcc/cp/error.c index daea3b3..323643d 100644 --- a/gcc/cp/error.c +++ b/gcc/cp/error.c @@ -19,7 +19,7 @@ along with GCC; see the file COPYING3. If not see #include "config.h" /* For use with name_hint. */ -#define INCLUDE_UNIQUE_PTR +#define INCLUDE_MEMORY #include "system.h" #include "coretypes.h" #include "cp-tree.h" diff --git a/gcc/cp/lex.c b/gcc/cp/lex.c index 43abd01..06de6cf 100644 --- a/gcc/cp/lex.c +++ b/gcc/cp/lex.c @@ -23,7 +23,7 @@ along with GCC; see the file COPYING3. If not see #include "config.h" /* For use with name_hint. */ -#define INCLUDE_UNIQUE_PTR +#define INCLUDE_MEMORY #include "system.h" #include "coretypes.h" #include "cp-tree.h" diff --git a/gcc/cp/name-lookup.c b/gcc/cp/name-lookup.c index 229ba45..6b5e434 100644 --- a/gcc/cp/name-lookup.c +++ b/gcc/cp/name-lookup.c @@ -19,7 +19,7 @@ along with GCC; see the file COPYING3. If not see <http://www.gnu.org/licenses/>. */ #include "config.h" -#define INCLUDE_UNIQUE_PTR +#define INCLUDE_MEMORY #include "system.h" #include "coretypes.h" #include "cp-tree.h" @@ -6340,7 +6340,7 @@ class namespace_limit_reached : public deferred_diagnostic { public: namespace_limit_reached (location_t loc, unsigned limit, tree name, - gnu::unique_ptr<deferred_diagnostic> wrapped) + std::unique_ptr<deferred_diagnostic> wrapped) : deferred_diagnostic (loc), m_limit (limit), m_name (name), m_wrapped (move (wrapped)) @@ -6360,7 +6360,7 @@ class namespace_limit_reached : public deferred_diagnostic private: unsigned m_limit; tree m_name; - gnu::unique_ptr<deferred_diagnostic> m_wrapped; + std::unique_ptr<deferred_diagnostic> m_wrapped; }; /* Subclass of deferred_diagnostic, for use when issuing a single suggestion. @@ -6604,7 +6604,7 @@ suggest_alternatives_for (location_t location, tree name, if (!result) result = suggest_alternatives_for_1 (location, name, suggest_misspellings); - return ns_hints.maybe_decorate_with_limit (gnu::move (result)); + return ns_hints.maybe_decorate_with_limit (std::move (result)); } /* The second half of suggest_alternatives_for, for when no exact matches @@ -6649,7 +6649,7 @@ suggest_alternatives_in_other_namespaces (location_t location, tree name) name_hint result = ns_hints.convert_candidates_to_name_hint (); - return ns_hints.maybe_decorate_with_limit (gnu::move (result)); + return ns_hints.maybe_decorate_with_limit (std::move (result)); } /* A well-known name within the C++ standard library, returned by diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index de464afd..52225d4 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -19,7 +19,7 @@ along with GCC; see the file COPYING3. If not see <http://www.gnu.org/licenses/>. */ #include "config.h" -#define INCLUDE_UNIQUE_PTR +#define INCLUDE_MEMORY #include "system.h" #include "coretypes.h" #include "cp-tree.h" diff --git a/gcc/selftest-run-tests.c b/gcc/selftest-run-tests.c index 6a8f291..8eb1239 100644 --- a/gcc/selftest-run-tests.c +++ b/gcc/selftest-run-tests.c @@ -71,7 +71,6 @@ selftest::run_tests () sreal_c_tests (); fibonacci_heap_c_tests (); typed_splay_tree_c_tests (); - unique_ptr_tests_cc_tests (); opt_proposer_c_tests (); opts_c_tests (); json_cc_tests (); diff --git a/gcc/selftest.h b/gcc/selftest.h index 24ef57cb..e6c7fc3 100644 --- a/gcc/selftest.h +++ b/gcc/selftest.h @@ -262,7 +262,6 @@ extern void tree_cfg_c_tests (); extern void tree_diagnostic_path_cc_tests (); extern void tristate_cc_tests (); extern void typed_splay_tree_c_tests (); -extern void unique_ptr_tests_cc_tests (); extern void vec_c_tests (); extern void vec_perm_indices_c_tests (); extern void wide_int_cc_tests (); diff --git a/gcc/system.h b/gcc/system.h index 4ac656c..2cd2017 100644 --- a/gcc/system.h +++ b/gcc/system.h @@ -737,12 +737,10 @@ extern int vsnprintf (char *, size_t, const char *, va_list); /* Some of the headers included by <memory> can use "abort" within a namespace, e.g. "_VSTD::abort();", which fails after we use the - preprocessor to redefine "abort" as "fancy_abort" below. - Given that unique-ptr.h can use "free", we need to do this after "free" - is declared but before "abort" is overridden. */ + preprocessor to redefine "abort" as "fancy_abort" below. */ -#ifdef INCLUDE_UNIQUE_PTR -# include "unique-ptr.h" +#ifdef INCLUDE_MEMORY +# include <memory> #endif #ifdef INCLUDE_MALLOC_H diff --git a/gcc/unique-ptr-tests.cc b/gcc/unique-ptr-tests.cc deleted file mode 100644 index 975dd57..0000000 --- a/gcc/unique-ptr-tests.cc +++ /dev/null @@ -1,236 +0,0 @@ -/* Unit tests for unique-ptr.h. - Copyright (C) 2017-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. - -You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING3. If not see -<http://www.gnu.org/licenses/>. */ - -#include "config.h" -#define INCLUDE_UNIQUE_PTR -#include "system.h" -#include "coretypes.h" -#include "selftest.h" - -#if CHECKING_P - -namespace selftest { - -namespace { - -/* A class for counting ctor and dtor invocations. */ - -class stats -{ -public: - stats () : ctor_count (0), dtor_count (0) {} - - int ctor_count; - int dtor_count; -}; - -/* A class that uses "stats" to track its ctor and dtor invocations. */ - -class foo -{ -public: - foo (stats &s) : m_s (s) { ++m_s.ctor_count; } - ~foo () { ++m_s.dtor_count; } - - int example_method () const { return 42; } - -private: - foo (const foo&); - foo & operator= (const foo &); - -private: - stats &m_s; -}; - -/* A struct for testing unique_ptr<T[]>. */ - -class has_default_ctor -{ -public: - has_default_ctor () : m_field (42) {} - int m_field; -}; - -/* A dummy struct for testing unique_xmalloc_ptr. */ - -struct dummy -{ - int field; -}; - -} // anonymous namespace - -/* Verify that the default ctor inits ptrs to NULL. */ - -static void -test_null_ptr () -{ - gnu::unique_ptr<void *> p; - ASSERT_EQ (NULL, p); - - gnu::unique_xmalloc_ptr<void *> q; - ASSERT_EQ (NULL, q); -} - -/* Verify that deletion happens when a unique_ptr goes out of scope. */ - -static void -test_implicit_deletion () -{ - stats s; - ASSERT_EQ (0, s.ctor_count); - ASSERT_EQ (0, s.dtor_count); - - { - gnu::unique_ptr<foo> f (new foo (s)); - ASSERT_NE (NULL, f); - ASSERT_EQ (1, s.ctor_count); - ASSERT_EQ (0, s.dtor_count); - } - - /* Verify that the foo was implicitly deleted. */ - ASSERT_EQ (1, s.ctor_count); - ASSERT_EQ (1, s.dtor_count); -} - -/* Verify that we can assign to a NULL unique_ptr. */ - -static void -test_overwrite_of_null () -{ - stats s; - ASSERT_EQ (0, s.ctor_count); - ASSERT_EQ (0, s.dtor_count); - - { - gnu::unique_ptr<foo> f; - ASSERT_EQ (NULL, f); - ASSERT_EQ (0, s.ctor_count); - ASSERT_EQ (0, s.dtor_count); - - /* Overwrite with a non-NULL value. */ - f = gnu::unique_ptr<foo> (new foo (s)); - ASSERT_EQ (1, s.ctor_count); - ASSERT_EQ (0, s.dtor_count); - } - - /* Verify that the foo is implicitly deleted. */ - ASSERT_EQ (1, s.ctor_count); - ASSERT_EQ (1, s.dtor_count); -} - -/* Verify that we can assign to a non-NULL unique_ptr. */ - -static void -test_overwrite_of_non_null () -{ - stats s; - ASSERT_EQ (0, s.ctor_count); - ASSERT_EQ (0, s.dtor_count); - - { - gnu::unique_ptr<foo> f (new foo (s)); - ASSERT_NE (NULL, f); - ASSERT_EQ (1, s.ctor_count); - ASSERT_EQ (0, s.dtor_count); - - /* Overwrite with a different value. */ - f = gnu::unique_ptr<foo> (new foo (s)); - ASSERT_EQ (2, s.ctor_count); - ASSERT_EQ (1, s.dtor_count); - } - - /* Verify that the 2nd foo was implicitly deleted. */ - ASSERT_EQ (2, s.ctor_count); - ASSERT_EQ (2, s.dtor_count); -} - -/* Verify that unique_ptr's overloaded ops work. */ - -static void -test_overloaded_ops () -{ - stats s; - gnu::unique_ptr<foo> f (new foo (s)); - ASSERT_EQ (42, f->example_method ()); - ASSERT_EQ (42, (*f).example_method ()); - ASSERT_EQ (f, f); - ASSERT_NE (NULL, f.get ()); - - gnu::unique_ptr<foo> g (new foo (s)); - ASSERT_NE (f, g); -} - -/* Verify that the gnu::unique_ptr specialization for T[] works. */ - -static void -test_array_new () -{ - const int num = 10; - gnu::unique_ptr<has_default_ctor[]> p (new has_default_ctor[num]); - ASSERT_NE (NULL, p.get ()); - /* Verify that operator[] works, and that the default ctor was called - on each element. */ - for (int i = 0; i < num; i++) - ASSERT_EQ (42, p[i].m_field); -} - -/* Verify that gnu::unique_xmalloc_ptr works. */ - -static void -test_xmalloc () -{ - gnu::unique_xmalloc_ptr<dummy> p (XNEW (dummy)); - ASSERT_NE (NULL, p.get ()); -} - -/* Verify the gnu::unique_xmalloc_ptr specialization for T[]. */ - -static void -test_xmalloc_array () -{ - const int num = 10; - gnu::unique_xmalloc_ptr<dummy[]> p (XNEWVEC (dummy, num)); - ASSERT_NE (NULL, p.get ()); - - /* Verify that operator[] works. */ - for (int i = 0; i < num; i++) - p[i].field = 42; - for (int i = 0; i < num; i++) - ASSERT_EQ (42, p[i].field); -} - -/* Run all of the selftests within this file. */ - -void -unique_ptr_tests_cc_tests () -{ - test_null_ptr (); - test_implicit_deletion (); - test_overwrite_of_null (); - test_overwrite_of_non_null (); - test_overloaded_ops (); - test_array_new (); - test_xmalloc (); - test_xmalloc_array (); -} - -} // namespace selftest - -#endif /* #if CHECKING_P */ diff --git a/include/unique-ptr.h b/include/unique-ptr.h deleted file mode 100644 index d1b2ba5..0000000 --- a/include/unique-ptr.h +++ /dev/null @@ -1,405 +0,0 @@ -/* gnu::unique_ptr, a simple std::unique_ptr replacement for C++03. - - Copyright (C) 2007-2021 Free Software Foundation, Inc. - - This file is part of GCC. - - This program 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 of the License, or - (at your option) any later version. - - This program 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. - - You should have received a copy of the GNU General Public License - along with this program. If not, see <http://www.gnu.org/licenses/>. */ - -/* gnu::unique_ptr defines a C++ owning smart pointer that exposes a - subset of the std::unique_ptr API. - - In fact, when compiled with a C++11 compiler, gnu::unique_ptr - actually _is_ std::unique_ptr. When compiled with a C++03 compiler - OTOH, it's an hand coded std::unique_ptr emulation that assumes - code is correct and doesn't try to be too smart. - - This supports custom deleters, but not _stateful_ deleters, so you - can't use those in C++11 mode either. Only the managed pointer is - stored in the smart pointer. That could be changed; it simply - wasn't found necessary. - - At the end of the file you'll find a gnu::unique_ptr partial - specialization that uses a custom (stateless) deleter: - gnu::unique_xmalloc_ptr. That is used to manage pointers to - objects allocated with xmalloc. - - The C++03 version was originally based on GCC 7.0's std::auto_ptr - and then heavily customized to behave more like C++11's - std::unique_ptr, but at this point, it no longer shares much at all - with the original file. But, that's the history and the reason for - the copyright's starting year. - - The C++03 version lets you shoot yourself in the foot, since - similarly to std::auto_ptr, the copy constructor and assignment - operators actually move. Also, in the name of simplicity, no - effort is spent on using SFINAE to prevent invalid conversions, - etc. This is not really a problem, because the goal here is to - allow code that would be correct using std::unique_ptr to be - equally correct in C++03 mode, and, just as efficient. If client - code compiles correctly with a C++11 (or newer) compiler, we know - we're not doing anything invalid by mistake. - - Usage notes: - - - Putting gnu::unique_ptr in standard containers is not supported, - since C++03 containers are not move-aware (and our emulation - relies on copy actually moving). - - - Since there's no nullptr in C++03, gnu::unique_ptr allows - implicit initialization and assignment from NULL instead. - - - To check whether there's an associated managed object, all these - work as expected: - - if (ptr) - if (!ptr) - if (ptr != NULL) - if (ptr == NULL) - if (NULL != ptr) - if (NULL == ptr) -*/ - -#ifndef GNU_UNIQUE_PTR_H -#define GNU_UNIQUE_PTR_H 1 - -#if __cplusplus >= 201103 -# include <memory> -#endif - -namespace gnu -{ - -#if __cplusplus >= 201103 - -/* In C++11 mode, all we need is import the standard - std::unique_ptr. */ -template<typename T> using unique_ptr = std::unique_ptr<T>; - -/* Pull in move as well. */ -using std::move; - -#else /* C++11 */ - -/* Default destruction policy used by gnu::unique_ptr when no deleter - is specified. Uses delete. */ - -template<typename T> -struct default_delete -{ - void operator () (T *ptr) const { delete ptr; } -}; - -/* Specialization for arrays. Uses delete[]. */ - -template<typename T> -struct default_delete<T[]> -{ - void operator () (T *ptr) const { delete [] ptr; } -}; - -namespace detail -{ -/* Type used to support implicit construction from NULL: - - gnu::unique_ptr<foo> func (....) - { - return NULL; - } - - and assignment from NULL: - - gnu::unique_ptr<foo> ptr (....); - ... - ptr = NULL; - - It is intentionally not defined anywhere. */ -struct nullptr_t; - -/* Base class of our unique_ptr emulation. Contains code common to - both unique_ptr<T, D> and unique_ptr<T[], D>. */ - -template<typename T, typename D> -class unique_ptr_base -{ -public: - typedef T *pointer; - typedef T element_type; - typedef D deleter_type; - - /* Takes ownership of a pointer. P is a pointer to an object of - element_type type. Defaults to NULL. */ - explicit unique_ptr_base (element_type *p = NULL) throw () : m_ptr (p) {} - - /* The "move" constructor. Really a copy constructor that actually - moves. Even though std::unique_ptr is not copyable, our little - simpler emulation allows it, because: - - - There are no rvalue references in C++03. Our move emulation - instead relies on copy/assignment moving, like std::auto_ptr. - - RVO/NRVO requires an accessible copy constructor - */ - unique_ptr_base (const unique_ptr_base &other) throw () - : m_ptr (const_cast<unique_ptr_base &> (other).release ()) {} - - /* Converting "move" constructor. Really an lvalue ref converting - constructor that actually moves. This allows constructs such as: - - unique_ptr<Derived> func_returning_unique_ptr (.....); - ... - unique_ptr<Base> ptr = func_returning_unique_ptr (.....); - */ - template<typename T1, typename D1> - unique_ptr_base (const unique_ptr_base<T1, D1> &other) throw () - : m_ptr (const_cast<unique_ptr_base<T1, D1> &> (other).release ()) {} - - /* The "move" assignment operator. Really an lvalue ref copy - assignment operator that actually moves. See comments above. */ - unique_ptr_base &operator= (const unique_ptr_base &other) throw () - { - reset (const_cast<unique_ptr_base &> (other).release ()); - return *this; - } - - /* Converting "move" assignment. Really an lvalue ref converting - copy assignment operator that moves. See comments above. */ - template<typename T1, typename D1> - unique_ptr_base &operator= (const unique_ptr_base<T1, D1> &other) throw () - { - reset (const_cast<unique_ptr_base<T1, D1> &> (other).release ()); - return *this; - } - - /* std::unique_ptr does not allow assignment, except from nullptr. - nullptr doesn't exist in C++03, so we allow assignment from NULL - instead [ptr = NULL;]. - */ - unique_ptr_base &operator= (detail::nullptr_t *) throw () - { - reset (); - return *this; - } - - ~unique_ptr_base () { call_deleter (); } - - /* "explicit operator bool ()" emulation using the safe bool - idiom. */ -private: - typedef void (unique_ptr_base::*explicit_operator_bool) () const; - void this_type_does_not_support_comparisons () const {} - -public: - operator explicit_operator_bool () const - { - return (m_ptr != NULL - ? &unique_ptr_base::this_type_does_not_support_comparisons - : 0); - } - - element_type *get () const throw () { return m_ptr; } - - element_type *release () throw () - { - pointer tmp = m_ptr; - m_ptr = NULL; - return tmp; - } - - void reset (element_type *p = NULL) throw () - { - if (p != m_ptr) - { - call_deleter (); - m_ptr = p; - } - } - -private: - - /* Call the deleter. Note we assume the deleter is "stateless". */ - void call_deleter () - { - D d; - - d (m_ptr); - } - - element_type *m_ptr; -}; - -} /* namespace detail */ - -/* Macro used to create a unique_ptr_base "partial specialization" -- - a subclass that uses a specific deleter. Basically this re-defines - the necessary constructors. This is necessary because C++03 - doesn't support inheriting constructors with "using". While at it, - we inherit the assignment operator. TYPE is the name of the type - being defined. Assumes that 'base_type' is a typedef of the - baseclass TYPE is inheriting from. */ -#define DEFINE_GNU_UNIQUE_PTR(TYPE) \ -public: \ - explicit TYPE (T *p = NULL) throw () \ - : base_type (p) {} \ - \ - TYPE (const TYPE &other) throw () : base_type (other) {} \ - \ - TYPE (detail::nullptr_t *) throw () : base_type (NULL) {} \ - \ - template<typename T1, typename D1> \ - TYPE (const detail::unique_ptr_base<T1, D1> &other) throw () \ - : base_type (other) {} \ - \ - using base_type::operator=; - -/* Define single-object gnu::unique_ptr. */ - -template <typename T, typename D = default_delete<T> > -class unique_ptr : public detail::unique_ptr_base<T, D> -{ - typedef detail::unique_ptr_base<T, D> base_type; - - DEFINE_GNU_UNIQUE_PTR (unique_ptr) - -public: - /* Dereferencing. */ - T &operator* () const throw () { return *this->get (); } - T *operator-> () const throw () { return this->get (); } -}; - -/* Define gnu::unique_ptr specialization for T[]. */ - -template <typename T, typename D> -class unique_ptr<T[], D> : public detail::unique_ptr_base<T, D> -{ - typedef detail::unique_ptr_base<T, D> base_type; - - DEFINE_GNU_UNIQUE_PTR (unique_ptr) - -public: - /* Indexing operator. */ - T &operator[] (size_t i) const { return this->get ()[i]; } -}; - -/* Comparison operators. */ - -template <typename T, typename D, - typename U, typename E> -inline bool -operator== (const detail::unique_ptr_base<T, D> &x, - const detail::unique_ptr_base<U, E> &y) -{ return x.get() == y.get(); } - -template <typename T, typename D, - typename U, typename E> -inline bool -operator!= (const detail::unique_ptr_base<T, D> &x, - const detail::unique_ptr_base<U, E> &y) -{ return x.get() != y.get(); } - -template<typename T, typename D, - typename U, typename E> -inline bool -operator< (const detail::unique_ptr_base<T, D> &x, - const detail::unique_ptr_base<U, E> &y) -{ return x.get() < y.get (); } - -template<typename T, typename D, - typename U, typename E> -inline bool -operator<= (const detail::unique_ptr_base<T, D> &x, - const detail::unique_ptr_base<U, E> &y) -{ return !(y < x); } - -template<typename T, typename D, - typename U, typename E> -inline bool -operator> (const detail::unique_ptr_base<T, D> &x, - const detail::unique_ptr_base<U, E> &y) -{ return y < x; } - -template<typename T, typename D, - typename U, typename E> -inline bool -operator>= (const detail::unique_ptr_base<T, D> &x, - const detail::unique_ptr_base<U, E> &y) -{ return !(x < y); } - -/* std::move "emulation". This is as simple as it can be -- no - attempt is made to emulate rvalue references. This relies on T - having move semantics like std::auto_ptr. - I.e., copy/assignment actually moves. */ - -template<typename T> -const T& -move (T& v) -{ - return v; -} - -#endif /* C++11 */ - -/* Define gnu::unique_xmalloc_ptr, a gnu::unique_ptr that manages - xmalloc'ed memory. */ - -/* The deleter for gnu::unique_xmalloc_ptr. Uses free. */ -template <typename T> -struct xmalloc_deleter -{ - void operator() (T *ptr) const { free (ptr); } -}; - -/* Same, for arrays. */ -template <typename T> -struct xmalloc_deleter<T[]> -{ - void operator() (T *ptr) const { free (ptr); } -}; - -#if __cplusplus >= 201103 - -/* In C++11, we just import the standard unique_ptr to our namespace - with a custom deleter. */ - -template<typename T> using unique_xmalloc_ptr - = std::unique_ptr<T, xmalloc_deleter<T>>; - -#else /* C++11 */ - -/* In C++03, we don't have template aliases, so we need to define a - subclass instead, and re-define the constructors, because C++03 - doesn't support inheriting constructors either. */ - -template <typename T> -class unique_xmalloc_ptr : public unique_ptr<T, xmalloc_deleter<T> > -{ - typedef unique_ptr<T, xmalloc_deleter<T> > base_type; - - DEFINE_GNU_UNIQUE_PTR (unique_xmalloc_ptr) -}; - -/* Define gnu::unique_xmalloc_ptr specialization for T[]. */ - -template <typename T> -class unique_xmalloc_ptr<T[]> : public unique_ptr<T[], xmalloc_deleter<T[]> > -{ - typedef unique_ptr<T[], xmalloc_deleter<T[]> > base_type; - - DEFINE_GNU_UNIQUE_PTR (unique_xmalloc_ptr) -}; - -#endif /* C++11 */ - -} /* namespace gnu */ - -#endif /* GNU_UNIQUE_PTR_H */ |