From 016d3b2e7c8ef0c9171ca4b24c8703628a6bf756 Mon Sep 17 00:00:00 2001 From: Beman Date: Sun, 1 Sep 2013 08:40:32 -0400 Subject: [PATCH] Rename the endian typedefs. Rationale: Subjective - during three months working on the B-tree library, the *un_t names were a constant source of irritation. Objective - the new scheme, which reverts the *un_t names to having no alignment decoration, provides consistent *_align* decoration for both FP and integer types. Also, the library now provides conversion functions which may reduce use of aligned endian types. --- doc/types.html | 270 +++++----- include/boost/endian/conversion.hpp | 2 +- include/boost/endian/types.hpp | 136 ++--- test/endian_in_union_test.cpp | 96 ++-- test/endian_operations_test.cpp | 224 ++++---- test/endian_test.cpp | 800 ++++++++++++++-------------- test/loop_time_test.cpp | 108 ++-- test/speed_test.cpp | 72 +-- test/speed_test_functions.cpp | 48 +- test/speed_test_functions.hpp | 48 +- 10 files changed, 902 insertions(+), 902 deletions(-) diff --git a/doc/types.html b/doc/types.html index e9c227f..18720a2 100644 --- a/doc/types.html +++ b/doc/types.html @@ -227,98 +227,98 @@ conventions for common use cases:

Alignment - big_intn_t + big_align_intn_t big signed 16,32,64 yes - big_uintn_t + big_align_uintn_t big unsigned 16,32,64 yes + + big_align_floatn_t + big + signed + 32,64 + yes + + + little_align_intn_t + little + signed + 16,32,64 + yes + + + little_align_uintn_t + little + unsigned + 16,32,64 + yes + + + little_align_floatn_t + little + signed + 32,64 + yes + + + big_intn_t + big + signed + 8,16,24,32,40,48,56,64 + no + + + big_uintn_t + big + unsigned + 8,16,24,32,40,48,56,64 + no + big_floatn_t big signed 32,64 - yes + no - little_intn_t + little_intn_t little signed - 16,32,64 - yes + 8,16,24,32,40,48,56,64 + no - little_uintn_t + little_uintn_t little unsigned - 16,32,64 - yes + 8,16,24,32,40,48,56,64 + no little_floatn_t little signed 32,64 - yes - - - big_intnun_t - big - signed - 8,16,24,32,40,48,56,64 no - big_uintnun_t - big - unsigned - 8,16,24,32,40,48,56,64 - no - - - big_floatnun_t - big - signed - 32,64 - no - - - little_intnun_t - little - signed - 8,16,24,32,40,48,56,64 - no - - - little_uintnun_t - little - unsigned - 8,16,24,32,40,48,56,64 - no - - - little_floatnun_t - little - signed - 32,64 - no - - - native_intnun_t + native_intn_t native signed 8,16,24,32,40,48,56,64 no - native_uintnun_t + native_uintn_t native unsigned 8,16,24,32,40,48,56,64 @@ -387,103 +387,103 @@ usual operations on integers are supplied.

