diff --git a/example/endian_example.cpp b/example/endian_example.cpp index 674a5ef..9373bbf 100644 --- a/example/endian_example.cpp +++ b/example/endian_example.cpp @@ -16,7 +16,7 @@ #include #include -#include +#include #include using namespace boost::endian; diff --git a/example/use_cases.cpp b/example/use_cases.cpp index 4199dae..ab6b2ab 100644 --- a/example/use_cases.cpp +++ b/example/use_cases.cpp @@ -12,7 +12,7 @@ #include #define BOOST_ENDIAN_LOG -#include +#include #include #include #include diff --git a/include/boost/endian/arithmetic.hpp b/include/boost/endian/arithmetic.hpp new file mode 100644 index 0000000..0072129 --- /dev/null +++ b/include/boost/endian/arithmetic.hpp @@ -0,0 +1,438 @@ +// boost/endian/arithmetic.hpp -------------------------------------------------------// + +// (C) Copyright Darin Adler 2000 +// (C) Copyright Beman Dawes 2006, 2009, 2014 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// See library home page at http://www.boost.org/libs/endian + +//--------------------------------------------------------------------------------------// + +// Original design developed by Darin Adler based on classes developed by Mark +// Borgerding. Four original class templates were combined into a single endian +// class template by Beman Dawes, who also added the unrolled_byte_loops sign +// partial specialization to correctly extend the sign when cover integer size +// differs from endian representation size. + +// TODO: When a compiler supporting constexpr becomes available, try possible uses. + +#ifndef BOOST_ENDIAN_HPP +#define BOOST_ENDIAN_HPP + +#if defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable:4365) // conversion ... signed/unsigned mismatch +#endif + +#ifdef BOOST_ENDIAN_LOG +# include +#endif + +#if defined(__BORLANDC__) || defined( __CODEGEARC__) +# pragma pack(push, 1) +#endif + +#include +#include +#include +#include +#define BOOST_ENDIAN_MINIMAL_COVER_OPERATORS +#include +#undef BOOST_ENDIAN_MINIMAL_COVER_OPERATORS +#include +#include +#include +#include +#include +#include + +# if CHAR_BIT != 8 +# error Platforms with CHAR_BIT != 8 are not supported +# endif + +# ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS +# define BOOST_ENDIAN_DEFAULT_CONSTRUCT {} // C++03 +# else +# define BOOST_ENDIAN_DEFAULT_CONSTRUCT = default; // C++0x +# endif + +# if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && defined(BOOST_ENDIAN_FORCE_PODNESS) +# define BOOST_ENDIAN_NO_CTORS +# endif + +# ifndef BOOST_ENDIAN_EXPLICIT_CTORS +# define BOOST_ENDIAN_EXPLICIT_OPT +# else +# define BOOST_ENDIAN_EXPLICIT_OPT explicit +# endif + +//---------------------------------- synopsis ----------------------------------------// + +namespace boost +{ +namespace endian +{ + +#ifndef BOOST_ENDIAN_ORDER_ENUM_DEFINED + BOOST_SCOPED_ENUM_START(order) + { + big, little, +# ifdef BOOST_BIG_ENDIAN + native = big +# else + native = little +# endif + }; BOOST_SCOPED_ENUM_END +# define BOOST_ENDIAN_ORDER_ENUM_DEFINED +#endif + + template + class endian_arithmetic; + + // big endian floating point aligned types + typedef endian_arithmetic big_float32_t; + typedef endian_arithmetic big_float64_t; + + // little endian floating point aligned types + typedef endian_arithmetic little_float32_t; + typedef endian_arithmetic little_float64_t; + + // big endian floating point unaligned types + typedef endian_arithmetic big_float32_ut; + typedef endian_arithmetic big_float64_ut; + + // little endian floating point unaligned types + typedef endian_arithmetic little_float32_ut; + typedef endian_arithmetic little_float64_ut; + + // big endian signed integer aligned types + typedef endian_arithmetic big_int16_t; + typedef endian_arithmetic big_int32_t; + typedef endian_arithmetic big_int64_t; + + // big endian unsigned integer aligned types + typedef endian_arithmetic big_uint16_t; + typedef endian_arithmetic big_uint32_t; + typedef endian_arithmetic big_uint64_t; + + // little endian signed integer aligned types + typedef endian_arithmetic little_int16_t; + typedef endian_arithmetic little_int32_t; + typedef endian_arithmetic little_int64_t; + + // little endian unsigned integer aligned types + typedef endian_arithmetic little_uint16_t; + typedef endian_arithmetic little_uint32_t; + typedef endian_arithmetic little_uint64_t; + + // aligned native endian typedefs are not provided because + // types are superior for this use case + + // big endian signed integer unaligned types + typedef endian_arithmetic big_int8_ut; + typedef endian_arithmetic big_int16_ut; + typedef endian_arithmetic big_int24_ut; + typedef endian_arithmetic big_int32_ut; + typedef endian_arithmetic big_int40_ut; + typedef endian_arithmetic big_int48_ut; + typedef endian_arithmetic big_int56_ut; + typedef endian_arithmetic big_int64_ut; + + // big endian unsigned integer unaligned types + typedef endian_arithmetic big_uint8_ut; + typedef endian_arithmetic big_uint16_ut; + typedef endian_arithmetic big_uint24_ut; + typedef endian_arithmetic big_uint32_ut; + typedef endian_arithmetic big_uint40_ut; + typedef endian_arithmetic big_uint48_ut; + typedef endian_arithmetic big_uint56_ut; + typedef endian_arithmetic big_uint64_ut; + + // little endian signed integer unaligned types + typedef endian_arithmetic little_int8_ut; + typedef endian_arithmetic little_int16_ut; + typedef endian_arithmetic little_int24_ut; + typedef endian_arithmetic little_int32_ut; + typedef endian_arithmetic little_int40_ut; + typedef endian_arithmetic little_int48_ut; + typedef endian_arithmetic little_int56_ut; + typedef endian_arithmetic little_int64_ut; + + // little endian unsigned integer unaligned types + typedef endian_arithmetic little_uint8_ut; + typedef endian_arithmetic little_uint16_ut; + typedef endian_arithmetic little_uint24_ut; + typedef endian_arithmetic little_uint32_ut; + typedef endian_arithmetic little_uint40_ut; + typedef endian_arithmetic little_uint48_ut; + typedef endian_arithmetic little_uint56_ut; + typedef endian_arithmetic little_uint64_ut; + +# ifdef BOOST_BIG_ENDIAN + // native endian signed integer unaligned types + typedef big_int8_ut native_int8_ut; + typedef big_int16_ut native_int16_ut; + typedef big_int24_ut native_int24_ut; + typedef big_int32_ut native_int32_ut; + typedef big_int40_ut native_int40_ut; + typedef big_int48_ut native_int48_ut; + typedef big_int56_ut native_int56_ut; + typedef big_int64_ut native_int64_ut; + + // native endian unsigned integer unaligned types + typedef big_uint8_ut native_uint8_ut; + typedef big_uint16_ut native_uint16_ut; + typedef big_uint24_ut native_uint24_ut; + typedef big_uint32_ut native_uint32_ut; + typedef big_uint40_ut native_uint40_ut; + typedef big_uint48_ut native_uint48_ut; + typedef big_uint56_ut native_uint56_ut; + typedef big_uint64_ut native_uint64_ut; + + // native endian floating point types + typedef big_float32_ut native_float32_ut; + typedef big_float64_ut native_float64_ut; + typedef big_float32_t native_float32_t; + typedef big_float64_t native_float64_t; +# else + // native endian signed integer unaligned types + typedef little_int8_ut native_int8_ut; + typedef little_int16_ut native_int16_ut; + typedef little_int24_ut native_int24_ut; + typedef little_int32_ut native_int32_ut; + typedef little_int40_ut native_int40_ut; + typedef little_int48_ut native_int48_ut; + typedef little_int56_ut native_int56_ut; + typedef little_int64_ut native_int64_ut; + + // native endian unsigned integer unaligned types + typedef little_uint8_ut native_uint8_ut; + typedef little_uint16_ut native_uint16_ut; + typedef little_uint24_ut native_uint24_ut; + typedef little_uint32_ut native_uint32_ut; + typedef little_uint40_ut native_uint40_ut; + typedef little_uint48_ut native_uint48_ut; + typedef little_uint56_ut native_uint56_ut; + typedef little_uint64_ut native_uint64_ut; + + // native endian floating point types + typedef little_float32_ut native_float32_ut; + typedef little_float64_ut native_float64_ut; + typedef little_float32_t native_float32_t; + typedef little_float64_t native_float64_t; +# endif +} // namespace boost +} // namespace endian + +//---------------------------------- end synopsis ------------------------------------// + +namespace boost +{ +namespace endian +{ + +// endian class template specializations ---------------------------------------------// + + // Specializations that represent unaligned bytes. + // Taking an integer type as a parameter provides a nice way to pass both + // the size and signness of the desired integer and get the appropriate + // corresponding integer type for the interface. + + // unaligned integer big endian specialization + template + class endian_arithmetic< order::big, T, n_bits, align::no > + : public endian_buffer< order::big, T, n_bits, align::no >, + cover_operators, T> + { + BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits ); + public: + typedef T value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(T val) BOOST_NOEXCEPT + { +# ifdef BOOST_ENDIAN_LOG + if ( endian_log ) + std::cout << "big, unaligned, " << n_bits << "-bits, construct(" << val << ")\n"; +# endif + detail::store_big_endian(this->m_value, val); + } +# endif + endian_arithmetic& operator=(T val) BOOST_NOEXCEPT + { detail::store_big_endian(this->m_value, val); return *this; } + operator value_type() const BOOST_NOEXCEPT { return this->value(); } + }; + + // unaligned float big endian specialization + template <> + class endian_arithmetic< order::big, float, 32, align::no > + : public endian_buffer< order::big, float, 32, align::no >, + cover_operators< endian_arithmetic< order::big, float, 32 >, float > + { + public: + typedef float value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(value_type val) BOOST_NOEXCEPT + { detail::big_reverse_copy(val, this->m_value); } +# endif + endian_arithmetic& operator=(value_type val) BOOST_NOEXCEPT + { detail::big_reverse_copy(val, this->m_value); return *this; } + operator value_type() const BOOST_NOEXCEPT { return this->value(); } + }; + + // unaligned double big endian specialization + template <> + class endian_arithmetic< order::big, double, 64, align::no > + : public endian_buffer< order::big, double, 64, align::no >, + cover_operators< endian_arithmetic< order::big, double, 64 >, double > + { + public: + typedef double value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(value_type val) BOOST_NOEXCEPT + { detail::big_reverse_copy(val, this->m_value); } +# endif + endian_arithmetic& operator=(value_type val) BOOST_NOEXCEPT + { detail::big_reverse_copy(val, this->m_value); return *this; } + operator value_type() const BOOST_NOEXCEPT { return this->value(); } + }; + + // unaligned float little endian specialization + template <> + class endian_arithmetic< order::little, float, 32, align::no > + : public endian_buffer< order::little, float, 32, align::no >, + cover_operators< endian_arithmetic< order::little, float, 32 >, float > + { + public: + typedef float value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(value_type val) BOOST_NOEXCEPT + { detail::little_reverse_copy(val, this->m_value); } +# endif + endian_arithmetic& operator=(value_type val) BOOST_NOEXCEPT + { detail::little_reverse_copy(val, this->m_value); return *this; } + operator value_type() const BOOST_NOEXCEPT { return this->value(); } + }; + + // unaligned double little endian specialization + template <> + class endian_arithmetic< order::little, double, 64, align::no > + : public endian_buffer< order::little, double, 64, align::no >, + cover_operators< endian_arithmetic< order::little, double, 64 >, double > + { + public: + typedef double value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(value_type val) BOOST_NOEXCEPT + { detail::little_reverse_copy(val, this->m_value); } +# endif + endian_arithmetic& operator=(value_type val) BOOST_NOEXCEPT + { detail::little_reverse_copy(val, this->m_value); return *this; } + operator value_type() const BOOST_NOEXCEPT { return this->value(); } + }; + + // unaligned little endian specialization + template + class endian_arithmetic< order::little, T, n_bits, align::no > + : public endian_buffer< order::little, T, n_bits, align::no >, + cover_operators< endian_arithmetic< order::little, T, n_bits >, T > + { + BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits ); + public: + typedef T value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(T val) BOOST_NOEXCEPT + { +# ifdef BOOST_ENDIAN_LOG + if ( endian_log ) + std::cout << "little, unaligned, " << n_bits << "-bits, construct(" << val << ")\n"; +# endif + detail::store_little_endian(this->m_value, val); + } +# endif + endian_arithmetic& operator=(T val) BOOST_NOEXCEPT + { detail::store_little_endian(this->m_value, val); return *this; } + operator value_type() const BOOST_NOEXCEPT { return this->value(); } + }; + + // align::yes specializations; only n_bits == 16/32/64 supported + + // aligned big endian specialization + template + class endian_arithmetic + : public endian_buffer< order::big, T, n_bits, align::yes >, + cover_operators, T> + { + BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits ); + BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 ); + public: + typedef T value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(T val) BOOST_NOEXCEPT + { +# ifdef BOOST_ENDIAN_LOG + if ( endian_log ) + std::cout << "big, aligned, " << n_bits << "-bits, construct(" << val << ")\n"; +# endif + this->m_value = ::boost::endian::big_endian_value(val); + } + +# endif + endian_arithmetic& operator=(T val) BOOST_NOEXCEPT + { + this->m_value = ::boost::endian::big_endian_value(val); + return *this; + } + operator value_type() const BOOST_NOEXCEPT { return this->value(); } + }; + + // aligned little endian specialization + template + class endian_arithmetic + : public endian_buffer< order::little, T, n_bits, align::yes >, + cover_operators, T> + { + BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits ); + BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 ); + public: + typedef T value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(T val) BOOST_NOEXCEPT + { +# ifdef BOOST_ENDIAN_LOG + if ( endian_log ) + std::cout << "little, aligned, " << n_bits << "-bits, construct(" << val << ")\n"; +# endif + this->m_value = ::boost::endian::little_endian_value(val); + } +# endif + endian_arithmetic& operator=(T val) BOOST_NOEXCEPT + { + this->m_value = ::boost::endian::little_endian_value(val); + return *this; + } + operator value_type() const BOOST_NOEXCEPT { return this->value(); } + }; + +} // namespace endian +} // namespace boost + +#if defined(__BORLANDC__) || defined( __CODEGEARC__) +# pragma pack(pop) +#endif + +#if defined(_MSC_VER) +# pragma warning(pop) +#endif + +#endif // BOOST_ENDIAN_HPP diff --git a/include/boost/endian/buffers.hpp b/include/boost/endian/buffers.hpp index fb349c8..2a1ad3e 100644 --- a/include/boost/endian/buffers.hpp +++ b/include/boost/endian/buffers.hpp @@ -84,136 +84,136 @@ namespace endian class endian_buffer; // aligned big endian floating point types - typedef endian_buffer big_align_floatbuf32_t; - typedef endian_buffer big_align_floatbuf64_t; + typedef endian_buffer big_floatbuf32_t; + typedef endian_buffer big_floatbuf64_t; // aligned little endian floating point types - typedef endian_buffer little_align_floatbuf32_t; - typedef endian_buffer little_align_floatbuf64_t; + typedef endian_buffer little_floatbuf32_t; + typedef endian_buffer little_floatbuf64_t; // unaligned big endian floating point types - typedef endian_buffer big_floatbuf32_t; - typedef endian_buffer big_floatbuf64_t; + typedef endian_buffer big_floatbuf32_ut; + typedef endian_buffer big_floatbuf64_ut; // unaligned little endian floating point types - typedef endian_buffer little_floatbuf32_t; - typedef endian_buffer little_floatbuf64_t; + typedef endian_buffer little_floatbuf32_ut; + typedef endian_buffer little_floatbuf64_ut; // aligned big endian signed integer types - typedef endian_buffer big_align_buf16_t; - typedef endian_buffer big_align_buf32_t; - typedef endian_buffer big_align_buf64_t; + typedef endian_buffer big_buf16_t; + typedef endian_buffer big_buf32_t; + typedef endian_buffer big_buf64_t; // aligned big endian unsigned integer types - typedef endian_buffer big_align_ubuf16_t; - typedef endian_buffer big_align_ubuf32_t; - typedef endian_buffer big_align_ubuf64_t; + typedef endian_buffer big_ubuf16_t; + typedef endian_buffer big_ubuf32_t; + typedef endian_buffer big_ubuf64_t; // aligned little endian signed integer types - typedef endian_buffer little_align_buf16_t; - typedef endian_buffer little_align_buf32_t; - typedef endian_buffer little_align_buf64_t; + typedef endian_buffer little_buf16_t; + typedef endian_buffer little_buf32_t; + typedef endian_buffer little_buf64_t; // aligned little endian unsigned integer types - typedef endian_buffer little_align_ubuf16_t; - typedef endian_buffer little_align_ubuf32_t; - typedef endian_buffer little_align_ubuf64_t; + typedef endian_buffer little_ubuf16_t; + typedef endian_buffer little_ubuf32_t; + typedef endian_buffer little_ubuf64_t; // aligned native endian typedefs are not provided because // types are superior for this use case // unaligned big endian signed integer types - typedef endian_buffer big_buf8_t; - typedef endian_buffer big_buf16_t; - typedef endian_buffer big_buf24_t; - typedef endian_buffer big_buf32_t; - typedef endian_buffer big_buf40_t; - typedef endian_buffer big_buf48_t; - typedef endian_buffer big_buf56_t; - typedef endian_buffer big_buf64_t; + typedef endian_buffer big_buf8_ut; + typedef endian_buffer big_buf16_ut; + typedef endian_buffer big_buf24_ut; + typedef endian_buffer big_buf32_ut; + typedef endian_buffer big_buf40_ut; + typedef endian_buffer big_buf48_ut; + typedef endian_buffer big_buf56_ut; + typedef endian_buffer big_buf64_ut; // unaligned big endian unsigned integer types - typedef endian_buffer big_ubuf8_t; - typedef endian_buffer big_ubuf16_t; - typedef endian_buffer big_ubuf24_t; - typedef endian_buffer big_ubuf32_t; - typedef endian_buffer big_ubuf40_t; - typedef endian_buffer big_ubuf48_t; - typedef endian_buffer big_ubuf56_t; - typedef endian_buffer big_ubuf64_t; + typedef endian_buffer big_ubuf8_ut; + typedef endian_buffer big_ubuf16_ut; + typedef endian_buffer big_ubuf24_ut; + typedef endian_buffer big_ubuf32_ut; + typedef endian_buffer big_ubuf40_ut; + typedef endian_buffer big_ubuf48_ut; + typedef endian_buffer big_ubuf56_ut; + typedef endian_buffer big_ubuf64_ut; // unaligned little endian signed integer types - typedef endian_buffer little_buf8_t; - typedef endian_buffer little_buf16_t; - typedef endian_buffer little_buf24_t; - typedef endian_buffer little_buf32_t; - typedef endian_buffer little_buf40_t; - typedef endian_buffer little_buf48_t; - typedef endian_buffer little_buf56_t; - typedef endian_buffer little_buf64_t; + typedef endian_buffer little_buf8_ut; + typedef endian_buffer little_buf16_ut; + typedef endian_buffer little_buf24_ut; + typedef endian_buffer little_buf32_ut; + typedef endian_buffer little_buf40_ut; + typedef endian_buffer little_buf48_ut; + typedef endian_buffer little_buf56_ut; + typedef endian_buffer little_buf64_ut; // unaligned little endian unsigned integer types - typedef endian_buffer little_ubuf8_t; - typedef endian_buffer little_ubuf16_t; - typedef endian_buffer little_ubuf24_t; - typedef endian_buffer little_ubuf32_t; - typedef endian_buffer little_ubuf40_t; - typedef endian_buffer little_ubuf48_t; - typedef endian_buffer little_ubuf56_t; - typedef endian_buffer little_ubuf64_t; + typedef endian_buffer little_ubuf8_ut; + typedef endian_buffer little_ubuf16_ut; + typedef endian_buffer little_ubuf24_ut; + typedef endian_buffer little_ubuf32_ut; + typedef endian_buffer little_ubuf40_ut; + typedef endian_buffer little_ubuf48_ut; + typedef endian_buffer little_ubuf56_ut; + typedef endian_buffer little_ubuf64_ut; # ifdef BOOST_BIG_ENDIAN // unaligned native endian signed integer types - typedef big_buf8_t native_buf8_t; - typedef big_buf16_t native_buf16_t; - typedef big_buf24_t native_buf24_t; - typedef big_buf32_t native_buf32_t; - typedef big_buf40_t native_buf40_t; - typedef big_buf48_t native_buf48_t; - typedef big_buf56_t native_buf56_t; - typedef big_buf64_t native_buf64_t; + typedef big_buf8_ut native_buf8_ut; + typedef big_buf16_ut native_buf16_ut; + typedef big_buf24_ut native_buf24_ut; + typedef big_buf32_ut native_buf32_ut; + typedef big_buf40_ut native_buf40_ut; + typedef big_buf48_ut native_buf48_ut; + typedef big_buf56_ut native_buf56_ut; + typedef big_buf64_ut native_buf64_ut; // unaligned native endian unsigned integer types - typedef big_ubuf8_t native_ubuf8_t; - typedef big_ubuf16_t native_ubuf16_t; - typedef big_ubuf24_t native_ubuf24_t; - typedef big_ubuf32_t native_ubuf32_t; - typedef big_ubuf40_t native_ubuf40_t; - typedef big_ubuf48_t native_ubuf48_t; - typedef big_ubuf56_t native_ubuf56_t; - typedef big_ubuf64_t native_ubuf64_t; + typedef big_ubuf8_ut native_ubuf8_ut; + typedef big_ubuf16_ut native_ubuf16_ut; + typedef big_ubuf24_ut native_ubuf24_ut; + typedef big_ubuf32_ut native_ubuf32_ut; + typedef big_ubuf40_ut native_ubuf40_ut; + typedef big_ubuf48_ut native_ubuf48_ut; + typedef big_ubuf56_ut native_ubuf56_ut; + typedef big_ubuf64_ut native_ubuf64_ut; // native endian floating point types + typedef big_floatbuf32_ut native_floatbuf32_ut; + typedef big_floatbuf64_ut native_floatbuf64_ut; typedef big_floatbuf32_t native_floatbuf32_t; typedef big_floatbuf64_t native_floatbuf64_t; - typedef big_align_floatbuf32_t native_align_floatbuf32_t; - typedef big_align_floatbuf64_t native_align_floatbuf64_t; # else // unaligned native endian signed integer types - typedef little_buf8_t native_buf8_t; - typedef little_buf16_t native_buf16_t; - typedef little_buf24_t native_buf24_t; - typedef little_buf32_t native_buf32_t; - typedef little_buf40_t native_buf40_t; - typedef little_buf48_t native_buf48_t; - typedef little_buf56_t native_buf56_t; - typedef little_buf64_t native_buf64_t; + typedef little_buf8_ut native_buf8_ut; + typedef little_buf16_ut native_buf16_ut; + typedef little_buf24_ut native_buf24_ut; + typedef little_buf32_ut native_buf32_ut; + typedef little_buf40_ut native_buf40_ut; + typedef little_buf48_ut native_buf48_ut; + typedef little_buf56_ut native_buf56_ut; + typedef little_buf64_ut native_buf64_ut; // unaligned native endian unsigned integer types - typedef little_ubuf8_t native_ubuf8_t; - typedef little_ubuf16_t native_ubuf16_t; - typedef little_ubuf24_t native_ubuf24_t; - typedef little_ubuf32_t native_ubuf32_t; - typedef little_ubuf40_t native_ubuf40_t; - typedef little_ubuf48_t native_ubuf48_t; - typedef little_ubuf56_t native_ubuf56_t; - typedef little_ubuf64_t native_ubuf64_t; + typedef little_ubuf8_ut native_ubuf8_ut; + typedef little_ubuf16_ut native_ubuf16_ut; + typedef little_ubuf24_ut native_ubuf24_ut; + typedef little_ubuf32_ut native_ubuf32_ut; + typedef little_ubuf40_ut native_ubuf40_ut; + typedef little_ubuf48_ut native_ubuf48_ut; + typedef little_ubuf56_ut native_ubuf56_ut; + typedef little_ubuf64_ut native_ubuf64_ut; // native endian floating point types + typedef little_floatbuf32_ut native_floatbuf32_ut; + typedef little_floatbuf64_ut native_floatbuf64_ut; typedef little_floatbuf32_t native_floatbuf32_t; typedef little_floatbuf64_t native_floatbuf64_t; - typedef little_align_floatbuf32_t native_align_floatbuf32_t; - typedef little_align_floatbuf64_t native_align_floatbuf64_t; # endif } // namespace boost } // namespace endian diff --git a/include/boost/endian/types.hpp b/include/boost/endian/types.hpp deleted file mode 100644 index c22bfab..0000000 --- a/include/boost/endian/types.hpp +++ /dev/null @@ -1,438 +0,0 @@ -// boost/endian/types.hpp ------------------------------------------------------------// - -// (C) Copyright Darin Adler 2000 -// (C) Copyright Beman Dawes 2006, 2009, 2014 - -// Distributed under the Boost Software License, Version 1.0. -// See http://www.boost.org/LICENSE_1_0.txt - -// See library home page at http://www.boost.org/libs/endian - -//--------------------------------------------------------------------------------------// - -// Original design developed by Darin Adler based on classes developed by Mark -// Borgerding. Four original class templates were combined into a single endian -// class template by Beman Dawes, who also added the unrolled_byte_loops sign -// partial specialization to correctly extend the sign when cover integer size -// differs from endian representation size. - -// TODO: When a compiler supporting constexpr becomes available, try possible uses. - -#ifndef BOOST_ENDIAN_HPP -#define BOOST_ENDIAN_HPP - -#if defined(_MSC_VER) -# pragma warning(push) -# pragma warning(disable:4365) // conversion ... signed/unsigned mismatch -#endif - -#ifdef BOOST_ENDIAN_LOG -# include -#endif - -#if defined(__BORLANDC__) || defined( __CODEGEARC__) -# pragma pack(push, 1) -#endif - -#include -#include -#include -#include -#define BOOST_ENDIAN_MINIMAL_COVER_OPERATORS -#include -#undef BOOST_ENDIAN_MINIMAL_COVER_OPERATORS -#include -#include -#include -#include -#include -#include - -# if CHAR_BIT != 8 -# error Platforms with CHAR_BIT != 8 are not supported -# endif - -# ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS -# define BOOST_ENDIAN_DEFAULT_CONSTRUCT {} // C++03 -# else -# define BOOST_ENDIAN_DEFAULT_CONSTRUCT = default; // C++0x -# endif - -# if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && defined(BOOST_ENDIAN_FORCE_PODNESS) -# define BOOST_ENDIAN_NO_CTORS -# endif - -# ifndef BOOST_ENDIAN_EXPLICIT_CTORS -# define BOOST_ENDIAN_EXPLICIT_OPT -# else -# define BOOST_ENDIAN_EXPLICIT_OPT explicit -# endif - -//---------------------------------- synopsis ----------------------------------------// - -namespace boost -{ -namespace endian -{ - -#ifndef BOOST_ENDIAN_ORDER_ENUM_DEFINED - BOOST_SCOPED_ENUM_START(order) - { - big, little, -# ifdef BOOST_BIG_ENDIAN - native = big -# else - native = little -# endif - }; BOOST_SCOPED_ENUM_END -# define BOOST_ENDIAN_ORDER_ENUM_DEFINED -#endif - - template - class endian; - - // aligned big endian floating point types - typedef endian big_align_float32_t; - typedef endian big_align_float64_t; - - // aligned little endian floating point types - typedef endian little_align_float32_t; - typedef endian little_align_float64_t; - - // unaligned big endian floating point types - typedef endian big_float32_t; - typedef endian big_float64_t; - - // unaligned little endian floating point types - typedef endian little_float32_t; - typedef endian little_float64_t; - - // aligned big endian signed integer types - typedef endian big_align_int16_t; - typedef endian big_align_int32_t; - typedef endian big_align_int64_t; - - // aligned big endian unsigned integer types - typedef endian big_align_uint16_t; - typedef endian big_align_uint32_t; - typedef endian big_align_uint64_t; - - // aligned little endian signed integer types - typedef endian little_align_int16_t; - typedef endian little_align_int32_t; - typedef endian little_align_int64_t; - - // aligned little endian unsigned integer types - typedef endian little_align_uint16_t; - typedef endian little_align_uint32_t; - typedef endian little_align_uint64_t; - - // aligned native endian typedefs are not provided because - // types are superior for this use case - - // unaligned big endian signed integer types - typedef endian big_int8_t; - typedef endian big_int16_t; - typedef endian big_int24_t; - typedef endian big_int32_t; - typedef endian big_int40_t; - typedef endian big_int48_t; - typedef endian big_int56_t; - typedef endian big_int64_t; - - // unaligned big endian unsigned integer types - typedef endian big_uint8_t; - typedef endian big_uint16_t; - typedef endian big_uint24_t; - typedef endian big_uint32_t; - typedef endian big_uint40_t; - typedef endian big_uint48_t; - typedef endian big_uint56_t; - typedef endian big_uint64_t; - - // unaligned little endian signed integer types - typedef endian little_int8_t; - typedef endian little_int16_t; - typedef endian little_int24_t; - typedef endian little_int32_t; - typedef endian little_int40_t; - typedef endian little_int48_t; - typedef endian little_int56_t; - typedef endian little_int64_t; - - // unaligned little endian unsigned integer types - typedef endian little_uint8_t; - typedef endian little_uint16_t; - typedef endian little_uint24_t; - typedef endian little_uint32_t; - typedef endian little_uint40_t; - typedef endian little_uint48_t; - typedef endian little_uint56_t; - typedef endian little_uint64_t; - -# ifdef BOOST_BIG_ENDIAN - // unaligned native endian signed integer types - typedef big_int8_t native_int8_t; - typedef big_int16_t native_int16_t; - typedef big_int24_t native_int24_t; - typedef big_int32_t native_int32_t; - typedef big_int40_t native_int40_t; - typedef big_int48_t native_int48_t; - typedef big_int56_t native_int56_t; - typedef big_int64_t native_int64_t; - - // unaligned native endian unsigned integer types - typedef big_uint8_t native_uint8_t; - typedef big_uint16_t native_uint16_t; - typedef big_uint24_t native_uint24_t; - typedef big_uint32_t native_uint32_t; - typedef big_uint40_t native_uint40_t; - typedef big_uint48_t native_uint48_t; - typedef big_uint56_t native_uint56_t; - typedef big_uint64_t native_uint64_t; - - // native endian floating point types - typedef big_float32_t native_float32_t; - typedef big_float64_t native_float64_t; - typedef big_align_float32_t native_align_float32_t; - typedef big_align_float64_t native_align_float64_t; -# else - // unaligned native endian signed integer types - typedef little_int8_t native_int8_t; - typedef little_int16_t native_int16_t; - typedef little_int24_t native_int24_t; - typedef little_int32_t native_int32_t; - typedef little_int40_t native_int40_t; - typedef little_int48_t native_int48_t; - typedef little_int56_t native_int56_t; - typedef little_int64_t native_int64_t; - - // unaligned native endian unsigned integer types - typedef little_uint8_t native_uint8_t; - typedef little_uint16_t native_uint16_t; - typedef little_uint24_t native_uint24_t; - typedef little_uint32_t native_uint32_t; - typedef little_uint40_t native_uint40_t; - typedef little_uint48_t native_uint48_t; - typedef little_uint56_t native_uint56_t; - typedef little_uint64_t native_uint64_t; - - // native endian floating point types - typedef little_float32_t native_float32_t; - typedef little_float64_t native_float64_t; - typedef little_align_float32_t native_align_float32_t; - typedef little_align_float64_t native_align_float64_t; -# endif -} // namespace boost -} // namespace endian - -//---------------------------------- end synopsis ------------------------------------// - -namespace boost -{ -namespace endian -{ - -// endian class template specializations ---------------------------------------------// - - // Specializations that represent unaligned bytes. - // Taking an integer type as a parameter provides a nice way to pass both - // the size and signness of the desired integer and get the appropriate - // corresponding integer type for the interface. - - // unaligned integer big endian specialization - template - class endian< order::big, T, n_bits, align::no > - : public endian_buffer< order::big, T, n_bits, align::no >, - cover_operators, T> - { - BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits ); - public: - typedef T value_type; -# ifndef BOOST_ENDIAN_NO_CTORS - endian() BOOST_ENDIAN_DEFAULT_CONSTRUCT - BOOST_ENDIAN_EXPLICIT_OPT endian(T val) BOOST_NOEXCEPT - { -# ifdef BOOST_ENDIAN_LOG - if ( endian_log ) - std::cout << "big, unaligned, " << n_bits << "-bits, construct(" << val << ")\n"; -# endif - detail::store_big_endian(this->m_value, val); - } -# endif - endian & operator=(T val) BOOST_NOEXCEPT - { detail::store_big_endian(this->m_value, val); return *this; } - operator value_type() const BOOST_NOEXCEPT { return this->value(); } - }; - - // unaligned float big endian specialization - template <> - class endian< order::big, float, 32, align::no > - : public endian_buffer< order::big, float, 32, align::no >, - cover_operators< endian< order::big, float, 32 >, float > - { - public: - typedef float value_type; -# ifndef BOOST_ENDIAN_NO_CTORS - endian() BOOST_ENDIAN_DEFAULT_CONSTRUCT - BOOST_ENDIAN_EXPLICIT_OPT endian(value_type val) BOOST_NOEXCEPT - { detail::big_reverse_copy(val, this->m_value); } -# endif - endian & operator=(value_type val) BOOST_NOEXCEPT - { detail::big_reverse_copy(val, this->m_value); return *this; } - operator value_type() const BOOST_NOEXCEPT { return this->value(); } - }; - - // unaligned double big endian specialization - template <> - class endian< order::big, double, 64, align::no > - : public endian_buffer< order::big, double, 64, align::no >, - cover_operators< endian< order::big, double, 64 >, double > - { - public: - typedef double value_type; -# ifndef BOOST_ENDIAN_NO_CTORS - endian() BOOST_ENDIAN_DEFAULT_CONSTRUCT - BOOST_ENDIAN_EXPLICIT_OPT endian(value_type val) BOOST_NOEXCEPT - { detail::big_reverse_copy(val, this->m_value); } -# endif - endian & operator=(value_type val) BOOST_NOEXCEPT - { detail::big_reverse_copy(val, this->m_value); return *this; } - operator value_type() const BOOST_NOEXCEPT { return this->value(); } - }; - - // unaligned float little endian specialization - template <> - class endian< order::little, float, 32, align::no > - : public endian_buffer< order::little, float, 32, align::no >, - cover_operators< endian< order::little, float, 32 >, float > - { - public: - typedef float value_type; -# ifndef BOOST_ENDIAN_NO_CTORS - endian() BOOST_ENDIAN_DEFAULT_CONSTRUCT - BOOST_ENDIAN_EXPLICIT_OPT endian(value_type val) BOOST_NOEXCEPT - { detail::little_reverse_copy(val, this->m_value); } -# endif - endian & operator=(value_type val) BOOST_NOEXCEPT - { detail::little_reverse_copy(val, this->m_value); return *this; } - operator value_type() const BOOST_NOEXCEPT { return this->value(); } - }; - - // unaligned double little endian specialization - template <> - class endian< order::little, double, 64, align::no > - : public endian_buffer< order::little, double, 64, align::no >, - cover_operators< endian< order::little, double, 64 >, double > - { - public: - typedef double value_type; -# ifndef BOOST_ENDIAN_NO_CTORS - endian() BOOST_ENDIAN_DEFAULT_CONSTRUCT - BOOST_ENDIAN_EXPLICIT_OPT endian(value_type val) BOOST_NOEXCEPT - { detail::little_reverse_copy(val, this->m_value); } -# endif - endian & operator=(value_type val) BOOST_NOEXCEPT - { detail::little_reverse_copy(val, this->m_value); return *this; } - operator value_type() const BOOST_NOEXCEPT { return this->value(); } - }; - - // unaligned little endian specialization - template - class endian< order::little, T, n_bits, align::no > - : public endian_buffer< order::little, T, n_bits, align::no >, - cover_operators< endian< order::little, T, n_bits >, T > - { - BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits ); - public: - typedef T value_type; -# ifndef BOOST_ENDIAN_NO_CTORS - endian() BOOST_ENDIAN_DEFAULT_CONSTRUCT - BOOST_ENDIAN_EXPLICIT_OPT endian(T val) BOOST_NOEXCEPT - { -# ifdef BOOST_ENDIAN_LOG - if ( endian_log ) - std::cout << "little, unaligned, " << n_bits << "-bits, construct(" << val << ")\n"; -# endif - detail::store_little_endian(this->m_value, val); - } -# endif - endian & operator=(T val) BOOST_NOEXCEPT - { detail::store_little_endian(this->m_value, val); return *this; } - operator value_type() const BOOST_NOEXCEPT { return this->value(); } - }; - - // align::yes specializations; only n_bits == 16/32/64 supported - - // aligned big endian specialization - template - class endian - : public endian_buffer< order::big, T, n_bits, align::yes >, - cover_operators, T> - { - BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits ); - BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 ); - public: - typedef T value_type; -# ifndef BOOST_ENDIAN_NO_CTORS - endian() BOOST_ENDIAN_DEFAULT_CONSTRUCT - BOOST_ENDIAN_EXPLICIT_OPT endian(T val) BOOST_NOEXCEPT - { -# ifdef BOOST_ENDIAN_LOG - if ( endian_log ) - std::cout << "big, aligned, " << n_bits << "-bits, construct(" << val << ")\n"; -# endif - this->m_value = ::boost::endian::big_endian_value(val); - } - -# endif - endian& operator=(T val) BOOST_NOEXCEPT - { - this->m_value = ::boost::endian::big_endian_value(val); - return *this; - } - operator value_type() const BOOST_NOEXCEPT { return this->value(); } - }; - - // aligned little endian specialization - template - class endian - : public endian_buffer< order::little, T, n_bits, align::yes >, - cover_operators, T> - { - BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits ); - BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 ); - public: - typedef T value_type; -# ifndef BOOST_ENDIAN_NO_CTORS - endian() BOOST_ENDIAN_DEFAULT_CONSTRUCT - BOOST_ENDIAN_EXPLICIT_OPT endian(T val) BOOST_NOEXCEPT - { -# ifdef BOOST_ENDIAN_LOG - if ( endian_log ) - std::cout << "little, aligned, " << n_bits << "-bits, construct(" << val << ")\n"; -# endif - this->m_value = ::boost::endian::little_endian_value(val); - } -# endif - endian& operator=(T val) BOOST_NOEXCEPT - { - this->m_value = ::boost::endian::little_endian_value(val); - return *this; - } - operator value_type() const BOOST_NOEXCEPT { return this->value(); } - }; - -} // namespace endian -} // namespace boost - -#if defined(__BORLANDC__) || defined( __CODEGEARC__) -# pragma pack(pop) -#endif - -#if defined(_MSC_VER) -# pragma warning(pop) -#endif - -#endif // BOOST_ENDIAN_HPP diff --git a/test/endian_in_union_test.cpp b/test/endian_in_union_test.cpp index 645afe3..1a2486b 100644 --- a/test/endian_in_union_test.cpp +++ b/test/endian_in_union_test.cpp @@ -15,7 +15,7 @@ #include -#include +#include #include #include @@ -23,59 +23,59 @@ using namespace boost::endian; union U { - big_int8_t big_8; - big_int16_t big_16; - big_int24_t big_24; - big_int32_t big_32; - big_int40_t big_40; - big_int48_t big_48; - big_int56_t big_56; - big_int64_t big_64; + big_int8_ut big_8; + big_int16_ut big_16; + big_int24_ut big_24; + big_int32_ut big_32; + big_int40_ut big_40; + big_int48_ut big_48; + big_int56_ut big_56; + big_int64_ut big_64; - big_uint8_t big_u8; - big_uint16_t big_u16; - big_uint24_t big_u24; - big_uint32_t big_u32; - big_uint40_t big_u40; - big_uint48_t big_u48; - big_uint56_t big_u56; - big_uint64_t big_u64; + big_uint8_ut big_u8; + big_uint16_ut big_u16; + big_uint24_ut big_u24; + big_uint32_ut big_u32; + big_uint40_ut big_u40; + big_uint48_ut big_u48; + big_uint56_ut big_u56; + big_uint64_ut big_u64; - little_int8_t little_8; - little_int16_t little_16; - little_int24_t little_24; - little_int32_t little_32; - little_int40_t little_40; - little_int48_t little_48; - little_int56_t little_56; - little_int64_t little_64; + little_int8_ut little_8; + little_int16_ut little_16; + little_int24_ut little_24; + little_int32_ut little_32; + little_int40_ut little_40; + little_int48_ut little_48; + little_int56_ut little_56; + little_int64_ut little_64; - little_uint8_t little_u8; - little_uint16_t little_u16; - little_uint24_t little_u24; - little_uint32_t little_u32; - little_uint40_t little_u40; - little_uint48_t little_u48; - little_uint56_t little_u56; - little_uint64_t little_u64; + little_uint8_ut little_u8; + little_uint16_ut little_u16; + little_uint24_ut little_u24; + little_uint32_ut little_u32; + little_uint40_ut little_u40; + little_uint48_ut little_u48; + little_uint56_ut little_u56; + little_uint64_ut little_u64; - native_int8_t native_8; - native_int16_t native_16; - native_int24_t native_24; - native_int32_t native_32; - native_int40_t native_40; - native_int48_t native_48; - native_int56_t native_56; - native_int64_t native_64; + native_int8_ut native_8; + native_int16_ut native_16; + native_int24_ut native_24; + native_int32_ut native_32; + native_int40_ut native_40; + native_int48_ut native_48; + native_int56_ut native_56; + native_int64_ut native_64; - native_uint8_t native_u8; - native_uint16_t native_u16; - native_uint24_t native_u24; - native_uint32_t native_u32; - native_uint40_t native_u40; - native_uint48_t native_u48; - native_uint56_t native_u56; - native_uint64_t native_u64; + native_uint8_ut native_u8; + native_uint16_ut native_u16; + native_uint24_ut native_u24; + native_uint32_ut native_u32; + native_uint40_ut native_u40; + native_uint48_ut native_u48; + native_uint56_ut native_u56; + native_uint64_ut native_u64; }; U foo; diff --git a/test/endian_operations_test.cpp b/test/endian_operations_test.cpp index 5f6e9af..d853007 100644 --- a/test/endian_operations_test.cpp +++ b/test/endian_operations_test.cpp @@ -44,7 +44,7 @@ #define BOOST_ENDIAN_LOG -#include +#include #include #include #include @@ -208,67 +208,67 @@ void op_test_aux() Test::test(); Test::test(); Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); Test::test(); - Test::test(); Test::test(); - Test::test(); - Test::test(); - Test::test(); Test::test(); - Test::test(); Test::test(); - Test::test(); Test::test(); - Test::test(); Test::test(); Test::test(); - Test::test(); Test::test(); Test::test(); Test::test(); Test::test(); - Test::test(); Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); #ifdef BOOST_LONG_ENDIAN_TEST - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); - Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); #endif } @@ -286,61 +286,61 @@ void op_test() op_test_aux(); op_test_aux(); op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); -#ifdef BOOST_LONG_ENDIAN_TEST - op_test_aux(); op_test_aux(); - op_test_aux(); op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); op_test_aux(); - op_test_aux(); op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); +#ifdef BOOST_LONG_ENDIAN_TEST + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); #endif } @@ -350,8 +350,8 @@ void test_inserter_and_extractor() { std::cout << "test inserter and extractor..." << std::endl; - be::big_uint64_t bu64(0x010203040506070ULL); - be::little_uint64_t lu64(0x010203040506070ULL); + be::big_uint64_ut bu64(0x010203040506070ULL); + be::little_uint64_ut lu64(0x010203040506070ULL); uint64_t x; @@ -368,13 +368,13 @@ void test_inserter_and_extractor() ss.clear(); ss << 0x010203040506070ULL; - be::big_uint64_t bu64z(0); + be::big_uint64_ut bu64z(0); ss >> bu64z; BOOST_TEST_EQ(bu64z, bu64); ss.clear(); ss << 0x010203040506070ULL; - be::little_uint64_t lu64z(0); + be::little_uint64_ut lu64z(0); ss >> lu64z; BOOST_TEST_EQ(lu64z, lu64); @@ -382,7 +382,7 @@ void test_inserter_and_extractor() } -void f_big_int32_t(be::big_int32_t) {} +void f_big_int32_ut(be::big_int32_ut) {} // main ------------------------------------------------------------------------------// @@ -392,10 +392,10 @@ int cpp_main(int, char * []) // make sure some simple things work - be::big_int32_t o1(1); - be::big_int32_t o2(2L); - be::big_int32_t o3(3LL); - be::big_int64_t o4(1); + be::big_int32_ut o1(1); + be::big_int32_ut o2(2L); + be::big_int32_ut o3(3LL); + be::big_int64_ut o4(1); // use cases; if BOOST_ENDIAN_LOG is defined, will output to clog info on // what overloads and conversions are actually being performed. @@ -403,14 +403,14 @@ int cpp_main(int, char * []) be::endian_log = true; std::clog << "set up test values\n"; - be::big_int32_t big(12345); - be::little_uint16_t little_u(10); - be::big_int64_t result; + be::big_int32_ut big(12345); + be::little_uint16_ut little_u(10); + be::big_int64_ut result; // this is the use case that is so irritating that it caused the endian // constructors to be made non-explicit - std::clog << "\nf(1234) where f(big_int32_t)\n"; - f_big_int32_t(1234); + std::clog << "\nf(1234) where f(big_int32_ut)\n"; + f_big_int32_ut(1234); std::clog << "\nresult = big\n"; result = big; @@ -470,8 +470,8 @@ int cpp_main(int, char * []) // test from Roland Schwarz that detected ambiguities; these ambiguities // were eliminated by BOOST_ENDIAN_MINIMAL_COVER_OPERATORS unsigned u; - be::little_uint32_t u1; - be::little_uint32_t u2; + be::little_uint32_ut u1; + be::little_uint32_ut u2; u = 9; u1 = 1; @@ -481,7 +481,7 @@ int cpp_main(int, char * []) // variations to detect ambiguities - be::little_uint32_t u3 = u1 + 5; + be::little_uint32_ut u3 = u1 + 5; u3 = u1 + 5u; if (u1 == 5) @@ -496,7 +496,7 @@ int cpp_main(int, char * []) u2 = u1 + 5u; // one more wrinkle - be::little_uint16_t u4(3); + be::little_uint16_ut u4(3); u4 = 3; std::clog << "\nu2 = u1 + u4\n"; u2 = u1 + u4; diff --git a/test/endian_test.cpp b/test/endian_test.cpp index db0f8e4..1a44874 100644 --- a/test/endian_test.cpp +++ b/test/endian_test.cpp @@ -20,7 +20,7 @@ #include -#include +#include #include #include @@ -155,82 +155,82 @@ namespace void check_data() { - big_int8_t big_8; - big_int16_t big_16; - big_int24_t big_24; - big_int32_t big_32; - big_int40_t big_40; - big_int48_t big_48; - big_int56_t big_56; - big_int64_t big_64; + big_int8_ut big_8; + big_int16_ut big_16; + big_int24_ut big_24; + big_int32_ut big_32; + big_int40_ut big_40; + big_int48_ut big_48; + big_int56_ut big_56; + big_int64_ut big_64; - big_uint8_t big_u8; - big_uint16_t big_u16; - big_uint24_t big_u24; - big_uint32_t big_u32; - big_uint40_t big_u40; - big_uint48_t big_u48; - big_uint56_t big_u56; - big_uint64_t big_u64; + big_uint8_ut big_u8; + big_uint16_ut big_u16; + big_uint24_ut big_u24; + big_uint32_ut big_u32; + big_uint40_ut big_u40; + big_uint48_ut big_u48; + big_uint56_ut big_u56; + big_uint64_ut big_u64; - little_int8_t little_8; - little_int16_t little_16; - little_int24_t little_24; - little_int32_t little_32; - little_int40_t little_40; - little_int48_t little_48; - little_int56_t little_56; - little_int64_t little_64; + little_int8_ut little_8; + little_int16_ut little_16; + little_int24_ut little_24; + little_int32_ut little_32; + little_int40_ut little_40; + little_int48_ut little_48; + little_int56_ut little_56; + little_int64_ut little_64; - little_uint8_t little_u8; - little_uint16_t little_u16; - little_uint24_t little_u24; - little_uint32_t little_u32; - little_uint40_t little_u40; - little_uint48_t little_u48; - little_uint56_t little_u56; - little_uint64_t little_u64; + little_uint8_ut little_u8; + little_uint16_ut little_u16; + little_uint24_ut little_u24; + little_uint32_ut little_u32; + little_uint40_ut little_u40; + little_uint48_ut little_u48; + little_uint56_ut little_u56; + little_uint64_ut little_u64; - native_int8_t native_8; - native_int16_t native_16; - native_int24_t native_24; - native_int32_t native_32; - native_int40_t native_40; - native_int48_t native_48; - native_int56_t native_56; - native_int64_t native_64; + native_int8_ut native_8; + native_int16_ut native_16; + native_int24_ut native_24; + native_int32_ut native_32; + native_int40_ut native_40; + native_int48_ut native_48; + native_int56_ut native_56; + native_int64_ut native_64; - native_uint8_t native_u8; - native_uint16_t native_u16; - native_uint24_t native_u24; - native_uint32_t native_u32; - native_uint40_t native_u40; - native_uint48_t native_u48; - native_uint56_t native_u56; - native_uint64_t native_u64; + native_uint8_ut native_u8; + native_uint16_ut native_u16; + native_uint24_ut native_u24; + native_uint32_ut native_u32; + native_uint40_ut native_u40; + native_uint48_ut native_u48; + native_uint56_ut native_u56; + native_uint64_ut native_u64; - big_align_int16_t big_align_int16; - big_align_int32_t big_align_int32; - big_align_int64_t big_align_int64; + big_int16_t big_align_int16; + big_int32_t big_align_int32; + big_int64_t big_align_int64; - big_align_uint16_t big_align_uint16; - big_align_uint32_t big_align_uint32; - big_align_uint64_t big_align_uint64; + big_uint16_t big_align_uint16; + big_uint32_t big_align_uint32; + big_uint64_t big_align_uint64; - little_align_int16_t little_align_int16; - little_align_int32_t little_align_int32; - little_align_int64_t little_align_int64; + little_int16_t little_align_int16; + little_int32_t little_align_int32; + little_int64_t little_align_int64; - little_align_uint16_t little_align_uint16; - little_align_uint32_t little_align_uint32; - little_align_uint64_t little_align_uint64; + little_uint16_t little_align_uint16; + little_uint32_t little_align_uint32; + little_uint64_t little_align_uint64; - big_align_float32_t big_align_float32; - big_align_float64_t big_align_float64; - little_align_float32_t little_align_float32; - little_align_float64_t little_align_float64; - native_align_float32_t native_align_float32; - native_align_float64_t native_align_float64; + big_float32_t big_align_float32; + big_float64_t big_align_float64; + little_float32_t little_align_float32; + little_float64_t little_align_float64; + native_float32_t native_align_float32; + native_float64_t native_align_float64; VERIFY(big_align_float32.data() == reinterpret_cast(&big_align_float32)); VERIFY(big_align_float64.data() == reinterpret_cast(&big_align_float64)); @@ -241,12 +241,12 @@ namespace VERIFY(native_align_float32.data() == reinterpret_cast(&native_align_float32)); VERIFY(native_align_float64.data() == reinterpret_cast(&native_align_float64)); - big_float32_t big_float32; - big_float64_t big_float64; - little_float32_t little_float32; - little_float64_t little_float64; - native_float32_t native_float32; - native_float64_t native_float64; + big_float32_ut big_float32; + big_float64_ut big_float64; + little_float32_ut little_float32; + little_float64_ut little_float64; + native_float32_ut native_float32; + native_float64_ut native_float64; VERIFY(big_float32.data() == reinterpret_cast(&big_float32)); VERIFY(big_float64.data() == reinterpret_cast(&big_float64)); @@ -336,13 +336,6 @@ namespace VERIFY( numeric_limits::digits == 7 ); VERIFY( numeric_limits::digits == 8 ); - VERIFY_SIZE(sizeof( big_align_float32_t ), 4 ); - VERIFY_SIZE(sizeof( big_align_float64_t ), 8 ); - VERIFY_SIZE(sizeof(little_align_float32_t), 4); - VERIFY_SIZE(sizeof(little_align_float64_t), 8); - VERIFY_SIZE(sizeof(native_align_float32_t), 4); - VERIFY_SIZE(sizeof(native_align_float64_t), 8); - VERIFY_SIZE(sizeof( big_float32_t ), 4 ); VERIFY_SIZE(sizeof( big_float64_t ), 8 ); VERIFY_SIZE(sizeof(little_float32_t), 4); @@ -350,75 +343,82 @@ namespace VERIFY_SIZE(sizeof(native_float32_t), 4); VERIFY_SIZE(sizeof(native_float64_t), 8); - VERIFY_SIZE( sizeof( big_int8_t ), 1 ); + VERIFY_SIZE(sizeof( big_float32_ut ), 4 ); + VERIFY_SIZE(sizeof( big_float64_ut ), 8 ); + VERIFY_SIZE(sizeof(little_float32_ut), 4); + VERIFY_SIZE(sizeof(little_float64_ut), 8); + VERIFY_SIZE(sizeof(native_float32_ut), 4); + VERIFY_SIZE(sizeof(native_float64_ut), 8); + + VERIFY_SIZE( sizeof( big_int8_ut ), 1 ); + VERIFY_SIZE( sizeof( big_int16_ut ), 2 ); + VERIFY_SIZE( sizeof( big_int24_ut ), 3 ); + VERIFY_SIZE( sizeof( big_int32_ut ), 4 ); + VERIFY_SIZE( sizeof( big_int40_ut ), 5 ); + VERIFY_SIZE( sizeof( big_int48_ut ), 6 ); + VERIFY_SIZE( sizeof( big_int56_ut ), 7 ); + VERIFY_SIZE( sizeof( big_int64_ut ), 8 ); + + VERIFY_SIZE( sizeof( big_uint8_ut ), 1 ); + VERIFY_SIZE( sizeof( big_uint16_ut ), 2 ); + VERIFY_SIZE( sizeof( big_uint24_ut ), 3 ); + VERIFY_SIZE( sizeof( big_uint32_ut ), 4 ); + VERIFY_SIZE( sizeof( big_uint40_ut ), 5 ); + VERIFY_SIZE( sizeof( big_uint48_ut ), 6 ); + VERIFY_SIZE( sizeof( big_uint56_ut ), 7 ); + VERIFY_SIZE( sizeof( big_uint64_ut ), 8 ); + + VERIFY_SIZE( sizeof( little_int8_ut ), 1 ); + VERIFY_SIZE( sizeof( little_int16_ut ), 2 ); + VERIFY_SIZE( sizeof( little_int24_ut ), 3 ); + VERIFY_SIZE( sizeof( little_int32_ut ), 4 ); + VERIFY_SIZE( sizeof( little_int40_ut ), 5 ); + VERIFY_SIZE( sizeof( little_int48_ut ), 6 ); + VERIFY_SIZE( sizeof( little_int56_ut ), 7 ); + VERIFY_SIZE( sizeof( little_int64_ut ), 8 ); + + VERIFY_SIZE( sizeof( little_uint8_ut ), 1 ); + VERIFY_SIZE( sizeof( little_uint16_ut ), 2 ); + VERIFY_SIZE( sizeof( little_uint24_ut ), 3 ); + VERIFY_SIZE( sizeof( little_uint32_ut ), 4 ); + VERIFY_SIZE( sizeof( little_uint40_ut ), 5 ); + VERIFY_SIZE( sizeof( little_uint48_ut ), 6 ); + VERIFY_SIZE( sizeof( little_uint56_ut ), 7 ); + VERIFY_SIZE( sizeof( little_uint64_ut ), 8 ); + + VERIFY_SIZE( sizeof( native_int8_ut ), 1 ); + VERIFY_SIZE( sizeof( native_int16_ut ), 2 ); + VERIFY_SIZE( sizeof( native_int24_ut ), 3 ); + VERIFY_SIZE( sizeof( native_int32_ut ), 4 ); + VERIFY_SIZE( sizeof( native_int40_ut ), 5 ); + VERIFY_SIZE( sizeof( native_int48_ut ), 6 ); + VERIFY_SIZE( sizeof( native_int56_ut ), 7 ); + VERIFY_SIZE( sizeof( native_int64_ut ), 8 ); + + VERIFY_SIZE( sizeof( native_uint8_ut ), 1 ); + VERIFY_SIZE( sizeof( native_uint16_ut ), 2 ); + VERIFY_SIZE( sizeof( native_uint24_ut ), 3 ); + VERIFY_SIZE( sizeof( native_uint32_ut ), 4 ); + VERIFY_SIZE( sizeof( native_uint40_ut ), 5 ); + VERIFY_SIZE( sizeof( native_uint48_ut ), 6 ); + VERIFY_SIZE( sizeof( native_uint56_ut ), 7 ); + VERIFY_SIZE( sizeof( native_uint64_ut ), 8 ); + VERIFY_SIZE( sizeof( big_int16_t ), 2 ); - VERIFY_SIZE( sizeof( big_int24_t ), 3 ); VERIFY_SIZE( sizeof( big_int32_t ), 4 ); - VERIFY_SIZE( sizeof( big_int40_t ), 5 ); - VERIFY_SIZE( sizeof( big_int48_t ), 6 ); - VERIFY_SIZE( sizeof( big_int56_t ), 7 ); VERIFY_SIZE( sizeof( big_int64_t ), 8 ); - VERIFY_SIZE( sizeof( big_uint8_t ), 1 ); VERIFY_SIZE( sizeof( big_uint16_t ), 2 ); - VERIFY_SIZE( sizeof( big_uint24_t ), 3 ); VERIFY_SIZE( sizeof( big_uint32_t ), 4 ); - VERIFY_SIZE( sizeof( big_uint40_t ), 5 ); - VERIFY_SIZE( sizeof( big_uint48_t ), 6 ); - VERIFY_SIZE( sizeof( big_uint56_t ), 7 ); VERIFY_SIZE( sizeof( big_uint64_t ), 8 ); - VERIFY_SIZE( sizeof( little_int8_t ), 1 ); VERIFY_SIZE( sizeof( little_int16_t ), 2 ); - VERIFY_SIZE( sizeof( little_int24_t ), 3 ); VERIFY_SIZE( sizeof( little_int32_t ), 4 ); - VERIFY_SIZE( sizeof( little_int40_t ), 5 ); - VERIFY_SIZE( sizeof( little_int48_t ), 6 ); - VERIFY_SIZE( sizeof( little_int56_t ), 7 ); VERIFY_SIZE( sizeof( little_int64_t ), 8 ); - VERIFY_SIZE( sizeof( little_uint8_t ), 1 ); VERIFY_SIZE( sizeof( little_uint16_t ), 2 ); - VERIFY_SIZE( sizeof( little_uint24_t ), 3 ); VERIFY_SIZE( sizeof( little_uint32_t ), 4 ); - VERIFY_SIZE( sizeof( little_uint40_t ), 5 ); - VERIFY_SIZE( sizeof( little_uint48_t ), 6 ); - VERIFY_SIZE( sizeof( little_uint56_t ), 7 ); VERIFY_SIZE( sizeof( little_uint64_t ), 8 ); - - VERIFY_SIZE( sizeof( native_int8_t ), 1 ); - VERIFY_SIZE( sizeof( native_int16_t ), 2 ); - VERIFY_SIZE( sizeof( native_int24_t ), 3 ); - VERIFY_SIZE( sizeof( native_int32_t ), 4 ); - VERIFY_SIZE( sizeof( native_int40_t ), 5 ); - VERIFY_SIZE( sizeof( native_int48_t ), 6 ); - VERIFY_SIZE( sizeof( native_int56_t ), 7 ); - VERIFY_SIZE( sizeof( native_int64_t ), 8 ); - - VERIFY_SIZE( sizeof( native_uint8_t ), 1 ); - VERIFY_SIZE( sizeof( native_uint16_t ), 2 ); - VERIFY_SIZE( sizeof( native_uint24_t ), 3 ); - VERIFY_SIZE( sizeof( native_uint32_t ), 4 ); - VERIFY_SIZE( sizeof( native_uint40_t ), 5 ); - VERIFY_SIZE( sizeof( native_uint48_t ), 6 ); - VERIFY_SIZE( sizeof( native_uint56_t ), 7 ); - VERIFY_SIZE( sizeof( native_uint64_t ), 8 ); - - VERIFY_SIZE( sizeof( big_align_int16_t ), 2 ); - VERIFY_SIZE( sizeof( big_align_int32_t ), 4 ); - VERIFY_SIZE( sizeof( big_align_int64_t ), 8 ); - - VERIFY_SIZE( sizeof( big_align_uint16_t ), 2 ); - VERIFY_SIZE( sizeof( big_align_uint32_t ), 4 ); - VERIFY_SIZE( sizeof( big_align_uint64_t ), 8 ); - - VERIFY_SIZE( sizeof( little_align_int16_t ), 2 ); - VERIFY_SIZE( sizeof( little_align_int32_t ), 4 ); - VERIFY_SIZE( sizeof( little_align_int64_t ), 8 ); - - VERIFY_SIZE( sizeof( little_align_uint16_t ), 2 ); - VERIFY_SIZE( sizeof( little_align_uint32_t ), 4 ); - VERIFY_SIZE( sizeof( little_align_uint64_t ), 8 ); } // check_size // check_alignment -------------------------------------------------------// @@ -430,148 +430,148 @@ namespace struct big_struct { - big_int8_t v0; - big_int16_t v1; - big_int24_t v3; + big_int8_ut v0; + big_int16_ut v1; + big_int24_ut v3; char v6; - big_int32_t v7; - big_int40_t v11; + big_int32_ut v7; + big_int40_ut v11; char v16; - big_int48_t v17; - big_int56_t v23; + big_int48_ut v17; + big_int56_ut v23; char v30; - big_int64_t v31; + big_int64_ut v31; }; struct big_u_struct { - big_uint8_t v0; - big_uint16_t v1; - big_uint24_t v3; + big_uint8_ut v0; + big_uint16_ut v1; + big_uint24_ut v3; char v6; - big_uint32_t v7; - big_uint40_t v11; + big_uint32_ut v7; + big_uint40_ut v11; char v16; - big_uint48_t v17; - big_uint56_t v23; + big_uint48_ut v17; + big_uint56_ut v23; char v30; - big_uint64_t v31; + big_uint64_ut v31; }; struct little_struct { - little_int8_t v0; - little_int16_t v1; - little_int24_t v3; + little_int8_ut v0; + little_int16_ut v1; + little_int24_ut v3; char v6; - little_int32_t v7; - little_int40_t v11; + little_int32_ut v7; + little_int40_ut v11; char v16; - little_int48_t v17; - little_int56_t v23; + little_int48_ut v17; + little_int56_ut v23; char v30; - little_int64_t v31; + little_int64_ut v31; }; struct little_u_struct { - little_uint8_t v0; - little_uint16_t v1; - little_uint24_t v3; + little_uint8_ut v0; + little_uint16_ut v1; + little_uint24_ut v3; char v6; - little_uint32_t v7; - little_uint40_t v11; + little_uint32_ut v7; + little_uint40_ut v11; char v16; - little_uint48_t v17; - little_uint56_t v23; + little_uint48_ut v17; + little_uint56_ut v23; char v30; - little_uint64_t v31; + little_uint64_ut v31; }; struct native_struct { - native_int8_t v0; - native_int16_t v1; - native_int24_t v3; + native_int8_ut v0; + native_int16_ut v1; + native_int24_ut v3; char v6; - native_int32_t v7; - native_int40_t v11; + native_int32_ut v7; + native_int40_ut v11; char v16; - native_int48_t v17; - native_int56_t v23; + native_int48_ut v17; + native_int56_ut v23; char v30; - native_int64_t v31; + native_int64_ut v31; }; struct native_u_struct { - native_uint8_t v0; - native_uint16_t v1; - native_uint24_t v3; + native_uint8_ut v0; + native_uint16_ut v1; + native_uint24_ut v3; char v6; - native_uint32_t v7; - native_uint40_t v11; + native_uint32_ut v7; + native_uint40_ut v11; char v16; - native_uint48_t v17; - native_uint56_t v23; + native_uint48_ut v17; + native_uint56_ut v23; char v30; - native_uint64_t v31; + native_uint64_ut v31; }; struct big_float_struct { int16_t v0; - big_align_float32_t v1; + big_float32_t v1; }; struct big_unaligned_float_struct { int16_t v0; - big_float32_t v1; + big_float32_ut v1; }; struct little_float_struct { int16_t v0; - little_align_float32_t v1; + little_float32_t v1; }; struct little_unaligned_float_struct { int16_t v0; - little_float32_t v1; + little_float32_ut v1; }; struct native_float_struct { int16_t v0; - native_align_float32_t v1; + native_float32_t v1; }; struct native_unaligned_float_struct { int16_t v0; - native_float32_t v1; + native_float32_ut v1; }; // aligned test cases struct big_aligned_struct { - big_align_int16_t v0; - big_align_int32_t v1; + big_int16_t v0; + big_int32_t v1; char v3; // on a 32-bit system, the padding here may be 3 rather than 7 bytes - big_align_int64_t v4; + big_int64_t v4; }; struct little_aligned_struct { - little_align_int16_t v0; - little_align_int32_t v1; + little_int16_t v0; + little_int32_t v1; char v3; // on a 32-bit system, the padding here may be 3 rather than 7 bytes - little_align_int64_t v4; + little_int64_t v4; }; int saved_err_count = err_count; @@ -605,295 +605,295 @@ namespace // aligned floating point types float big_float32_expected = (std::numeric_limits::max) (); boost::endian::big_endian(big_float32_expected); - big_align_float32_t big_float32((std::numeric_limits::max) ()); + big_float32_t big_float32((std::numeric_limits::max) ()); VERIFY(std::memcmp(big_float32.data(), reinterpret_cast(&big_float32_expected), sizeof(float)) == 0); float little_float32_expected = (std::numeric_limits::max) (); boost::endian::little_endian(little_float32_expected); - little_align_float32_t little_float32((std::numeric_limits::max) ()); + little_float32_t little_float32((std::numeric_limits::max) ()); VERIFY(std::memcmp(little_float32.data(), reinterpret_cast(&little_float32_expected), sizeof(float)) == 0); double big_float64_expected = (std::numeric_limits::max) (); boost::endian::big_endian(big_float64_expected); - big_align_float64_t big_float64((std::numeric_limits::max) ()); + big_float64_t big_float64((std::numeric_limits::max) ()); VERIFY(std::memcmp(big_float64.data(), reinterpret_cast(&big_float64_expected), sizeof(double)) == 0); double little_float64_expected = (std::numeric_limits::max) (); boost::endian::little_endian(little_float64_expected); - little_align_float64_t little_float64((std::numeric_limits::max) ()); + little_float64_t little_float64((std::numeric_limits::max) ()); VERIFY(std::memcmp(little_float64.data(), reinterpret_cast(&little_float64_expected), sizeof(double)) == 0); - VERIFY_VALUE_AND_OPS( big_align_float32_t, float, (std::numeric_limits::max) () ); - VERIFY_VALUE_AND_OPS( big_align_float32_t, float, (std::numeric_limits::min) () ); - VERIFY_VALUE_AND_OPS( big_align_float64_t, double, (std::numeric_limits::max) () ); - VERIFY_VALUE_AND_OPS( big_align_float64_t, double, (std::numeric_limits::min) () ); + VERIFY_VALUE_AND_OPS( big_float32_t, float, (std::numeric_limits::max) () ); + VERIFY_VALUE_AND_OPS( big_float32_t, float, (std::numeric_limits::min) () ); + VERIFY_VALUE_AND_OPS( big_float64_t, double, (std::numeric_limits::max) () ); + VERIFY_VALUE_AND_OPS( big_float64_t, double, (std::numeric_limits::min) () ); - VERIFY_VALUE_AND_OPS( little_align_float32_t, float, (std::numeric_limits::max) () ); - VERIFY_VALUE_AND_OPS( little_align_float32_t, float, (std::numeric_limits::min) () ); - VERIFY_VALUE_AND_OPS( little_align_float64_t, double, (std::numeric_limits::max) () ); - VERIFY_VALUE_AND_OPS( little_align_float64_t, double, (std::numeric_limits::min) () ); + VERIFY_VALUE_AND_OPS( little_float32_t, float, (std::numeric_limits::max) () ); + VERIFY_VALUE_AND_OPS( little_float32_t, float, (std::numeric_limits::min) () ); + VERIFY_VALUE_AND_OPS( little_float64_t, double, (std::numeric_limits::max) () ); + VERIFY_VALUE_AND_OPS( little_float64_t, double, (std::numeric_limits::min) () ); // unaligned floating point types float big_float32un_expected = (std::numeric_limits::max) (); boost::endian::big_endian(big_float32un_expected); - big_float32_t big_float32un((std::numeric_limits::max) ()); + big_float32_ut big_float32un((std::numeric_limits::max) ()); VERIFY(std::memcmp(big_float32un.data(), reinterpret_cast(&big_float32un_expected), sizeof(float)) == 0); float little_float32un_expected = (std::numeric_limits::max) (); boost::endian::little_endian(little_float32un_expected); - little_float32_t little_float32un((std::numeric_limits::max) ()); + little_float32_ut little_float32un((std::numeric_limits::max) ()); VERIFY(std::memcmp(little_float32un.data(), reinterpret_cast(&little_float32un_expected), sizeof(float)) == 0); double big_float64un_expected = (std::numeric_limits::max) (); boost::endian::big_endian(big_float64un_expected); - big_float64_t big_float64un((std::numeric_limits::max) ()); + big_float64_ut big_float64un((std::numeric_limits::max) ()); VERIFY(std::memcmp(big_float64un.data(), reinterpret_cast(&big_float64un_expected), sizeof(double)) == 0); double little_float64un_expected = (std::numeric_limits::max) (); boost::endian::little_endian(little_float64un_expected); - little_float64_t little_float64un((std::numeric_limits::max) ()); + little_float64_ut little_float64un((std::numeric_limits::max) ()); VERIFY(std::memcmp(little_float64un.data(), reinterpret_cast(&little_float64un_expected), sizeof(double)) == 0); - VERIFY_VALUE_AND_OPS( big_float32_t, float, (std::numeric_limits::max) () ); - VERIFY_VALUE_AND_OPS( big_float32_t, float, (std::numeric_limits::min) () ); - VERIFY_VALUE_AND_OPS( big_float64_t, double, (std::numeric_limits::max) () ); - VERIFY_VALUE_AND_OPS( big_float64_t, double, (std::numeric_limits::min) () ); + VERIFY_VALUE_AND_OPS( big_float32_ut, float, (std::numeric_limits::max) () ); + VERIFY_VALUE_AND_OPS( big_float32_ut, float, (std::numeric_limits::min) () ); + VERIFY_VALUE_AND_OPS( big_float64_ut, double, (std::numeric_limits::max) () ); + VERIFY_VALUE_AND_OPS( big_float64_ut, double, (std::numeric_limits::min) () ); - VERIFY_VALUE_AND_OPS( little_float32_t, float, (std::numeric_limits::max) () ); - VERIFY_VALUE_AND_OPS( little_float32_t, float, (std::numeric_limits::min) () ); - VERIFY_VALUE_AND_OPS( little_float64_t, double, (std::numeric_limits::max) () ); - VERIFY_VALUE_AND_OPS( little_float64_t, double, (std::numeric_limits::min) () ); + VERIFY_VALUE_AND_OPS( little_float32_ut, float, (std::numeric_limits::max) () ); + VERIFY_VALUE_AND_OPS( little_float32_ut, float, (std::numeric_limits::min) () ); + VERIFY_VALUE_AND_OPS( little_float64_ut, double, (std::numeric_limits::max) () ); + VERIFY_VALUE_AND_OPS( little_float64_ut, double, (std::numeric_limits::min) () ); float a = 1.0F; - big_align_float32_t b(1.0F); - big_float32_t c(1.0F); - little_align_float32_t d(1.0F); - little_float32_t e(1.0F); + big_float32_t b(1.0F); + big_float32_ut c(1.0F); + little_float32_t d(1.0F); + little_float32_ut e(1.0F); VERIFY(a==b); VERIFY(a==c); VERIFY(a==d); VERIFY(a==e); // unaligned integer types - VERIFY_BIG_REPRESENTATION( big_int8_t ); - VERIFY_VALUE_AND_OPS( big_int8_t, int_least8_t, 0x7f ); - VERIFY_VALUE_AND_OPS( big_int8_t, int_least8_t, -0x80 ); + VERIFY_BIG_REPRESENTATION( big_int8_ut ); + VERIFY_VALUE_AND_OPS( big_int8_ut, int_least8_t, 0x7f ); + VERIFY_VALUE_AND_OPS( big_int8_ut, int_least8_t, -0x80 ); + VERIFY_BIG_REPRESENTATION( big_int16_ut ); + VERIFY_VALUE_AND_OPS( big_int16_ut, int_least16_t, 0x7fff ); + VERIFY_VALUE_AND_OPS( big_int16_ut, int_least16_t, -0x8000 ); + + VERIFY_BIG_REPRESENTATION( big_int24_ut ); + VERIFY_VALUE_AND_OPS( big_int24_ut, int_least32_t, 0x7fffff ); + VERIFY_VALUE_AND_OPS( big_int24_ut, int_least32_t, -0x800000 ); + + VERIFY_BIG_REPRESENTATION( big_int32_ut ); + VERIFY_VALUE_AND_OPS( big_int32_ut, int_least32_t, 0x7fffffff ); + VERIFY_VALUE_AND_OPS( big_int32_ut, int_least32_t, -0x7fffffff-1 ); + + VERIFY_BIG_REPRESENTATION( big_int40_ut ); + VERIFY_VALUE_AND_OPS( big_int40_ut, int_least64_t, 0x7fffffffffLL ); + VERIFY_VALUE_AND_OPS( big_int40_ut, int_least64_t, -0x8000000000LL ); + + VERIFY_BIG_REPRESENTATION( big_int48_ut ); + VERIFY_VALUE_AND_OPS( big_int48_ut, int_least64_t, 0x7fffffffffffLL ); + VERIFY_VALUE_AND_OPS( big_int48_ut, int_least64_t, -0x800000000000LL ); + + VERIFY_BIG_REPRESENTATION( big_int56_ut ); + VERIFY_VALUE_AND_OPS( big_int56_ut, int_least64_t, 0x7fffffffffffffLL ); + VERIFY_VALUE_AND_OPS( big_int56_ut, int_least64_t, -0x80000000000000LL ); + + VERIFY_BIG_REPRESENTATION( big_int64_ut ); + VERIFY_VALUE_AND_OPS( big_int64_ut, int_least64_t, 0x7fffffffffffffffLL ); + VERIFY_VALUE_AND_OPS( big_int64_ut, int_least64_t, -0x7fffffffffffffffLL-1 ); + + VERIFY_BIG_REPRESENTATION( big_uint8_ut ); + VERIFY_VALUE_AND_OPS( big_uint8_ut, uint_least8_t, 0xff ); + + VERIFY_BIG_REPRESENTATION( big_uint16_ut ); + VERIFY_VALUE_AND_OPS( big_uint16_ut, uint_least16_t, 0xffff ); + + VERIFY_BIG_REPRESENTATION( big_uint24_ut ); + VERIFY_VALUE_AND_OPS( big_uint24_ut, uint_least32_t, 0xffffff ); + + VERIFY_BIG_REPRESENTATION( big_uint32_ut ); + VERIFY_VALUE_AND_OPS( big_uint32_ut, uint_least32_t, 0xffffffff ); + + VERIFY_BIG_REPRESENTATION( big_uint40_ut ); + VERIFY_VALUE_AND_OPS( big_uint40_ut, uint_least64_t, 0xffffffffffLL ); + + VERIFY_BIG_REPRESENTATION( big_uint48_ut ); + VERIFY_VALUE_AND_OPS( big_uint48_ut, uint_least64_t, 0xffffffffffffLL ); + + VERIFY_BIG_REPRESENTATION( big_uint56_ut ); + VERIFY_VALUE_AND_OPS( big_uint56_ut, uint_least64_t, 0xffffffffffffffLL ); + + VERIFY_BIG_REPRESENTATION( big_uint64_ut ); + VERIFY_VALUE_AND_OPS( big_uint64_ut, uint_least64_t, 0xffffffffffffffffULL ); + + VERIFY_LITTLE_REPRESENTATION( little_int8_ut ); + VERIFY_VALUE_AND_OPS( little_int8_ut, int_least8_t, 0x7f ); + VERIFY_VALUE_AND_OPS( little_int8_ut, int_least8_t, -0x80 ); + + VERIFY_LITTLE_REPRESENTATION( little_int16_ut ); + VERIFY_VALUE_AND_OPS( little_int16_ut, int_least16_t, 0x7fff ); + VERIFY_VALUE_AND_OPS( little_int16_ut, int_least16_t, -0x8000 ); + + VERIFY_LITTLE_REPRESENTATION( little_int24_ut ); + VERIFY_VALUE_AND_OPS( little_int24_ut, int_least32_t, 0x7fffff ); + VERIFY_VALUE_AND_OPS( little_int24_ut, int_least32_t, -0x800000 ); + + VERIFY_LITTLE_REPRESENTATION( little_int32_ut ); + VERIFY_VALUE_AND_OPS( little_int32_ut, int_least32_t, 0x7fffffff ); + VERIFY_VALUE_AND_OPS( little_int32_ut, int_least32_t, -0x7fffffff-1 ); + + VERIFY_LITTLE_REPRESENTATION( little_int40_ut ); + VERIFY_VALUE_AND_OPS( little_int40_ut, int_least64_t, 0x7fffffffffLL ); + VERIFY_VALUE_AND_OPS( little_int40_ut, int_least64_t, -0x8000000000LL ); + + VERIFY_LITTLE_REPRESENTATION( little_int48_ut ); + VERIFY_VALUE_AND_OPS( little_int48_ut, int_least64_t, 0x7fffffffffffLL ); + VERIFY_VALUE_AND_OPS( little_int48_ut, int_least64_t, -0x800000000000LL ); + + VERIFY_LITTLE_REPRESENTATION( little_int56_ut ); + VERIFY_VALUE_AND_OPS( little_int56_ut, int_least64_t, 0x7fffffffffffffLL ); + VERIFY_VALUE_AND_OPS( little_int56_ut, int_least64_t, -0x80000000000000LL ); + + VERIFY_LITTLE_REPRESENTATION( little_int64_ut ); + VERIFY_VALUE_AND_OPS( little_int64_ut, int_least64_t, 0x7fffffffffffffffLL ); + VERIFY_VALUE_AND_OPS( little_int64_ut, int_least64_t, -0x7fffffffffffffffLL-1 ); + + VERIFY_LITTLE_REPRESENTATION( little_uint8_ut ); + VERIFY_VALUE_AND_OPS( little_uint8_ut, uint_least8_t, 0xff ); + + VERIFY_LITTLE_REPRESENTATION( little_uint16_ut ); + VERIFY_VALUE_AND_OPS( little_uint16_ut, uint_least16_t, 0xffff ); + + VERIFY_LITTLE_REPRESENTATION( little_uint24_ut ); + VERIFY_VALUE_AND_OPS( little_uint24_ut, uint_least32_t, 0xffffff ); + + VERIFY_LITTLE_REPRESENTATION( little_uint32_ut ); + VERIFY_VALUE_AND_OPS( little_uint32_ut, uint_least32_t, 0xffffffff ); + + VERIFY_LITTLE_REPRESENTATION( little_uint40_ut ); + VERIFY_VALUE_AND_OPS( little_uint40_ut, uint_least64_t, 0xffffffffffLL ); + + VERIFY_LITTLE_REPRESENTATION( little_uint48_ut ); + VERIFY_VALUE_AND_OPS( little_uint48_ut, uint_least64_t, 0xffffffffffffLL ); + + VERIFY_LITTLE_REPRESENTATION( little_uint56_ut ); + VERIFY_VALUE_AND_OPS( little_uint56_ut, uint_least64_t, 0xffffffffffffffLL ); + + VERIFY_LITTLE_REPRESENTATION( little_uint64_ut ); + VERIFY_VALUE_AND_OPS( little_uint64_ut, uint_least64_t, 0xffffffffffffffffULL ); + + VERIFY_NATIVE_REPRESENTATION( native_int8_ut ); + VERIFY_VALUE_AND_OPS( native_int8_ut, int_least8_t, 0x7f ); + VERIFY_VALUE_AND_OPS( native_int8_ut, int_least8_t, -0x80 ); + + VERIFY_NATIVE_REPRESENTATION( native_int16_ut ); + VERIFY_VALUE_AND_OPS( native_int16_ut, int_least16_t, 0x7fff ); + VERIFY_VALUE_AND_OPS( native_int16_ut, int_least16_t, -0x8000 ); + + VERIFY_NATIVE_REPRESENTATION( native_int24_ut ); + VERIFY_VALUE_AND_OPS( native_int24_ut, int_least32_t, 0x7fffff ); + VERIFY_VALUE_AND_OPS( native_int24_ut, int_least32_t, -0x800000 ); + + VERIFY_NATIVE_REPRESENTATION( native_int32_ut ); + VERIFY_VALUE_AND_OPS( native_int32_ut, int_least32_t, 0x7fffffff ); + VERIFY_VALUE_AND_OPS( native_int32_ut, int_least32_t, -0x7fffffff-1 ); + + VERIFY_NATIVE_REPRESENTATION( native_int40_ut ); + VERIFY_VALUE_AND_OPS( native_int40_ut, int_least64_t, 0x7fffffffffLL ); + VERIFY_VALUE_AND_OPS( native_int40_ut, int_least64_t, -0x8000000000LL ); + + VERIFY_NATIVE_REPRESENTATION( native_int48_ut ); + VERIFY_VALUE_AND_OPS( native_int48_ut, int_least64_t, 0x7fffffffffffLL ); + VERIFY_VALUE_AND_OPS( native_int48_ut, int_least64_t, -0x800000000000LL ); + + VERIFY_NATIVE_REPRESENTATION( native_int56_ut ); + VERIFY_VALUE_AND_OPS( native_int56_ut, int_least64_t, 0x7fffffffffffffLL ); + VERIFY_VALUE_AND_OPS( native_int56_ut, int_least64_t, -0x80000000000000LL ); + + VERIFY_NATIVE_REPRESENTATION( native_int64_ut ); + VERIFY_VALUE_AND_OPS( native_int64_ut, int_least64_t, 0x7fffffffffffffffLL ); + VERIFY_VALUE_AND_OPS( native_int64_ut, int_least64_t, -0x7fffffffffffffffLL-1 ); + + VERIFY_NATIVE_REPRESENTATION( native_uint8_ut ); + VERIFY_VALUE_AND_OPS( native_uint8_ut, uint_least8_t, 0xff ); + + VERIFY_NATIVE_REPRESENTATION( native_uint16_ut ); + VERIFY_VALUE_AND_OPS( native_uint16_ut, uint_least16_t, 0xffff ); + + VERIFY_NATIVE_REPRESENTATION( native_uint24_ut ); + VERIFY_VALUE_AND_OPS( native_uint24_ut, uint_least32_t, 0xffffff ); + + VERIFY_NATIVE_REPRESENTATION( native_uint32_ut ); + VERIFY_VALUE_AND_OPS( native_uint32_ut, uint_least32_t, 0xffffffff ); + + VERIFY_NATIVE_REPRESENTATION( native_uint40_ut ); + VERIFY_VALUE_AND_OPS( native_uint40_ut, uint_least64_t, 0xffffffffffLL ); + + VERIFY_NATIVE_REPRESENTATION( native_uint48_ut ); + VERIFY_VALUE_AND_OPS( native_uint48_ut, uint_least64_t, 0xffffffffffffLL ); + + VERIFY_NATIVE_REPRESENTATION( native_uint56_ut ); + VERIFY_VALUE_AND_OPS( native_uint56_ut, uint_least64_t, 0xffffffffffffffLL ); + + VERIFY_NATIVE_REPRESENTATION( native_uint64_ut ); + VERIFY_VALUE_AND_OPS( native_uint64_ut, uint_least64_t, 0xffffffffffffffffULL ); + + // aligned integer types VERIFY_BIG_REPRESENTATION( big_int16_t ); VERIFY_VALUE_AND_OPS( big_int16_t, int_least16_t, 0x7fff ); VERIFY_VALUE_AND_OPS( big_int16_t, int_least16_t, -0x8000 ); - VERIFY_BIG_REPRESENTATION( big_int24_t ); - VERIFY_VALUE_AND_OPS( big_int24_t, int_least32_t, 0x7fffff ); - VERIFY_VALUE_AND_OPS( big_int24_t, int_least32_t, -0x800000 ); - VERIFY_BIG_REPRESENTATION( big_int32_t ); VERIFY_VALUE_AND_OPS( big_int32_t, int_least32_t, 0x7fffffff ); VERIFY_VALUE_AND_OPS( big_int32_t, int_least32_t, -0x7fffffff-1 ); - VERIFY_BIG_REPRESENTATION( big_int40_t ); - VERIFY_VALUE_AND_OPS( big_int40_t, int_least64_t, 0x7fffffffffLL ); - VERIFY_VALUE_AND_OPS( big_int40_t, int_least64_t, -0x8000000000LL ); - - VERIFY_BIG_REPRESENTATION( big_int48_t ); - VERIFY_VALUE_AND_OPS( big_int48_t, int_least64_t, 0x7fffffffffffLL ); - VERIFY_VALUE_AND_OPS( big_int48_t, int_least64_t, -0x800000000000LL ); - - VERIFY_BIG_REPRESENTATION( big_int56_t ); - VERIFY_VALUE_AND_OPS( big_int56_t, int_least64_t, 0x7fffffffffffffLL ); - VERIFY_VALUE_AND_OPS( big_int56_t, int_least64_t, -0x80000000000000LL ); - VERIFY_BIG_REPRESENTATION( big_int64_t ); VERIFY_VALUE_AND_OPS( big_int64_t, int_least64_t, 0x7fffffffffffffffLL ); VERIFY_VALUE_AND_OPS( big_int64_t, int_least64_t, -0x7fffffffffffffffLL-1 ); - VERIFY_BIG_REPRESENTATION( big_uint8_t ); - VERIFY_VALUE_AND_OPS( big_uint8_t, uint_least8_t, 0xff ); - VERIFY_BIG_REPRESENTATION( big_uint16_t ); VERIFY_VALUE_AND_OPS( big_uint16_t, uint_least16_t, 0xffff ); - VERIFY_BIG_REPRESENTATION( big_uint24_t ); - VERIFY_VALUE_AND_OPS( big_uint24_t, uint_least32_t, 0xffffff ); - VERIFY_BIG_REPRESENTATION( big_uint32_t ); VERIFY_VALUE_AND_OPS( big_uint32_t, uint_least32_t, 0xffffffff ); - VERIFY_BIG_REPRESENTATION( big_uint40_t ); - VERIFY_VALUE_AND_OPS( big_uint40_t, uint_least64_t, 0xffffffffffLL ); - - VERIFY_BIG_REPRESENTATION( big_uint48_t ); - VERIFY_VALUE_AND_OPS( big_uint48_t, uint_least64_t, 0xffffffffffffLL ); - - VERIFY_BIG_REPRESENTATION( big_uint56_t ); - VERIFY_VALUE_AND_OPS( big_uint56_t, uint_least64_t, 0xffffffffffffffLL ); - VERIFY_BIG_REPRESENTATION( big_uint64_t ); VERIFY_VALUE_AND_OPS( big_uint64_t, uint_least64_t, 0xffffffffffffffffULL ); - VERIFY_LITTLE_REPRESENTATION( little_int8_t ); - VERIFY_VALUE_AND_OPS( little_int8_t, int_least8_t, 0x7f ); - VERIFY_VALUE_AND_OPS( little_int8_t, int_least8_t, -0x80 ); - VERIFY_LITTLE_REPRESENTATION( little_int16_t ); VERIFY_VALUE_AND_OPS( little_int16_t, int_least16_t, 0x7fff ); VERIFY_VALUE_AND_OPS( little_int16_t, int_least16_t, -0x8000 ); - VERIFY_LITTLE_REPRESENTATION( little_int24_t ); - VERIFY_VALUE_AND_OPS( little_int24_t, int_least32_t, 0x7fffff ); - VERIFY_VALUE_AND_OPS( little_int24_t, int_least32_t, -0x800000 ); - VERIFY_LITTLE_REPRESENTATION( little_int32_t ); VERIFY_VALUE_AND_OPS( little_int32_t, int_least32_t, 0x7fffffff ); VERIFY_VALUE_AND_OPS( little_int32_t, int_least32_t, -0x7fffffff-1 ); - VERIFY_LITTLE_REPRESENTATION( little_int40_t ); - VERIFY_VALUE_AND_OPS( little_int40_t, int_least64_t, 0x7fffffffffLL ); - VERIFY_VALUE_AND_OPS( little_int40_t, int_least64_t, -0x8000000000LL ); - - VERIFY_LITTLE_REPRESENTATION( little_int48_t ); - VERIFY_VALUE_AND_OPS( little_int48_t, int_least64_t, 0x7fffffffffffLL ); - VERIFY_VALUE_AND_OPS( little_int48_t, int_least64_t, -0x800000000000LL ); - - VERIFY_LITTLE_REPRESENTATION( little_int56_t ); - VERIFY_VALUE_AND_OPS( little_int56_t, int_least64_t, 0x7fffffffffffffLL ); - VERIFY_VALUE_AND_OPS( little_int56_t, int_least64_t, -0x80000000000000LL ); - VERIFY_LITTLE_REPRESENTATION( little_int64_t ); VERIFY_VALUE_AND_OPS( little_int64_t, int_least64_t, 0x7fffffffffffffffLL ); VERIFY_VALUE_AND_OPS( little_int64_t, int_least64_t, -0x7fffffffffffffffLL-1 ); - VERIFY_LITTLE_REPRESENTATION( little_uint8_t ); - VERIFY_VALUE_AND_OPS( little_uint8_t, uint_least8_t, 0xff ); - VERIFY_LITTLE_REPRESENTATION( little_uint16_t ); VERIFY_VALUE_AND_OPS( little_uint16_t, uint_least16_t, 0xffff ); - VERIFY_LITTLE_REPRESENTATION( little_uint24_t ); - VERIFY_VALUE_AND_OPS( little_uint24_t, uint_least32_t, 0xffffff ); - VERIFY_LITTLE_REPRESENTATION( little_uint32_t ); VERIFY_VALUE_AND_OPS( little_uint32_t, uint_least32_t, 0xffffffff ); - VERIFY_LITTLE_REPRESENTATION( little_uint40_t ); - VERIFY_VALUE_AND_OPS( little_uint40_t, uint_least64_t, 0xffffffffffLL ); - - VERIFY_LITTLE_REPRESENTATION( little_uint48_t ); - VERIFY_VALUE_AND_OPS( little_uint48_t, uint_least64_t, 0xffffffffffffLL ); - - VERIFY_LITTLE_REPRESENTATION( little_uint56_t ); - VERIFY_VALUE_AND_OPS( little_uint56_t, uint_least64_t, 0xffffffffffffffLL ); - VERIFY_LITTLE_REPRESENTATION( little_uint64_t ); VERIFY_VALUE_AND_OPS( little_uint64_t, uint_least64_t, 0xffffffffffffffffULL ); - VERIFY_NATIVE_REPRESENTATION( native_int8_t ); - VERIFY_VALUE_AND_OPS( native_int8_t, int_least8_t, 0x7f ); - VERIFY_VALUE_AND_OPS( native_int8_t, int_least8_t, -0x80 ); - - VERIFY_NATIVE_REPRESENTATION( native_int16_t ); - VERIFY_VALUE_AND_OPS( native_int16_t, int_least16_t, 0x7fff ); - VERIFY_VALUE_AND_OPS( native_int16_t, int_least16_t, -0x8000 ); - - VERIFY_NATIVE_REPRESENTATION( native_int24_t ); - VERIFY_VALUE_AND_OPS( native_int24_t, int_least32_t, 0x7fffff ); - VERIFY_VALUE_AND_OPS( native_int24_t, int_least32_t, -0x800000 ); - - VERIFY_NATIVE_REPRESENTATION( native_int32_t ); - VERIFY_VALUE_AND_OPS( native_int32_t, int_least32_t, 0x7fffffff ); - VERIFY_VALUE_AND_OPS( native_int32_t, int_least32_t, -0x7fffffff-1 ); - - VERIFY_NATIVE_REPRESENTATION( native_int40_t ); - VERIFY_VALUE_AND_OPS( native_int40_t, int_least64_t, 0x7fffffffffLL ); - VERIFY_VALUE_AND_OPS( native_int40_t, int_least64_t, -0x8000000000LL ); - - VERIFY_NATIVE_REPRESENTATION( native_int48_t ); - VERIFY_VALUE_AND_OPS( native_int48_t, int_least64_t, 0x7fffffffffffLL ); - VERIFY_VALUE_AND_OPS( native_int48_t, int_least64_t, -0x800000000000LL ); - - VERIFY_NATIVE_REPRESENTATION( native_int56_t ); - VERIFY_VALUE_AND_OPS( native_int56_t, int_least64_t, 0x7fffffffffffffLL ); - VERIFY_VALUE_AND_OPS( native_int56_t, int_least64_t, -0x80000000000000LL ); - - VERIFY_NATIVE_REPRESENTATION( native_int64_t ); - VERIFY_VALUE_AND_OPS( native_int64_t, int_least64_t, 0x7fffffffffffffffLL ); - VERIFY_VALUE_AND_OPS( native_int64_t, int_least64_t, -0x7fffffffffffffffLL-1 ); - - VERIFY_NATIVE_REPRESENTATION( native_uint8_t ); - VERIFY_VALUE_AND_OPS( native_uint8_t, uint_least8_t, 0xff ); - - VERIFY_NATIVE_REPRESENTATION( native_uint16_t ); - VERIFY_VALUE_AND_OPS( native_uint16_t, uint_least16_t, 0xffff ); - - VERIFY_NATIVE_REPRESENTATION( native_uint24_t ); - VERIFY_VALUE_AND_OPS( native_uint24_t, uint_least32_t, 0xffffff ); - - VERIFY_NATIVE_REPRESENTATION( native_uint32_t ); - VERIFY_VALUE_AND_OPS( native_uint32_t, uint_least32_t, 0xffffffff ); - - VERIFY_NATIVE_REPRESENTATION( native_uint40_t ); - VERIFY_VALUE_AND_OPS( native_uint40_t, uint_least64_t, 0xffffffffffLL ); - - VERIFY_NATIVE_REPRESENTATION( native_uint48_t ); - VERIFY_VALUE_AND_OPS( native_uint48_t, uint_least64_t, 0xffffffffffffLL ); - - VERIFY_NATIVE_REPRESENTATION( native_uint56_t ); - VERIFY_VALUE_AND_OPS( native_uint56_t, uint_least64_t, 0xffffffffffffffLL ); - - VERIFY_NATIVE_REPRESENTATION( native_uint64_t ); - VERIFY_VALUE_AND_OPS( native_uint64_t, uint_least64_t, 0xffffffffffffffffULL ); - - // aligned integer types - VERIFY_BIG_REPRESENTATION( big_align_int16_t ); - VERIFY_VALUE_AND_OPS( big_align_int16_t, int_least16_t, 0x7fff ); - VERIFY_VALUE_AND_OPS( big_align_int16_t, int_least16_t, -0x8000 ); - - VERIFY_BIG_REPRESENTATION( big_align_int32_t ); - VERIFY_VALUE_AND_OPS( big_align_int32_t, int_least32_t, 0x7fffffff ); - VERIFY_VALUE_AND_OPS( big_align_int32_t, int_least32_t, -0x7fffffff-1 ); - - VERIFY_BIG_REPRESENTATION( big_align_int64_t ); - VERIFY_VALUE_AND_OPS( big_align_int64_t, int_least64_t, 0x7fffffffffffffffLL ); - VERIFY_VALUE_AND_OPS( big_align_int64_t, int_least64_t, -0x7fffffffffffffffLL-1 ); - - VERIFY_BIG_REPRESENTATION( big_align_uint16_t ); - VERIFY_VALUE_AND_OPS( big_align_uint16_t, uint_least16_t, 0xffff ); - - VERIFY_BIG_REPRESENTATION( big_align_uint32_t ); - VERIFY_VALUE_AND_OPS( big_align_uint32_t, uint_least32_t, 0xffffffff ); - - VERIFY_BIG_REPRESENTATION( big_align_uint64_t ); - VERIFY_VALUE_AND_OPS( big_align_uint64_t, uint_least64_t, 0xffffffffffffffffULL ); - - VERIFY_LITTLE_REPRESENTATION( little_align_int16_t ); - VERIFY_VALUE_AND_OPS( little_align_int16_t, int_least16_t, 0x7fff ); - VERIFY_VALUE_AND_OPS( little_align_int16_t, int_least16_t, -0x8000 ); - - VERIFY_LITTLE_REPRESENTATION( little_align_int32_t ); - VERIFY_VALUE_AND_OPS( little_align_int32_t, int_least32_t, 0x7fffffff ); - VERIFY_VALUE_AND_OPS( little_align_int32_t, int_least32_t, -0x7fffffff-1 ); - - VERIFY_LITTLE_REPRESENTATION( little_align_int64_t ); - VERIFY_VALUE_AND_OPS( little_align_int64_t, int_least64_t, 0x7fffffffffffffffLL ); - VERIFY_VALUE_AND_OPS( little_align_int64_t, int_least64_t, -0x7fffffffffffffffLL-1 ); - - VERIFY_LITTLE_REPRESENTATION( little_align_uint16_t ); - VERIFY_VALUE_AND_OPS( little_align_uint16_t, uint_least16_t, 0xffff ); - - VERIFY_LITTLE_REPRESENTATION( little_align_uint32_t ); - VERIFY_VALUE_AND_OPS( little_align_uint32_t, uint_least32_t, 0xffffffff ); - - VERIFY_LITTLE_REPRESENTATION( little_align_uint64_t ); - VERIFY_VALUE_AND_OPS( little_align_uint64_t, uint_least64_t, 0xffffffffffffffffULL ); - } // check_representation_and_range class MyInt @@ -908,9 +908,9 @@ namespace void check_udt() { - typedef boost::endian::endian< order::big, MyInt, 32 > mybig_int32_t; + typedef boost::endian::endian_arithmetic< order::big, MyInt, 32 > mybig_int32_ut; - mybig_int32_t v(10); + mybig_int32_ut v(10); cout << "+v is " << +v << endl; v += 1; cout << "v is " << +v << endl; @@ -966,10 +966,10 @@ int cpp_main( int argc, char * argv[] ) check_data(); check_udt(); - //timing_test ( "big_int32_t" ); - //timing_test( "big_align_int32_t" ); - //timing_test ( "little_int32_t" ); - //timing_test( "little_align_int32_t" ); + //timing_test ( "big_int32_ut" ); + //timing_test( "big_int32_t" ); + //timing_test ( "little_int32_ut" ); + //timing_test( "little_int32_t" ); cout << "\n" << err_count << " errors detected\nTest " << (err_count==0 ? "passed\n\n" : "failed\n\n"); diff --git a/test/loop_time_test.cpp b/test/loop_time_test.cpp index 3d949b7..0c8c67f 100644 --- a/test/loop_time_test.cpp +++ b/test/loop_time_test.cpp @@ -15,7 +15,7 @@ #include #include -#include +#include #include #include #include @@ -119,84 +119,84 @@ namespace void test_big_align_int16() { cout << "16-bit aligned big endian"; - time(); + time(); cout << "\n"; } void test_little_align_int16() { cout << "16-bit aligned little endian"; - time(); + time(); cout << "\n"; } void test_big_int16() { cout << "16-bit unaligned big endian"; - time(); + time(); cout << "\n"; } void test_little_int16() { cout << "16-bit unaligned little endian"; - time(); + time(); cout << "\n"; } void test_big_align_int32() { cout << "32-bit aligned big endian"; - time(); + time(); cout << "\n"; } void test_little_align_int32() { cout << "32-bit aligned little endian"; - time(); + time(); cout << "\n"; } void test_big_int32() { cout << "32-bit unaligned big endian"; - time(); + time(); cout << "\n"; } void test_little_int32() { cout << "32-bit unaligned little endian"; - time(); + time(); cout << "\n"; } void test_big_align_int64() { cout << "64-bit aligned big endian"; - time(); + time(); cout << "\n"; } void test_little_align_int64() { cout << "64-bit aligned little endian"; - time(); + time(); cout << "\n"; } void test_big_int64() { cout << "64-bit unaligned big endian"; - time(); + time(); cout << "\n"; } void test_little_int64() { cout << "64-bit unaligned little endian"; - time(); + time(); cout << "\n"; } diff --git a/test/msvc/endian.sln b/test/msvc/endian.sln index 82d0960..38875dd 100644 --- a/test/msvc/endian.sln +++ b/test/msvc/endian.sln @@ -128,7 +128,6 @@ Global {BFB68CF4-EB92-4E5C-9694-A939496C5CDE}.Release|Win32.Build.0 = Release|Win32 {BFB68CF4-EB92-4E5C-9694-A939496C5CDE}.Release|x64.ActiveCfg = Release|Win32 {36BF451A-EAEF-4140-92E4-6EA461A26107}.Debug|Win32.ActiveCfg = Debug|Win32 - {36BF451A-EAEF-4140-92E4-6EA461A26107}.Debug|Win32.Build.0 = Debug|Win32 {36BF451A-EAEF-4140-92E4-6EA461A26107}.Debug|x64.ActiveCfg = Debug|Win32 {36BF451A-EAEF-4140-92E4-6EA461A26107}.Release|Win32.ActiveCfg = Release|Win32 {36BF451A-EAEF-4140-92E4-6EA461A26107}.Release|Win32.Build.0 = Release|Win32 diff --git a/test/speed_test.cpp b/test/speed_test.cpp index 760aa88..c8adfc2 100644 --- a/test/speed_test.cpp +++ b/test/speed_test.cpp @@ -16,7 +16,7 @@ #include "speed_test_functions.hpp" #include -#include +#include #include #include #include @@ -96,63 +96,63 @@ namespace cout << "" << t.format(places, "%t") << " s"; } - void test_big_align_int16() + void test_big_int16() { cout << "16-bit aligned big endian"; - time(user::return_x_big_align_int16); - time(user::return_x_value_big_align_int16); - time(user::return_x_in_place_big_align_int16); - time(user::return_x_big_align_int16); + time(user::return_x_big_int16); + time(user::return_x_value_big_int16); + time(user::return_x_in_place_big_int16); + time(user::return_x_big_int16); cout << "\n"; } - void test_little_align_int16() + void test_little_int16() { cout << "16-bit aligned little endian"; - time(user::return_x_little_align_int16); - time(user::return_x_value_little_align_int16); - time(user::return_x_in_place_little_align_int16); - time(user::return_x_little_align_int16); + time(user::return_x_little_int16); + time(user::return_x_value_little_int16); + time(user::return_x_in_place_little_int16); + time(user::return_x_little_int16); cout << "\n"; } - void test_big_align_int32() + void test_big_int32() { cout << "32-bit aligned big endian"; - time(user::return_x_big_align_int32); - time(user::return_x_value_big_align_int32); - time(user::return_x_in_place_big_align_int32); - time(user::return_x_big_align_int32); + time(user::return_x_big_int32); + time(user::return_x_value_big_int32); + time(user::return_x_in_place_big_int32); + time(user::return_x_big_int32); cout << "\n"; } - void test_little_align_int32() + void test_little_int32() { cout << "32-bit aligned little endian"; - time(user::return_x_little_align_int32); - time(user::return_x_value_little_align_int32); - time(user::return_x_in_place_little_align_int32); - time(user::return_x_little_align_int32); + time(user::return_x_little_int32); + time(user::return_x_value_little_int32); + time(user::return_x_in_place_little_int32); + time(user::return_x_little_int32); cout << "\n"; } - void test_big_align_int64() + void test_big_int64() { cout << "64-bit aligned big endian"; - time(user::return_x_big_align_int64); - time(user::return_x_value_big_align_int64); - time(user::return_x_in_place_big_align_int64); - time(user::return_x_big_align_int64); + time(user::return_x_big_int64); + time(user::return_x_value_big_int64); + time(user::return_x_in_place_big_int64); + time(user::return_x_big_int64); cout << "\n"; } - void test_little_align_int64() + void test_little_int64() { cout << "64-bit aligned little endian"; - time(user::return_x_little_align_int64); - time(user::return_x_value_little_align_int64); - time(user::return_x_in_place_little_align_int64); - time(user::return_x_little_align_int64); + time(user::return_x_little_int64); + time(user::return_x_value_little_int64); + time(user::return_x_in_place_little_int64); + time(user::return_x_little_int64); cout << "\n"; } @@ -182,12 +182,12 @@ int cpp_main(int argc, char* argv[]) "\n" ; - test_big_align_int16(); - test_little_align_int16(); - test_big_align_int32(); - test_little_align_int32(); - test_big_align_int64(); - test_little_align_int64(); + test_big_int16(); + test_little_int16(); + test_big_int32(); + test_little_int32(); + test_big_int64(); + test_little_int64(); cout << "\n\n\n\n"; diff --git a/test/speed_test_functions.cpp b/test/speed_test_functions.cpp index 3c578a5..95904ff 100644 --- a/test/speed_test_functions.cpp +++ b/test/speed_test_functions.cpp @@ -1,5 +1,5 @@ // speed_test_functions.cpp ----------------------------------------------------------// - + // Copyright Beman Dawes 2013 // Distributed under the Boost Software License, Version 1.0. @@ -20,31 +20,31 @@ namespace user { - int16_t return_x_big_align_int16(int16_t x, big_align_int16_t) BOOST_NOEXCEPT {return x;} - int16_t return_x_little_align_int16(int16_t x, little_align_int16_t) BOOST_NOEXCEPT {return x;} - int16_t return_x_value_big_align_int16(int16_t x, big_align_int16_t) BOOST_NOEXCEPT {return big_endian_value(x);} - int16_t return_x_value_little_align_int16(int16_t x, little_align_int16_t) BOOST_NOEXCEPT {return little_endian_value(x);} - int16_t return_x_in_place_big_align_int16(int16_t x, big_align_int16_t) BOOST_NOEXCEPT {big_endian(x);return x;} - int16_t return_x_in_place_little_align_int16(int16_t x, little_align_int16_t) BOOST_NOEXCEPT {little_endian(x);return x;} - int16_t return_y_big_align_int16(int16_t x, big_align_int16_t y) BOOST_NOEXCEPT {return y;} - int16_t return_y_little_align_int16(int16_t x, little_align_int16_t y) BOOST_NOEXCEPT {return y;} + int16_t return_x_big_int16(int16_t x, big_int16_t) BOOST_NOEXCEPT {return x;} + int16_t return_x_little_int16(int16_t x, little_int16_t) BOOST_NOEXCEPT {return x;} + int16_t return_x_value_big_int16(int16_t x, big_int16_t) BOOST_NOEXCEPT {return big_endian_value(x);} + int16_t return_x_value_little_int16(int16_t x, little_int16_t) BOOST_NOEXCEPT {return little_endian_value(x);} + int16_t return_x_in_place_big_int16(int16_t x, big_int16_t) BOOST_NOEXCEPT {big_endian(x);return x;} + int16_t return_x_in_place_little_int16(int16_t x, little_int16_t) BOOST_NOEXCEPT {little_endian(x);return x;} + int16_t return_y_big_int16(int16_t x, big_int16_t y) BOOST_NOEXCEPT {return y;} + int16_t return_y_little_int16(int16_t x, little_int16_t y) BOOST_NOEXCEPT {return y;} - int32_t return_x_big_align_int32(int32_t x, big_align_int32_t) BOOST_NOEXCEPT {return x;} - int32_t return_x_little_align_int32(int32_t x, little_align_int32_t) BOOST_NOEXCEPT {return x;} - int32_t return_x_value_big_align_int32(int32_t x, big_align_int32_t) BOOST_NOEXCEPT {return big_endian_value(x);} - int32_t return_x_value_little_align_int32(int32_t x, little_align_int32_t) BOOST_NOEXCEPT {return little_endian_value(x);} - int32_t return_x_in_place_big_align_int32(int32_t x, big_align_int32_t) BOOST_NOEXCEPT {big_endian(x);return x;} - int32_t return_x_in_place_little_align_int32(int32_t x, little_align_int32_t) BOOST_NOEXCEPT {little_endian(x);return x;} - int32_t return_y_big_align_int32(int32_t x, big_align_int32_t y) BOOST_NOEXCEPT {return y;} - int32_t return_y_little_align_int32(int32_t x, little_align_int32_t y) BOOST_NOEXCEPT {return y;} + int32_t return_x_big_int32(int32_t x, big_int32_t) BOOST_NOEXCEPT {return x;} + int32_t return_x_little_int32(int32_t x, little_int32_t) BOOST_NOEXCEPT {return x;} + int32_t return_x_value_big_int32(int32_t x, big_int32_t) BOOST_NOEXCEPT {return big_endian_value(x);} + int32_t return_x_value_little_int32(int32_t x, little_int32_t) BOOST_NOEXCEPT {return little_endian_value(x);} + int32_t return_x_in_place_big_int32(int32_t x, big_int32_t) BOOST_NOEXCEPT {big_endian(x);return x;} + int32_t return_x_in_place_little_int32(int32_t x, little_int32_t) BOOST_NOEXCEPT {little_endian(x);return x;} + int32_t return_y_big_int32(int32_t x, big_int32_t y) BOOST_NOEXCEPT {return y;} + int32_t return_y_little_int32(int32_t x, little_int32_t y) BOOST_NOEXCEPT {return y;} - int64_t return_x_big_align_int64(int64_t x, big_align_int64_t) BOOST_NOEXCEPT {return x;} - int64_t return_x_little_align_int64(int64_t x, little_align_int64_t) BOOST_NOEXCEPT {return x;} - int64_t return_x_value_big_align_int64(int64_t x, big_align_int64_t) BOOST_NOEXCEPT {return big_endian_value(x);} - int64_t return_x_value_little_align_int64(int64_t x, little_align_int64_t) BOOST_NOEXCEPT {return little_endian_value(x);} - int64_t return_x_in_place_big_align_int64(int64_t x, big_align_int64_t) BOOST_NOEXCEPT {big_endian(x);return x;} - int64_t return_x_in_place_little_align_int64(int64_t x, little_align_int64_t) BOOST_NOEXCEPT {little_endian(x);return x;} - int64_t return_y_big_align_int64(int64_t x, big_align_int64_t y) BOOST_NOEXCEPT {return y;} - int64_t return_y_little_align_int64(int64_t x, little_align_int64_t y) BOOST_NOEXCEPT {return y;} + int64_t return_x_big_int64(int64_t x, big_int64_t) BOOST_NOEXCEPT {return x;} + int64_t return_x_little_int64(int64_t x, little_int64_t) BOOST_NOEXCEPT {return x;} + int64_t return_x_value_big_int64(int64_t x, big_int64_t) BOOST_NOEXCEPT {return big_endian_value(x);} + int64_t return_x_value_little_int64(int64_t x, little_int64_t) BOOST_NOEXCEPT {return little_endian_value(x);} + int64_t return_x_in_place_big_int64(int64_t x, big_int64_t) BOOST_NOEXCEPT {big_endian(x);return x;} + int64_t return_x_in_place_little_int64(int64_t x, little_int64_t) BOOST_NOEXCEPT {little_endian(x);return x;} + int64_t return_y_big_int64(int64_t x, big_int64_t y) BOOST_NOEXCEPT {return y;} + int64_t return_y_little_int64(int64_t x, little_int64_t y) BOOST_NOEXCEPT {return y;} } diff --git a/test/speed_test_functions.hpp b/test/speed_test_functions.hpp index 3bc5416..4c1aa33 100644 --- a/test/speed_test_functions.hpp +++ b/test/speed_test_functions.hpp @@ -17,39 +17,39 @@ #define BOOST_ENDIAN_SPEED_TEST_FUNCTIONS_HPP #include -#include +#include namespace user { using namespace boost; using namespace boost::endian; - int16_t return_x_big_align_int16(int16_t x, big_align_int16_t y) BOOST_NOEXCEPT; - int16_t return_x_little_align_int16(int16_t x, little_align_int16_t y) BOOST_NOEXCEPT; - int16_t return_x_value_big_align_int16(int16_t x, big_align_int16_t) BOOST_NOEXCEPT; - int16_t return_x_value_little_align_int16(int16_t x, little_align_int16_t y) BOOST_NOEXCEPT; - int16_t return_x_in_place_big_align_int16(int16_t x, big_align_int16_t y) BOOST_NOEXCEPT; - int16_t return_x_in_place_little_align_int16(int16_t x, little_align_int16_t y) BOOST_NOEXCEPT; - int16_t return_y_big_align_int16(int16_t x, big_align_int16_t y) BOOST_NOEXCEPT; - int16_t return_y_little_align_int16(int16_t x, little_align_int16_t y) BOOST_NOEXCEPT; + int16_t return_x_big_int16(int16_t x, big_int16_t y) BOOST_NOEXCEPT; + int16_t return_x_little_int16(int16_t x, little_int16_t y) BOOST_NOEXCEPT; + int16_t return_x_value_big_int16(int16_t x, big_int16_t) BOOST_NOEXCEPT; + int16_t return_x_value_little_int16(int16_t x, little_int16_t y) BOOST_NOEXCEPT; + int16_t return_x_in_place_big_int16(int16_t x, big_int16_t y) BOOST_NOEXCEPT; + int16_t return_x_in_place_little_int16(int16_t x, little_int16_t y) BOOST_NOEXCEPT; + int16_t return_y_big_int16(int16_t x, big_int16_t y) BOOST_NOEXCEPT; + int16_t return_y_little_int16(int16_t x, little_int16_t y) BOOST_NOEXCEPT; - int32_t return_x_big_align_int32(int32_t x, big_align_int32_t y) BOOST_NOEXCEPT; - int32_t return_x_little_align_int32(int32_t x, little_align_int32_t y) BOOST_NOEXCEPT; - int32_t return_x_value_big_align_int32(int32_t x, big_align_int32_t) BOOST_NOEXCEPT; - int32_t return_x_value_little_align_int32(int32_t x, little_align_int32_t y) BOOST_NOEXCEPT; - int32_t return_x_in_place_big_align_int32(int32_t x, big_align_int32_t y) BOOST_NOEXCEPT; - int32_t return_x_in_place_little_align_int32(int32_t x, little_align_int32_t y) BOOST_NOEXCEPT; - int32_t return_y_big_align_int32(int32_t x, big_align_int32_t y) BOOST_NOEXCEPT; - int32_t return_y_little_align_int32(int32_t x, little_align_int32_t y) BOOST_NOEXCEPT; + int32_t return_x_big_int32(int32_t x, big_int32_t y) BOOST_NOEXCEPT; + int32_t return_x_little_int32(int32_t x, little_int32_t y) BOOST_NOEXCEPT; + int32_t return_x_value_big_int32(int32_t x, big_int32_t) BOOST_NOEXCEPT; + int32_t return_x_value_little_int32(int32_t x, little_int32_t y) BOOST_NOEXCEPT; + int32_t return_x_in_place_big_int32(int32_t x, big_int32_t y) BOOST_NOEXCEPT; + int32_t return_x_in_place_little_int32(int32_t x, little_int32_t y) BOOST_NOEXCEPT; + int32_t return_y_big_int32(int32_t x, big_int32_t y) BOOST_NOEXCEPT; + int32_t return_y_little_int32(int32_t x, little_int32_t y) BOOST_NOEXCEPT; - int64_t return_x_big_align_int64(int64_t x, big_align_int64_t y) BOOST_NOEXCEPT; - int64_t return_x_little_align_int64(int64_t x, little_align_int64_t y) BOOST_NOEXCEPT; - int64_t return_x_value_big_align_int64(int64_t x, big_align_int64_t) BOOST_NOEXCEPT; - int64_t return_x_value_little_align_int64(int64_t x, little_align_int64_t y) BOOST_NOEXCEPT; - int64_t return_x_in_place_big_align_int64(int64_t x, big_align_int64_t y) BOOST_NOEXCEPT; - int64_t return_x_in_place_little_align_int64(int64_t x, little_align_int64_t y) BOOST_NOEXCEPT; - int64_t return_y_big_align_int64(int64_t x, big_align_int64_t y) BOOST_NOEXCEPT; - int64_t return_y_little_align_int64(int64_t x, little_align_int64_t y) BOOST_NOEXCEPT; + int64_t return_x_big_int64(int64_t x, big_int64_t y) BOOST_NOEXCEPT; + int64_t return_x_little_int64(int64_t x, little_int64_t y) BOOST_NOEXCEPT; + int64_t return_x_value_big_int64(int64_t x, big_int64_t) BOOST_NOEXCEPT; + int64_t return_x_value_little_int64(int64_t x, little_int64_t y) BOOST_NOEXCEPT; + int64_t return_x_in_place_big_int64(int64_t x, big_int64_t y) BOOST_NOEXCEPT; + int64_t return_x_in_place_little_int64(int64_t x, little_int64_t y) BOOST_NOEXCEPT; + int64_t return_y_big_int64(int64_t x, big_int64_t y) BOOST_NOEXCEPT; + int64_t return_y_little_int64(int64_t x, little_int64_t y) BOOST_NOEXCEPT; }