From 7f9d91e6d24b51a8cd18c8fb3dd118eb73ad2658 Mon Sep 17 00:00:00 2001 From: Beman Date: Sun, 26 May 2013 12:05:33 -0400 Subject: [PATCH] Rename unaligned integers to fit the floating point pattern. Unifies the naming pattern, deliberately makes the unaligned type names a bit uglier. --- doc/done_list.html | 37 +- doc/types.html | 237 ++++++------ include/boost/endian/conversion.hpp | 2 +- include/boost/endian/types.hpp | 112 +++--- test/endian_in_union_test.cpp | 96 ++--- test/endian_operations_test.cpp | 222 ++++++------ test/endian_test.cpp | 536 ++++++++++++++-------------- 7 files changed, 638 insertions(+), 604 deletions(-) diff --git a/doc/done_list.html b/doc/done_list.html index 28f35a4..4fb97ef 100644 --- a/doc/done_list.html +++ b/doc/done_list.html @@ -12,33 +12,38 @@

Endian changes since formal review

Enums and typedefs

Two scoped enums are provided:

@@ -232,6 +233,13 @@ conventions for common use cases:

16,32,64 yes + + big_floatn_t + big + signed + 32,64 + yes + little_intn_t little @@ -247,42 +255,63 @@ conventions for common use cases:

yes - big_n_t + little_floatn_t + little + signed + 32,64 + yes + + + big_intnun_t big signed 8,16,24,32,40,48,56,64 no - big_un_t + big_uintnun_t big unsigned 8,16,24,32,40,48,56,64 no - little_n_t + big_floatnun_t + big + signed + 32,64 + no + + + little_intnun_t little signed 8,16,24,32,40,48,56,64 no - little_un_t + little_uintnun_t little unsigned 8,16,24,32,40,48,56,64 no - native_n_t + little_floatnun_t + little + signed + 32,64 + no + + + native_intnun_t native signed 8,16,24,32,40,48,56,64 no - native_un_t + native_uintnun_t native unsigned 8,16,24,32,40,48,56,64 @@ -294,27 +323,13 @@ conventions for common use cases:

and structs. This is an important characteristic that can be exploited to minimize wasted space in memory, files, and network transmissions.

Warning: -Code that uses aligned types is inherently non-portable because alignment +Code that uses aligned types is possibly non-portable because alignment requirements vary between hardware architectures and because alignment may be affected by compiler switches or pragmas. Furthermore, aligned types are only available on architectures with 16, 32, and 64-bit integer types.

-

Note: One-byte big-endian, little-endian, and native-endian types +

Note: One-byte types have identical functionality. They are provided to improve code readability and searchability.

-

Comment on naming

-

When first exposed to endian types, programmers often fit them into a mental model -based on the <cstdint> types. Using that model, it is natural to -expect a 56-bit big-endian signed integer to be named int_big56_t -rather than big56_t.

-

As experience using these type grows, the realization creeps in that they are -lousy arithmetic integers - they are really byte holders that for convenience -support arithmetic operations - and for use in internal interfaces or -anything more than trivial arithmetic computations it is far better to convert -values of these endian types to traditional integer types.

-

That seems to lead to formation of a new mental model specific to endian byte-holder types. In that model, the endianness -is the key feature, and the integer aspect is downplayed. -Once that mental transition is made, a name like big56_t is a good -reflection of the mental model

Class template endian