endian operator--(endian& x, int) noexcept; }; - typedef endian<order::big, float, 32, align::yes> big_float32_t; - typedef endian<order::big, double, 64, align::yes> big_float64_t; - - // aligned little endian floating point types - typedef endian<order::little, float, 32, align::yes> little_float32_t; - typedef endian<order::little, double, 64, align::yes> little_float64_t; - - // unaligned big endian floating point types - typedef endian<order::big, float, 32, align::no> big_float32un_t; - typedef endian<order::big, double, 64, align::no> big_float64un_t; + typedef endian<order::big, float, 32, align::yes> big_align_float32_t; + typedef endian<order::big, double, 64, align::yes> big_align_float64_t; + + // aligned little endian floating point types + typedef endian<order::little, float, 32, align::yes> little_align_float32_t; + typedef endian<order::little, double, 64, align::yes> little_align_float64_t; + + // unaligned big endian floating point types + typedef endian<order::big, float, 32, align::no> big_float32un_t; + typedef endian<order::big, double, 64, align::no> big_float64un_t; // unaligned little endian floating point types - typedef endian<order::little, float, 32, align::no> little_float32un_t; - typedef endian<order::little, double, 64, align::no> little_float64un_t; + typedef endian<order::little, float, 32, align::no> little_float32un_t; + typedef endian<order::little, double, 64, align::no> little_float64un_t; // aligned big endian signed integer types - typedef endian<order::big, int16_t, 16, align::yes> big_int16_t; - typedef endian<order::big, int32_t, 32, align::yes> big_int32_t; - typedef endian<order::big, int64_t, 64, align::yes> big_int64_t; - - // aligned big endian unsigned integer types - typedef endian<order::big, uint16_t, 16, align::yes> big_uint16_t; - typedef endian<order::big, uint32_t, 32, align::yes> big_uint32_t; - typedef endian<order::big, uint64_t, 64, align::yes> big_uint64_t; - - // aligned little endian signed integer types - typedef endian<order::little, int16_t, 16, align::yes> little_int16_t; - typedef endian<order::little, int32_t, 32, align::yes> little_int32_t; - typedef endian<order::little, int64_t, 64, align::yes> little_int64_t; - - // aligned little endian unsigned integer types - typedef endian<order::little, uint16_t, 16, align::yes> little_uint16_t; - typedef endian<order::little, uint32_t, 32, align::yes> little_uint32_t; - typedef endian<order::little, uint64_t, 64, align::yes> little_uint64_t; - - // aligned native endian typedefs are not provided because - // <cstdint> types are superior for this use case + typedef endian<order::big, int16_t, 16, align::yes> big_align_int16_t; + typedef endian<order::big, int32_t, 32, align::yes> big_align_int32_t; + typedef endian<order::big, int64_t, 64, align::yes> big_align_int64_t; + + // aligned big endian unsigned integer types + typedef endian<order::big, uint16_t, 16, align::yes> big_align_uint16_t; + typedef endian<order::big, uint32_t, 32, align::yes> big_align_uint32_t; + typedef endian<order::big, uint64_t, 64, align::yes> big_align_uint64_t; + + // aligned little endian signed integer types + typedef endian<order::little, int16_t, 16, align::yes> little_align_int16_t; + typedef endian<order::little, int32_t, 32, align::yes> little_align_int32_t; + typedef endian<order::little, int64_t, 64, align::yes> little_align_int64_t; + + // aligned little endian unsigned integer types + typedef endian<order::little, uint16_t, 16, align::yes> little_align_uint16_t; + typedef endian<order::little, uint32_t, 32, align::yes> little_align_uint32_t; + typedef endian<order::little, uint64_t, 64, align::yes> little_align_uint64_t; + + // aligned native endian typedefs are not provided because + // <cstdint> types are superior for this use case // unaligned big endian signed integer types - typedef endian<order::big, int_least8_t, 8> big_int8un_t; - typedef endian<order::big, int_least16_t, 16> big_int16un_t; - typedef endian<order::big, int_least32_t, 24> big_int24un_t; - typedef endian<order::big, int_least32_t, 32> big_int32un_t; - typedef endian<order::big, int_least64_t, 40> big_int40un_t; - typedef endian<order::big, int_least64_t, 48> big_int48un_t; - typedef endian<order::big, int_least64_t, 56> big_int56un_t; - typedef endian<order::big, int_least64_t, 64> big_int64un_t; + typedef endian<order::big, int_least8_t, 8> big_int8_t; + typedef endian<order::big, int_least16_t, 16> big_int16_t; + typedef endian<order::big, int_least32_t, 24> big_int24_t; + typedef endian<order::big, int_least32_t, 32> big_int32_t; + typedef endian<order::big, int_least64_t, 40> big_int40_t; + typedef endian<order::big, int_least64_t, 48> big_int48_t; + typedef endian<order::big, int_least64_t, 56> big_int56_t; + typedef endian<order::big, int_least64_t, 64> big_int64_t; // unaligned big endian unsigned integer types - typedef endian<order::big, uint_least8_t, 8> big_uint8un_t; - typedef endian<order::big, uint_least16_t, 16> big_uint16un_t; - typedef endian<order::big, uint_least32_t, 24> big_uint24un_t; - typedef endian<order::big, uint_least32_t, 32> big_uint32un_t; - typedef endian<order::big, uint_least64_t, 40> big_uint40un_t; - typedef endian<order::big, uint_least64_t, 48> big_uint48un_t; - typedef endian<order::big, uint_least64_t, 56> big_uint56un_t; - typedef endian<order::big, uint_least64_t, 64> big_uint64un_t; + typedef endian<order::big, uint_least8_t, 8> big_uint8_t; + typedef endian<order::big, uint_least16_t, 16> big_uint16_t; + typedef endian<order::big, uint_least32_t, 24> big_uint24_t; + typedef endian<order::big, uint_least32_t, 32> big_uint32_t; + typedef endian<order::big, uint_least64_t, 40> big_uint40_t; + typedef endian<order::big, uint_least64_t, 48> big_uint48_t; + typedef endian<order::big, uint_least64_t, 56> big_uint56_t; + typedef endian<order::big, uint_least64_t, 64> big_uint64_t; // unaligned little endian signed integer types - typedef endian<order::little, int_least8_t, 8> little_int8un_t; - typedef endian<order::little, int_least16_t, 16> little_int16un_t; - typedef endian<order::little, int_least32_t, 24> little_int24un_t; - typedef endian<order::little, int_least32_t, 32> little_int32un_t; - typedef endian<order::little, int_least64_t, 40> little_int40un_t; - typedef endian<order::little, int_least64_t, 48> little_int48un_t; - typedef endian<order::little, int_least64_t, 56> little_int56un_t; - typedef endian<order::little, int_least64_t, 64> little_int64un_t; + typedef endian<order::little, int_least8_t, 8> little_int8_t; + typedef endian<order::little, int_least16_t, 16> little_int16_t; + typedef endian<order::little, int_least32_t, 24> little_int24_t; + typedef endian<order::little, int_least32_t, 32> little_int32_t; + typedef endian<order::little, int_least64_t, 40> little_int40_t; + typedef endian<order::little, int_least64_t, 48> little_int48_t; + typedef endian<order::little, int_least64_t, 56> little_int56_t; + typedef endian<order::little, int_least64_t, 64> little_int64_t; // unaligned little endian unsigned integer types - typedef endian<order::little, uint_least8_t, 8> little_uint8un_t; - typedef endian<order::little, uint_least16_t, 16> little_uint16un_t; - typedef endian<order::little, uint_least32_t, 24> little_uint24un_t; - typedef endian<order::little, uint_least32_t, 32> little_uint32un_t; - typedef endian<order::little, uint_least64_t, 40> little_uint40un_t; - typedef endian<order::little, uint_least64_t, 48> little_uint48un_t; - typedef endian<order::little, uint_least64_t, 56> little_uint56un_t; - typedef endian<order::little, uint_least64_t, 64> little_uint64un_t; + typedef endian<order::little, uint_least8_t, 8> little_uint8_t; + typedef endian<order::little, uint_least16_t, 16> little_uint16_t; + typedef endian<order::little, uint_least32_t, 24> little_uint24_t; + typedef endian<order::little, uint_least32_t, 32> little_uint32_t; + typedef endian<order::little, uint_least64_t, 40> little_uint40_t; + typedef endian<order::little, uint_least64_t, 48> little_uint48_t; + typedef endian<order::little, uint_least64_t, 56> little_uint56_t; + typedef endian<order::little, uint_least64_t, 64> little_uint64_t; // unaligned native endian signed integer types - typedef endian<order::native, int_least8_t, 8> native_int8un_t; - typedef endian<order::native, int_least16_t, 16> native_int16un_t; - typedef endian<order::native, int_least32_t, 24> native_int24un_t; - typedef endian<order::native, int_least32_t, 32> native_int32un_t; - typedef endian<order::native, int_least64_t, 40> native_int40un_t; - typedef endian<order::native, int_least64_t, 48> native_int48un_t; - typedef endian<order::native, int_least64_t, 56> native_int56un_t; - typedef endian<order::native, int_least64_t, 64> native_int64un_t; + typedef endian<order::native, int_least8_t, 8> native_int8_t; + typedef endian<order::native, int_least16_t, 16> native_int16_t; + typedef endian<order::native, int_least32_t, 24> native_int24_t; + typedef endian<order::native, int_least32_t, 32> native_int32_t; + typedef endian<order::native, int_least64_t, 40> native_int40_t; + typedef endian<order::native, int_least64_t, 48> native_int48_t; + typedef endian<order::native, int_least64_t, 56> native_int56_t; + typedef endian<order::native, int_least64_t, 64> native_int64_t; // unaligned native endian unsigned integer types - typedef endian<order::native, uint_least8_t, 8> native_uint8un_t; - typedef endian<order::native, uint_least16_t, 16> native_uint16un_t; - typedef endian<order::native, uint_least32_t, 24> native_uint24un_t; - typedef endian<order::native, uint_least32_t, 32> native_uint32un_t; - typedef endian<order::native, uint_least64_t, 40> native_uint40un_t; - typedef endian<order::native, uint_least64_t, 48> native_uint48un_t; - typedef endian<order::native, uint_least64_t, 56> native_uint56un_t; - typedef endian<order::native, uint_least64_t, 64> native_uint64un_t; + typedef endian<order::native, uint_least8_t, 8> native_uint8_t; + typedef endian<order::native, uint_least16_t, 16> native_uint16_t; + typedef endian<order::native, uint_least32_t, 24> native_uint24_t; + typedef endian<order::native, uint_least32_t, 32> native_uint32_t; + typedef endian<order::native, uint_least64_t, 40> native_uint40_t; + typedef endian<order::native, uint_least64_t, 48> native_uint48_t; + typedef endian<order::native, uint_least64_t, 56> native_uint56_t; + typedef endian<order::native, uint_least64_t, 64> native_uint64_t; } // namespace endian } // namespace boost @@ -617,7 +617,7 @@ differs from endian representation size. Vicente Botet and other reviewers suggested supporting floating point types.

