From fc7733ade17d534427735c742046792e66464fd7 Mon Sep 17 00:00:00 2001 From: Beman Date: Wed, 19 Nov 2014 10:53:11 -0500 Subject: [PATCH] Major renaming. Class "endian" becomes class "endian_arithmetic" to mimic the C++ standard's description of such types as "arithmetic types". Rename header accordingly. The convenience typedefs have been changed shorten aligned names, as they are often being, but keeping the unaligned type names relatively short via a simple "_ut" suffix. --- example/endian_example.cpp | 2 +- example/use_cases.cpp | 2 +- include/boost/endian/arithmetic.hpp | 438 +++++++++++++++ include/boost/endian/buffers.hpp | 176 +++---- include/boost/endian/types.hpp | 438 --------------- test/endian_in_union_test.cpp | 98 ++-- test/endian_operations_test.cpp | 232 ++++---- test/endian_test.cpp | 792 ++++++++++++++-------------- test/loop_time_test.cpp | 26 +- test/msvc/endian.sln | 1 - test/speed_test.cpp | 74 +-- test/speed_test_functions.cpp | 50 +- test/speed_test_functions.hpp | 50 +- 13 files changed, 1189 insertions(+), 1190 deletions(-) create mode 100644 include/boost/endian/arithmetic.hpp delete mode 100644 include/boost/endian/types.hpp 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; }