An endian is an integer byte-holder with user-specified endianness, value type, size, and alignment. The @@ -364,88 +379,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; + + // 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; + // 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; - + 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; - + 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; - + 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; - + 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 - + // unaligned big endian signed integer types - typedef endian<order::big, int_least8_t, 8> big_8_t; - typedef endian<order::big, int_least16_t, 16> big_16_t; - typedef endian<order::big, int_least32_t, 24> big_24_t; - typedef endian<order::big, int_least32_t, 32> big_32_t; - typedef endian<order::big, int_least64_t, 40> big_40_t; - typedef endian<order::big, int_least64_t, 48> big_48_t; - typedef endian<order::big, int_least64_t, 56> big_56_t; - typedef endian<order::big, int_least64_t, 64> big_64_t; - + 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; + // unaligned big endian unsigned integer types - typedef endian<order::big, uint_least8_t, 8> big_u8_t; - typedef endian<order::big, uint_least16_t, 16> big_u16_t; - typedef endian<order::big, uint_least32_t, 24> big_u24_t; - typedef endian<order::big, uint_least32_t, 32> big_u32_t; - typedef endian<order::big, uint_least64_t, 40> big_u40_t; - typedef endian<order::big, uint_least64_t, 48> big_u48_t; - typedef endian<order::big, uint_least64_t, 56> big_u56_t; - typedef endian<order::big, uint_least64_t, 64> big_u64_t; - + 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; + // unaligned little endian signed integer types - typedef endian<order::little, int_least8_t, 8> little_8_t; - typedef endian<order::little, int_least16_t, 16> little_16_t; - typedef endian<order::little, int_least32_t, 24> little_24_t; - typedef endian<order::little, int_least32_t, 32> little_32_t; - typedef endian<order::little, int_least64_t, 40> little_40_t; - typedef endian<order::little, int_least64_t, 48> little_48_t; - typedef endian<order::little, int_least64_t, 56> little_56_t; - typedef endian<order::little, int_least64_t, 64> little_64_t; - + 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; + // unaligned little endian unsigned integer types - typedef endian<order::little, uint_least8_t, 8> little_u8_t; - typedef endian<order::little, uint_least16_t, 16> little_u16_t; - typedef endian<order::little, uint_least32_t, 24> little_u24_t; - typedef endian<order::little, uint_least32_t, 32> little_u32_t; - typedef endian<order::little, uint_least64_t, 40> little_u40_t; - typedef endian<order::little, uint_least64_t, 48> little_u48_t; - typedef endian<order::little, uint_least64_t, 56> little_u56_t; - typedef endian<order::little, uint_least64_t, 64> little_u64_t; - + 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; + // unaligned native endian signed integer types - typedef endian<order::native, int_least8_t, 8> native_8_t; - typedef endian<order::native, int_least16_t, 16> native_16_t; - typedef endian<order::native, int_least32_t, 24> native_24_t; - typedef endian<order::native, int_least32_t, 32> native_32_t; - typedef endian<order::native, int_least64_t, 40> native_40_t; - typedef endian<order::native, int_least64_t, 48> native_48_t; - typedef endian<order::native, int_least64_t, 56> native_56_t; - typedef endian<order::native, int_least64_t, 64> native_64_t; - + 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; + // unaligned native endian unsigned integer types - typedef endian<order::native, uint_least8_t, 8> native_u8_t; - typedef endian<order::native, uint_least16_t, 16> native_u16_t; - typedef endian<order::native, uint_least32_t, 24> native_u24_t; - typedef endian<order::native, uint_least32_t, 32> native_u32_t; - typedef endian<order::native, uint_least64_t, 40> native_u40_t; - typedef endian<order::native, uint_least64_t, 48> native_u48_t; - typedef endian<order::native, uint_least64_t, 56> native_u56_t; - typedef endian<order::native, uint_least64_t, 64> native_u64_t; + 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; } // namespace endian } // namespace boost @@ -513,7 +543,7 @@ use of Boost.Endian with real compilers.

Which is better, big-endian or little-endian? Big-endian tends to be a bit more of an industry standard, but little-endian may be preferred for -applications that run primarily on x86 (Intel/AMD) and other little-endian +applications that run primarily Intel/AMD on x86, x64, and other little-endian CPU's. The Wikipedia article gives more pros and cons.

What good is native endianness? It provides alignment and @@ -526,8 +556,8 @@ common CPU architectures, that optimization is only available for aligned types. That allows I/O of maximally efficient types on an application's primary platform, yet produces data files are portable to all platforms. The code, however, is -likely to be more fragile and less portable than with the unaligned types.

-

These types are really just byte-holders. Why provide the arithmetic +likely to be somewhat less portable than with the unaligned types.

+

The endian types are really just byte-holders. Why provide the arithmetic operations at all? Providing a full set of operations reduces program clutter and makes code both easier to write and to read. Consider incrementing a variable in a record. It is very convenient to write:

@@ -536,7 +566,7 @@ incrementing a variable in a record. It is very convenient to write:

    int temp(record.foo);
     ++temp;
     record.foo = temp;
-

Design considerations for Boost.Endian integers

+

Design considerations for Boost.Endian types

Experience

Classes with similar functionality have been independently developed by several Boost programmers and used very successful in high-value, high-use applications for many years. These independently developed endian libraries -often evolved from C libraries that were also widely used. Endian integers have proven widely useful across a wide +often evolved from C libraries that were also widely used. Endian types have proven widely useful across a wide range of computer architectures and applications.

Motivating use cases

Neil Mayhew writes: "I can also provide a meaningful use-case for this @@ -603,8 +632,8 @@ sign partial specialization to correctly extend the sign when cover integer size differs from endian representation size.

Last revised: -22 May, 2013

-

© Copyright Beman Dawes, 2006-2009

+26 May, 2013

+