Last revised: -30 May, 2013

+31 August, 2013

© Copyright Beman Dawes, 2006-2009, 2013

Distributed under the Boost Software License, Version 1.0. See www.boost.org/ LICENSE_1_0.txt

diff --git a/include/boost/endian/conversion.hpp b/include/boost/endian/conversion.hpp index 1c62db9..f2a8175 100644 --- a/include/boost/endian/conversion.hpp +++ b/include/boost/endian/conversion.hpp @@ -128,7 +128,7 @@ namespace endian namespace detail // These functions are unsafe for general use, so is placed in namespace detail. - // Think of what happens if you reverse_value a std::pair; the bytes + // Think of what happens if you reverse_value a std::pair; the bytes // from first end up in second and the bytes from second end up in first. Not good! { // general reverse_value function template useful in testing diff --git a/include/boost/endian/types.hpp b/include/boost/endian/types.hpp index a78d443..82c7dd8 100644 --- a/include/boost/endian/types.hpp +++ b/include/boost/endian/types.hpp @@ -81,103 +81,103 @@ namespace endian class endian; // aligned big endian floating point types - typedef endian big_float32_t; - typedef endian big_float64_t; + typedef endian big_align_float32_t; + typedef endian big_align_float64_t; // aligned little endian floating point types - typedef endian little_float32_t; - typedef endian little_float64_t; + typedef endian little_align_float32_t; + typedef endian little_align_float64_t; // unaligned big endian floating point types - typedef endian big_float32un_t; - typedef endian big_float64un_t; + typedef endian big_float32_t; + typedef endian big_float64_t; // unaligned little endian floating point types - typedef endian little_float32un_t; - typedef endian little_float64un_t; + typedef endian little_float32_t; + typedef endian little_float64_t; // aligned big endian signed integer types - typedef endian big_int16_t; - typedef endian big_int32_t; - typedef endian big_int64_t; + 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_uint16_t; - typedef endian big_uint32_t; - typedef endian big_uint64_t; + 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_int16_t; - typedef endian little_int32_t; - typedef endian little_int64_t; + 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_uint16_t; - typedef endian little_uint32_t; - typedef endian little_uint64_t; + 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_int8un_t; - typedef endian big_int16un_t; - typedef endian big_int24un_t; - typedef endian big_int32un_t; - typedef endian big_int40un_t; - typedef endian big_int48un_t; - typedef endian big_int56un_t; - typedef endian big_int64un_t; + 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_uint8un_t; - typedef endian big_uint16un_t; - typedef endian big_uint24un_t; - typedef endian big_uint32un_t; - typedef endian big_uint40un_t; - typedef endian big_uint48un_t; - typedef endian big_uint56un_t; - typedef endian big_uint64un_t; + 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_int8un_t; - typedef endian little_int16un_t; - typedef endian little_int24un_t; - typedef endian little_int32un_t; - typedef endian little_int40un_t; - typedef endian little_int48un_t; - typedef endian little_int56un_t; - typedef endian little_int64un_t; + 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_uint8un_t; - typedef endian little_uint16un_t; - typedef endian little_uint24un_t; - typedef endian little_uint32un_t; - typedef endian little_uint40un_t; - typedef endian little_uint48un_t; - typedef endian little_uint56un_t; - typedef endian little_uint64un_t; + 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; // unaligned native endian signed integer types - typedef endian native_int8un_t; - typedef endian native_int16un_t; - typedef endian native_int24un_t; - typedef endian native_int32un_t; - typedef endian native_int40un_t; - typedef endian native_int48un_t; - typedef endian native_int56un_t; - typedef endian native_int64un_t; + typedef endian native_int8_t; + typedef endian native_int16_t; + typedef endian native_int24_t; + typedef endian native_int32_t; + typedef endian native_int40_t; + typedef endian native_int48_t; + typedef endian native_int56_t; + typedef endian native_int64_t; // unaligned native endian unsigned integer types - typedef endian native_uint8un_t; - typedef endian native_uint16un_t; - typedef endian native_uint24un_t; - typedef endian native_uint32un_t; - typedef endian native_uint40un_t; - typedef endian native_uint48un_t; - typedef endian native_uint56un_t; - typedef endian native_uint64un_t; + typedef endian native_uint8_t; + typedef endian native_uint16_t; + typedef endian native_uint24_t; + typedef endian native_uint32_t; + typedef endian native_uint40_t; + typedef endian native_uint48_t; + typedef endian native_uint56_t; + typedef endian native_uint64_t; } // namespace boost } // namespace endian diff --git a/test/endian_in_union_test.cpp b/test/endian_in_union_test.cpp index 718b1aa..645afe3 100644 --- a/test/endian_in_union_test.cpp +++ b/test/endian_in_union_test.cpp @@ -23,59 +23,59 @@ using namespace boost::endian; union U { - big_int8un_t big_8; - big_int16un_t big_16; - big_int24un_t big_24; - big_int32un_t big_32; - big_int40un_t big_40; - big_int48un_t big_48; - big_int56un_t big_56; - big_int64un_t big_64; + 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_uint8un_t big_u8; - big_uint16un_t big_u16; - big_uint24un_t big_u24; - big_uint32un_t big_u32; - big_uint40un_t big_u40; - big_uint48un_t big_u48; - big_uint56un_t big_u56; - big_uint64un_t big_u64; + 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; - little_int8un_t little_8; - little_int16un_t little_16; - little_int24un_t little_24; - little_int32un_t little_32; - little_int40un_t little_40; - little_int48un_t little_48; - little_int56un_t little_56; - little_int64un_t little_64; + 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_uint8un_t little_u8; - little_uint16un_t little_u16; - little_uint24un_t little_u24; - little_uint32un_t little_u32; - little_uint40un_t little_u40; - little_uint48un_t little_u48; - little_uint56un_t little_u56; - little_uint64un_t little_u64; + 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; - native_int8un_t native_8; - native_int16un_t native_16; - native_int24un_t native_24; - native_int32un_t native_32; - native_int40un_t native_40; - native_int48un_t native_48; - native_int56un_t native_56; - native_int64un_t native_64; + 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_uint8un_t native_u8; - native_uint16un_t native_u16; - native_uint24un_t native_u24; - native_uint32un_t native_u32; - native_uint40un_t native_u40; - native_uint48un_t native_u48; - native_uint56un_t native_u56; - native_uint64un_t native_u64; + 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; }; U foo; diff --git a/test/endian_operations_test.cpp b/test/endian_operations_test.cpp index f11dac2..42315ac 100644 --- a/test/endian_operations_test.cpp +++ b/test/endian_operations_test.cpp @@ -205,67 +205,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 } @@ -283,61 +283,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(); + 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(); + 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 } @@ -349,10 +349,10 @@ int cpp_main(int, char * []) // make sure some simple things work - be::big_int32un_t o1(1); - be::big_int32un_t o2(2L); - be::big_int32un_t o3(3LL); - be::big_int64un_t o4(1); + be::big_int32_t o1(1); + be::big_int32_t o2(2L); + be::big_int32_t o3(3LL); + be::big_int64_t o4(1); // use cases; if BOOST_ENDIAN_LOG is defined, will output to clog info on // what overloads and conversions are actually being performed. @@ -360,9 +360,9 @@ int cpp_main(int, char * []) be::endian_log = true; std::clog << "set up test values\n"; - be::big_int32un_t big(12345); - be::little_uint16un_t little_u(10); - be::big_int64un_t result; + be::big_int32_t big(12345); + be::little_uint16_t little_u(10); + be::big_int64_t result; std::clog << "\nresult = +big\n"; @@ -421,15 +421,15 @@ int cpp_main(int, char * []) // test from Roland Schwarz that detected ambiguities unsigned u; - be::little_uint32un_t u1; - be::little_uint32un_t u2; + be::little_uint32_t u1; + be::little_uint32_t u2; u = 1; u1 = 1; u2 = u1 + u; // one more wrinkle - be::little_uint16un_t u3(3); + be::little_uint16_t u3(3); u3 = 3; u2 = u1 + u3; diff --git a/test/endian_test.cpp b/test/endian_test.cpp index 215486b..990b367 100644 --- a/test/endian_test.cpp +++ b/test/endian_test.cpp @@ -155,75 +155,86 @@ namespace void check_data() { - big_int8un_t big_8; - big_int16un_t big_16; - big_int24un_t big_24; - big_int32un_t big_32; - big_int40un_t big_40; - big_int48un_t big_48; - big_int56un_t big_56; - big_int64un_t big_64; + 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_uint8un_t big_u8; - big_uint16un_t big_u16; - big_uint24un_t big_u24; - big_uint32un_t big_u32; - big_uint40un_t big_u40; - big_uint48un_t big_u48; - big_uint56un_t big_u56; - big_uint64un_t big_u64; + 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; - little_int8un_t little_8; - little_int16un_t little_16; - little_int24un_t little_24; - little_int32un_t little_32; - little_int40un_t little_40; - little_int48un_t little_48; - little_int56un_t little_56; - little_int64un_t little_64; + 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_uint8un_t little_u8; - little_uint16un_t little_u16; - little_uint24un_t little_u24; - little_uint32un_t little_u32; - little_uint40un_t little_u40; - little_uint48un_t little_u48; - little_uint56un_t little_u56; - little_uint64un_t little_u64; + 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; - native_int8un_t native_8; - native_int16un_t native_16; - native_int24un_t native_24; - native_int32un_t native_32; - native_int40un_t native_40; - native_int48un_t native_48; - native_int56un_t native_56; - native_int64un_t native_64; + 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_uint8un_t native_u8; - native_uint16un_t native_u16; - native_uint24un_t native_u24; - native_uint32un_t native_u32; - native_uint40un_t native_u40; - native_uint48un_t native_u48; - native_uint56un_t native_u56; - native_uint64un_t native_u64; + 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; - big_int16_t big_int16; - big_int32_t big_int32; - big_int64_t big_int64; + big_align_int16_t big_align_int16; + big_align_int32_t big_align_int32; + big_align_int64_t big_align_int64; - big_uint16_t big_uint16; - big_uint32_t big_uint32; - big_uint64_t big_uint64; + big_align_uint16_t big_align_uint16; + big_align_uint32_t big_align_uint32; + big_align_uint64_t big_align_uint64; - little_int16_t little_int16; - little_int32_t little_int32; - little_int64_t little_int64; + little_align_int16_t little_align_int16; + little_align_int32_t little_align_int32; + little_align_int64_t little_align_int64; - little_uint16_t little_uint16 ; - little_uint32_t little_uint32 ; - little_uint64_t little_uint64 ; + little_align_uint16_t little_align_uint16; + little_align_uint32_t little_align_uint32; + little_align_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; + + VERIFY(big_align_float32.data() == reinterpret_cast(&big_align_float32)); + VERIFY(big_align_float64.data() == reinterpret_cast(&big_align_float64)); + + VERIFY(little_align_float32.data() == reinterpret_cast(&little_align_float32)); + VERIFY(little_align_float64.data() == reinterpret_cast(&little_align_float64)); big_float32_t big_float32; big_float64_t big_float64; @@ -236,17 +247,6 @@ namespace VERIFY(little_float32.data() == reinterpret_cast(&little_float32)); VERIFY(little_float64.data() == reinterpret_cast(&little_float64)); - big_float32un_t big_float32un; - big_float64un_t big_float64un; - little_float32un_t little_float32un; - little_float64un_t little_float64un; - - VERIFY(big_float32un.data() == reinterpret_cast(&big_float32un)); - VERIFY(big_float64un.data() == reinterpret_cast(&big_float64un)); - - VERIFY(little_float32un.data() == reinterpret_cast(&little_float32un)); - VERIFY(little_float64un.data() == reinterpret_cast(&little_float64un)); - VERIFY(big_8.data() == reinterpret_cast(&big_8)); VERIFY(big_16.data() == reinterpret_cast(&big_16)); VERIFY(big_24.data() == reinterpret_cast(&big_24)); @@ -301,21 +301,21 @@ namespace VERIFY(native_u56.data() == reinterpret_cast(&native_u56)); VERIFY(native_u64.data() == reinterpret_cast(&native_u64)); - VERIFY(big_int16.data() == reinterpret_cast(&big_int16)); - VERIFY(big_int32.data() == reinterpret_cast(&big_int32)); - VERIFY(big_int64.data() == reinterpret_cast(&big_int64)); + VERIFY(big_align_int16.data() == reinterpret_cast(&big_align_int16)); + VERIFY(big_align_int32.data() == reinterpret_cast(&big_align_int32)); + VERIFY(big_align_int64.data() == reinterpret_cast(&big_align_int64)); - VERIFY(big_uint16.data() == reinterpret_cast(&big_uint16)); - VERIFY(big_uint32.data() == reinterpret_cast(&big_uint32)); - VERIFY(big_uint64.data() == reinterpret_cast(&big_uint64)); + VERIFY(big_align_uint16.data() == reinterpret_cast(&big_align_uint16)); + VERIFY(big_align_uint32.data() == reinterpret_cast(&big_align_uint32)); + VERIFY(big_align_uint64.data() == reinterpret_cast(&big_align_uint64)); - VERIFY(little_int16.data() == reinterpret_cast(&little_int16)); - VERIFY(little_int32.data() == reinterpret_cast(&little_int32)); - VERIFY(little_int64.data() == reinterpret_cast(&little_int64)); + VERIFY(little_align_int16.data() == reinterpret_cast(&little_align_int16)); + VERIFY(little_align_int32.data() == reinterpret_cast(&little_align_int32)); + VERIFY(little_align_int64.data() == reinterpret_cast(&little_align_int64)); - VERIFY(little_uint16.data() == reinterpret_cast(&little_uint16)); - VERIFY(little_uint32.data() == reinterpret_cast(&little_uint32)); - VERIFY(little_uint64.data() == reinterpret_cast(&little_uint64)); + VERIFY(little_align_uint16.data() == reinterpret_cast(&little_align_uint16)); + VERIFY(little_align_uint32.data() == reinterpret_cast(&little_align_uint32)); + VERIFY(little_align_uint64.data() == reinterpret_cast(&little_align_uint64)); } @@ -326,85 +326,85 @@ 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( big_float32_t ), 4 ); VERIFY_SIZE(sizeof( big_float64_t ), 8 ); VERIFY_SIZE(sizeof( little_float32_t ), 4 ); VERIFY_SIZE(sizeof( little_float64_t ), 8 ); - VERIFY_SIZE(sizeof( big_float32un_t ), 4 ); - VERIFY_SIZE(sizeof( big_float64un_t ), 8 ); - VERIFY_SIZE(sizeof( little_float32un_t ), 4 ); - VERIFY_SIZE(sizeof( little_float64un_t ), 8 ); - - VERIFY_SIZE( sizeof( big_int8un_t ), 1 ); - VERIFY_SIZE( sizeof( big_int16un_t ), 2 ); - VERIFY_SIZE( sizeof( big_int24un_t ), 3 ); - VERIFY_SIZE( sizeof( big_int32un_t ), 4 ); - VERIFY_SIZE( sizeof( big_int40un_t ), 5 ); - VERIFY_SIZE( sizeof( big_int48un_t ), 6 ); - VERIFY_SIZE( sizeof( big_int56un_t ), 7 ); - VERIFY_SIZE( sizeof( big_int64un_t ), 8 ); - - VERIFY_SIZE( sizeof( big_uint8un_t ), 1 ); - VERIFY_SIZE( sizeof( big_uint16un_t ), 2 ); - VERIFY_SIZE( sizeof( big_uint24un_t ), 3 ); - VERIFY_SIZE( sizeof( big_uint32un_t ), 4 ); - VERIFY_SIZE( sizeof( big_uint40un_t ), 5 ); - VERIFY_SIZE( sizeof( big_uint48un_t ), 6 ); - VERIFY_SIZE( sizeof( big_uint56un_t ), 7 ); - VERIFY_SIZE( sizeof( big_uint64un_t ), 8 ); - - VERIFY_SIZE( sizeof( little_int8un_t ), 1 ); - VERIFY_SIZE( sizeof( little_int16un_t ), 2 ); - VERIFY_SIZE( sizeof( little_int24un_t ), 3 ); - VERIFY_SIZE( sizeof( little_int32un_t ), 4 ); - VERIFY_SIZE( sizeof( little_int40un_t ), 5 ); - VERIFY_SIZE( sizeof( little_int48un_t ), 6 ); - VERIFY_SIZE( sizeof( little_int56un_t ), 7 ); - VERIFY_SIZE( sizeof( little_int64un_t ), 8 ); - - VERIFY_SIZE( sizeof( little_uint8un_t ), 1 ); - VERIFY_SIZE( sizeof( little_uint16un_t ), 2 ); - VERIFY_SIZE( sizeof( little_uint24un_t ), 3 ); - VERIFY_SIZE( sizeof( little_uint32un_t ), 4 ); - VERIFY_SIZE( sizeof( little_uint40un_t ), 5 ); - VERIFY_SIZE( sizeof( little_uint48un_t ), 6 ); - VERIFY_SIZE( sizeof( little_uint56un_t ), 7 ); - VERIFY_SIZE( sizeof( little_uint64un_t ), 8 ); - - VERIFY_SIZE( sizeof( native_int8un_t ), 1 ); - VERIFY_SIZE( sizeof( native_int16un_t ), 2 ); - VERIFY_SIZE( sizeof( native_int24un_t ), 3 ); - VERIFY_SIZE( sizeof( native_int32un_t ), 4 ); - VERIFY_SIZE( sizeof( native_int40un_t ), 5 ); - VERIFY_SIZE( sizeof( native_int48un_t ), 6 ); - VERIFY_SIZE( sizeof( native_int56un_t ), 7 ); - VERIFY_SIZE( sizeof( native_int64un_t ), 8 ); - - VERIFY_SIZE( sizeof( native_uint8un_t ), 1 ); - VERIFY_SIZE( sizeof( native_uint16un_t ), 2 ); - VERIFY_SIZE( sizeof( native_uint24un_t ), 3 ); - VERIFY_SIZE( sizeof( native_uint32un_t ), 4 ); - VERIFY_SIZE( sizeof( native_uint40un_t ), 5 ); - VERIFY_SIZE( sizeof( native_uint48un_t ), 6 ); - VERIFY_SIZE( sizeof( native_uint56un_t ), 7 ); - VERIFY_SIZE( sizeof( native_uint64un_t ), 8 ); - + VERIFY_SIZE( sizeof( big_int8_t ), 1 ); 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 -------------------------------------------------------// @@ -416,124 +416,124 @@ namespace struct big_struct { - big_int8un_t v0; - big_int16un_t v1; - big_int24un_t v3; + big_int8_t v0; + big_int16_t v1; + big_int24_t v3; char v6; - big_int32un_t v7; - big_int40un_t v11; + big_int32_t v7; + big_int40_t v11; char v16; - big_int48un_t v17; - big_int56un_t v23; + big_int48_t v17; + big_int56_t v23; char v30; - big_int64un_t v31; + big_int64_t v31; }; struct big_u_struct { - big_uint8un_t v0; - big_uint16un_t v1; - big_uint24un_t v3; + big_uint8_t v0; + big_uint16_t v1; + big_uint24_t v3; char v6; - big_uint32un_t v7; - big_uint40un_t v11; + big_uint32_t v7; + big_uint40_t v11; char v16; - big_uint48un_t v17; - big_uint56un_t v23; + big_uint48_t v17; + big_uint56_t v23; char v30; - big_uint64un_t v31; + big_uint64_t v31; }; struct little_struct { - little_int8un_t v0; - little_int16un_t v1; - little_int24un_t v3; + little_int8_t v0; + little_int16_t v1; + little_int24_t v3; char v6; - little_int32un_t v7; - little_int40un_t v11; + little_int32_t v7; + little_int40_t v11; char v16; - little_int48un_t v17; - little_int56un_t v23; + little_int48_t v17; + little_int56_t v23; char v30; - little_int64un_t v31; + little_int64_t v31; }; struct little_u_struct { - little_uint8un_t v0; - little_uint16un_t v1; - little_uint24un_t v3; + little_uint8_t v0; + little_uint16_t v1; + little_uint24_t v3; char v6; - little_uint32un_t v7; - little_uint40un_t v11; + little_uint32_t v7; + little_uint40_t v11; char v16; - little_uint48un_t v17; - little_uint56un_t v23; + little_uint48_t v17; + little_uint56_t v23; char v30; - little_uint64un_t v31; + little_uint64_t v31; }; struct native_struct { - native_int8un_t v0; - native_int16un_t v1; - native_int24un_t v3; + native_int8_t v0; + native_int16_t v1; + native_int24_t v3; char v6; - native_int32un_t v7; - native_int40un_t v11; + native_int32_t v7; + native_int40_t v11; char v16; - native_int48un_t v17; - native_int56un_t v23; + native_int48_t v17; + native_int56_t v23; char v30; - native_int64un_t v31; + native_int64_t v31; }; struct native_u_struct { - native_uint8un_t v0; - native_uint16un_t v1; - native_uint24un_t v3; + native_uint8_t v0; + native_uint16_t v1; + native_uint24_t v3; char v6; - native_uint32un_t v7; - native_uint40un_t v11; + native_uint32_t v7; + native_uint40_t v11; char v16; - native_uint48un_t v17; - native_uint56un_t v23; + native_uint48_t v17; + native_uint56_t v23; char v30; - native_uint64un_t v31; + native_uint64_t v31; }; struct big_float_struct { int16_t v0; - big_float32_t v1; + big_align_float32_t v1; }; struct big_unaligned_float_struct { int16_t v0; - big_float32un_t v1; + big_float32_t v1; }; // aligned test cases struct big_aligned_struct { - big_int16_t v0; - big_int32_t v1; + big_align_int16_t v0; + big_align_int32_t v1; char v3; // on a 32-bit system, the padding here may be 3 rather than 7 bytes - big_int64_t v4; + big_align_int64_t v4; }; struct little_aligned_struct { - little_int16_t v0; - little_int32_t v1; + little_align_int16_t v0; + little_align_int32_t v1; char v3; // on a 32-bit system, the padding here may be 3 rather than 7 bytes - little_int64_t v4; + little_align_int64_t v4; }; int saved_err_count = err_count; @@ -563,295 +563,295 @@ namespace // aligned floating point types float big_float32_expected = (std::numeric_limits::max) (); boost::endian::big_endian(big_float32_expected); - big_float32_t big_float32((std::numeric_limits::max) ()); + big_align_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_float32_t little_float32((std::numeric_limits::max) ()); + little_align_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_float64_t big_float64((std::numeric_limits::max) ()); + big_align_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_float64_t little_float64((std::numeric_limits::max) ()); + little_align_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_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_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( 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_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) () ); // unaligned floating point types float big_float32un_expected = (std::numeric_limits::max) (); boost::endian::big_endian(big_float32un_expected); - big_float32un_t big_float32un((std::numeric_limits::max) ()); + big_float32_t 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_float32un_t little_float32un((std::numeric_limits::max) ()); + little_float32_t 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_float64un_t big_float64un((std::numeric_limits::max) ()); + big_float64_t 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_float64un_t little_float64un((std::numeric_limits::max) ()); + little_float64_t 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_float32un_t, float, (std::numeric_limits::max) () ); - VERIFY_VALUE_AND_OPS( big_float32un_t, float, (std::numeric_limits::min) () ); - VERIFY_VALUE_AND_OPS( big_float64un_t, double, (std::numeric_limits::max) () ); - VERIFY_VALUE_AND_OPS( big_float64un_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_float32un_t, float, (std::numeric_limits::max) () ); - VERIFY_VALUE_AND_OPS( little_float32un_t, float, (std::numeric_limits::min) () ); - VERIFY_VALUE_AND_OPS( little_float64un_t, double, (std::numeric_limits::max) () ); - VERIFY_VALUE_AND_OPS( little_float64un_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) () ); float a = 1.0F; - big_float32_t b(1.0F); - big_float32un_t c(1.0F); - little_float32_t d(1.0F); - little_float32un_t e(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); VERIFY(a==b); VERIFY(a==c); VERIFY(a==d); VERIFY(a==e); // unaligned integer types - VERIFY_BIG_REPRESENTATION( big_int8un_t ); - VERIFY_VALUE_AND_OPS( big_int8un_t, int_least8_t, 0x7f ); - VERIFY_VALUE_AND_OPS( big_int8un_t, int_least8_t, -0x80 ); + 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_int16un_t ); - VERIFY_VALUE_AND_OPS( big_int16un_t, int_least16_t, 0x7fff ); - VERIFY_VALUE_AND_OPS( big_int16un_t, int_least16_t, -0x8000 ); - - VERIFY_BIG_REPRESENTATION( big_int24un_t ); - VERIFY_VALUE_AND_OPS( big_int24un_t, int_least32_t, 0x7fffff ); - VERIFY_VALUE_AND_OPS( big_int24un_t, int_least32_t, -0x800000 ); - - VERIFY_BIG_REPRESENTATION( big_int32un_t ); - VERIFY_VALUE_AND_OPS( big_int32un_t, int_least32_t, 0x7fffffff ); - VERIFY_VALUE_AND_OPS( big_int32un_t, int_least32_t, -0x7fffffff-1 ); - - VERIFY_BIG_REPRESENTATION( big_int40un_t ); - VERIFY_VALUE_AND_OPS( big_int40un_t, int_least64_t, 0x7fffffffffLL ); - VERIFY_VALUE_AND_OPS( big_int40un_t, int_least64_t, -0x8000000000LL ); - - VERIFY_BIG_REPRESENTATION( big_int48un_t ); - VERIFY_VALUE_AND_OPS( big_int48un_t, int_least64_t, 0x7fffffffffffLL ); - VERIFY_VALUE_AND_OPS( big_int48un_t, int_least64_t, -0x800000000000LL ); - - VERIFY_BIG_REPRESENTATION( big_int56un_t ); - VERIFY_VALUE_AND_OPS( big_int56un_t, int_least64_t, 0x7fffffffffffffLL ); - VERIFY_VALUE_AND_OPS( big_int56un_t, int_least64_t, -0x80000000000000LL ); - - VERIFY_BIG_REPRESENTATION( big_int64un_t ); - VERIFY_VALUE_AND_OPS( big_int64un_t, int_least64_t, 0x7fffffffffffffffLL ); - VERIFY_VALUE_AND_OPS( big_int64un_t, int_least64_t, -0x7fffffffffffffffLL-1 ); - - VERIFY_BIG_REPRESENTATION( big_uint8un_t ); - VERIFY_VALUE_AND_OPS( big_uint8un_t, uint_least8_t, 0xff ); - - VERIFY_BIG_REPRESENTATION( big_uint16un_t ); - VERIFY_VALUE_AND_OPS( big_uint16un_t, uint_least16_t, 0xffff ); - - VERIFY_BIG_REPRESENTATION( big_uint24un_t ); - VERIFY_VALUE_AND_OPS( big_uint24un_t, uint_least32_t, 0xffffff ); - - VERIFY_BIG_REPRESENTATION( big_uint32un_t ); - VERIFY_VALUE_AND_OPS( big_uint32un_t, uint_least32_t, 0xffffffff ); - - VERIFY_BIG_REPRESENTATION( big_uint40un_t ); - VERIFY_VALUE_AND_OPS( big_uint40un_t, uint_least64_t, 0xffffffffffLL ); - - VERIFY_BIG_REPRESENTATION( big_uint48un_t ); - VERIFY_VALUE_AND_OPS( big_uint48un_t, uint_least64_t, 0xffffffffffffLL ); - - VERIFY_BIG_REPRESENTATION( big_uint56un_t ); - VERIFY_VALUE_AND_OPS( big_uint56un_t, uint_least64_t, 0xffffffffffffffLL ); - - VERIFY_BIG_REPRESENTATION( big_uint64un_t ); - VERIFY_VALUE_AND_OPS( big_uint64un_t, uint_least64_t, 0xffffffffffffffffULL ); - - VERIFY_LITTLE_REPRESENTATION( little_int8un_t ); - VERIFY_VALUE_AND_OPS( little_int8un_t, int_least8_t, 0x7f ); - VERIFY_VALUE_AND_OPS( little_int8un_t, int_least8_t, -0x80 ); - - VERIFY_LITTLE_REPRESENTATION( little_int16un_t ); - VERIFY_VALUE_AND_OPS( little_int16un_t, int_least16_t, 0x7fff ); - VERIFY_VALUE_AND_OPS( little_int16un_t, int_least16_t, -0x8000 ); - - VERIFY_LITTLE_REPRESENTATION( little_int24un_t ); - VERIFY_VALUE_AND_OPS( little_int24un_t, int_least32_t, 0x7fffff ); - VERIFY_VALUE_AND_OPS( little_int24un_t, int_least32_t, -0x800000 ); - - VERIFY_LITTLE_REPRESENTATION( little_int32un_t ); - VERIFY_VALUE_AND_OPS( little_int32un_t, int_least32_t, 0x7fffffff ); - VERIFY_VALUE_AND_OPS( little_int32un_t, int_least32_t, -0x7fffffff-1 ); - - VERIFY_LITTLE_REPRESENTATION( little_int40un_t ); - VERIFY_VALUE_AND_OPS( little_int40un_t, int_least64_t, 0x7fffffffffLL ); - VERIFY_VALUE_AND_OPS( little_int40un_t, int_least64_t, -0x8000000000LL ); - - VERIFY_LITTLE_REPRESENTATION( little_int48un_t ); - VERIFY_VALUE_AND_OPS( little_int48un_t, int_least64_t, 0x7fffffffffffLL ); - VERIFY_VALUE_AND_OPS( little_int48un_t, int_least64_t, -0x800000000000LL ); - - VERIFY_LITTLE_REPRESENTATION( little_int56un_t ); - VERIFY_VALUE_AND_OPS( little_int56un_t, int_least64_t, 0x7fffffffffffffLL ); - VERIFY_VALUE_AND_OPS( little_int56un_t, int_least64_t, -0x80000000000000LL ); - - VERIFY_LITTLE_REPRESENTATION( little_int64un_t ); - VERIFY_VALUE_AND_OPS( little_int64un_t, int_least64_t, 0x7fffffffffffffffLL ); - VERIFY_VALUE_AND_OPS( little_int64un_t, int_least64_t, -0x7fffffffffffffffLL-1 ); - - VERIFY_LITTLE_REPRESENTATION( little_uint8un_t ); - VERIFY_VALUE_AND_OPS( little_uint8un_t, uint_least8_t, 0xff ); - - VERIFY_LITTLE_REPRESENTATION( little_uint16un_t ); - VERIFY_VALUE_AND_OPS( little_uint16un_t, uint_least16_t, 0xffff ); - - VERIFY_LITTLE_REPRESENTATION( little_uint24un_t ); - VERIFY_VALUE_AND_OPS( little_uint24un_t, uint_least32_t, 0xffffff ); - - VERIFY_LITTLE_REPRESENTATION( little_uint32un_t ); - VERIFY_VALUE_AND_OPS( little_uint32un_t, uint_least32_t, 0xffffffff ); - - VERIFY_LITTLE_REPRESENTATION( little_uint40un_t ); - VERIFY_VALUE_AND_OPS( little_uint40un_t, uint_least64_t, 0xffffffffffLL ); - - VERIFY_LITTLE_REPRESENTATION( little_uint48un_t ); - VERIFY_VALUE_AND_OPS( little_uint48un_t, uint_least64_t, 0xffffffffffffLL ); - - VERIFY_LITTLE_REPRESENTATION( little_uint56un_t ); - VERIFY_VALUE_AND_OPS( little_uint56un_t, uint_least64_t, 0xffffffffffffffLL ); - - VERIFY_LITTLE_REPRESENTATION( little_uint64un_t ); - VERIFY_VALUE_AND_OPS( little_uint64un_t, uint_least64_t, 0xffffffffffffffffULL ); - - VERIFY_NATIVE_REPRESENTATION( native_int8un_t ); - VERIFY_VALUE_AND_OPS( native_int8un_t, int_least8_t, 0x7f ); - VERIFY_VALUE_AND_OPS( native_int8un_t, int_least8_t, -0x80 ); - - VERIFY_NATIVE_REPRESENTATION( native_int16un_t ); - VERIFY_VALUE_AND_OPS( native_int16un_t, int_least16_t, 0x7fff ); - VERIFY_VALUE_AND_OPS( native_int16un_t, int_least16_t, -0x8000 ); - - VERIFY_NATIVE_REPRESENTATION( native_int24un_t ); - VERIFY_VALUE_AND_OPS( native_int24un_t, int_least32_t, 0x7fffff ); - VERIFY_VALUE_AND_OPS( native_int24un_t, int_least32_t, -0x800000 ); - - VERIFY_NATIVE_REPRESENTATION( native_int32un_t ); - VERIFY_VALUE_AND_OPS( native_int32un_t, int_least32_t, 0x7fffffff ); - VERIFY_VALUE_AND_OPS( native_int32un_t, int_least32_t, -0x7fffffff-1 ); - - VERIFY_NATIVE_REPRESENTATION( native_int40un_t ); - VERIFY_VALUE_AND_OPS( native_int40un_t, int_least64_t, 0x7fffffffffLL ); - VERIFY_VALUE_AND_OPS( native_int40un_t, int_least64_t, -0x8000000000LL ); - - VERIFY_NATIVE_REPRESENTATION( native_int48un_t ); - VERIFY_VALUE_AND_OPS( native_int48un_t, int_least64_t, 0x7fffffffffffLL ); - VERIFY_VALUE_AND_OPS( native_int48un_t, int_least64_t, -0x800000000000LL ); - - VERIFY_NATIVE_REPRESENTATION( native_int56un_t ); - VERIFY_VALUE_AND_OPS( native_int56un_t, int_least64_t, 0x7fffffffffffffLL ); - VERIFY_VALUE_AND_OPS( native_int56un_t, int_least64_t, -0x80000000000000LL ); - - VERIFY_NATIVE_REPRESENTATION( native_int64un_t ); - VERIFY_VALUE_AND_OPS( native_int64un_t, int_least64_t, 0x7fffffffffffffffLL ); - VERIFY_VALUE_AND_OPS( native_int64un_t, int_least64_t, -0x7fffffffffffffffLL-1 ); - - VERIFY_NATIVE_REPRESENTATION( native_uint8un_t ); - VERIFY_VALUE_AND_OPS( native_uint8un_t, uint_least8_t, 0xff ); - - VERIFY_NATIVE_REPRESENTATION( native_uint16un_t ); - VERIFY_VALUE_AND_OPS( native_uint16un_t, uint_least16_t, 0xffff ); - - VERIFY_NATIVE_REPRESENTATION( native_uint24un_t ); - VERIFY_VALUE_AND_OPS( native_uint24un_t, uint_least32_t, 0xffffff ); - - VERIFY_NATIVE_REPRESENTATION( native_uint32un_t ); - VERIFY_VALUE_AND_OPS( native_uint32un_t, uint_least32_t, 0xffffffff ); - - VERIFY_NATIVE_REPRESENTATION( native_uint40un_t ); - VERIFY_VALUE_AND_OPS( native_uint40un_t, uint_least64_t, 0xffffffffffLL ); - - VERIFY_NATIVE_REPRESENTATION( native_uint48un_t ); - VERIFY_VALUE_AND_OPS( native_uint48un_t, uint_least64_t, 0xffffffffffffLL ); - - VERIFY_NATIVE_REPRESENTATION( native_uint56un_t ); - VERIFY_VALUE_AND_OPS( native_uint56un_t, uint_least64_t, 0xffffffffffffffLL ); - - VERIFY_NATIVE_REPRESENTATION( native_uint64un_t ); - VERIFY_VALUE_AND_OPS( native_uint64un_t, 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 @@ -866,9 +866,9 @@ namespace void check_udt() { - typedef boost::endian::endian< order::big, MyInt, 32 > mybig_int32un_t; + typedef boost::endian::endian< order::big, MyInt, 32 > mybig_int32_t; - mybig_int32un_t v(10); + mybig_int32_t v(10); cout << "+v is " << +v << endl; v += 1; cout << "v is " << +v << endl; @@ -924,10 +924,10 @@ int cpp_main( int argc, char * argv[] ) check_data(); check_udt(); - //timing_test ( "big_int32un_t" ); - //timing_test( "big_int32_t" ); - //timing_test ( "little_int32un_t" ); - //timing_test( "little_int32_t" ); + //timing_test ( "big_int32_t" ); + //timing_test( "big_align_int32_t" ); + //timing_test ( "little_int32_t" ); + //timing_test( "little_align_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 6938e0c..3d949b7 100644 --- a/test/loop_time_test.cpp +++ b/test/loop_time_test.cpp @@ -116,87 +116,87 @@ namespace } - void test_big_int16() + void test_big_align_int16() { cout << "16-bit aligned big endian"; + time(); + cout << "\n"; + } + + void test_little_align_int16() + { + cout << "16-bit aligned little endian"; + time(); + cout << "\n"; + } + + void test_big_int16() + { + cout << "16-bit unaligned big endian"; time(); cout << "\n"; } void test_little_int16() { - cout << "16-bit aligned little endian"; + cout << "16-bit unaligned little endian"; time(); cout << "\n"; } - - void test_big_int16un() - { - cout << "16-bit unaligned big endian"; - time(); - cout << "\n"; - } - - void test_little_int16un() - { - cout << "16-bit unaligned little endian"; - time(); - cout << "\n"; - } - void test_big_int32() + void test_big_align_int32() { cout << "32-bit aligned big endian"; + time(); + cout << "\n"; + } + + void test_little_align_int32() + { + cout << "32-bit aligned little endian"; + time(); + cout << "\n"; + } + + void test_big_int32() + { + cout << "32-bit unaligned big endian"; time(); cout << "\n"; } void test_little_int32() { - cout << "32-bit aligned little endian"; + cout << "32-bit unaligned little endian"; time(); cout << "\n"; } - - void test_big_int32un() - { - cout << "32-bit unaligned big endian"; - time(); - cout << "\n"; - } - - void test_little_int32un() - { - cout << "32-bit unaligned little endian"; - time(); - cout << "\n"; - } - void test_big_int64() + void test_big_align_int64() { cout << "64-bit aligned big endian"; + time(); + cout << "\n"; + } + + void test_little_align_int64() + { + cout << "64-bit aligned little endian"; + time(); + cout << "\n"; + } + + void test_big_int64() + { + cout << "64-bit unaligned big endian"; time(); cout << "\n"; } void test_little_int64() - { - cout << "64-bit aligned little endian"; - time(); - cout << "\n"; - } - - void test_big_int64un() - { - cout << "64-bit unaligned big endian"; - time(); - cout << "\n"; - } - - void test_little_int64un() { cout << "64-bit unaligned little endian"; - time(); + time(); cout << "\n"; } @@ -224,20 +224,20 @@ int cpp_main(int argc, char* argv[]) "\n" ; + test_big_align_int16(); + test_little_align_int16(); test_big_int16(); test_little_int16(); - test_big_int16un(); - test_little_int16un(); + test_big_align_int32(); + test_little_align_int32(); test_big_int32(); test_little_int32(); - test_big_int32un(); - test_little_int32un(); + test_big_align_int64(); + test_little_align_int64(); test_big_int64(); test_little_int64(); - test_big_int64un(); - test_little_int64un(); cout << "\n\n\n\n"; diff --git a/test/speed_test.cpp b/test/speed_test.cpp index 36eeaae..760aa88 100644 --- a/test/speed_test.cpp +++ b/test/speed_test.cpp @@ -96,63 +96,63 @@ namespace cout << "" << t.format(places, "%t") << " s"; } - void test_big_int16() + void test_big_align_int16() { cout << "16-bit aligned big endian"; - 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); + 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); cout << "\n"; } - void test_little_int16() + void test_little_align_int16() { cout << "16-bit aligned little endian"; - 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); + 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); cout << "\n"; } - void test_big_int32() + void test_big_align_int32() { cout << "32-bit aligned big endian"; - 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); + 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); cout << "\n"; } - void test_little_int32() + void test_little_align_int32() { cout << "32-bit aligned little endian"; - 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); + 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); cout << "\n"; } - void test_big_int64() + void test_big_align_int64() { cout << "64-bit aligned big endian"; - 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); + 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); cout << "\n"; } - void test_little_int64() + void test_little_align_int64() { cout << "64-bit aligned little endian"; - 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); + 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); cout << "\n"; } @@ -182,12 +182,12 @@ int cpp_main(int argc, char* argv[]) "\n" ; - test_big_int16(); - test_little_int16(); - test_big_int32(); - test_little_int32(); - test_big_int64(); - test_little_int64(); + test_big_align_int16(); + test_little_align_int16(); + test_big_align_int32(); + test_little_align_int32(); + test_big_align_int64(); + test_little_align_int64(); cout << "\n\n\n\n"; diff --git a/test/speed_test_functions.cpp b/test/speed_test_functions.cpp index 44548a3..3c578a5 100644 --- a/test/speed_test_functions.cpp +++ b/test/speed_test_functions.cpp @@ -20,31 +20,31 @@ namespace user { - 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;} + 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;} - 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;} + 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;} - 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;} + 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;} } diff --git a/test/speed_test_functions.hpp b/test/speed_test_functions.hpp index 2932844..3bc5416 100644 --- a/test/speed_test_functions.hpp +++ b/test/speed_test_functions.hpp @@ -24,32 +24,32 @@ namespace user using namespace boost; using namespace boost::endian; - 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; + 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; - 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; + 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; - 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; + 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; }