From fea45591b219e91e68b4a588d004b27a3a8c629a Mon Sep 17 00:00:00 2001 From: Jeffrey Walton Date: Sun, 4 Sep 2016 02:29:32 -0400 Subject: [PATCH] Add constexpr to size_max() methods for C++11 --- secblock.h | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/secblock.h b/secblock.h index 442fd096..862f28bd 100644 --- a/secblock.h +++ b/secblock.h @@ -52,8 +52,8 @@ public: //! because the latter is \a not a \a constexpr. Some compilers, like Clang, do not //! optimize it well under all circumstances. Compilers like GCC, ICC and MSVC appear //! to optimize it well in either form. - size_type max_size() const {return (SIZE_MAX/sizeof(T));} - + CRYPTOPP_CONSTEXPR size_type max_size() const {return (SIZE_MAX/sizeof(T));} + #if defined(CRYPTOPP_CXX11_VARIADIC_TEMPLATES) || defined(CRYPTOPP_DOXYGEN_PROCESSING) //! \brief Constructs a new U using variadic arguments @@ -65,7 +65,7 @@ public: //! is defined. The define is controlled by compiler versions detected in config.h. template void construct(U* ptr, Args&&... args) {::new ((void*)ptr) U(std::forward(args)...);} - + //! \brief Destroys an U constructed with variadic arguments //! \tparam U the type to be forwarded //! \details This is a C++11 feature. It is available when CRYPTOPP_CXX11_VARIADIC_TEMPLATES @@ -76,11 +76,11 @@ public: #endif protected: - + //! \brief Verifies the allocator can satisfy a request based on size //! \param size the size of the allocation, in elements //! \throws InvalidArgument - //! \details CheckSize verifies the number of elements requested is valid. + //! \details CheckSize verifies the number of elements requested is valid. //! \details If size is greater than max_size(), then InvalidArgument is thrown. //! The library throws InvalidArgument if the size is too large to satisfy. //! \details Internally, preprocessor macros are used rather than std::numeric_limits @@ -126,7 +126,7 @@ typename A::pointer StandardReallocate(A& alloc, T *oldPtr, typename A::size_typ { typename A::pointer newPointer = alloc.allocate(newSize, NULL); const size_t copySize = STDMIN(oldSize, newSize) * sizeof(T); - + if (oldPtr && newPointer) {memcpy_s(newPointer, copySize, oldPtr, copySize);} alloc.deallocate(oldPtr, oldSize); return newPointer; @@ -140,7 +140,7 @@ typename A::pointer StandardReallocate(A& alloc, T *oldPtr, typename A::size_typ //! \class AllocatorWithCleanup //! \brief Allocates a block of memory with cleanup -//! \tparam T class or type +//! \tparam T class or type //! \tparam T_Align16 boolean that determines whether allocations should be aligned on 16-byte boundaries //! \details If T_Align16 is true, then AllocatorWithCleanup calls AlignedAllocate() //! for memory allocations. If T_Align16 is false, then AllocatorWithCleanup() calls @@ -162,10 +162,10 @@ public: //! and less than max_size(), then an attempt is made to fulfill the request using either //! AlignedAllocate() or UnalignedAllocate(). //! \details AlignedAllocate() is used if T_Align16 is true. - //! UnalignedAllocate() used if T_Align16 is false. + //! UnalignedAllocate() used if T_Align16 is false. //! \details This is the C++ *Placement New* operator. ptr is not used, and the function //! asserts in Debug builds if ptr is non-NULL. - //! \sa CallNewHandler() for the methods used to recover from a failed + //! \sa CallNewHandler() for the methods used to recover from a failed //! allocation attempt. //! \note size is the count of elements, and not the number of bytes pointer allocate(size_type size, const void *ptr = NULL) @@ -188,10 +188,10 @@ public: //! \param ptr the pointer for the allocation //! \param size the size of the allocation, in elements //! \details Internally, SecureWipeArray() is called before deallocating the memory. - //! Once the memory block is wiped or zeroized, AlignedDeallocate() or + //! Once the memory block is wiped or zeroized, AlignedDeallocate() or //! UnalignedDeallocate() is called. //! \details AlignedDeallocate() is used if T_Align16 is true. - //! UnalignedDeallocate() used if T_Align16 is false. + //! UnalignedDeallocate() used if T_Align16 is false. void deallocate(void *ptr, size_type size) { assert((ptr && size) || !(ptr || size)); @@ -278,7 +278,7 @@ public: assert(false); } - size_type max_size() const {return 0;} + CRYPTOPP_CONSTEXPR size_type max_size() const {return 0;} //LCOV_EXCL_STOP }; @@ -410,7 +410,7 @@ public: return newPointer; } - size_type max_size() const {return STDMAX(m_fallbackAllocator.max_size(), S);} + CRYPTOPP_CONSTEXPR size_type max_size() const {return STDMAX(m_fallbackAllocator.max_size(), S);} private: @@ -446,7 +446,7 @@ public: //! \note size is the count of elements, and not the number of bytes explicit SecBlock(size_type size=0) : m_size(size), m_ptr(m_alloc.allocate(size, NULL)) { } - + //! \brief Copy construct a SecBlock from another SecBlock //! \param t the other SecBlock //! \throws std::bad_alloc @@ -460,7 +460,7 @@ public: //! \param ptr a pointer to an array of T //! \param len the number of elements in the memory block //! \throws std::bad_alloc - //! \details If ptr!=NULL and len!=0, then the block is initialized from the pointer ptr. + //! \details If ptr!=NULL and len!=0, then the block is initialized from the pointer ptr. //! If ptr==NULL and len!=0, then the block is initialized to 0. //! Otherwise, the block is empty and \a not initialized. //! \note size is the count of elements, and not the number of bytes @@ -802,7 +802,7 @@ __stl_alloc_rebind(CryptoPP::AllocatorWithCleanup<_Tp1>& __a, const _Tp2*) #endif NAMESPACE_END - + #if CRYPTOPP_MSC_VERSION # pragma warning(pop) #endif