Remove stlport C++11 extensions These were used for platforms which don't have full C++11 support. We've since moved on to requiring at least C++14. Bug: b/75229322 Bug: b/147359661 Change-Id: I0754c3b9cd5ac38e8b690f66d719101298c1e25e Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/50888 Kokoro-Result: kokoro <noreply+kokoro@google.com> Tested-by: Nicolas Capens <nicolascapens@google.com> Reviewed-by: Alexis Hétu <sugoi@google.com> Commit-Queue: Nicolas Capens <nicolascapens@google.com>
diff --git a/third_party/stlport-cpp11-extension/memory b/third_party/stlport-cpp11-extension/memory deleted file mode 100644 index 2ff5435..0000000 --- a/third_party/stlport-cpp11-extension/memory +++ /dev/null
@@ -1,352 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef _STLPORT_CPP11_EXTENSION_MEMORY_ -#define _STLPORT_CPP11_EXTENSION_MEMORY_ - -// This file extends stlport's <memory> implementation to provide support for: -// - std::shared_ptr (C++11) -// - std::unique_ptr (C++11) - -// Cloned from master branch vendor/google/native/cmds/sysproxy/shared_ptr.h -// Upstream commit ff64c352c35c46a14f15503778781889a816eea4 -// Upstream Change-Id: I481ec53b08beecde2bf6dc38e5933342235da3d9 - -#include <stlport/memory> - -namespace std { - -template <typename T> -class shared_ptr { - public: - shared_ptr(); - explicit shared_ptr(T *value); - shared_ptr(const shared_ptr &rhs); - shared_ptr &operator=(const shared_ptr &rhs); - template <typename U> - shared_ptr(const shared_ptr<U> &rhs); - template <typename U> - shared_ptr &operator=(const shared_ptr<U> &rhs); - ~shared_ptr(); - - T *get() const; - T *operator->() const; - T &operator*() const; - - template <typename U> - bool operator==(const shared_ptr<U> &rhs) const; - template <typename U> - bool operator!=(const shared_ptr<U> &rhs) const; - template <typename U> - bool operator<(const shared_ptr<U> &rhs) const; - template <typename U> - bool operator<=(const shared_ptr<U> &rhs) const; - template <typename U> - bool operator>(const shared_ptr<U> &rhs) const; - template <typename U> - bool operator>=(const shared_ptr<U> &rhs) const; - - void reset(T *value = NULL); - - // TODO(haining) Work with Deleter - - private: - template <typename U> - friend class shared_ptr; - - struct Node { - T *value; - int *count; - }; - // Thread safe decrement, deletes node_ if holding last remaining reference. - // Any use of node_ after calling this function is unsafe unless node_ is - // reassigned. - void DecNode(); - - // Thread safe increment. - void IncNode(); - - // Creates a Node referring to NULL. - static Node NewNullNode(); - - // Creates a Node referring to value. - static Node NewNodeFor(T *value); - - Node node_; -}; - -template <typename T> -typename shared_ptr<T>::Node shared_ptr<T>::NewNodeFor(T *value) { - Node n = {value, new int(1)}; - return n; -} - -template <typename T> -typename shared_ptr<T>::Node shared_ptr<T>::NewNullNode() { - return NewNodeFor(NULL); -} - -template <typename T> -void shared_ptr<T>::reset(T *value) { - DecNode(); - node_ = NewNodeFor(value); -} - -template <typename T> -shared_ptr<T>::shared_ptr() : node_(NewNullNode()) {} - -template <typename T> -void shared_ptr<T>::DecNode() { - bool should_delete = __atomic_fetch_sub(node_.count, 1, __ATOMIC_SEQ_CST) == 0; - // The only accesses to node_ that should be made after this line is the - // deletion conditional on should_delete. Anything else is unsafe since - // because another thread could have deleted node_ - if (should_delete) { - delete node_.value; - delete node_.count; - node_.value = NULL; - node_.count = NULL; - } -} - -template <typename T> -void shared_ptr<T>::IncNode() { - __atomic_fetch_add(node_.count, 1, __ATOMIC_SEQ_CST); -} - -template <typename T> -shared_ptr<T>::shared_ptr(T *value) { - node_ = NewNodeFor(value); -} - -template <typename T> -shared_ptr<T>::shared_ptr(const shared_ptr &rhs) : node_(rhs.node_) { - IncNode(); -} - -template <typename T> -template <typename U> -shared_ptr<T>::shared_ptr(const shared_ptr<U> &rhs) { - node_.value = rhs.node_.value; - node_.count = rhs.node_.count; - node_.m = rhs.node_.m; - IncNode(); -} - -template <typename T> -shared_ptr<T> &shared_ptr<T>::operator=(const shared_ptr &rhs) { - if (node_.value == rhs.node_.value) { - return *this; - } - - DecNode(); - node_ = rhs.node_; - IncNode(); - return *this; -} - -template <typename T> -template <typename U> -shared_ptr<T> &shared_ptr<T>::operator=(const shared_ptr<U> &rhs) { - if (node_.value == rhs.node_.value) { - return *this; - } - - DecNode(); - node_.value = rhs.node_.value; - node_.count = rhs.node_.count; - node_.m = rhs.node_.m; - IncNode(); - return *this; -} - -template <typename T> -shared_ptr<T>::~shared_ptr() { - DecNode(); -} - -template <typename T> -T *shared_ptr<T>::get() const { - return node_.value; -} - -template <typename T> -T *shared_ptr<T>::operator->() const { - return get(); -} - -template <typename T> -T &shared_ptr<T>::operator*() const { - return *node_.value; -} - -template <typename T> -template <typename U> -bool shared_ptr<T>::operator==(const shared_ptr<U> &rhs) const { - return node_.value == rhs.node_.value; -} - -template <typename T> -template <typename U> -bool shared_ptr<T>::operator!=(const shared_ptr<U> &rhs) const { - return node_.value != rhs.node_.value; -} - -template <typename T> -template <typename U> -bool shared_ptr<T>::operator<(const shared_ptr<U> &rhs) const { - return node_.value < rhs.node_.value; -} - -template <typename T> -template <typename U> -bool shared_ptr<T>::operator<=(const shared_ptr<U> &rhs) const { - return node_.value <= rhs.node_.value; -} - -template <typename T> -template <typename U> -bool shared_ptr<T>::operator>(const shared_ptr<U> &rhs) const { - return node_.value > rhs.node_.value; -} - -template <typename T> -template <typename U> -bool shared_ptr<T>::operator>=(const shared_ptr<U> &rhs) const { - return node_.value >= rhs.node_.value; -} - -#if !defined(DISALLOW_COPY_AND_ASSIGN) -#define DISALLOW_COPY_AND_ASSIGN(TypeName) \ - TypeName(const TypeName&); \ - void operator=(const TypeName&); -#endif - -#include <cstddef> - -// Default deleter for pointer types. -template <typename T> -struct DefaultDelete { - void operator()(T* p) const { delete p; } -}; - -// Default deleter for array types. -template <typename T> -struct DefaultDelete<T[]> { - void operator()(T* p) const { delete[] p; } -}; - -// A smart pointer that deletes the given pointer on destruction. -// Equivalent to C++11's std::unique_ptr -// Named to be in keeping with Android style but also to avoid -// collision with any other implementation, until we can switch over -// to unique_ptr. -// Use thus: -// unique_ptr<C> c(new C); - -namespace workaround_internal { -template <typename T, typename Deleter> -class UniquePtrBase { - public: - // Construct a new UniquePtrBase, taking ownership of the given raw pointer. - explicit UniquePtrBase(T* ptr = 0) : mPtr(ptr), mDeleter() {} - explicit UniquePtrBase(T* ptr, Deleter d) : mPtr(ptr), mDeleter(d) {} - - ~UniquePtrBase() { reset(); } - - // Accessors. - T* get() const { return mPtr; } - - // Returns the raw pointer and hands over ownership to the caller. - // The pointer will not be deleted by UniquePtrBase. - T* release() { - T* result = mPtr; - mPtr = 0; - return result; - } - - // Takes ownership of the given raw pointer. - // If this smart pointer previously owned a different raw pointer, that - // raw pointer will be freed. - void reset(T* ptr = 0) { - T* old_ptr = mPtr; - mPtr = ptr; - if (old_ptr != NULL && mPtr != old_ptr) { - get_deleter()(old_ptr); - } - } - - Deleter& get_deleter() { return mDeleter; } - const Deleter& get_deleter() const { return mDeleter; } - - private: - // This is so users can compare against null. Callers should be able - // to invoke operator== and operator!= above with NULL pointers but not - // with any other pointer. - struct RawDummy {}; - - public: - bool operator==(const RawDummy*) const { return get() == NULL; } - friend bool operator==(const RawDummy*, const UniquePtrBase& self) { - return self == NULL; - } - - bool operator!=(const RawDummy*) const { return !(*this == NULL); } - friend bool operator!=(const RawDummy*, const UniquePtrBase& self) { - return self != NULL; - } - - private: - // The raw pointer. - T* mPtr; - Deleter mDeleter; - - DISALLOW_COPY_AND_ASSIGN(UniquePtrBase); -}; -} // namespace workaround_internal - -template <typename T, typename Deleter = DefaultDelete<T> > -class unique_ptr : public workaround_internal::UniquePtrBase<T, Deleter> { - typedef workaround_internal::UniquePtrBase<T, Deleter> Base; - public: - // Construct a new unique_ptr, taking ownership of the given raw pointer. - explicit unique_ptr(T* ptr = 0) : Base(ptr) { } - explicit unique_ptr(T* ptr, Deleter d) : Base(ptr, d) { } - - T& operator*() const { return *this->get(); } - T* operator->() const { return this->get(); } -}; - -// Partial specialization for array types. Like std::unique_ptr, this removes -// operator* and operator-> but adds operator[]. -template <typename T, typename Deleter> -class unique_ptr<T[], Deleter> : public workaround_internal::UniquePtrBase<T, Deleter> { - typedef workaround_internal::UniquePtrBase<T, Deleter> Base; - public: - explicit unique_ptr(T* ptr = 0) : Base(ptr) { } - explicit unique_ptr(T* ptr, Deleter d) : Base(ptr, d) { } - - T& operator[](std::ptrdiff_t i) const { return this->get()[i]; } -}; - -template <typename T> -shared_ptr<T> make_shared() { - return shared_ptr<T>(new T); -} - -} // namespace std - -#endif // _STLPORT_CPP11_EXTENSION_MEMORY_
diff --git a/third_party/stlport-cpp11-extension/string b/third_party/stlport-cpp11-extension/string deleted file mode 100644 index 53f6125..0000000 --- a/third_party/stlport-cpp11-extension/string +++ /dev/null
@@ -1,44 +0,0 @@ -/* - * Copyright (C) 2018 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef _STLPORT_CPP11_EXTENSION_STRING_ -#define _STLPORT_CPP11_EXTENSION_STRING_ - -// This file extends stlport's <string> implementation to provide support for: -// - std::to_string (C++11) - -// Cloned from master branch vendor/google/native/cmds/sysproxy/shared_ptr.h -// Upstream commit ff64c352c35c46a14f15503778781889a816eea4 -// Upstream Change-Id: I481ec53b08beecde2bf6dc38e5933342235da3d9 - -// Include the original stlport <string> header. -#include <stlport/string> - -#include <sstream> - -namespace std { - -template <typename T> -std::string to_string(const T& val) { - std::ostringstream temp; - temp << val; - return temp.str(); -} - -} // namespace std - -#endif // _STLPORT_CPP11_EXTENSION_STRING_ -