mirror of
https://github.com/shadps4-emu/ext-cryptopp.git
synced 2024-11-26 19:30:21 +00:00
Whitespace check-in
This commit is contained in:
Jeffrey Walton
parent
53c03d2b3c
commit
96172f95ab
454
misc.h
454
misc.h
@ -182,10 +182,10 @@ struct CompileAssert
|
||||
/// \brief Counts elements in an array
|
||||
/// \param arr an array of elements
|
||||
/// \details COUNTOF counts elements in an array. On Windows COUNTOF(x) is defined
|
||||
/// to <tt>_countof(x)</tt> to ensure correct results for pointers.
|
||||
/// to <tt>_countof(x)</tt> to ensure correct results for pointers.
|
||||
/// \note COUNTOF does not produce correct results with pointers, and an array must be used.
|
||||
/// <tt>sizeof(x)/sizeof(x[0])</tt> suffers the same problem. The risk is eliminated by using
|
||||
/// <tt>_countof(x)</tt> on Windows. Windows will provide the immunity for other platforms.
|
||||
/// <tt>sizeof(x)/sizeof(x[0])</tt> suffers the same problem. The risk is eliminated by using
|
||||
/// <tt>_countof(x)</tt> on Windows. Windows will provide the immunity for other platforms.
|
||||
# define COUNTOF(arr)
|
||||
#else
|
||||
// VS2005 added _countof
|
||||
@ -230,8 +230,8 @@ protected:
|
||||
|
||||
/// \brief Ensures an object is not copyable
|
||||
/// \details NotCopyable ensures an object is not copyable by making the
|
||||
/// copy constructor and assignment operator private. Deleters are used
|
||||
/// under C++11.
|
||||
/// copy constructor and assignment operator private. Deleters are used
|
||||
/// under C++11.
|
||||
/// \sa Clonable class
|
||||
class NotCopyable
|
||||
{
|
||||
@ -259,12 +259,12 @@ struct NewObject
|
||||
#if CRYPTOPP_DOXYGEN_PROCESSING
|
||||
/// \brief A memory barrier
|
||||
/// \details MEMORY_BARRIER attempts to ensure reads and writes are completed
|
||||
/// in the absence of a language synchronization point. It is used by the
|
||||
/// Singleton class if the compiler supports it. The barrier is provided at the
|
||||
/// customary places in a double-checked initialization.
|
||||
/// in the absence of a language synchronization point. It is used by the
|
||||
/// Singleton class if the compiler supports it. The barrier is provided at the
|
||||
/// customary places in a double-checked initialization.
|
||||
/// \details Internally, MEMORY_BARRIER uses <tt>std::atomic_thread_fence</tt> if
|
||||
/// C++11 atomics are available. Otherwise, <tt>intrinsic(_ReadWriteBarrier)</tt>,
|
||||
/// <tt>_ReadWriteBarrier()</tt> or <tt>__asm__("" ::: "memory")</tt> is used.
|
||||
/// C++11 atomics are available. Otherwise, <tt>intrinsic(_ReadWriteBarrier)</tt>,
|
||||
/// <tt>_ReadWriteBarrier()</tt> or <tt>__asm__("" ::: "memory")</tt> is used.
|
||||
#define MEMORY_BARRIER ...
|
||||
#else
|
||||
#if defined(CRYPTOPP_CXX11_ATOMICS)
|
||||
@ -286,19 +286,19 @@ struct NewObject
|
||||
/// \tparam F the object factory for T
|
||||
/// \tparam instance an instance counter for the class object
|
||||
/// \details This class safely initializes a static object in a multithreaded environment. For C++03
|
||||
/// and below it will do so without using locks for portability. If two threads call Ref() at the same
|
||||
/// time, they may get back different references, and one object may end up being memory leaked. This
|
||||
/// is by design and it avoids a subltle initialization problem ina multithreaded environment with thread
|
||||
/// local storage on early Windows platforms, like Windows XP and Windows 2003.
|
||||
/// and below it will do so without using locks for portability. If two threads call Ref() at the same
|
||||
/// time, they may get back different references, and one object may end up being memory leaked. This
|
||||
/// is by design and it avoids a subltle initialization problem ina multithreaded environment with thread
|
||||
/// local storage on early Windows platforms, like Windows XP and Windows 2003.
|
||||
/// \details For C++11 and above, a standard double-checked locking pattern with thread fences
|
||||
/// are used. The locks and fences are standard and do not hinder portability.
|
||||
/// are used. The locks and fences are standard and do not hinder portability.
|
||||
/// \details Microsoft's C++11 implementation provides the necessary primitive support on Windows Vista and
|
||||
/// above when using Visual Studio 2015 (<tt>cl.exe</tt> version 19.00). If C++11 is desired, you should
|
||||
/// set <tt>WINVER</tt> or <tt>_WIN32_WINNT</tt> to 0x600 (or above), and compile with Visual Studio 2015.
|
||||
/// above when using Visual Studio 2015 (<tt>cl.exe</tt> version 19.00). If C++11 is desired, you should
|
||||
/// set <tt>WINVER</tt> or <tt>_WIN32_WINNT</tt> to 0x600 (or above), and compile with Visual Studio 2015.
|
||||
/// \sa <A HREF="http://preshing.com/20130930/double-checked-locking-is-fixed-in-cpp11/">Double-Checked Locking
|
||||
/// is Fixed In C++11</A>, <A HREF="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2660.htm">Dynamic
|
||||
/// Initialization and Destruction with Concurrency</A> and
|
||||
/// <A HREF="http://msdn.microsoft.com/en-us/library/6yh4a9k1.aspx">Thread Local Storage (TLS)</A> on MSDN.
|
||||
/// is Fixed In C++11</A>, <A HREF="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2660.htm">Dynamic
|
||||
/// Initialization and Destruction with Concurrency</A> and
|
||||
/// <A HREF="http://msdn.microsoft.com/en-us/library/6yh4a9k1.aspx">Thread Local Storage (TLS)</A> on MSDN.
|
||||
/// \since Crypto++ 5.2
|
||||
template <class T, class F = NewObject<T>, int instance=0>
|
||||
class Singleton
|
||||
@ -318,7 +318,7 @@ private:
|
||||
/// \tparam F the object factory for T
|
||||
/// \tparam instance an instance counter for the class object
|
||||
/// \details Ref() is used to create the object using the object factory. The
|
||||
/// object is only created once with the limitations discussed in the class documentation.
|
||||
/// object is only created once with the limitations discussed in the class documentation.
|
||||
/// \sa <A HREF="http://preshing.com/20130930/double-checked-locking-is-fixed-in-cpp11/">Double-Checked Locking is Fixed In C++11</A>
|
||||
/// \since Crypto++ 5.2
|
||||
template <class T, class F, int instance>
|
||||
@ -379,7 +379,7 @@ template <class T, class F, int instance>
|
||||
/// \param pointer a pointer
|
||||
/// \param offset a offset into the pointer
|
||||
/// \details PtrAdd can be used to squash Clang and GCC
|
||||
/// UBsan findings for pointer addition and subtraction.
|
||||
/// UBsan findings for pointer addition and subtraction.
|
||||
template <typename PTR, typename OFF>
|
||||
inline PTR PtrAdd(PTR pointer, OFF offset)
|
||||
{
|
||||
@ -392,7 +392,7 @@ inline PTR PtrAdd(PTR pointer, OFF offset)
|
||||
/// \param pointer a pointer
|
||||
/// \param offset a offset into the pointer
|
||||
/// \details PtrSub can be used to squash Clang and GCC
|
||||
/// UBsan findings for pointer addition and subtraction.
|
||||
/// UBsan findings for pointer addition and subtraction.
|
||||
template <typename PTR, typename OFF>
|
||||
inline PTR PtrSub(PTR pointer, OFF offset)
|
||||
{
|
||||
@ -404,10 +404,10 @@ inline PTR PtrSub(PTR pointer, OFF offset)
|
||||
/// \param pointer1 the first pointer
|
||||
/// \param pointer2 the second pointer
|
||||
/// \details PtrDiff can be used to squash Clang and GCC
|
||||
/// UBsan findings for pointer addition and subtraction.
|
||||
/// pointer1 and pointer2 must point to the same object or
|
||||
/// array (or one past the end), and yields the number of
|
||||
/// elements (not bytes) difference.
|
||||
/// UBsan findings for pointer addition and subtraction.
|
||||
/// pointer1 and pointer2 must point to the same object or
|
||||
/// array (or one past the end), and yields the number of
|
||||
/// elements (not bytes) difference.
|
||||
template <typename PTR>
|
||||
inline ptrdiff_t PtrDiff(const PTR pointer1, const PTR pointer2)
|
||||
{
|
||||
@ -419,10 +419,10 @@ inline ptrdiff_t PtrDiff(const PTR pointer1, const PTR pointer2)
|
||||
/// \param pointer1 the first pointer
|
||||
/// \param pointer2 the second pointer
|
||||
/// \details PtrByteDiff can be used to squash Clang and GCC
|
||||
/// UBsan findings for pointer addition and subtraction.
|
||||
/// pointer1 and pointer2 must point to the same object or
|
||||
/// array (or one past the end), and yields the number of
|
||||
/// bytes (not elements) difference.
|
||||
/// UBsan findings for pointer addition and subtraction.
|
||||
/// pointer1 and pointer2 must point to the same object or
|
||||
/// array (or one past the end), and yields the number of
|
||||
/// bytes (not elements) difference.
|
||||
template <typename PTR>
|
||||
inline size_t PtrByteDiff(const PTR pointer1, const PTR pointer2)
|
||||
{
|
||||
@ -492,17 +492,17 @@ size_t BytePtrSize(const SecByteBlock& str);
|
||||
/// \param count the number of bytes to copy
|
||||
/// \throws InvalidArgument
|
||||
/// \details ISO/IEC TR-24772 provides bounds checking interfaces for potentially
|
||||
/// unsafe functions like memcpy(), strcpy() and memmove(). However,
|
||||
/// not all standard libraries provides them, like Glibc. The library's
|
||||
/// memcpy_s() is a near-drop in replacement. Its only a near-replacement
|
||||
/// because the library's version throws an InvalidArgument on a bounds violation.
|
||||
/// unsafe functions like memcpy(), strcpy() and memmove(). However,
|
||||
/// not all standard libraries provides them, like Glibc. The library's
|
||||
/// memcpy_s() is a near-drop in replacement. Its only a near-replacement
|
||||
/// because the library's version throws an InvalidArgument on a bounds violation.
|
||||
/// \details memcpy_s() and memmove_s() are guarded by __STDC_WANT_SECURE_LIB__.
|
||||
/// If __STDC_WANT_SECURE_LIB__ is not defined or defined to 0, then the library
|
||||
/// makes memcpy_s() and memmove_s() available. The library will also optionally
|
||||
/// make the symbols available if <tt>CRYPTOPP_WANT_SECURE_LIB</tt> is defined.
|
||||
/// <tt>CRYPTOPP_WANT_SECURE_LIB</tt> is in config.h, but it is disabled by default.
|
||||
/// If __STDC_WANT_SECURE_LIB__ is not defined or defined to 0, then the library
|
||||
/// makes memcpy_s() and memmove_s() available. The library will also optionally
|
||||
/// make the symbols available if <tt>CRYPTOPP_WANT_SECURE_LIB</tt> is defined.
|
||||
/// <tt>CRYPTOPP_WANT_SECURE_LIB</tt> is in config.h, but it is disabled by default.
|
||||
/// \details memcpy_s() will assert the pointers src and dest are not NULL
|
||||
/// in debug builds. Passing NULL for either pointer is undefined behavior.
|
||||
/// in debug builds. Passing NULL for either pointer is undefined behavior.
|
||||
inline void memcpy_s(void *dest, size_t sizeInBytes, const void *src, size_t count)
|
||||
{
|
||||
// Safer functions on Windows for C&A, http://github.com/weidai11/cryptopp/issues/55
|
||||
@ -524,7 +524,7 @@ inline void memcpy_s(void *dest, size_t sizeInBytes, const void *src, size_t cou
|
||||
# pragma warning(disable: 6386)
|
||||
# endif
|
||||
#endif
|
||||
if (src && dest)
|
||||
if (src != NULLPTR && dest != NULLPTR)
|
||||
std::memcpy(dest, src, count);
|
||||
#if CRYPTOPP_MSC_VERSION
|
||||
# pragma warning(pop)
|
||||
@ -538,17 +538,17 @@ inline void memcpy_s(void *dest, size_t sizeInBytes, const void *src, size_t cou
|
||||
/// \param count the number of bytes to copy
|
||||
/// \throws InvalidArgument
|
||||
/// \details ISO/IEC TR-24772 provides bounds checking interfaces for potentially
|
||||
/// unsafe functions like memcpy(), strcpy() and memmove(). However,
|
||||
/// not all standard libraries provides them, like Glibc. The library's
|
||||
/// memmove_s() is a near-drop in replacement. Its only a near-replacement
|
||||
/// because the library's version throws an InvalidArgument on a bounds violation.
|
||||
/// unsafe functions like memcpy(), strcpy() and memmove(). However,
|
||||
/// not all standard libraries provides them, like Glibc. The library's
|
||||
/// memmove_s() is a near-drop in replacement. Its only a near-replacement
|
||||
/// because the library's version throws an InvalidArgument on a bounds violation.
|
||||
/// \details memcpy_s() and memmove_s() are guarded by __STDC_WANT_SECURE_LIB__.
|
||||
/// If __STDC_WANT_SECURE_LIB__ is not defined or defined to 0, then the library
|
||||
/// makes memcpy_s() and memmove_s() available. The library will also optionally
|
||||
/// make the symbols available if <tt>CRYPTOPP_WANT_SECURE_LIB</tt> is defined.
|
||||
/// <tt>CRYPTOPP_WANT_SECURE_LIB</tt> is in config.h, but it is disabled by default.
|
||||
/// If __STDC_WANT_SECURE_LIB__ is not defined or defined to 0, then the library
|
||||
/// makes memcpy_s() and memmove_s() available. The library will also optionally
|
||||
/// make the symbols available if <tt>CRYPTOPP_WANT_SECURE_LIB</tt> is defined.
|
||||
/// <tt>CRYPTOPP_WANT_SECURE_LIB</tt> is in config.h, but it is disabled by default.
|
||||
/// \details memmove_s() will assert the pointers src and dest are not NULL
|
||||
/// in debug builds. Passing NULL for either pointer is undefined behavior.
|
||||
/// in debug builds. Passing NULL for either pointer is undefined behavior.
|
||||
inline void memmove_s(void *dest, size_t sizeInBytes, const void *src, size_t count)
|
||||
{
|
||||
// Safer functions on Windows for C&A, http://github.com/weidai11/cryptopp/issues/55
|
||||
@ -568,7 +568,7 @@ inline void memmove_s(void *dest, size_t sizeInBytes, const void *src, size_t co
|
||||
# pragma warning(disable: 6386)
|
||||
# endif
|
||||
#endif
|
||||
if (src && dest)
|
||||
if (src != NULLPTR && dest != NULLPTR)
|
||||
std::memmove(dest, src, count);
|
||||
#if CRYPTOPP_MSC_VERSION
|
||||
# pragma warning(pop)
|
||||
@ -588,10 +588,10 @@ inline void memmove_s(void *dest, size_t sizeInBytes, const void *src, size_t co
|
||||
/// \param a the first value
|
||||
/// \param b the second value
|
||||
/// \details C++03 does not provide support for <tt>std::swap(__m128i a, __m128i b)</tt>
|
||||
/// because <tt>__m128i</tt> is an <tt>unsigned long long[2]</tt>. Most compilers
|
||||
/// support it out of the box, but Sun Studio C++ compilers 12.2 and 12.3 do not.
|
||||
/// because <tt>__m128i</tt> is an <tt>unsigned long long[2]</tt>. Most compilers
|
||||
/// support it out of the box, but Sun Studio C++ compilers 12.2 and 12.3 do not.
|
||||
/// \sa <A HREF="http://stackoverflow.com/q/38417413">How to swap two __m128i variables
|
||||
/// in C++03 given its an opaque type and an array?</A> on Stack Overflow.
|
||||
/// in C++03 given its an opaque type and an array?</A> on Stack Overflow.
|
||||
template <class T>
|
||||
inline void vec_swap(T& a, T& b)
|
||||
{
|
||||
@ -611,7 +611,7 @@ inline void vec_swap(T& a, T& b)
|
||||
/// \param value the integer value to write for each byte
|
||||
/// \param num the size of the source memory block, in bytes
|
||||
/// \details Internally the function calls memset with the value value, and receives the
|
||||
/// return value from memset as a <tt>volatile</tt> pointer.
|
||||
/// return value from memset as a <tt>volatile</tt> pointer.
|
||||
inline void * memset_z(void *ptr, int value, size_t num)
|
||||
{
|
||||
// avoid extranous warning on GCC 4.3.2 Ubuntu 8.10
|
||||
@ -732,7 +732,7 @@ std::string IntToString(T value, unsigned int base = 10)
|
||||
/// \param base the base to use during the conversion
|
||||
/// \returns the string representation of value in base.
|
||||
/// \details this template function specialization was added to suppress
|
||||
/// Coverity findings on IntToString() with unsigned types.
|
||||
/// Coverity findings on IntToString() with unsigned types.
|
||||
template <> CRYPTOPP_DLL
|
||||
std::string IntToString<word64>(word64 value, unsigned int base);
|
||||
|
||||
@ -741,20 +741,20 @@ std::string IntToString<word64>(word64 value, unsigned int base);
|
||||
/// \param base the base to use during the conversion
|
||||
/// \returns the string representation of value in base.
|
||||
/// \details This is a template specialization of IntToString(). Use it
|
||||
/// like IntToString():
|
||||
/// like IntToString():
|
||||
/// <pre>
|
||||
/// // Print integer in base 10
|
||||
/// Integer n...
|
||||
/// std::string s = IntToString(n, 10);
|
||||
/// // Print integer in base 10
|
||||
/// Integer n...
|
||||
/// std::string s = IntToString(n, 10);
|
||||
/// </pre>
|
||||
/// \details The string is presented with lowercase letters by default. A
|
||||
/// hack is available to switch to uppercase letters without modifying
|
||||
/// the function signature.
|
||||
/// hack is available to switch to uppercase letters without modifying
|
||||
/// the function signature.
|
||||
/// <pre>
|
||||
/// // Print integer in base 16, uppercase letters
|
||||
/// Integer n...
|
||||
/// const unsigned int UPPER = (1 << 31);
|
||||
/// std::string s = IntToString(n, (UPPER | 16));</pre>
|
||||
/// // Print integer in base 16, uppercase letters
|
||||
/// Integer n...
|
||||
/// const unsigned int UPPER = (1 << 31);
|
||||
/// std::string s = IntToString(n, (UPPER | 16));</pre>
|
||||
template <> CRYPTOPP_DLL
|
||||
std::string IntToString<Integer>(Integer value, unsigned int base);
|
||||
|
||||
@ -839,7 +839,7 @@ unsigned int BitPrecision(const T &value)
|
||||
/// \param v the 32-bit value to test
|
||||
/// \returns the number of trailing 0-bits in v, starting at the least significant bit position
|
||||
/// \details TrailingZeros returns the number of trailing 0-bits in v, starting at the least
|
||||
/// significant bit position. The return value is undefined if there are no 1-bits set in the value v.
|
||||
/// significant bit position. The return value is undefined if there are no 1-bits set in the value v.
|
||||
/// \note The function does not return 0 if no 1-bits are set because 0 collides with a 1-bit at the 0-th position.
|
||||
inline unsigned int TrailingZeros(word32 v)
|
||||
{
|
||||
@ -870,7 +870,7 @@ inline unsigned int TrailingZeros(word32 v)
|
||||
/// \param v the 64-bit value to test
|
||||
/// \returns the number of trailing 0-bits in v, starting at the least significant bit position
|
||||
/// \details TrailingZeros returns the number of trailing 0-bits in v, starting at the least
|
||||
/// significant bit position. The return value is undefined if there are no 1-bits set in the value v.
|
||||
/// significant bit position. The return value is undefined if there are no 1-bits set in the value v.
|
||||
/// \note The function does not return 0 if no 1-bits are set because 0 collides with a 1-bit at the 0-th position.
|
||||
inline unsigned int TrailingZeros(word64 v)
|
||||
{
|
||||
@ -896,9 +896,9 @@ inline unsigned int TrailingZeros(word64 v)
|
||||
/// \param value the value to truncate or mask
|
||||
/// \param bits the number of bits to truncate or mask
|
||||
/// \returns the value truncated to the specified number of bits, starting at the least
|
||||
/// significant bit position
|
||||
/// significant bit position
|
||||
/// \details This function masks the low-order bits of value and returns the result. The
|
||||
/// mask is created with <tt>(1 << bits) - 1</tt>.
|
||||
/// mask is created with <tt>(1 << bits) - 1</tt>.
|
||||
template <class T>
|
||||
inline T Crop(T value, size_t bits)
|
||||
{
|
||||
@ -921,7 +921,7 @@ inline size_t BitsToBytes(size_t bitCount)
|
||||
/// \param byteCount the number of bytes
|
||||
/// \returns the minimum number of words required by byteCount
|
||||
/// \details BytesToWords is effectively a ceiling function based on <tt>WORD_SIZE</tt>.
|
||||
/// <tt>WORD_SIZE</tt> is defined in config.h
|
||||
/// <tt>WORD_SIZE</tt> is defined in config.h
|
||||
inline size_t BytesToWords(size_t byteCount)
|
||||
{
|
||||
return ((byteCount+WORD_SIZE-1)/WORD_SIZE);
|
||||
@ -931,7 +931,7 @@ inline size_t BytesToWords(size_t byteCount)
|
||||
/// \param bitCount the number of bits
|
||||
/// \returns the minimum number of words required by bitCount
|
||||
/// \details BitsToWords is effectively a ceiling function based on <tt>WORD_BITS</tt>.
|
||||
/// <tt>WORD_BITS</tt> is defined in config.h
|
||||
/// <tt>WORD_BITS</tt> is defined in config.h
|
||||
inline size_t BitsToWords(size_t bitCount)
|
||||
{
|
||||
return ((bitCount+WORD_BITS-1)/(WORD_BITS));
|
||||
@ -941,7 +941,7 @@ inline size_t BitsToWords(size_t bitCount)
|
||||
/// \param bitCount the number of bits
|
||||
/// \returns the minimum number of double words required by bitCount
|
||||
/// \details BitsToDwords is effectively a ceiling function based on <tt>2*WORD_BITS</tt>.
|
||||
/// <tt>WORD_BITS</tt> is defined in config.h
|
||||
/// <tt>WORD_BITS</tt> is defined in config.h
|
||||
inline size_t BitsToDwords(size_t bitCount)
|
||||
{
|
||||
return ((bitCount+2*WORD_BITS-1)/(2*WORD_BITS));
|
||||
@ -952,7 +952,7 @@ inline size_t BitsToDwords(size_t bitCount)
|
||||
/// \param mask the mask to XOR with the buffer
|
||||
/// \param count the size of the buffers, in bytes
|
||||
/// \details The function effectively visits each element in the buffers and performs
|
||||
/// <tt>buf[i] ^= mask[i]</tt>. buf and mask must be of equal size.
|
||||
/// <tt>buf[i] ^= mask[i]</tt>. buf and mask must be of equal size.
|
||||
CRYPTOPP_DLL void CRYPTOPP_API xorbuf(byte *buf, const byte *mask, size_t count);
|
||||
|
||||
/// Performs an XOR of an input buffer with a mask and stores the result in an output buffer
|
||||
@ -961,7 +961,7 @@ CRYPTOPP_DLL void CRYPTOPP_API xorbuf(byte *buf, const byte *mask, size_t count)
|
||||
/// \param mask the mask buffer to XOR with the input buffer
|
||||
/// \param count the size of the buffers, in bytes
|
||||
/// \details The function effectively visits each element in the buffers and performs
|
||||
/// <tt>output[i] = input[i] ^ mask[i]</tt>. output, input and mask must be of equal size.
|
||||
/// <tt>output[i] = input[i] ^ mask[i]</tt>. output, input and mask must be of equal size.
|
||||
CRYPTOPP_DLL void CRYPTOPP_API xorbuf(byte *output, const byte *input, const byte *mask, size_t count);
|
||||
|
||||
/// \brief Performs a near constant-time comparison of two equally sized buffers
|
||||
@ -969,11 +969,11 @@ CRYPTOPP_DLL void CRYPTOPP_API xorbuf(byte *output, const byte *input, const byt
|
||||
/// \param buf2 the second buffer
|
||||
/// \param count the size of the buffers, in bytes
|
||||
/// \details VerifyBufsEqual performs an XOR of the elements in two equally sized
|
||||
/// buffers and retruns a result based on the XOR operation. A count of 0 returns
|
||||
/// true because two empty buffers are considered equal.
|
||||
/// buffers and retruns a result based on the XOR operation. A count of 0 returns
|
||||
/// true because two empty buffers are considered equal.
|
||||
/// \details The function is near constant-time because CPU micro-code timings could
|
||||
/// affect the "constant-ness". Calling code is responsible for mitigating timing
|
||||
/// attacks if the buffers are not equally sized.
|
||||
/// affect the "constant-ness". Calling code is responsible for mitigating timing
|
||||
/// attacks if the buffers are not equally sized.
|
||||
/// \sa ModPowerOf2
|
||||
CRYPTOPP_DLL bool CRYPTOPP_API VerifyBufsEqual(const byte *buf1, const byte *buf2, size_t count);
|
||||
|
||||
@ -981,8 +981,8 @@ CRYPTOPP_DLL bool CRYPTOPP_API VerifyBufsEqual(const byte *buf1, const byte *buf
|
||||
/// \param value the value to test
|
||||
/// \returns true if value is a power of 2, false otherwise
|
||||
/// \details The function creates a mask of <tt>value - 1</tt> and returns the result
|
||||
/// of an AND operation compared to 0. If value is 0 or less than 0, then the function
|
||||
/// returns false.
|
||||
/// of an AND operation compared to 0. If value is 0 or less than 0, then the function
|
||||
/// returns false.
|
||||
template <class T>
|
||||
inline bool IsPowerOf2(const T &value)
|
||||
{
|
||||
@ -1063,9 +1063,9 @@ inline word128 NumericLimitsMax()
|
||||
/// \param b the subtrahend
|
||||
/// \returns the difference produced by the saturating subtract
|
||||
/// \details Saturating arithmetic restricts results to a fixed range. Results that are
|
||||
/// less than 0 are clamped at 0.
|
||||
/// less than 0 are clamped at 0.
|
||||
/// \details Use of saturating arithmetic in places can be advantageous because it can
|
||||
/// avoid a branch by using an instruction like a conditional move (<tt>CMOVE</tt>).
|
||||
/// avoid a branch by using an instruction like a conditional move (<tt>CMOVE</tt>).
|
||||
template <class T1, class T2>
|
||||
inline T1 SaturatingSubtract(const T1 &a, const T2 &b)
|
||||
{
|
||||
@ -1080,9 +1080,9 @@ inline T1 SaturatingSubtract(const T1 &a, const T2 &b)
|
||||
/// \param b the subtrahend
|
||||
/// \returns the difference produced by the saturating subtract
|
||||
/// \details Saturating arithmetic restricts results to a fixed range. Results that are
|
||||
/// less than 1 are clamped at 1.
|
||||
/// less than 1 are clamped at 1.
|
||||
/// \details Use of saturating arithmetic in places can be advantageous because it can
|
||||
/// avoid a branch by using an instruction like a conditional move (<tt>CMOVE</tt>).
|
||||
/// avoid a branch by using an instruction like a conditional move (<tt>CMOVE</tt>).
|
||||
template <class T1, class T2>
|
||||
inline T1 SaturatingSubtract1(const T1 &a, const T2 &b)
|
||||
{
|
||||
@ -1096,7 +1096,7 @@ inline T1 SaturatingSubtract1(const T1 &a, const T2 &b)
|
||||
/// \param a the first value
|
||||
/// \param b the second value
|
||||
/// \returns ModPowerOf2() returns <tt>a & (b-1)</tt>. <tt>b</tt> must be a power of 2.
|
||||
/// Use IsPowerOf2() to determine if <tt>b</tt> is a suitable candidate.
|
||||
/// Use IsPowerOf2() to determine if <tt>b</tt> is a suitable candidate.
|
||||
/// \sa IsPowerOf2
|
||||
template <class T1, class T2>
|
||||
inline T2 ModPowerOf2(const T1 &a, const T2 &b)
|
||||
@ -1113,10 +1113,10 @@ inline T2 ModPowerOf2(const T1 &a, const T2 &b)
|
||||
/// \param m the value to reduce \n to to a multiple
|
||||
/// \returns the possibly unmodified value \n
|
||||
/// \details RoundDownToMultipleOf is effectively a floor function based on m. The function returns
|
||||
/// the value <tt>n - n\%m</tt>. If n is a multiple of m, then the original value is returned.
|
||||
/// the value <tt>n - n\%m</tt>. If n is a multiple of m, then the original value is returned.
|
||||
/// \note <tt>T1</tt> and <tt>T2</tt> should be usigned arithmetic types. If <tt>T1</tt> or
|
||||
/// <tt>T2</tt> is signed, then the value should be non-negative. The library asserts in
|
||||
/// debug builds when practical, but allows you to perform the operation in release builds.
|
||||
/// <tt>T2</tt> is signed, then the value should be non-negative. The library asserts in
|
||||
/// debug builds when practical, but allows you to perform the operation in release builds.
|
||||
template <class T1, class T2>
|
||||
inline T1 RoundDownToMultipleOf(const T1 &n, const T2 &m)
|
||||
{
|
||||
@ -1142,11 +1142,11 @@ inline T1 RoundDownToMultipleOf(const T1 &n, const T2 &m)
|
||||
/// \param m the value to reduce \n to to a multiple
|
||||
/// \returns the possibly unmodified value \n
|
||||
/// \details RoundUpToMultipleOf is effectively a ceiling function based on m. The function
|
||||
/// returns the value <tt>n + n\%m</tt>. If n is a multiple of m, then the original value is
|
||||
/// returned. If the value n would overflow, then an InvalidArgument exception is thrown.
|
||||
/// returns the value <tt>n + n\%m</tt>. If n is a multiple of m, then the original value is
|
||||
/// returned. If the value n would overflow, then an InvalidArgument exception is thrown.
|
||||
/// \note <tt>T1</tt> and <tt>T2</tt> should be usigned arithmetic types. If <tt>T1</tt> or
|
||||
/// <tt>T2</tt> is signed, then the value should be non-negative. The library asserts in
|
||||
/// debug builds when practical, but allows you to perform the operation in release builds.
|
||||
/// <tt>T2</tt> is signed, then the value should be non-negative. The library asserts in
|
||||
/// debug builds when practical, but allows you to perform the operation in release builds.
|
||||
template <class T1, class T2>
|
||||
inline T1 RoundUpToMultipleOf(const T1 &n, const T2 &m)
|
||||
{
|
||||
@ -1168,11 +1168,11 @@ inline T1 RoundUpToMultipleOf(const T1 &n, const T2 &m)
|
||||
/// \tparam T class or type
|
||||
/// \returns the minimum alignment requirements of <tt>T</tt>, in bytes
|
||||
/// \details Internally the function calls C++11's <tt>alignof</tt> if available. If not
|
||||
/// available, then the function uses compiler specific extensions such as
|
||||
/// <tt>__alignof</tt> and <tt>_alignof_</tt>. If an extension is not available, then
|
||||
/// the function uses <tt>__BIGGEST_ALIGNMENT__</tt> if <tt>__BIGGEST_ALIGNMENT__</tt>
|
||||
/// is smaller than <tt>sizeof(T)</tt>. <tt>sizeof(T)</tt> is used if all others are
|
||||
/// not available.
|
||||
/// available, then the function uses compiler specific extensions such as
|
||||
/// <tt>__alignof</tt> and <tt>_alignof_</tt>. If an extension is not available, then
|
||||
/// the function uses <tt>__BIGGEST_ALIGNMENT__</tt> if <tt>__BIGGEST_ALIGNMENT__</tt>
|
||||
/// is smaller than <tt>sizeof(T)</tt>. <tt>sizeof(T)</tt> is used if all others are
|
||||
/// not available.
|
||||
template <class T>
|
||||
inline unsigned int GetAlignmentOf()
|
||||
{
|
||||
@ -1226,11 +1226,11 @@ inline bool IsAligned(const void *ptr)
|
||||
}
|
||||
|
||||
#if (CRYPTOPP_LITTLE_ENDIAN)
|
||||
typedef LittleEndian NativeByteOrder;
|
||||
typedef LittleEndian NativeByteOrder;
|
||||
#elif (CRYPTOPP_BIG_ENDIAN)
|
||||
typedef BigEndian NativeByteOrder;
|
||||
typedef BigEndian NativeByteOrder;
|
||||
#else
|
||||
# error "Unable to determine endian-ness"
|
||||
# error "Unable to determine endianness"
|
||||
#endif
|
||||
|
||||
/// \brief Returns NativeByteOrder as an enumerated ByteOrder value
|
||||
@ -1260,12 +1260,12 @@ inline bool NativeByteOrderIs(ByteOrder order)
|
||||
/// \tparam T class or type
|
||||
/// \param obj the cipher object being queried
|
||||
/// \returns ENCRYPTION if the cipher obj is being operated in its forward direction,
|
||||
/// DECRYPTION otherwise
|
||||
/// DECRYPTION otherwise
|
||||
/// \details A cipher can be operated in a "forward" direction (encryption) or a "reverse"
|
||||
/// direction (decryption). The operations do not have to be symmetric, meaning a second
|
||||
/// application of the transformation does not necessariy return the original message.
|
||||
/// That is, <tt>E(D(m))</tt> may not equal <tt>E(E(m))</tt>; and <tt>D(E(m))</tt> may not
|
||||
/// equal <tt>D(D(m))</tt>.
|
||||
/// direction (decryption). The operations do not have to be symmetric, meaning a second
|
||||
/// application of the transformation does not necessariy return the original message.
|
||||
/// That is, <tt>E(D(m))</tt> may not equal <tt>E(E(m))</tt>; and <tt>D(E(m))</tt> may not
|
||||
/// equal <tt>D(D(m))</tt>.
|
||||
template <class T>
|
||||
inline CipherDir GetCipherDir(const T &obj)
|
||||
{
|
||||
@ -1276,7 +1276,7 @@ inline CipherDir GetCipherDir(const T &obj)
|
||||
/// \param inout the byte block
|
||||
/// \param size the size of the block, in bytes
|
||||
/// \details Performs an addition with carry by adding 1 on a block of bytes starting at the least
|
||||
/// significant byte. Once carry is 0, the function terminates and returns to the caller.
|
||||
/// significant byte. Once carry is 0, the function terminates and returns to the caller.
|
||||
/// \note The function is not constant time because it stops processing when the carry is 0.
|
||||
inline void IncrementCounterByOne(byte *inout, unsigned int size)
|
||||
{
|
||||
@ -1296,7 +1296,7 @@ inline void IncrementCounterByOne(byte *inout, unsigned int size)
|
||||
/// \param input the source block of bytes
|
||||
/// \param size the size of the block
|
||||
/// \details Performs an addition with carry on a block of bytes starting at the least significant
|
||||
/// byte. Once carry is 0, the remaining bytes from input are copied to output using memcpy.
|
||||
/// byte. Once carry is 0, the remaining bytes from input are copied to output using memcpy.
|
||||
/// \details The function is close to near-constant time because it operates on all the bytes in the blocks.
|
||||
inline void IncrementCounterByOne(byte *output, const byte *input, unsigned int size)
|
||||
{
|
||||
@ -1352,7 +1352,7 @@ inline void ConditionalSwapPointers(bool c, T &a, T &b)
|
||||
/// \param buf an array of elements
|
||||
/// \param n the number of elements in the array
|
||||
/// \details The operation performs a wipe or zeroization. The function
|
||||
/// attempts to survive optimizations and dead code removal.
|
||||
/// attempts to survive optimizations and dead code removal.
|
||||
template <class T>
|
||||
void SecureWipeBuffer(T *buf, size_t n)
|
||||
{
|
||||
@ -1371,7 +1371,7 @@ void SecureWipeBuffer(T *buf, size_t n)
|
||||
/// \param buf an array of bytes
|
||||
/// \param n the number of elements in the array
|
||||
/// \details The operation performs a wipe or zeroization. The function
|
||||
/// attempts to survive optimizations and dead code removal.
|
||||
/// attempts to survive optimizations and dead code removal.
|
||||
template<> inline void SecureWipeBuffer(byte *buf, size_t n)
|
||||
{
|
||||
volatile byte *p = buf;
|
||||
@ -1386,7 +1386,7 @@ template<> inline void SecureWipeBuffer(byte *buf, size_t n)
|
||||
/// \param buf an array of 16-bit words
|
||||
/// \param n the number of elements in the array
|
||||
/// \details The operation performs a wipe or zeroization. The function
|
||||
/// attempts to survive optimizations and dead code removal.
|
||||
/// attempts to survive optimizations and dead code removal.
|
||||
template<> inline void SecureWipeBuffer(word16 *buf, size_t n)
|
||||
{
|
||||
volatile word16 *p = buf;
|
||||
@ -1401,7 +1401,7 @@ template<> inline void SecureWipeBuffer(word16 *buf, size_t n)
|
||||
/// \param buf an array of 32-bit words
|
||||
/// \param n the number of elements in the array
|
||||
/// \details The operation performs a wipe or zeroization. The function
|
||||
/// attempts to survive optimizations and dead code removal.
|
||||
/// attempts to survive optimizations and dead code removal.
|
||||
template<> inline void SecureWipeBuffer(word32 *buf, size_t n)
|
||||
{
|
||||
volatile word32 *p = buf;
|
||||
@ -1416,7 +1416,7 @@ template<> inline void SecureWipeBuffer(word32 *buf, size_t n)
|
||||
/// \param buf an array of 64-bit words
|
||||
/// \param n the number of elements in the array
|
||||
/// \details The operation performs a wipe or zeroization. The function
|
||||
/// attempts to survive optimizations and dead code removal.
|
||||
/// attempts to survive optimizations and dead code removal.
|
||||
template<> inline void SecureWipeBuffer(word64 *buf, size_t n)
|
||||
{
|
||||
#if CRYPTOPP_BOOL_X64
|
||||
@ -1468,7 +1468,7 @@ template<> inline void SecureWipeBuffer(word64 *buf, size_t n)
|
||||
/// \param buf an array of elements
|
||||
/// \param n the number of elements in the array
|
||||
/// \details The operation performs a wipe or zeroization. The function
|
||||
/// attempts to survive optimizations and dead code removal.
|
||||
/// attempts to survive optimizations and dead code removal.
|
||||
template <class T>
|
||||
inline void SecureWipeArray(T *buf, size_t n)
|
||||
{
|
||||
@ -1487,13 +1487,13 @@ inline void SecureWipeArray(T *buf, size_t n)
|
||||
/// \param throwOnError flag indicating the function should throw on error
|
||||
/// \returns str converted to a multibyte string or an empty string.
|
||||
/// \details StringNarrow() converts a wide string to a narrow string using C++ std::wcstombs() under
|
||||
/// the executing thread's locale. A locale must be set before using this function, and it can be
|
||||
/// set with std::setlocale() if needed. Upon success, the converted string is returned.
|
||||
/// the executing thread's locale. A locale must be set before using this function, and it can be
|
||||
/// set with std::setlocale() if needed. Upon success, the converted string is returned.
|
||||
/// \details Upon failure with throwOnError as false, the function returns an empty string. If
|
||||
/// throwOnError as true, the function throws an InvalidArgument() exception.
|
||||
/// throwOnError as true, the function throws an InvalidArgument() exception.
|
||||
/// \note If you try to convert, say, the Chinese character for "bone" from UTF-16 (0x9AA8) to UTF-8
|
||||
/// (0xE9 0xAA 0xA8), then you must ensure the locale is available. If the locale is not available,
|
||||
/// then a 0x21 error is returned on Windows which eventually results in an InvalidArgument() exception.
|
||||
/// (0xE9 0xAA 0xA8), then you must ensure the locale is available. If the locale is not available,
|
||||
/// then a 0x21 error is returned on Windows which eventually results in an InvalidArgument() exception.
|
||||
std::string StringNarrow(const wchar_t *str, bool throwOnError = true);
|
||||
|
||||
/// \brief Converts a multibyte C-string to a wide character string
|
||||
@ -1501,13 +1501,13 @@ std::string StringNarrow(const wchar_t *str, bool throwOnError = true);
|
||||
/// \param throwOnError flag indicating the function should throw on error
|
||||
/// \returns str converted to a multibyte string or an empty string.
|
||||
/// \details StringWiden() converts a narrow string to a wide string using C++ std::mbstowcs() under
|
||||
/// the executing thread's locale. A locale must be set before using this function, and it can be
|
||||
/// set with std::setlocale() if needed. Upon success, the converted string is returned.
|
||||
/// the executing thread's locale. A locale must be set before using this function, and it can be
|
||||
/// set with std::setlocale() if needed. Upon success, the converted string is returned.
|
||||
/// \details Upon failure with throwOnError as false, the function returns an empty string. If
|
||||
/// throwOnError as true, the function throws an InvalidArgument() exception.
|
||||
/// throwOnError as true, the function throws an InvalidArgument() exception.
|
||||
/// \note If you try to convert, say, the Chinese character for "bone" from UTF-8 (0xE9 0xAA 0xA8)
|
||||
/// to UTF-16 (0x9AA8), then you must ensure the locale is available. If the locale is not available,
|
||||
/// then a 0x21 error is returned on Windows which eventually results in an InvalidArgument() exception.
|
||||
/// to UTF-16 (0x9AA8), then you must ensure the locale is available. If the locale is not available,
|
||||
/// then a 0x21 error is returned on Windows which eventually results in an InvalidArgument() exception.
|
||||
std::wstring StringWiden(const char *str, bool throwOnError = true);
|
||||
|
||||
// ************** rotate functions ***************
|
||||
@ -1518,13 +1518,13 @@ std::wstring StringWiden(const char *str, bool throwOnError = true);
|
||||
/// \param x the value to rotate
|
||||
/// \details This is a portable C/C++ implementation. The value x to be rotated can be 8 to 64-bits wide.
|
||||
/// \details R must be in the range <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// Use rotlMod if the rotate amount R is outside the range.
|
||||
/// Use rotlMod if the rotate amount R is outside the range.
|
||||
/// \details Use rotlConstant when the rotate amount is constant. The template function was added
|
||||
/// because Clang did not propagate the constant when passed as a function parameter. Clang's
|
||||
/// need for a constexpr meant rotlFixed failed to compile on occassion.
|
||||
/// because Clang did not propagate the constant when passed as a function parameter. Clang's
|
||||
/// need for a constexpr meant rotlFixed failed to compile on occassion.
|
||||
/// \note rotlConstant attempts to enlist a <tt>rotate IMM</tt> instruction because its often faster
|
||||
/// than a <tt>rotate REG</tt>. Immediate rotates can be up to three times faster than their register
|
||||
/// counterparts.
|
||||
/// than a <tt>rotate REG</tt>. Immediate rotates can be up to three times faster than their register
|
||||
/// counterparts.
|
||||
/// \sa rotlConstant, rotrConstant, rotlFixed, rotrFixed, rotlVariable, rotrVariable
|
||||
/// \since Crypto++ 6.0
|
||||
template <unsigned int R, class T> inline T rotlConstant(T x)
|
||||
@ -1545,13 +1545,13 @@ template <unsigned int R, class T> inline T rotlConstant(T x)
|
||||
/// \param x the value to rotate
|
||||
/// \details This is a portable C/C++ implementation. The value x to be rotated can be 8 to 64-bits wide.
|
||||
/// \details R must be in the range <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// Use rotrMod if the rotate amount R is outside the range.
|
||||
/// Use rotrMod if the rotate amount R is outside the range.
|
||||
/// \details Use rotrConstant when the rotate amount is constant. The template function was added
|
||||
/// because Clang did not propagate the constant when passed as a function parameter. Clang's
|
||||
/// need for a constexpr meant rotrFixed failed to compile on occassion.
|
||||
/// because Clang did not propagate the constant when passed as a function parameter. Clang's
|
||||
/// need for a constexpr meant rotrFixed failed to compile on occassion.
|
||||
/// \note rotrConstant attempts to enlist a <tt>rotate IMM</tt> instruction because its often faster
|
||||
/// than a <tt>rotate REG</tt>. Immediate rotates can be up to three times faster than their register
|
||||
/// counterparts.
|
||||
/// than a <tt>rotate REG</tt>. Immediate rotates can be up to three times faster than their register
|
||||
/// counterparts.
|
||||
/// \sa rotlConstant, rotrConstant, rotlFixed, rotrFixed, rotlVariable, rotrVariable
|
||||
template <unsigned int R, class T> inline T rotrConstant(T x)
|
||||
{
|
||||
@ -1571,11 +1571,11 @@ template <unsigned int R, class T> inline T rotrConstant(T x)
|
||||
/// \param y the number of bit positions to rotate the value
|
||||
/// \details This is a portable C/C++ implementation. The value x to be rotated can be 8 to 64-bits wide.
|
||||
/// \details y must be in the range <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// Use rotlMod if the rotate amount y is outside the range.
|
||||
/// Use rotlMod if the rotate amount y is outside the range.
|
||||
/// \note rotlFixed attempts to enlist a <tt>rotate IMM</tt> instruction because its often faster
|
||||
/// than a <tt>rotate REG</tt>. Immediate rotates can be up to three times faster than their register
|
||||
/// counterparts. New code should use <tt>rotlConstant</tt>, which accepts the rotate amount as a
|
||||
/// template parameter.
|
||||
/// than a <tt>rotate REG</tt>. Immediate rotates can be up to three times faster than their register
|
||||
/// counterparts. New code should use <tt>rotlConstant</tt>, which accepts the rotate amount as a
|
||||
/// template parameter.
|
||||
/// \sa rotlConstant, rotrConstant, rotlFixed, rotrFixed, rotlVariable, rotrVariable
|
||||
/// \since Crypto++ 6.0
|
||||
template <class T> inline T rotlFixed(T x, unsigned int y)
|
||||
@ -1596,11 +1596,11 @@ template <class T> inline T rotlFixed(T x, unsigned int y)
|
||||
/// \param y the number of bit positions to rotate the value
|
||||
/// \details This is a portable C/C++ implementation. The value x to be rotated can be 8 to 64-bits wide.
|
||||
/// \details y must be in the range <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// Use rotrMod if the rotate amount y is outside the range.
|
||||
/// Use rotrMod if the rotate amount y is outside the range.
|
||||
/// \note rotrFixed attempts to enlist a <tt>rotate IMM</tt> instruction because its often faster
|
||||
/// than a <tt>rotate REG</tt>. Immediate rotates can be up to three times faster than their register
|
||||
/// counterparts. New code should use <tt>rotrConstant</tt>, which accepts the rotate amount as a
|
||||
/// template parameter.
|
||||
/// than a <tt>rotate REG</tt>. Immediate rotates can be up to three times faster than their register
|
||||
/// counterparts. New code should use <tt>rotrConstant</tt>, which accepts the rotate amount as a
|
||||
/// template parameter.
|
||||
/// \sa rotlConstant, rotrConstant, rotlFixed, rotrFixed, rotlVariable, rotrVariable
|
||||
/// \since Crypto++ 3.0
|
||||
template <class T> inline T rotrFixed(T x, unsigned int y)
|
||||
@ -1621,10 +1621,10 @@ template <class T> inline T rotrFixed(T x, unsigned int y)
|
||||
/// \param y the number of bit positions to rotate the value
|
||||
/// \details This is a portable C/C++ implementation. The value x to be rotated can be 8 to 64-bits wide.
|
||||
/// \details y must be in the range <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// Use rotlMod if the rotate amount y is outside the range.
|
||||
/// Use rotlMod if the rotate amount y is outside the range.
|
||||
/// \note rotlVariable attempts to enlist a <tt>rotate IMM</tt> instruction because its often faster
|
||||
/// than a <tt>rotate REG</tt>. Immediate rotates can be up to three times faster than their register
|
||||
/// counterparts.
|
||||
/// than a <tt>rotate REG</tt>. Immediate rotates can be up to three times faster than their register
|
||||
/// counterparts.
|
||||
/// \sa rotlConstant, rotrConstant, rotlFixed, rotrFixed, rotlVariable, rotrVariable
|
||||
/// \since Crypto++ 3.0
|
||||
template <class T> inline T rotlVariable(T x, unsigned int y)
|
||||
@ -1641,10 +1641,10 @@ template <class T> inline T rotlVariable(T x, unsigned int y)
|
||||
/// \param y the number of bit positions to rotate the value
|
||||
/// \details This is a portable C/C++ implementation. The value x to be rotated can be 8 to 64-bits wide.
|
||||
/// \details y must be in the range <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// Use rotrMod if the rotate amount y is outside the range.
|
||||
/// Use rotrMod if the rotate amount y is outside the range.
|
||||
/// \note rotrVariable attempts to enlist a <tt>rotate IMM</tt> instruction because its often faster
|
||||
/// than a <tt>rotate REG</tt>. Immediate rotates can be up to three times faster than their register
|
||||
/// counterparts.
|
||||
/// than a <tt>rotate REG</tt>. Immediate rotates can be up to three times faster than their register
|
||||
/// counterparts.
|
||||
/// \sa rotlConstant, rotrConstant, rotlFixed, rotrFixed, rotlVariable, rotrVariable
|
||||
/// \since Crypto++ 3.0
|
||||
template <class T> inline T rotrVariable(T x, unsigned int y)
|
||||
@ -1694,8 +1694,8 @@ template <class T> inline T rotrMod(T x, unsigned int y)
|
||||
/// \param x the 32-bit value to rotate
|
||||
/// \param y the number of bit positions to rotate the value
|
||||
/// \details This is a Microsoft specific implementation using <tt>_lrotl</tt> provided by
|
||||
/// <stdlib.h>. The value x to be rotated is 32-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// <stdlib.h>. The value x to be rotated is 32-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// \note rotlFixed will assert in Debug builds if is outside the allowed range.
|
||||
/// \since Crypto++ 3.0
|
||||
template<> inline word32 rotlFixed<word32>(word32 x, unsigned int y)
|
||||
@ -1710,8 +1710,8 @@ template<> inline word32 rotlFixed<word32>(word32 x, unsigned int y)
|
||||
/// \param x the 32-bit value to rotate
|
||||
/// \param y the number of bit positions to rotate the value
|
||||
/// \details This is a Microsoft specific implementation using <tt>_lrotr</tt> provided by
|
||||
/// <stdlib.h>. The value x to be rotated is 32-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// <stdlib.h>. The value x to be rotated is 32-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// \note rotrFixed will assert in Debug builds if is outside the allowed range.
|
||||
/// \since Crypto++ 3.0
|
||||
template<> inline word32 rotrFixed<word32>(word32 x, unsigned int y)
|
||||
@ -1726,8 +1726,8 @@ template<> inline word32 rotrFixed<word32>(word32 x, unsigned int y)
|
||||
/// \param x the 32-bit value to rotate
|
||||
/// \param y the number of bit positions to rotate the value
|
||||
/// \details This is a Microsoft specific implementation using <tt>_lrotl</tt> provided by
|
||||
/// <stdlib.h>. The value x to be rotated is 32-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// <stdlib.h>. The value x to be rotated is 32-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// \note rotlVariable will assert in Debug builds if is outside the allowed range.
|
||||
/// \since Crypto++ 3.0
|
||||
template<> inline word32 rotlVariable<word32>(word32 x, unsigned int y)
|
||||
@ -1741,8 +1741,8 @@ template<> inline word32 rotlVariable<word32>(word32 x, unsigned int y)
|
||||
/// \param x the 32-bit value to rotate
|
||||
/// \param y the number of bit positions to rotate the value
|
||||
/// \details This is a Microsoft specific implementation using <tt>_lrotr</tt> provided by
|
||||
/// <stdlib.h>. The value x to be rotated is 32-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// <stdlib.h>. The value x to be rotated is 32-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// \note rotrVariable will assert in Debug builds if is outside the allowed range.
|
||||
/// \since Crypto++ 3.0
|
||||
template<> inline word32 rotrVariable<word32>(word32 x, unsigned int y)
|
||||
@ -1756,8 +1756,8 @@ template<> inline word32 rotrVariable<word32>(word32 x, unsigned int y)
|
||||
/// \param x the 32-bit value to rotate
|
||||
/// \param y the number of bit positions to rotate the value
|
||||
/// \details This is a Microsoft specific implementation using <tt>_lrotl</tt> provided by
|
||||
/// <stdlib.h>. The value x to be rotated is 32-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// <stdlib.h>. The value x to be rotated is 32-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// \since Crypto++ 3.0
|
||||
template<> inline word32 rotlMod<word32>(word32 x, unsigned int y)
|
||||
{
|
||||
@ -1770,8 +1770,8 @@ template<> inline word32 rotlMod<word32>(word32 x, unsigned int y)
|
||||
/// \param x the 32-bit value to rotate
|
||||
/// \param y the number of bit positions to rotate the value
|
||||
/// \details This is a Microsoft specific implementation using <tt>_lrotr</tt> provided by
|
||||
/// <stdlib.h>. The value x to be rotated is 32-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// <stdlib.h>. The value x to be rotated is 32-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// \since Crypto++ 3.0
|
||||
template<> inline word32 rotrMod<word32>(word32 x, unsigned int y)
|
||||
{
|
||||
@ -1789,8 +1789,8 @@ template<> inline word32 rotrMod<word32>(word32 x, unsigned int y)
|
||||
/// \param x the 64-bit value to rotate
|
||||
/// \param y the number of bit positions to rotate the value
|
||||
/// \details This is a Microsoft specific implementation using <tt>_lrotl</tt> provided by
|
||||
/// <stdlib.h>. The value x to be rotated is 64-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// <stdlib.h>. The value x to be rotated is 64-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// \note rotrFixed will assert in Debug builds if is outside the allowed range.
|
||||
/// \since Crypto++ 3.0
|
||||
template<> inline word64 rotlFixed<word64>(word64 x, unsigned int y)
|
||||
@ -1805,8 +1805,8 @@ template<> inline word64 rotlFixed<word64>(word64 x, unsigned int y)
|
||||
/// \param x the 64-bit value to rotate
|
||||
/// \param y the number of bit positions to rotate the value
|
||||
/// \details This is a Microsoft specific implementation using <tt>_lrotr</tt> provided by
|
||||
/// <stdlib.h>. The value x to be rotated is 64-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// <stdlib.h>. The value x to be rotated is 64-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// \note rotrFixed will assert in Debug builds if is outside the allowed range.
|
||||
/// \since Crypto++ 3.0
|
||||
template<> inline word64 rotrFixed<word64>(word64 x, unsigned int y)
|
||||
@ -1821,8 +1821,8 @@ template<> inline word64 rotrFixed<word64>(word64 x, unsigned int y)
|
||||
/// \param x the 64-bit value to rotate
|
||||
/// \param y the number of bit positions to rotate the value
|
||||
/// \details This is a Microsoft specific implementation using <tt>_lrotl</tt> provided by
|
||||
/// <stdlib.h>. The value x to be rotated is 64-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// <stdlib.h>. The value x to be rotated is 64-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// \note rotlVariable will assert in Debug builds if is outside the allowed range.
|
||||
/// \since Crypto++ 3.0
|
||||
template<> inline word64 rotlVariable<word64>(word64 x, unsigned int y)
|
||||
@ -1836,8 +1836,8 @@ template<> inline word64 rotlVariable<word64>(word64 x, unsigned int y)
|
||||
/// \param x the 64-bit value to rotate
|
||||
/// \param y the number of bit positions to rotate the value
|
||||
/// \details This is a Microsoft specific implementation using <tt>_lrotr</tt> provided by
|
||||
/// <stdlib.h>. The value x to be rotated is 64-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// <stdlib.h>. The value x to be rotated is 64-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// \note rotrVariable will assert in Debug builds if is outside the allowed range.
|
||||
/// \since Crypto++ 3.0
|
||||
template<> inline word64 rotrVariable<word64>(word64 x, unsigned int y)
|
||||
@ -1851,8 +1851,8 @@ template<> inline word64 rotrVariable<word64>(word64 x, unsigned int y)
|
||||
/// \param x the 64-bit value to rotate
|
||||
/// \param y the number of bit positions to rotate the value
|
||||
/// \details This is a Microsoft specific implementation using <tt>_lrotl</tt> provided by
|
||||
/// <stdlib.h>. The value x to be rotated is 64-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// <stdlib.h>. The value x to be rotated is 64-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// \since Crypto++ 3.0
|
||||
template<> inline word64 rotlMod<word64>(word64 x, unsigned int y)
|
||||
{
|
||||
@ -1865,8 +1865,8 @@ template<> inline word64 rotlMod<word64>(word64 x, unsigned int y)
|
||||
/// \param x the 64-bit value to rotate
|
||||
/// \param y the number of bit positions to rotate the value
|
||||
/// \details This is a Microsoft specific implementation using <tt>_lrotr</tt> provided by
|
||||
/// <stdlib.h>. The value x to be rotated is 64-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// <stdlib.h>. The value x to be rotated is 64-bits. y must be in the range
|
||||
/// <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.
|
||||
/// \since Crypto++ 3.0
|
||||
template<> inline word64 rotrMod<word64>(word64 x, unsigned int y)
|
||||
{
|
||||
@ -2138,9 +2138,9 @@ inline word64 BitReverse(word64 value)
|
||||
/// \brief Reverses bits in a value
|
||||
/// \param value the value to reverse
|
||||
/// \details The template overload of BitReverse operates on signed and unsigned values.
|
||||
/// Internally the size of T is checked, and then value is cast to a byte,
|
||||
/// word16, word32 or word64. After the cast, the appropriate BitReverse
|
||||
/// overload is called.
|
||||
/// Internally the size of T is checked, and then value is cast to a byte,
|
||||
/// word16, word32 or word64. After the cast, the appropriate BitReverse
|
||||
/// overload is called.
|
||||
template <class T>
|
||||
inline T BitReverse(T value)
|
||||
{
|
||||
@ -2164,8 +2164,8 @@ inline T BitReverse(T value)
|
||||
/// \param order the ByteOrder of the data
|
||||
/// \param value the value to conditionally reverse
|
||||
/// \details Internally, the ConditionalByteReverse calls NativeByteOrderIs.
|
||||
/// If order matches native byte order, then the original value is returned.
|
||||
/// If not, then ByteReverse is called on the value before returning to the caller.
|
||||
/// If order matches native byte order, then the original value is returned.
|
||||
/// If not, then ByteReverse is called on the value before returning to the caller.
|
||||
template <class T>
|
||||
inline T ConditionalByteReverse(ByteOrder order, T value)
|
||||
{
|
||||
@ -2178,11 +2178,11 @@ inline T ConditionalByteReverse(ByteOrder order, T value)
|
||||
/// \param in the input array of elements
|
||||
/// \param byteCount the total number of bytes in the array
|
||||
/// \details Internally, ByteReverse visits each element in the in array
|
||||
/// calls ByteReverse on it, and writes the result to out.
|
||||
/// calls ByteReverse on it, and writes the result to out.
|
||||
/// \details ByteReverse does not process tail byes, or bytes that are
|
||||
/// not part of a full element. If T is int (and int is 4 bytes), then
|
||||
/// <tt>byteCount = 10</tt> means only the first 2 elements or 8 bytes are
|
||||
/// reversed.
|
||||
/// not part of a full element. If T is int (and int is 4 bytes), then
|
||||
/// <tt>byteCount = 10</tt> means only the first 2 elements or 8 bytes are
|
||||
/// reversed.
|
||||
/// \details The following program should help illustrate the behavior.
|
||||
/// <pre>vector<word32> v1, v2;
|
||||
///
|
||||
@ -2196,12 +2196,12 @@ inline T ConditionalByteReverse(ByteOrder order, T value)
|
||||
///
|
||||
/// cout << "V1: ";
|
||||
/// for(unsigned int i = 0; i < v1.size(); i++)
|
||||
/// cout << std::hex << v1[i] << " ";
|
||||
/// cout << std::hex << v1[i] << " ";
|
||||
/// cout << endl;
|
||||
///
|
||||
/// cout << "V2: ";
|
||||
/// for(unsigned int i = 0; i < v2.size(); i++)
|
||||
/// cout << std::hex << v2[i] << " ";
|
||||
/// cout << std::hex << v2[i] << " ";
|
||||
/// cout << endl;</pre>
|
||||
/// The program above results in the following output.
|
||||
/// <pre>V1: 00000001 00000002 00000003 00000004
|
||||
@ -2227,11 +2227,11 @@ void ByteReverse(T *out, const T *in, size_t byteCount)
|
||||
/// \param in the input array of elements
|
||||
/// \param byteCount the byte count of the arrays
|
||||
/// \details Internally, ByteReverse visits each element in the in array
|
||||
/// calls ByteReverse on it depending on the desired endianness, and writes the result to out.
|
||||
/// calls ByteReverse on it depending on the desired endianness, and writes the result to out.
|
||||
/// \details ByteReverse does not process tail byes, or bytes that are
|
||||
/// not part of a full element. If T is int (and int is 4 bytes), then
|
||||
/// <tt>byteCount = 10</tt> means only the first 2 elements or 8 bytes are
|
||||
/// reversed.
|
||||
/// not part of a full element. If T is int (and int is 4 bytes), then
|
||||
/// <tt>byteCount = 10</tt> means only the first 2 elements or 8 bytes are
|
||||
/// reversed.
|
||||
/// \sa ByteReverse
|
||||
template <class T>
|
||||
inline void ConditionalByteReverse(ByteOrder order, T *out, const T *in, size_t byteCount)
|
||||
@ -2430,14 +2430,14 @@ inline void UnalignedbyteNonTemplate(ByteOrder order, byte *block, word64 value,
|
||||
/// \param block the byte buffer to be processed
|
||||
/// \returns the word in the specified byte order
|
||||
/// \details GetWord() provides alternate read access to a block of memory. The flag assumeAligned indicates
|
||||
/// if the memory block is aligned for class or type T. The enumeration ByteOrder is BIG_ENDIAN_ORDER or
|
||||
/// LITTLE_ENDIAN_ORDER.
|
||||
/// if the memory block is aligned for class or type T. The enumeration ByteOrder is BIG_ENDIAN_ORDER or
|
||||
/// LITTLE_ENDIAN_ORDER.
|
||||
/// \details An example of reading two word32 values from a block of memory is shown below. <tt>w</tt>
|
||||
/// will be <tt>0x03020100</tt>.
|
||||
/// will be <tt>0x03020100</tt>.
|
||||
/// <pre>
|
||||
/// word32 w;
|
||||
/// byte buffer[4] = {0,1,2,3};
|
||||
/// w = GetWord<word32>(false, LITTLE_ENDIAN_ORDER, buffer);
|
||||
/// word32 w;
|
||||
/// byte buffer[4] = {0,1,2,3};
|
||||
/// w = GetWord<word32>(false, LITTLE_ENDIAN_ORDER, buffer);
|
||||
/// </pre>
|
||||
template <class T>
|
||||
inline T GetWord(bool assumeAligned, ByteOrder order, const byte *block)
|
||||
@ -2445,7 +2445,7 @@ inline T GetWord(bool assumeAligned, ByteOrder order, const byte *block)
|
||||
CRYPTOPP_UNUSED(assumeAligned);
|
||||
|
||||
T temp = 0;
|
||||
if (block) {std::memcpy(&temp, block, sizeof(T));}
|
||||
if (block != NULLPTR) {std::memcpy(&temp, block, sizeof(T));}
|
||||
return ConditionalByteReverse(order, temp);
|
||||
}
|
||||
|
||||
@ -2456,14 +2456,14 @@ inline T GetWord(bool assumeAligned, ByteOrder order, const byte *block)
|
||||
/// \param result the word in the specified byte order
|
||||
/// \param block the byte buffer to be processed
|
||||
/// \details GetWord() provides alternate read access to a block of memory. The flag assumeAligned indicates
|
||||
/// if the memory block is aligned for class or type T. The enumeration ByteOrder is BIG_ENDIAN_ORDER or
|
||||
/// LITTLE_ENDIAN_ORDER.
|
||||
/// if the memory block is aligned for class or type T. The enumeration ByteOrder is BIG_ENDIAN_ORDER or
|
||||
/// LITTLE_ENDIAN_ORDER.
|
||||
/// \details An example of reading two word32 values from a block of memory is shown below. <tt>w</tt>
|
||||
/// will be <tt>0x03020100</tt>.
|
||||
/// will be <tt>0x03020100</tt>.
|
||||
/// <pre>
|
||||
/// word32 w;
|
||||
/// byte buffer[4] = {0,1,2,3};
|
||||
/// w = GetWord<word32>(false, LITTLE_ENDIAN_ORDER, buffer);
|
||||
/// word32 w;
|
||||
/// byte buffer[4] = {0,1,2,3};
|
||||
/// w = GetWord<word32>(false, LITTLE_ENDIAN_ORDER, buffer);
|
||||
/// </pre>
|
||||
template <class T>
|
||||
inline void GetWord(bool assumeAligned, ByteOrder order, T &result, const byte *block)
|
||||
@ -2479,8 +2479,8 @@ inline void GetWord(bool assumeAligned, ByteOrder order, T &result, const byte *
|
||||
/// \param value the word in the specified byte order
|
||||
/// \param xorBlock an optional byte buffer to xor
|
||||
/// \details PutWord() provides alternate write access to a block of memory. The flag assumeAligned indicates
|
||||
/// if the memory block is aligned for class or type T. The enumeration ByteOrder is BIG_ENDIAN_ORDER or
|
||||
/// LITTLE_ENDIAN_ORDER.
|
||||
/// if the memory block is aligned for class or type T. The enumeration ByteOrder is BIG_ENDIAN_ORDER or
|
||||
/// LITTLE_ENDIAN_ORDER.
|
||||
template <class T>
|
||||
inline void PutWord(bool assumeAligned, ByteOrder order, byte *block, T value, const byte *xorBlock = NULLPTR)
|
||||
{
|
||||
@ -2488,8 +2488,8 @@ inline void PutWord(bool assumeAligned, ByteOrder order, byte *block, T value, c
|
||||
|
||||
T t1, t2;
|
||||
t1 = ConditionalByteReverse(order, value);
|
||||
if (xorBlock) {std::memcpy(&t2, xorBlock, sizeof(T)); t1 ^= t2;}
|
||||
if (block) {std::memcpy(block, &t1, sizeof(T));}
|
||||
if (xorBlock != NULLPTR) {std::memcpy(&t2, xorBlock, sizeof(T)); t1 ^= t2;}
|
||||
if (block != NULLPTR) {std::memcpy(block, &t1, sizeof(T));}
|
||||
}
|
||||
|
||||
/// \brief Access a block of memory
|
||||
@ -2497,15 +2497,15 @@ inline void PutWord(bool assumeAligned, ByteOrder order, byte *block, T value, c
|
||||
/// \tparam B enumeration indicating endianness
|
||||
/// \tparam A flag indicating alignment
|
||||
/// \details GetBlock() provides alternate read access to a block of memory. The enumeration B is
|
||||
/// BigEndian or LittleEndian. The flag A indicates if the memory block is aligned for class or type T.
|
||||
/// Repeatedly applying operator() results in advancing in the block of memory.
|
||||
/// BigEndian or LittleEndian. The flag A indicates if the memory block is aligned for class or type T.
|
||||
/// Repeatedly applying operator() results in advancing in the block of memory.
|
||||
/// \details An example of reading two word32 values from a block of memory is shown below. <tt>w1</tt>
|
||||
/// will be <tt>0x03020100</tt> and <tt>w1</tt> will be <tt>0x07060504</tt>.
|
||||
/// will be <tt>0x03020100</tt> and <tt>w1</tt> will be <tt>0x07060504</tt>.
|
||||
/// <pre>
|
||||
/// word32 w1, w2;
|
||||
/// byte buffer[8] = {0,1,2,3,4,5,6,7};
|
||||
/// GetBlock<word32, LittleEndian> block(buffer);
|
||||
/// block(w1)(w2);
|
||||
/// word32 w1, w2;
|
||||
/// byte buffer[8] = {0,1,2,3,4,5,6,7};
|
||||
/// GetBlock<word32, LittleEndian> block(buffer);
|
||||
/// block(w1)(w2);
|
||||
/// </pre>
|
||||
template <class T, class B, bool A=false>
|
||||
class GetBlock
|
||||
@ -2538,15 +2538,15 @@ private:
|
||||
/// \tparam B enumeration indicating endianness
|
||||
/// \tparam A flag indicating alignment
|
||||
/// \details PutBlock() provides alternate write access to a block of memory. The enumeration B is
|
||||
/// BigEndian or LittleEndian. The flag A indicates if the memory block is aligned for class or type T.
|
||||
/// Repeatedly applying operator() results in advancing in the block of memory.
|
||||
/// BigEndian or LittleEndian. The flag A indicates if the memory block is aligned for class or type T.
|
||||
/// Repeatedly applying operator() results in advancing in the block of memory.
|
||||
/// \details An example of writing two word32 values from a block of memory is shown below. After the code
|
||||
/// executes, the byte buffer will be <tt>{0,1,2,3,4,5,6,7}</tt>.
|
||||
/// executes, the byte buffer will be <tt>{0,1,2,3,4,5,6,7}</tt>.
|
||||
/// <pre>
|
||||
/// word32 w1=0x03020100, w2=0x07060504;
|
||||
/// byte buffer[8];
|
||||
/// PutBlock<word32, LittleEndian> block(NULLPTR, buffer);
|
||||
/// block(w1)(w2);
|
||||
/// word32 w1=0x03020100, w2=0x07060504;
|
||||
/// byte buffer[8];
|
||||
/// PutBlock<word32, LittleEndian> block(NULLPTR, buffer);
|
||||
/// block(w1)(w2);
|
||||
/// </pre>
|
||||
template <class T, class B, bool A=false>
|
||||
class PutBlock
|
||||
@ -2583,7 +2583,7 @@ private:
|
||||
/// \tparam GA flag indicating alignment for the Get operation
|
||||
/// \tparam PA flag indicating alignment for the Put operation
|
||||
/// \details GetBlock() provides alternate write access to a block of memory. The enumeration B is
|
||||
/// BigEndian or LittleEndian. The flag A indicates if the memory block is aligned for class or type T.
|
||||
/// BigEndian or LittleEndian. The flag A indicates if the memory block is aligned for class or type T.
|
||||
/// \sa GetBlock() and PutBlock().
|
||||
template <class T, class B, bool GA=false, bool PA=false>
|
||||
struct BlockGetAndPut
|
||||
@ -2625,14 +2625,14 @@ T StringToWord(const std::string &str, ByteOrder order = BIG_ENDIAN_ORDER)
|
||||
/// \brief Safely shift values when undefined behavior could occur
|
||||
/// \tparam overflow boolean flag indicating if overflow is present
|
||||
/// \details SafeShifter safely shifts values when undefined behavior could occur under C/C++ rules.
|
||||
/// The class behaves much like a saturating arithmetic class, clamping values rather than allowing
|
||||
/// the compiler to remove undefined behavior.
|
||||
/// The class behaves much like a saturating arithmetic class, clamping values rather than allowing
|
||||
/// the compiler to remove undefined behavior.
|
||||
/// \sa SafeShifter<true>, SafeShifter<false>
|
||||
template <bool overflow> struct SafeShifter;
|
||||
|
||||
/// \brief Shifts a value in the presence of overflow
|
||||
/// \details the true template parameter indicates overflow would occur.
|
||||
/// In this case, SafeShifter clamps the value and returns 0.
|
||||
/// In this case, SafeShifter clamps the value and returns 0.
|
||||
template<> struct SafeShifter<true>
|
||||
{
|
||||
/// \brief Right shifts a value that overflows
|
||||
@ -2662,7 +2662,7 @@ template<> struct SafeShifter<true>
|
||||
|
||||
/// \brief Shifts a value in the absence of overflow
|
||||
/// \details the false template parameter indicates overflow would not occur.
|
||||
/// In this case, SafeShifter returns the shfted value.
|
||||
/// In this case, SafeShifter returns the shfted value.
|
||||
template<> struct SafeShifter<false>
|
||||
{
|
||||
/// \brief Right shifts a value that does not overflow
|
||||
@ -2694,8 +2694,8 @@ template<> struct SafeShifter<false>
|
||||
/// \param value the value to right shift
|
||||
/// \result the shifted value or 0
|
||||
/// \details SafeRightShift safely shifts the value to the right when undefined behavior
|
||||
/// could occur under C/C++ rules. SafeRightShift will return the shifted value or 0
|
||||
/// if undefined behavior would occur.
|
||||
/// could occur under C/C++ rules. SafeRightShift will return the shifted value or 0
|
||||
/// if undefined behavior would occur.
|
||||
template <unsigned int bits, class T>
|
||||
inline T SafeRightShift(T value)
|
||||
{
|
||||
@ -2708,8 +2708,8 @@ inline T SafeRightShift(T value)
|
||||
/// \param value the value to left shift
|
||||
/// \result the shifted value or 0
|
||||
/// \details SafeLeftShift safely shifts the value to the left when undefined behavior
|
||||
/// could occur under C/C++ rules. SafeLeftShift will return the shifted value or 0
|
||||
/// if undefined behavior would occur.
|
||||
/// could occur under C/C++ rules. SafeLeftShift will return the shifted value or 0
|
||||
/// if undefined behavior would occur.
|
||||
template <unsigned int bits, class T>
|
||||
inline T SafeLeftShift(T value)
|
||||
{
|
||||
|
||||
Loading…
Reference in New Issue
Block a user