Skip to content

S
swiftshader
Commit 7c84426d by Nicolas Capens Committed by Nicolas Capens
Options

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: 's avatarNicolas Capens <nicolascapens@google.com> Reviewed-by: 's avatarAlexis Hétu <sugoi@google.com> Commit-Queue: Nicolas Capens <nicolascapens@google.com>
parent f36e874a
Showing with 0 additions and 396 deletions
third_party/stlport-cpp11-extension/memory deleted 100644 → 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_
third_party/stlport-cpp11-extension/string deleted 100644 → 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_
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment