Subject: [Boost-commit] svn:boost r74245 - in trunk/boost/spirit/home: karma/binary qi/binary support/detail support/detail/endian support/detail/integer
From: hartmut.kaiser_at_[hidden]
Date: 2011-09-05 18:31:05
Author: hkaiser
Date: 2011-09-05 18:31:02 EDT (Mon, 05 Sep 2011)
New Revision: 74245
URL: http://svn.boost.org/trac/boost/changeset/74245
Log:
Spirit: preparing for the now to be accepted Boost.Endian library
Added:
trunk/boost/spirit/home/support/detail/endian/ (props changed)
trunk/boost/spirit/home/support/detail/endian/cover_operators.hpp (contents, props changed)
trunk/boost/spirit/home/support/detail/endian/endian.hpp (contents, props changed)
Removed:
trunk/boost/spirit/home/support/detail/integer/
Text files modified:
trunk/boost/spirit/home/karma/binary/binary.hpp | 26 +++++++++++++-------------
trunk/boost/spirit/home/qi/binary/binary.hpp | 26 +++++++++++++-------------
trunk/boost/spirit/home/support/detail/endian.hpp | 12 +++++++++---
3 files changed, 35 insertions(+), 29 deletions(-)
Modified: trunk/boost/spirit/home/karma/binary/binary.hpp
==============================================================================
--- trunk/boost/spirit/home/karma/binary/binary.hpp (original)
+++ trunk/boost/spirit/home/karma/binary/binary.hpp 2011-09-05 18:31:02 EDT (Mon, 05 Sep 2011)
@@ -142,11 +142,11 @@
#endif
///////////////////////////////////////////////////////////////////////
- template <BOOST_SCOPED_ENUM(boost::integer::endianness) bits>
+ template <BOOST_SCOPED_ENUM(boost::endian::endianness) bits>
struct what;
template <>
- struct what<boost::integer::endianness::native>
+ struct what<boost::endian::endianness::native>
{
static info is()
{
@@ -155,7 +155,7 @@
};
template <>
- struct what<boost::integer::endianness::little>
+ struct what<boost::endian::endianness::little>
{
static info is()
{
@@ -164,7 +164,7 @@
};
template <>
- struct what<boost::integer::endianness::big>
+ struct what<boost::endian::endianness::big>
{
static info is()
{
@@ -174,7 +174,7 @@
}
///////////////////////////////////////////////////////////////////////////
- template <BOOST_SCOPED_ENUM(boost::integer::endianness) endian, int bits>
+ template <BOOST_SCOPED_ENUM(boost::endian::endianness) endian, int bits>
struct any_binary_generator
: primitive_generator<any_binary_generator<endian, bits> >
{
@@ -195,7 +195,7 @@
// Even if the endian types are not pod's (at least not in the
// definition of C++03) it seems to be safe to assume they are.
// This allows us to treat them as a sequence of consecutive bytes.
- boost::integer::endian<
+ boost::endian::endian<
endian, typename karma::detail::integer<bits>::type, bits
> p;
@@ -245,7 +245,7 @@
};
///////////////////////////////////////////////////////////////////////////
- template <BOOST_SCOPED_ENUM(boost::integer::endianness) endian, int bits>
+ template <BOOST_SCOPED_ENUM(boost::endian::endianness) endian, int bits>
struct literal_binary_generator
: primitive_generator<literal_binary_generator<endian, bits> >
{
@@ -296,7 +296,7 @@
return karma::detail::what<endian>::is();
}
- typedef boost::integer::endian<
+ typedef boost::endian::endian<
endian, typename karma::detail::integer<bits>::type, bits
> data_type;
@@ -308,7 +308,7 @@
///////////////////////////////////////////////////////////////////////////
namespace detail
{
- template <BOOST_SCOPED_ENUM(boost::integer::endianness) endian
+ template <BOOST_SCOPED_ENUM(boost::endian::endianness) endian
, int bits>
struct basic_binary
{
@@ -321,7 +321,7 @@
};
template <typename Modifiers
- , BOOST_SCOPED_ENUM(boost::integer::endianness) endian, int bits>
+ , BOOST_SCOPED_ENUM(boost::endian::endianness) endian, int bits>
struct basic_binary_literal
{
typedef literal_binary_generator<endian, bits> result_type;
@@ -334,16 +334,16 @@
};
}
-#define BOOST_SPIRIT_MAKE_BINARY_PRIMITIVE(name, endian, bits) \
+#define BOOST_SPIRIT_MAKE_BINARY_PRIMITIVE(name, endiantype, bits) \
template <typename Modifiers> \
struct make_primitive<tag::name, Modifiers> \
- : detail::basic_binary<boost::integer::endianness::endian, bits> {}; \
+ : detail::basic_binary<boost::endian::endianness::endiantype, bits> {}; \
\
template <typename Modifiers, typename A0> \
struct make_primitive<terminal_ex<tag::name, fusion::vector1<A0> > \
, Modifiers> \
: detail::basic_binary_literal<Modifiers \
- , boost::integer::endianness::endian, bits> {}; \
+ , boost::endian::endianness::endiantype, bits> {}; \
\
/***/
Modified: trunk/boost/spirit/home/qi/binary/binary.hpp
==============================================================================
--- trunk/boost/spirit/home/qi/binary/binary.hpp (original)
+++ trunk/boost/spirit/home/qi/binary/binary.hpp 2011-09-05 18:31:02 EDT (Mon, 05 Sep 2011)
@@ -136,11 +136,11 @@
#endif
///////////////////////////////////////////////////////////////////////
- template <BOOST_SCOPED_ENUM(boost::integer::endianness) bits>
+ template <BOOST_SCOPED_ENUM(boost::endian::endianness) bits>
struct what;
template <>
- struct what<boost::integer::endianness::native>
+ struct what<boost::endian::endianness::native>
{
static std::string is()
{
@@ -149,7 +149,7 @@
};
template <>
- struct what<boost::integer::endianness::little>
+ struct what<boost::endian::endianness::little>
{
static char const* is()
{
@@ -158,7 +158,7 @@
};
template <>
- struct what<boost::integer::endianness::big>
+ struct what<boost::endian::endianness::big>
{
static char const* is()
{
@@ -168,13 +168,13 @@
}
///////////////////////////////////////////////////////////////////////////
- template <BOOST_SCOPED_ENUM(boost::integer::endianness) endian, int bits>
+ template <BOOST_SCOPED_ENUM(boost::endian::endianness) endian, int bits>
struct any_binary_parser : primitive_parser<any_binary_parser<endian, bits> >
{
template <typename Context, typename Iterator>
struct attribute
{
- typedef boost::integer::endian<
+ typedef boost::endian::endian<
endian, typename qi::detail::integer<bits>::type, bits
> type;
};
@@ -212,7 +212,7 @@
///////////////////////////////////////////////////////////////////////////
template <typename Int
- , BOOST_SCOPED_ENUM(boost::integer::endianness) endian, int bits>
+ , BOOST_SCOPED_ENUM(boost::endian::endianness) endian, int bits>
struct binary_lit_parser
: primitive_parser<binary_lit_parser<Int, endian, bits> >
{
@@ -237,7 +237,7 @@
// definition of C++03) it seems to be safe to assume they are
// (but in C++0x the endian types _are_ PODs).
// This allows us to treat them as a sequence of consecutive bytes.
- boost::integer::endian<
+ boost::endian::endian<
endian, typename qi::detail::integer<bits>::type, bits> attr_;
#if defined(BOOST_MSVC)
@@ -276,7 +276,7 @@
///////////////////////////////////////////////////////////////////////////
// Parser generators: make_xxx function (objects)
///////////////////////////////////////////////////////////////////////////
- template <BOOST_SCOPED_ENUM(boost::integer::endianness) endian, int bits>
+ template <BOOST_SCOPED_ENUM(boost::endian::endianness) endian, int bits>
struct make_binary_parser
{
typedef any_binary_parser<endian, bits> result_type;
@@ -287,7 +287,7 @@
};
template <typename Int
- , BOOST_SCOPED_ENUM(boost::integer::endianness) endian, int bits>
+ , BOOST_SCOPED_ENUM(boost::endian::endianness) endian, int bits>
struct make_binary_lit_parser
{
typedef binary_lit_parser<Int, endian, bits> result_type;
@@ -298,15 +298,15 @@
}
};
-#define BOOST_SPIRIT_MAKE_BINARY_PRIMITIVE(name, endian, bits) \
+#define BOOST_SPIRIT_MAKE_BINARY_PRIMITIVE(name, endiantype, bits) \
template <typename Modifiers> \
struct make_primitive<tag::name, Modifiers> \
- : make_binary_parser<boost::integer::endianness::endian, bits> {}; \
+ : make_binary_parser<boost::endian::endianness::endiantype, bits> {}; \
\
template <typename Modifiers, typename A0> \
struct make_primitive< \
terminal_ex<tag::name, fusion::vector1<A0> > , Modifiers> \
- : make_binary_lit_parser<A0, boost::integer::endianness::endian, bits> {};\
+ : make_binary_lit_parser<A0, boost::endian::endianness::endiantype, bits> {};\
\
/***/
Modified: trunk/boost/spirit/home/support/detail/endian.hpp
==============================================================================
--- trunk/boost/spirit/home/support/detail/endian.hpp (original)
+++ trunk/boost/spirit/home/support/detail/endian.hpp 2011-09-05 18:31:02 EDT (Mon, 05 Sep 2011)
@@ -14,14 +14,20 @@
#include <boost/version.hpp>
// We need to treat the endian number types as PODs
-#define BOOST_ENDIAN_FORCE_PODNESS
+#if !defined(BOOST_ENDIAN_FORCE_PODNESS)
+#define BOOST_ENDIAN_FORCE_PODNESS 1
+#endif
// If Boost has the endian library, use it, otherwise use an adapted version
// included with Spirit
#if BOOST_VERSION >= 104900
-#include <boost/integer/endian.hpp>
+#include <boost/endian/integers.hpp>
#else
-#include <boost/spirit/home/support/detail/integer/endian.hpp>
+#include <boost/spirit/home/support/detail/endian/endian.hpp>
+namespace boost { namespace endian
+{
+ using namespace boost::spirit::endian;
+}}
#endif
#endif
Added: trunk/boost/spirit/home/support/detail/endian/cover_operators.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/spirit/home/support/detail/endian/cover_operators.hpp 2011-09-05 18:31:02 EDT (Mon, 05 Sep 2011)
@@ -0,0 +1,115 @@
+// boost/integer/cover_operators.hpp ----------------------------------------//
+
+// Copyright Darin Adler 2000
+// Copyright Beman Dawes 2008
+
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//----------------------------------------------------------------------------//
+
+// If the class being covered has a non-explicit conversion to an integer type
+// then a smaller number of cover operations are needed. Define the macro
+// BOOST_MINIMAL_INTEGER_COVER_OPERATORS to indicate this.
+
+// Define BOOST_NO_IO_COVER_OPERATORS if I/O cover operations are not desired.
+
+//----------------------------------------------------------------------------//
+
+#ifndef BOOST_SPIRIT_INTEGER_COVER_OPERATORS_HPP
+#define BOOST_SPIRIT_INTEGER_COVER_OPERATORS_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+# ifndef BOOST_MINIMAL_INTEGER_COVER_OPERATORS
+# include <boost/operators.hpp>
+# endif
+
+#include <iosfwd>
+
+namespace boost { namespace spirit
+{
+ namespace endian
+ {
+
+ // A class that adds integer operators to an integer cover class
+
+ template <typename T, typename IntegerType>
+ class cover_operators
+# ifndef BOOST_MINIMAL_INTEGER_COVER_OPERATORS
+ : boost::operators<T>
+# endif
+ {
+ // The other operations take advantage of the type conversion that's
+ // built into unary +.
+
+ // Unary operations.
+ friend IntegerType operator+(const T& x) { return x; }
+# ifndef BOOST_MINIMAL_INTEGER_COVER_OPERATORS
+ friend IntegerType operator-(const T& x) { return -+x; }
+ friend IntegerType operator~(const T& x) { return ~+x; }
+ friend IntegerType operator!(const T& x) { return !+x; }
+
+ // The basic ordering operations.
+ friend bool operator==(const T& x, IntegerType y) { return +x == y; }
+ friend bool operator<(const T& x, IntegerType y) { return +x < y; }
+# endif
+
+ // The basic arithmetic operations.
+ friend T& operator+=(T& x, IntegerType y) { return x = +x + y; }
+ friend T& operator-=(T& x, IntegerType y) { return x = +x - y; }
+ friend T& operator*=(T& x, IntegerType y) { return x = +x * y; }
+ friend T& operator/=(T& x, IntegerType y) { return x = +x / y; }
+ friend T& operator%=(T& x, IntegerType y) { return x = +x % y; }
+ friend T& operator&=(T& x, IntegerType y) { return x = +x & y; }
+ friend T& operator|=(T& x, IntegerType y) { return x = +x | y; }
+ friend T& operator^=(T& x, IntegerType y) { return x = +x ^ y; }
+ friend T& operator<<=(T& x, IntegerType y) { return x = +x << y; }
+ friend T& operator>>=(T& x, IntegerType y) { return x = +x >> y; }
+
+ // A few binary arithmetic operations not covered by operators base class.
+ friend IntegerType operator<<(const T& x, IntegerType y) { return +x << y; }
+ friend IntegerType operator>>(const T& x, IntegerType y) { return +x >> y; }
+
+ // Auto-increment and auto-decrement can be defined in terms of the
+ // arithmetic operations.
+ friend T& operator++(T& x) { return x += 1; }
+ friend T& operator--(T& x) { return x -= 1; }
+
+# ifdef BOOST_MINIMAL_INTEGER_COVER_OPERATORS
+ friend T operator++(T& x, int)
+ {
+ T tmp(x);
+ x += 1;
+ return tmp;
+ }
+ friend T operator--(T& x, int)
+ {
+ T tmp(x);
+ x -= 1;
+ return tmp;
+ }
+# endif
+
+# ifndef BOOST_NO_IO_COVER_OPERATORS
+ // TODO: stream I/O needs to be templatized on the stream type, so will
+ // work with wide streams, etc.
+
+ // Stream input and output.
+ friend std::ostream& operator<<(std::ostream& s, const T& x)
+ { return s << +x; }
+ friend std::istream& operator>>(std::istream& s, T& x)
+ {
+ IntegerType i;
+ if (s >> i)
+ x = i;
+ return s;
+ }
+# endif
+ };
+ } // namespace endian
+}} // namespace boost::spirit
+
+#endif // BOOST_SPIRIT_INTEGER_COVER_OPERATORS_HPP
Added: trunk/boost/spirit/home/support/detail/endian/endian.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/spirit/home/support/detail/endian/endian.hpp 2011-09-05 18:31:02 EDT (Mon, 05 Sep 2011)
@@ -0,0 +1,426 @@
+// Boost endian.hpp header file -------------------------------------------------------//
+
+// (C) Copyright Darin Adler 2000
+// (C) Copyright Beman Dawes 2006, 2009
+
+// Distributed under the Boost Software License, Version 1.0.
+// See http://www.boost.org/LICENSE_1_0.txt
+
+// See library home page at http://www.boost.org/libs/endian
+
+//--------------------------------------------------------------------------------------//
+
+// Original design developed by Darin Adler based on classes developed by Mark
+// Borgerding. Four original class templates were combined into a single endian
+// class template by Beman Dawes, who also added the unrolled_byte_loops sign
+// partial specialization to correctly extend the sign when cover integer size
+// differs from endian representation size.
+
+// TODO: When a compiler supporting constexpr becomes available, try possible uses.
+
+#ifndef BOOST_SPIRIT_ENDIAN_HPP
+#define BOOST_SPIRIT_ENDIAN_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#ifdef BOOST_ENDIAN_LOG
+# include <iostream>
+#endif
+
+#if defined(__BORLANDC__) || defined( __CODEGEARC__)
+# pragma pack(push, 1)
+#endif
+
+#include <boost/config.hpp>
+#include <boost/detail/endian.hpp>
+#define BOOST_MINIMAL_INTEGER_COVER_OPERATORS
+#define BOOST_NO_IO_COVER_OPERATORS
+#include <boost/spirit/home/support/detail/endian/cover_operators.hpp>
+#undef BOOST_NO_IO_COVER_OPERATORS
+#undef BOOST_MINIMAL_INTEGER_COVER_OPERATORS
+#include <boost/type_traits/is_signed.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/spirit/home/support/detail/scoped_enum_emulation.hpp>
+#include <iosfwd>
+#include <climits>
+
+# if CHAR_BIT != 8
+# error Platforms with CHAR_BIT != 8 are not supported
+# endif
+
+# define BOOST_ENDIAN_DEFAULT_CONSTRUCT {} // C++03
+
+# if defined(BOOST_ENDIAN_FORCE_PODNESS)
+# define BOOST_ENDIAN_NO_CTORS
+# endif
+
+
+namespace boost { namespace spirit
+{
+ namespace detail
+ {
+ // Unrolled loops for loading and storing streams of bytes.
+
+ template <typename T, std::size_t n_bytes,
+ bool sign=boost::is_signed<T>::value >
+ struct unrolled_byte_loops
+ {
+ typedef unrolled_byte_loops<T, n_bytes - 1, sign> next;
+
+ static T load_big(const unsigned char* bytes)
+ { return *(bytes - 1) | (next::load_big(bytes - 1) << 8); }
+ static T load_little(const unsigned char* bytes)
+ { return *bytes | (next::load_little(bytes + 1) << 8); }
+
+ static void store_big(char* bytes, T value)
+ {
+ *(bytes - 1) = static_cast<char>(value);
+ next::store_big(bytes - 1, value >> 8);
+ }
+ static void store_little(char* bytes, T value)
+ {
+ *bytes = static_cast<char>(value);
+ next::store_little(bytes + 1, value >> 8);
+ }
+ };
+
+ template <typename T>
+ struct unrolled_byte_loops<T, 1, false>
+ {
+ static T load_big(const unsigned char* bytes)
+ { return *(bytes - 1); }
+ static T load_little(const unsigned char* bytes)
+ { return *bytes; }
+ static void store_big(char* bytes, T value)
+ { *(bytes - 1) = static_cast<char>(value); }
+ static void store_little(char* bytes, T value)
+ { *bytes = static_cast<char>(value); }
+
+ };
+
+ template <typename T>
+ struct unrolled_byte_loops<T, 1, true>
+ {
+ static T load_big(const unsigned char* bytes)
+ { return *reinterpret_cast<const signed char*>(bytes - 1); }
+ static T load_little(const unsigned char* bytes)
+ { return *reinterpret_cast<const signed char*>(bytes); }
+ static void store_big(char* bytes, T value)
+ { *(bytes - 1) = static_cast<char>(value); }
+ static void store_little(char* bytes, T value)
+ { *bytes = static_cast<char>(value); }
+ };
+
+ template <typename T, std::size_t n_bytes>
+ inline
+ T load_big_endian(const void* bytes)
+ {
+ return unrolled_byte_loops<T, n_bytes>::load_big
+ (static_cast<const unsigned char*>(bytes) + n_bytes);
+ }
+
+ template <typename T, std::size_t n_bytes>
+ inline
+ T load_little_endian(const void* bytes)
+ {
+ return unrolled_byte_loops<T, n_bytes>::load_little
+ (static_cast<const unsigned char*>(bytes));
+ }
+
+ template <typename T, std::size_t n_bytes>
+ inline
+ void store_big_endian(void* bytes, T value)
+ {
+ unrolled_byte_loops<T, n_bytes>::store_big
+ (static_cast<char*>(bytes) + n_bytes, value);
+ }
+
+ template <typename T, std::size_t n_bytes>
+ inline
+ void store_little_endian(void* bytes, T value)
+ {
+ unrolled_byte_loops<T, n_bytes>::store_little
+ (static_cast<char*>(bytes), value);
+ }
+
+ } // namespace detail
+
+ namespace endian
+ {
+
+# ifdef BOOST_ENDIAN_LOG
+ bool endian_log(true);
+# endif
+
+
+ // endian class template and specializations ---------------------------------------//
+
+ BOOST_SCOPED_ENUM_START(endianness) { big, little, native }; BOOST_SCOPED_ENUM_END
+ BOOST_SCOPED_ENUM_START(alignment) { unaligned, aligned }; BOOST_SCOPED_ENUM_END
+
+ template <BOOST_SCOPED_ENUM(endianness) E, typename T, std::size_t n_bits,
+ BOOST_SCOPED_ENUM(alignment) A = alignment::unaligned>
+ class endian;
+
+ // Specializations that represent unaligned bytes.
+ // Taking an integer type as a parameter provides a nice way to pass both
+ // the size and signedness of the desired integer and get the appropriate
+ // corresponding integer type for the interface.
+
+ // unaligned big endian specialization
+ template <typename T, std::size_t n_bits>
+ class endian< endianness::big, T, n_bits, alignment::unaligned >
+ : cover_operators< endian< endianness::big, T, n_bits >, T >
+ {
+ BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
+ public:
+ typedef T value_type;
+# ifndef BOOST_ENDIAN_NO_CTORS
+ endian() BOOST_ENDIAN_DEFAULT_CONSTRUCT
+ explicit endian(T val)
+ {
+# ifdef BOOST_ENDIAN_LOG
+ if ( endian_log )
+ std::clog << "big, unaligned, " << n_bits << "-bits, construct(" << val << ")\n";
+# endif
+ detail::store_big_endian<T, n_bits/8>(m_value, val);
+ }
+# endif
+ endian & operator=(T val) { detail::store_big_endian<T, n_bits/8>(m_value, val); return *this; }
+ operator T() const
+ {
+# ifdef BOOST_ENDIAN_LOG
+ if ( endian_log )
+ std::clog << "big, unaligned, " << n_bits << "-bits, convert(" << detail::load_big_endian<T, n_bits/8>(m_value) << ")\n";
+# endif
+ return detail::load_big_endian<T, n_bits/8>(m_value);
+ }
+ private:
+ char m_value[n_bits/8];
+ };
+
+ // unaligned little endian specialization
+ template <typename T, std::size_t n_bits>
+ class endian< endianness::little, T, n_bits, alignment::unaligned >
+ : cover_operators< endian< endianness::little, T, n_bits >, T >
+ {
+ BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
+ public:
+ typedef T value_type;
+# ifndef BOOST_ENDIAN_NO_CTORS
+ endian() BOOST_ENDIAN_DEFAULT_CONSTRUCT
+ explicit endian(T val)
+ {
+# ifdef BOOST_ENDIAN_LOG
+ if ( endian_log )
+ std::clog << "little, unaligned, " << n_bits << "-bits, construct(" << val << ")\n";
+# endif
+ detail::store_little_endian<T, n_bits/8>(m_value, val);
+ }
+# endif
+ endian & operator=(T val) { detail::store_little_endian<T, n_bits/8>(m_value, val); return *this; }
+ operator T() const
+ {
+# ifdef BOOST_ENDIAN_LOG
+ if ( endian_log )
+ std::clog << "little, unaligned, " << n_bits << "-bits, convert(" << detail::load_little_endian<T, n_bits/8>(m_value) << ")\n";
+# endif
+ return detail::load_little_endian<T, n_bits/8>(m_value);
+ }
+ private:
+ char m_value[n_bits/8];
+ };
+
+ // unaligned native endian specialization
+ template <typename T, std::size_t n_bits>
+ class endian< endianness::native, T, n_bits, alignment::unaligned >
+ : cover_operators< endian< endianness::native, T, n_bits >, T >
+ {
+ BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
+ public:
+ typedef T value_type;
+# ifndef BOOST_ENDIAN_NO_CTORS
+ endian() BOOST_ENDIAN_DEFAULT_CONSTRUCT
+# ifdef BOOST_BIG_ENDIAN
+ explicit endian(T val) { detail::store_big_endian<T, n_bits/8>(m_value, val); }
+# else
+ explicit endian(T val) { detail::store_little_endian<T, n_bits/8>(m_value, val); }
+# endif
+# endif
+# ifdef BOOST_BIG_ENDIAN
+ endian & operator=(T val) { detail::store_big_endian<T, n_bits/8>(m_value, val); return *this; }
+ operator T() const { return detail::load_big_endian<T, n_bits/8>(m_value); }
+# else
+ endian & operator=(T val) { detail::store_little_endian<T, n_bits/8>(m_value, val); return *this; }
+ operator T() const { return detail::load_little_endian<T, n_bits/8>(m_value); }
+# endif
+ private:
+ char m_value[n_bits/8];
+ };
+
+ // Specializations that mimic built-in integer types.
+ // These typically have the same alignment as the underlying types.
+
+ // aligned big endian specialization
+ template <typename T, std::size_t n_bits>
+ class endian< endianness::big, T, n_bits, alignment::aligned >
+ : cover_operators< endian< endianness::big, T, n_bits, alignment::aligned >, T >
+ {
+ BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
+ BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 );
+ public:
+ typedef T value_type;
+# ifndef BOOST_ENDIAN_NO_CTORS
+ endian() BOOST_ENDIAN_DEFAULT_CONSTRUCT
+# ifdef BOOST_BIG_ENDIAN
+ endian(T val) : m_value(val) { }
+# else
+ explicit endian(T val) { detail::store_big_endian<T, sizeof(T)>(&m_value, val); }
+# endif
+# endif
+# ifdef BOOST_BIG_ENDIAN
+ endian & operator=(T val) { m_value = val; return *this; }
+ operator T() const { return m_value; }
+# else
+ endian & operator=(T val) { detail::store_big_endian<T, sizeof(T)>(&m_value, val); return *this; }
+ operator T() const { return detail::load_big_endian<T, sizeof(T)>(&m_value); }
+# endif
+ private:
+ T m_value;
+ };
+
+ // aligned little endian specialization
+ template <typename T, std::size_t n_bits>
+ class endian< endianness::little, T, n_bits, alignment::aligned >
+ : cover_operators< endian< endianness::little, T, n_bits, alignment::aligned >, T >
+ {
+ BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
+ BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 );
+ public:
+ typedef T value_type;
+# ifndef BOOST_ENDIAN_NO_CTORS
+ endian() BOOST_ENDIAN_DEFAULT_CONSTRUCT
+# ifdef BOOST_LITTLE_ENDIAN
+ endian(T val) : m_value(val) { }
+# else
+ explicit endian(T val) { detail::store_little_endian<T, sizeof(T)>(&m_value, val); }
+# endif
+# endif
+# ifdef BOOST_LITTLE_ENDIAN
+ endian & operator=(T val) { m_value = val; return *this; }
+ operator T() const { return m_value; }
+ #else
+ endian & operator=(T val) { detail::store_little_endian<T, sizeof(T)>(&m_value, val); return *this; }
+ operator T() const { return detail::load_little_endian<T, sizeof(T)>(&m_value); }
+ #endif
+ private:
+ T m_value;
+ };
+
+ // naming convention typedefs ------------------------------------------------------//
+
+ // unaligned big endian signed integer types
+ typedef endian< endianness::big, int_least8_t, 8 > big8_t;
+ typedef endian< endianness::big, int_least16_t, 16 > big16_t;
+ typedef endian< endianness::big, int_least32_t, 24 > big24_t;
+ typedef endian< endianness::big, int_least32_t, 32 > big32_t;
+ typedef endian< endianness::big, int_least64_t, 40 > big40_t;
+ typedef endian< endianness::big, int_least64_t, 48 > big48_t;
+ typedef endian< endianness::big, int_least64_t, 56 > big56_t;
+ typedef endian< endianness::big, int_least64_t, 64 > big64_t;
+
+ // unaligned big endian unsigned integer types
+ typedef endian< endianness::big, uint_least8_t, 8 > ubig8_t;
+ typedef endian< endianness::big, uint_least16_t, 16 > ubig16_t;
+ typedef endian< endianness::big, uint_least32_t, 24 > ubig24_t;
+ typedef endian< endianness::big, uint_least32_t, 32 > ubig32_t;
+ typedef endian< endianness::big, uint_least64_t, 40 > ubig40_t;
+ typedef endian< endianness::big, uint_least64_t, 48 > ubig48_t;
+ typedef endian< endianness::big, uint_least64_t, 56 > ubig56_t;
+ typedef endian< endianness::big, uint_least64_t, 64 > ubig64_t;
+
+ // unaligned little endian signed integer types
+ typedef endian< endianness::little, int_least8_t, 8 > little8_t;
+ typedef endian< endianness::little, int_least16_t, 16 > little16_t;
+ typedef endian< endianness::little, int_least32_t, 24 > little24_t;
+ typedef endian< endianness::little, int_least32_t, 32 > little32_t;
+ typedef endian< endianness::little, int_least64_t, 40 > little40_t;
+ typedef endian< endianness::little, int_least64_t, 48 > little48_t;
+ typedef endian< endianness::little, int_least64_t, 56 > little56_t;
+ typedef endian< endianness::little, int_least64_t, 64 > little64_t;
+
+ // unaligned little endian unsigned integer types
+ typedef endian< endianness::little, uint_least8_t, 8 > ulittle8_t;
+ typedef endian< endianness::little, uint_least16_t, 16 > ulittle16_t;
+ typedef endian< endianness::little, uint_least32_t, 24 > ulittle24_t;
+ typedef endian< endianness::little, uint_least32_t, 32 > ulittle32_t;
+ typedef endian< endianness::little, uint_least64_t, 40 > ulittle40_t;
+ typedef endian< endianness::little, uint_least64_t, 48 > ulittle48_t;
+ typedef endian< endianness::little, uint_least64_t, 56 > ulittle56_t;
+ typedef endian< endianness::little, uint_least64_t, 64 > ulittle64_t;
+
+ // unaligned native endian signed integer types
+ typedef endian< endianness::native, int_least8_t, 8 > native8_t;
+ typedef endian< endianness::native, int_least16_t, 16 > native16_t;
+ typedef endian< endianness::native, int_least32_t, 24 > native24_t;
+ typedef endian< endianness::native, int_least32_t, 32 > native32_t;
+ typedef endian< endianness::native, int_least64_t, 40 > native40_t;
+ typedef endian< endianness::native, int_least64_t, 48 > native48_t;
+ typedef endian< endianness::native, int_least64_t, 56 > native56_t;
+ typedef endian< endianness::native, int_least64_t, 64 > native64_t;
+
+ // unaligned native endian unsigned integer types
+ typedef endian< endianness::native, uint_least8_t, 8 > unative8_t;
+ typedef endian< endianness::native, uint_least16_t, 16 > unative16_t;
+ typedef endian< endianness::native, uint_least32_t, 24 > unative24_t;
+ typedef endian< endianness::native, uint_least32_t, 32 > unative32_t;
+ typedef endian< endianness::native, uint_least64_t, 40 > unative40_t;
+ typedef endian< endianness::native, uint_least64_t, 48 > unative48_t;
+ typedef endian< endianness::native, uint_least64_t, 56 > unative56_t;
+ typedef endian< endianness::native, uint_least64_t, 64 > unative64_t;
+
+#define BOOST_HAS_INT16_T
+#define BOOST_HAS_INT32_T
+#define BOOST_HAS_INT64_T
+
+ // These types only present if platform has exact size integers:
+ // aligned big endian signed integer types
+ // aligned big endian unsigned integer types
+ // aligned little endian signed integer types
+ // aligned little endian unsigned integer types
+
+ // aligned native endian typedefs are not provided because
+ // <cstdint> types are superior for this use case
+
+# if defined(BOOST_HAS_INT16_T)
+ typedef endian< endianness::big, int16_t, 16, alignment::aligned > aligned_big16_t;
+ typedef endian< endianness::big, uint16_t, 16, alignment::aligned > aligned_ubig16_t;
+ typedef endian< endianness::little, int16_t, 16, alignment::aligned > aligned_little16_t;
+ typedef endian< endianness::little, uint16_t, 16, alignment::aligned > aligned_ulittle16_t;
+# endif
+
+# if defined(BOOST_HAS_INT32_T)
+ typedef endian< endianness::big, int32_t, 32, alignment::aligned > aligned_big32_t;
+ typedef endian< endianness::big, uint32_t, 32, alignment::aligned > aligned_ubig32_t;
+ typedef endian< endianness::little, int32_t, 32, alignment::aligned > aligned_little32_t;
+ typedef endian< endianness::little, uint32_t, 32, alignment::aligned > aligned_ulittle32_t;
+# endif
+
+# if defined(BOOST_HAS_INT64_T)
+ typedef endian< endianness::big, int64_t, 64, alignment::aligned > aligned_big64_t;
+ typedef endian< endianness::big, uint64_t, 64, alignment::aligned > aligned_ubig64_t;
+ typedef endian< endianness::little, int64_t, 64, alignment::aligned > aligned_little64_t;
+ typedef endian< endianness::little, uint64_t, 64, alignment::aligned > aligned_ulittle64_t;
+# endif
+
+ } // namespace endian
+}} // namespace boost::spirit
+
+#if defined(__BORLANDC__) || defined( __CODEGEARC__)
+# pragma pack(pop)
+#endif
+
+#endif // BOOST_SPIRIT_ENDIAN_HPP