© Copyright Beman Dawes, 2006-2009

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 012d5b4..cb65ccc 100644 --- a/include/boost/endian/conversion.hpp +++ b/include/boost/endian/conversion.hpp @@ -127,7 +127,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 8f6eee0..308a374 100644 --- a/include/boost/endian/types.hpp +++ b/include/boost/endian/types.hpp @@ -81,20 +81,20 @@ namespace endian class endian; // aligned big endian floating point types - typedef boost::endian::endian big_float32_t; - typedef boost::endian::endian big_float64_t; + typedef endian big_float32_t; + typedef endian big_float64_t; // aligned little endian floating point types - typedef boost::endian::endian little_float32_t; - typedef boost::endian::endian little_float64_t; + typedef endian little_float32_t; + typedef endian little_float64_t; // unaligned big endian floating point types - typedef boost::endian::endian big_float32un_t; - typedef boost::endian::endian big_float64un_t; + typedef endian big_float32un_t; + typedef endian big_float64un_t; // unaligned little endian floating point types - typedef boost::endian::endian little_float32un_t; - typedef boost::endian::endian little_float64un_t; + typedef endian little_float32un_t; + typedef endian little_float64un_t; // aligned big endian signed integer types typedef endian big_int16_t; @@ -120,64 +120,64 @@ namespace endian // types are superior for this use case // unaligned big endian signed integer types - typedef endian big_8_t; - typedef endian big_16_t; - typedef endian big_24_t; - typedef endian big_32_t; - typedef endian big_40_t; - typedef endian big_48_t; - typedef endian big_56_t; - typedef endian big_64_t; + 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; // unaligned big endian unsigned integer types - typedef endian big_u8_t; - typedef endian big_u16_t; - typedef endian big_u24_t; - typedef endian big_u32_t; - typedef endian big_u40_t; - typedef endian big_u48_t; - typedef endian big_u56_t; - typedef endian big_u64_t; + 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; // unaligned little endian signed integer types - typedef endian little_8_t; - typedef endian little_16_t; - typedef endian little_24_t; - typedef endian little_32_t; - typedef endian little_40_t; - typedef endian little_48_t; - typedef endian little_56_t; - typedef endian little_64_t; + 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; // unaligned little endian unsigned integer types - typedef endian little_u8_t; - typedef endian little_u16_t; - typedef endian little_u24_t; - typedef endian little_u32_t; - typedef endian little_u40_t; - typedef endian little_u48_t; - typedef endian little_u56_t; - typedef endian little_u64_t; + 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; // unaligned native endian signed integer types - typedef endian native_8_t; - typedef endian native_16_t; - typedef endian native_24_t; - typedef endian native_32_t; - typedef endian native_40_t; - typedef endian native_48_t; - typedef endian native_56_t; - typedef endian native_64_t; + 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; // unaligned native endian unsigned integer types - typedef endian native_u8_t; - typedef endian native_u16_t; - typedef endian native_u24_t; - typedef endian native_u32_t; - typedef endian native_u40_t; - typedef endian native_u48_t; - typedef endian native_u56_t; - typedef endian native_u64_t; + 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; } // namespace boost } // namespace endian diff --git a/test/endian_in_union_test.cpp b/test/endian_in_union_test.cpp index 87525c3..718b1aa 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_8_t big_8; - big_16_t big_16; - big_24_t big_24; - big_32_t big_32; - big_40_t big_40; - big_48_t big_48; - big_56_t big_56; - big_64_t big_64; + 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_u8_t big_u8; - big_u16_t big_u16; - big_u24_t big_u24; - big_u32_t big_u32; - big_u40_t big_u40; - big_u48_t big_u48; - big_u56_t big_u56; - big_u64_t big_u64; + 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; - little_8_t little_8; - little_16_t little_16; - little_24_t little_24; - little_32_t little_32; - little_40_t little_40; - little_48_t little_48; - little_56_t little_56; - little_64_t little_64; + 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_u8_t little_u8; - little_u16_t little_u16; - little_u24_t little_u24; - little_u32_t little_u32; - little_u40_t little_u40; - little_u48_t little_u48; - little_u56_t little_u56; - little_u64_t little_u64; + 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; - native_8_t native_8; - native_16_t native_16; - native_24_t native_24; - native_32_t native_32; - native_40_t native_40; - native_48_t native_48; - native_56_t native_56; - native_64_t native_64; + 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_u8_t native_u8; - native_u16_t native_u16; - native_u24_t native_u24; - native_u32_t native_u32; - native_u40_t native_u40; - native_u48_t native_u48; - native_u56_t native_u56; - native_u64_t native_u64; + 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; }; U foo; diff --git a/test/endian_operations_test.cpp b/test/endian_operations_test.cpp index a2be9c0..c9ae151 100644 --- a/test/endian_operations_test.cpp +++ b/test/endian_operations_test.cpp @@ -141,8 +141,8 @@ void op_test_aux() #ifdef BOOST_SHORT_ENDIAN_TEST Test::test(); Test::test(); - Test::test(); - Test::test(); + Test::test(); + Test::test(); #else Test::test(); Test::test(); @@ -155,54 +155,54 @@ 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(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + Test::test(); + 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 } @@ -212,9 +212,9 @@ void op_test() #ifdef BOOST_SHORT_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(); #else op_test_aux(); op_test_aux(); @@ -227,54 +227,54 @@ 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(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); - op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + op_test_aux(); + 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 } @@ -286,10 +286,10 @@ int cpp_main(int, char * []) // make sure some simple things work - be::big_32_t o1(1); - be::big_32_t o2(2L); - be::big_32_t o3(3LL); - be::big_64_t o4(1); + be::big_int32un_t o1(1); + be::big_int32un_t o2(2L); + be::big_int32un_t o3(3LL); + be::big_int64un_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. @@ -297,9 +297,9 @@ int cpp_main(int, char * []) be::endian_log = true; std::clog << "set up test values\n"; - be::big_32_t big(12345); - be::little_u16_t little_u(10); - be::big_64_t result; + be::big_int32un_t big(12345); + be::little_uint16un_t little_u(10); + be::big_int64un_t result; std::clog << "\nresult = +big\n"; @@ -358,15 +358,15 @@ int cpp_main(int, char * []) // test from Roland Schwarz that detected ambiguities unsigned u; - be::little_u32_t u1; - be::little_u32_t u2; + be::little_uint32un_t u1; + be::little_uint32un_t u2; u = 1; u1 = 1; u2 = u1 + u; // one more wrinkle - be::little_u16_t u3(3); + be::little_uint16un_t u3(3); u3 = 3; u2 = u1 + u3; diff --git a/test/endian_test.cpp b/test/endian_test.cpp index a8cb464..745cc2e 100644 --- a/test/endian_test.cpp +++ b/test/endian_test.cpp @@ -155,59 +155,59 @@ namespace void check_data() { - big_8_t big_8; - big_16_t big_16; - big_24_t big_24; - big_32_t big_32; - big_40_t big_40; - big_48_t big_48; - big_56_t big_56; - big_64_t big_64; + 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_u8_t big_u8; - big_u16_t big_u16; - big_u24_t big_u24; - big_u32_t big_u32; - big_u40_t big_u40; - big_u48_t big_u48; - big_u56_t big_u56; - big_u64_t big_u64; + 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; - little_8_t little_8; - little_16_t little_16; - little_24_t little_24; - little_32_t little_32; - little_40_t little_40; - little_48_t little_48; - little_56_t little_56; - little_64_t little_64; + 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_u8_t little_u8; - little_u16_t little_u16; - little_u24_t little_u24; - little_u32_t little_u32; - little_u40_t little_u40; - little_u48_t little_u48; - little_u56_t little_u56; - little_u64_t little_u64; + 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; - native_8_t native_8; - native_16_t native_16; - native_24_t native_24; - native_32_t native_32; - native_40_t native_40; - native_48_t native_48; - native_56_t native_56; - native_64_t native_64; + 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_u8_t native_u8; - native_u16_t native_u16; - native_u24_t native_u24; - native_u32_t native_u32; - native_u40_t native_u40; - native_u48_t native_u48; - native_u56_t native_u56; - native_u64_t native_u64; + 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; big_int16_t big_int16; big_int32_t big_int32; @@ -336,59 +336,59 @@ namespace VERIFY_SIZE(sizeof( little_float32un_t ), 4 ); VERIFY_SIZE(sizeof( little_float64un_t ), 8 ); - VERIFY_SIZE( sizeof( big_8_t ), 1 ); - VERIFY_SIZE( sizeof( big_16_t ), 2 ); - VERIFY_SIZE( sizeof( big_24_t ), 3 ); - VERIFY_SIZE( sizeof( big_32_t ), 4 ); - VERIFY_SIZE( sizeof( big_40_t ), 5 ); - VERIFY_SIZE( sizeof( big_48_t ), 6 ); - VERIFY_SIZE( sizeof( big_56_t ), 7 ); - VERIFY_SIZE( sizeof( big_64_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_u8_t ), 1 ); - VERIFY_SIZE( sizeof( big_u16_t ), 2 ); - VERIFY_SIZE( sizeof( big_u24_t ), 3 ); - VERIFY_SIZE( sizeof( big_u32_t ), 4 ); - VERIFY_SIZE( sizeof( big_u40_t ), 5 ); - VERIFY_SIZE( sizeof( big_u48_t ), 6 ); - VERIFY_SIZE( sizeof( big_u56_t ), 7 ); - VERIFY_SIZE( sizeof( big_u64_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_8_t ), 1 ); - VERIFY_SIZE( sizeof( little_16_t ), 2 ); - VERIFY_SIZE( sizeof( little_24_t ), 3 ); - VERIFY_SIZE( sizeof( little_32_t ), 4 ); - VERIFY_SIZE( sizeof( little_40_t ), 5 ); - VERIFY_SIZE( sizeof( little_48_t ), 6 ); - VERIFY_SIZE( sizeof( little_56_t ), 7 ); - VERIFY_SIZE( sizeof( little_64_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_u8_t ), 1 ); - VERIFY_SIZE( sizeof( little_u16_t ), 2 ); - VERIFY_SIZE( sizeof( little_u24_t ), 3 ); - VERIFY_SIZE( sizeof( little_u32_t ), 4 ); - VERIFY_SIZE( sizeof( little_u40_t ), 5 ); - VERIFY_SIZE( sizeof( little_u48_t ), 6 ); - VERIFY_SIZE( sizeof( little_u56_t ), 7 ); - VERIFY_SIZE( sizeof( little_u64_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_8_t ), 1 ); - VERIFY_SIZE( sizeof( native_16_t ), 2 ); - VERIFY_SIZE( sizeof( native_24_t ), 3 ); - VERIFY_SIZE( sizeof( native_32_t ), 4 ); - VERIFY_SIZE( sizeof( native_40_t ), 5 ); - VERIFY_SIZE( sizeof( native_48_t ), 6 ); - VERIFY_SIZE( sizeof( native_56_t ), 7 ); - VERIFY_SIZE( sizeof( native_64_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_u8_t ), 1 ); - VERIFY_SIZE( sizeof( native_u16_t ), 2 ); - VERIFY_SIZE( sizeof( native_u24_t ), 3 ); - VERIFY_SIZE( sizeof( native_u32_t ), 4 ); - VERIFY_SIZE( sizeof( native_u40_t ), 5 ); - VERIFY_SIZE( sizeof( native_u48_t ), 6 ); - VERIFY_SIZE( sizeof( native_u56_t ), 7 ); - VERIFY_SIZE( sizeof( native_u64_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_int16_t ), 2 ); VERIFY_SIZE( sizeof( big_int32_t ), 4 ); @@ -416,92 +416,92 @@ namespace struct big_struct { - big_8_t v0; - big_16_t v1; - big_24_t v3; + big_int8un_t v0; + big_int16un_t v1; + big_int24un_t v3; char v6; - big_32_t v7; - big_40_t v11; + big_int32un_t v7; + big_int40un_t v11; char v16; - big_48_t v17; - big_56_t v23; + big_int48un_t v17; + big_int56un_t v23; char v30; - big_64_t v31; + big_int64un_t v31; }; struct big_u_struct { - big_u8_t v0; - big_u16_t v1; - big_u24_t v3; + big_uint8un_t v0; + big_uint16un_t v1; + big_uint24un_t v3; char v6; - big_u32_t v7; - big_u40_t v11; + big_uint32un_t v7; + big_uint40un_t v11; char v16; - big_u48_t v17; - big_u56_t v23; + big_uint48un_t v17; + big_uint56un_t v23; char v30; - big_u64_t v31; + big_uint64un_t v31; }; struct little_struct { - little_8_t v0; - little_16_t v1; - little_24_t v3; + little_int8un_t v0; + little_int16un_t v1; + little_int24un_t v3; char v6; - little_32_t v7; - little_40_t v11; + little_int32un_t v7; + little_int40un_t v11; char v16; - little_48_t v17; - little_56_t v23; + little_int48un_t v17; + little_int56un_t v23; char v30; - little_64_t v31; + little_int64un_t v31; }; struct little_u_struct { - little_u8_t v0; - little_u16_t v1; - little_u24_t v3; + little_uint8un_t v0; + little_uint16un_t v1; + little_uint24un_t v3; char v6; - little_u32_t v7; - little_u40_t v11; + little_uint32un_t v7; + little_uint40un_t v11; char v16; - little_u48_t v17; - little_u56_t v23; + little_uint48un_t v17; + little_uint56un_t v23; char v30; - little_u64_t v31; + little_uint64un_t v31; }; struct native_struct { - native_8_t v0; - native_16_t v1; - native_24_t v3; + native_int8un_t v0; + native_int16un_t v1; + native_int24un_t v3; char v6; - native_32_t v7; - native_40_t v11; + native_int32un_t v7; + native_int40un_t v11; char v16; - native_48_t v17; - native_56_t v23; + native_int48un_t v17; + native_int56un_t v23; char v30; - native_64_t v31; + native_int64un_t v31; }; struct native_u_struct { - native_u8_t v0; - native_u16_t v1; - native_u24_t v3; + native_uint8un_t v0; + native_uint16un_t v1; + native_uint24un_t v3; char v6; - native_u32_t v7; - native_u40_t v11; + native_uint32un_t v7; + native_uint40un_t v11; char v16; - native_u48_t v17; - native_u56_t v23; + native_uint48un_t v17; + native_uint56un_t v23; char v30; - native_u64_t v31; + native_uint64un_t v31; }; struct big_float_struct @@ -639,173 +639,173 @@ namespace VERIFY(a==e); // unaligned integer types - VERIFY_BIG_REPRESENTATION( big_8_t ); - VERIFY_VALUE_AND_OPS( big_8_t, int_least8_t, 0x7f ); - VERIFY_VALUE_AND_OPS( big_8_t, int_least8_t, -0x80 ); + 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_16_t ); - VERIFY_VALUE_AND_OPS( big_16_t, int_least16_t, 0x7fff ); - VERIFY_VALUE_AND_OPS( big_16_t, int_least16_t, -0x8000 ); + 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_24_t ); - VERIFY_VALUE_AND_OPS( big_24_t, int_least32_t, 0x7fffff ); - VERIFY_VALUE_AND_OPS( big_24_t, int_least32_t, -0x800000 ); + 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_32_t ); - VERIFY_VALUE_AND_OPS( big_32_t, int_least32_t, 0x7fffffff ); - VERIFY_VALUE_AND_OPS( big_32_t, int_least32_t, -0x7fffffff-1 ); + 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_40_t ); - VERIFY_VALUE_AND_OPS( big_40_t, int_least64_t, 0x7fffffffffLL ); - VERIFY_VALUE_AND_OPS( big_40_t, int_least64_t, -0x8000000000LL ); + 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_48_t ); - VERIFY_VALUE_AND_OPS( big_48_t, int_least64_t, 0x7fffffffffffLL ); - VERIFY_VALUE_AND_OPS( big_48_t, int_least64_t, -0x800000000000LL ); + 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_56_t ); - VERIFY_VALUE_AND_OPS( big_56_t, int_least64_t, 0x7fffffffffffffLL ); - VERIFY_VALUE_AND_OPS( big_56_t, int_least64_t, -0x80000000000000LL ); + 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_64_t ); - VERIFY_VALUE_AND_OPS( big_64_t, int_least64_t, 0x7fffffffffffffffLL ); - VERIFY_VALUE_AND_OPS( big_64_t, int_least64_t, -0x7fffffffffffffffLL-1 ); + 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_u8_t ); - VERIFY_VALUE_AND_OPS( big_u8_t, uint_least8_t, 0xff ); + VERIFY_BIG_REPRESENTATION( big_uint8un_t ); + VERIFY_VALUE_AND_OPS( big_uint8un_t, uint_least8_t, 0xff ); - VERIFY_BIG_REPRESENTATION( big_u16_t ); - VERIFY_VALUE_AND_OPS( big_u16_t, uint_least16_t, 0xffff ); + VERIFY_BIG_REPRESENTATION( big_uint16un_t ); + VERIFY_VALUE_AND_OPS( big_uint16un_t, uint_least16_t, 0xffff ); - VERIFY_BIG_REPRESENTATION( big_u24_t ); - VERIFY_VALUE_AND_OPS( big_u24_t, uint_least32_t, 0xffffff ); + VERIFY_BIG_REPRESENTATION( big_uint24un_t ); + VERIFY_VALUE_AND_OPS( big_uint24un_t, uint_least32_t, 0xffffff ); - VERIFY_BIG_REPRESENTATION( big_u32_t ); - VERIFY_VALUE_AND_OPS( big_u32_t, uint_least32_t, 0xffffffff ); + VERIFY_BIG_REPRESENTATION( big_uint32un_t ); + VERIFY_VALUE_AND_OPS( big_uint32un_t, uint_least32_t, 0xffffffff ); - VERIFY_BIG_REPRESENTATION( big_u40_t ); - VERIFY_VALUE_AND_OPS( big_u40_t, uint_least64_t, 0xffffffffffLL ); + VERIFY_BIG_REPRESENTATION( big_uint40un_t ); + VERIFY_VALUE_AND_OPS( big_uint40un_t, uint_least64_t, 0xffffffffffLL ); - VERIFY_BIG_REPRESENTATION( big_u48_t ); - VERIFY_VALUE_AND_OPS( big_u48_t, uint_least64_t, 0xffffffffffffLL ); + VERIFY_BIG_REPRESENTATION( big_uint48un_t ); + VERIFY_VALUE_AND_OPS( big_uint48un_t, uint_least64_t, 0xffffffffffffLL ); - VERIFY_BIG_REPRESENTATION( big_u56_t ); - VERIFY_VALUE_AND_OPS( big_u56_t, uint_least64_t, 0xffffffffffffffLL ); + VERIFY_BIG_REPRESENTATION( big_uint56un_t ); + VERIFY_VALUE_AND_OPS( big_uint56un_t, uint_least64_t, 0xffffffffffffffLL ); - VERIFY_BIG_REPRESENTATION( big_u64_t ); - VERIFY_VALUE_AND_OPS( big_u64_t, uint_least64_t, 0xffffffffffffffffULL ); + VERIFY_BIG_REPRESENTATION( big_uint64un_t ); + VERIFY_VALUE_AND_OPS( big_uint64un_t, uint_least64_t, 0xffffffffffffffffULL ); - VERIFY_LITTLE_REPRESENTATION( little_8_t ); - VERIFY_VALUE_AND_OPS( little_8_t, int_least8_t, 0x7f ); - VERIFY_VALUE_AND_OPS( little_8_t, int_least8_t, -0x80 ); + 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_16_t ); - VERIFY_VALUE_AND_OPS( little_16_t, int_least16_t, 0x7fff ); - VERIFY_VALUE_AND_OPS( little_16_t, int_least16_t, -0x8000 ); + 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_24_t ); - VERIFY_VALUE_AND_OPS( little_24_t, int_least32_t, 0x7fffff ); - VERIFY_VALUE_AND_OPS( little_24_t, int_least32_t, -0x800000 ); + 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_32_t ); - VERIFY_VALUE_AND_OPS( little_32_t, int_least32_t, 0x7fffffff ); - VERIFY_VALUE_AND_OPS( little_32_t, int_least32_t, -0x7fffffff-1 ); + 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_40_t ); - VERIFY_VALUE_AND_OPS( little_40_t, int_least64_t, 0x7fffffffffLL ); - VERIFY_VALUE_AND_OPS( little_40_t, int_least64_t, -0x8000000000LL ); + 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_48_t ); - VERIFY_VALUE_AND_OPS( little_48_t, int_least64_t, 0x7fffffffffffLL ); - VERIFY_VALUE_AND_OPS( little_48_t, int_least64_t, -0x800000000000LL ); + 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_56_t ); - VERIFY_VALUE_AND_OPS( little_56_t, int_least64_t, 0x7fffffffffffffLL ); - VERIFY_VALUE_AND_OPS( little_56_t, int_least64_t, -0x80000000000000LL ); + 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_64_t ); - VERIFY_VALUE_AND_OPS( little_64_t, int_least64_t, 0x7fffffffffffffffLL ); - VERIFY_VALUE_AND_OPS( little_64_t, int_least64_t, -0x7fffffffffffffffLL-1 ); + 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_u8_t ); - VERIFY_VALUE_AND_OPS( little_u8_t, uint_least8_t, 0xff ); + VERIFY_LITTLE_REPRESENTATION( little_uint8un_t ); + VERIFY_VALUE_AND_OPS( little_uint8un_t, uint_least8_t, 0xff ); - VERIFY_LITTLE_REPRESENTATION( little_u16_t ); - VERIFY_VALUE_AND_OPS( little_u16_t, uint_least16_t, 0xffff ); + VERIFY_LITTLE_REPRESENTATION( little_uint16un_t ); + VERIFY_VALUE_AND_OPS( little_uint16un_t, uint_least16_t, 0xffff ); - VERIFY_LITTLE_REPRESENTATION( little_u24_t ); - VERIFY_VALUE_AND_OPS( little_u24_t, uint_least32_t, 0xffffff ); + VERIFY_LITTLE_REPRESENTATION( little_uint24un_t ); + VERIFY_VALUE_AND_OPS( little_uint24un_t, uint_least32_t, 0xffffff ); - VERIFY_LITTLE_REPRESENTATION( little_u32_t ); - VERIFY_VALUE_AND_OPS( little_u32_t, uint_least32_t, 0xffffffff ); + VERIFY_LITTLE_REPRESENTATION( little_uint32un_t ); + VERIFY_VALUE_AND_OPS( little_uint32un_t, uint_least32_t, 0xffffffff ); - VERIFY_LITTLE_REPRESENTATION( little_u40_t ); - VERIFY_VALUE_AND_OPS( little_u40_t, uint_least64_t, 0xffffffffffLL ); + VERIFY_LITTLE_REPRESENTATION( little_uint40un_t ); + VERIFY_VALUE_AND_OPS( little_uint40un_t, uint_least64_t, 0xffffffffffLL ); - VERIFY_LITTLE_REPRESENTATION( little_u48_t ); - VERIFY_VALUE_AND_OPS( little_u48_t, uint_least64_t, 0xffffffffffffLL ); + VERIFY_LITTLE_REPRESENTATION( little_uint48un_t ); + VERIFY_VALUE_AND_OPS( little_uint48un_t, uint_least64_t, 0xffffffffffffLL ); - VERIFY_LITTLE_REPRESENTATION( little_u56_t ); - VERIFY_VALUE_AND_OPS( little_u56_t, uint_least64_t, 0xffffffffffffffLL ); + VERIFY_LITTLE_REPRESENTATION( little_uint56un_t ); + VERIFY_VALUE_AND_OPS( little_uint56un_t, uint_least64_t, 0xffffffffffffffLL ); - VERIFY_LITTLE_REPRESENTATION( little_u64_t ); - VERIFY_VALUE_AND_OPS( little_u64_t, uint_least64_t, 0xffffffffffffffffULL ); + VERIFY_LITTLE_REPRESENTATION( little_uint64un_t ); + VERIFY_VALUE_AND_OPS( little_uint64un_t, uint_least64_t, 0xffffffffffffffffULL ); - VERIFY_NATIVE_REPRESENTATION( native_8_t ); - VERIFY_VALUE_AND_OPS( native_8_t, int_least8_t, 0x7f ); - VERIFY_VALUE_AND_OPS( native_8_t, int_least8_t, -0x80 ); + 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_16_t ); - VERIFY_VALUE_AND_OPS( native_16_t, int_least16_t, 0x7fff ); - VERIFY_VALUE_AND_OPS( native_16_t, int_least16_t, -0x8000 ); + 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_24_t ); - VERIFY_VALUE_AND_OPS( native_24_t, int_least32_t, 0x7fffff ); - VERIFY_VALUE_AND_OPS( native_24_t, int_least32_t, -0x800000 ); + 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_32_t ); - VERIFY_VALUE_AND_OPS( native_32_t, int_least32_t, 0x7fffffff ); - VERIFY_VALUE_AND_OPS( native_32_t, int_least32_t, -0x7fffffff-1 ); + 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_40_t ); - VERIFY_VALUE_AND_OPS( native_40_t, int_least64_t, 0x7fffffffffLL ); - VERIFY_VALUE_AND_OPS( native_40_t, int_least64_t, -0x8000000000LL ); + 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_48_t ); - VERIFY_VALUE_AND_OPS( native_48_t, int_least64_t, 0x7fffffffffffLL ); - VERIFY_VALUE_AND_OPS( native_48_t, int_least64_t, -0x800000000000LL ); + 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_56_t ); - VERIFY_VALUE_AND_OPS( native_56_t, int_least64_t, 0x7fffffffffffffLL ); - VERIFY_VALUE_AND_OPS( native_56_t, int_least64_t, -0x80000000000000LL ); + 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_64_t ); - VERIFY_VALUE_AND_OPS( native_64_t, int_least64_t, 0x7fffffffffffffffLL ); - VERIFY_VALUE_AND_OPS( native_64_t, int_least64_t, -0x7fffffffffffffffLL-1 ); + 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_u8_t ); - VERIFY_VALUE_AND_OPS( native_u8_t, uint_least8_t, 0xff ); + VERIFY_NATIVE_REPRESENTATION( native_uint8un_t ); + VERIFY_VALUE_AND_OPS( native_uint8un_t, uint_least8_t, 0xff ); - VERIFY_NATIVE_REPRESENTATION( native_u16_t ); - VERIFY_VALUE_AND_OPS( native_u16_t, uint_least16_t, 0xffff ); + VERIFY_NATIVE_REPRESENTATION( native_uint16un_t ); + VERIFY_VALUE_AND_OPS( native_uint16un_t, uint_least16_t, 0xffff ); - VERIFY_NATIVE_REPRESENTATION( native_u24_t ); - VERIFY_VALUE_AND_OPS( native_u24_t, uint_least32_t, 0xffffff ); + VERIFY_NATIVE_REPRESENTATION( native_uint24un_t ); + VERIFY_VALUE_AND_OPS( native_uint24un_t, uint_least32_t, 0xffffff ); - VERIFY_NATIVE_REPRESENTATION( native_u32_t ); - VERIFY_VALUE_AND_OPS( native_u32_t, uint_least32_t, 0xffffffff ); + VERIFY_NATIVE_REPRESENTATION( native_uint32un_t ); + VERIFY_VALUE_AND_OPS( native_uint32un_t, uint_least32_t, 0xffffffff ); - VERIFY_NATIVE_REPRESENTATION( native_u40_t ); - VERIFY_VALUE_AND_OPS( native_u40_t, uint_least64_t, 0xffffffffffLL ); + VERIFY_NATIVE_REPRESENTATION( native_uint40un_t ); + VERIFY_VALUE_AND_OPS( native_uint40un_t, uint_least64_t, 0xffffffffffLL ); - VERIFY_NATIVE_REPRESENTATION( native_u48_t ); - VERIFY_VALUE_AND_OPS( native_u48_t, uint_least64_t, 0xffffffffffffLL ); + VERIFY_NATIVE_REPRESENTATION( native_uint48un_t ); + VERIFY_VALUE_AND_OPS( native_uint48un_t, uint_least64_t, 0xffffffffffffLL ); - VERIFY_NATIVE_REPRESENTATION( native_u56_t ); - VERIFY_VALUE_AND_OPS( native_u56_t, uint_least64_t, 0xffffffffffffffLL ); + VERIFY_NATIVE_REPRESENTATION( native_uint56un_t ); + VERIFY_VALUE_AND_OPS( native_uint56un_t, uint_least64_t, 0xffffffffffffffLL ); - VERIFY_NATIVE_REPRESENTATION( native_u64_t ); - VERIFY_VALUE_AND_OPS( native_u64_t, uint_least64_t, 0xffffffffffffffffULL ); + 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 ); @@ -864,9 +864,9 @@ namespace void check_udt() { - typedef boost::endian::endian< order::big, MyInt, 32 > mybig_32_t; + typedef boost::endian::endian< order::big, MyInt, 32 > mybig_int32un_t; - mybig_32_t v(10); + mybig_int32un_t v(10); cout << "+v is " << +v << endl; v += 1; cout << "v is " << +v << endl; @@ -922,9 +922,9 @@ int cpp_main( int argc, char * argv[] ) check_data(); check_udt(); - //timing_test ( "big_32_t" ); + //timing_test ( "big_int32un_t" ); //timing_test( "big_int32_t" ); - //timing_test ( "little_32_t" ); + //timing_test ( "little_int32un_t" ); //timing_test( "little_int32_t" ); cout << "\n" << err_count << " errors detected\nTest "