Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r76386 - in branches/release: . boost boost/spirit boost/spirit/home boost/spirit/home/karma boost/spirit/home/karma/binary boost/spirit/home/karma/detail boost/spirit/home/karma/directive boost/spirit/home/karma/nonterminal boost/spirit/home/karma/operator boost/spirit/home/lex/lexer/lexertl boost/spirit/home/lex/qi boost/spirit/home/qi/binary boost/spirit/home/support boost/spirit/home/support/detail/endian boost/spirit/home/support/detail/lexer boost/spirit/home/support/detail/lexer/parser boost/spirit/home/support/iterators boost/spirit/home/support/iterators/detail boost/spirit/repository/home/karma/nonterminal libs libs/spirit libs/spirit/doc libs/spirit/doc/karma libs/spirit/doc/qi libs/spirit/repository/doc libs/spirit/repository/doc/qi libs/spirit/repository/example/karma libs/spirit/repository/example/qi libs/spirit/test libs/spirit/test/karma libs/spirit/test/lex libs/spirit/test/qi
From: hartmut.kaiser_at_[hidden]
Date: 2012-01-09 09:36:50


Author: hkaiser
Date: 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
New Revision: 76386
URL: http://svn.boost.org/trac/boost/changeset/76386

Log:
Spirit: merging from trunk
Added:
   branches/release/libs/spirit/repository/doc/what_s_new.qbk
      - copied unchanged from r75321, /trunk/libs/spirit/repository/doc/what_s_new.qbk
   branches/release/libs/spirit/test/karma/regression_center_alignment.cpp
      - copied unchanged from r76385, /trunk/libs/spirit/test/karma/regression_center_alignment.cpp
   branches/release/libs/spirit/test/lex/regression_static_wide_6253.cpp
      - copied unchanged from r75910, /trunk/libs/spirit/test/lex/regression_static_wide_6253.cpp
Properties modified:
   branches/release/ (props changed)
   branches/release/boost/ (props changed)
   branches/release/boost/spirit/ (props changed)
   branches/release/boost/spirit/home/ (props changed)
   branches/release/boost/spirit/home/karma/ (props changed)
   branches/release/boost/spirit/home/support/attributes.hpp (contents, props changed)
   branches/release/libs/ (props changed)
   branches/release/libs/spirit/ (props changed)
   branches/release/libs/spirit/doc/ (props changed)
   branches/release/libs/spirit/test/ (props changed)
Text files modified:
   branches/release/boost/spirit/home/karma/binary/binary.hpp | 119 ++++++++++++++++++----
   branches/release/boost/spirit/home/karma/detail/extract_from.hpp | 34 +++---
   branches/release/boost/spirit/home/karma/detail/pass_container.hpp | 56 +++++-----
   branches/release/boost/spirit/home/karma/directive/center_alignment.hpp | 32 +++---
   branches/release/boost/spirit/home/karma/directive/duplicate.hpp | 32 +++---
   branches/release/boost/spirit/home/karma/nonterminal/rule.hpp | 2
   branches/release/boost/spirit/home/karma/operator/alternative.hpp | 5
   branches/release/boost/spirit/home/karma/operator/sequence.hpp | 43 ++++---
   branches/release/boost/spirit/home/lex/lexer/lexertl/generate_static.hpp | 209 ++++++++++++++++++++++++++-------------
   branches/release/boost/spirit/home/lex/lexer/lexertl/lexer.hpp | 110 ++++++++++----------
   branches/release/boost/spirit/home/lex/qi/plain_raw_token.hpp | 18 +-
   branches/release/boost/spirit/home/lex/qi/plain_token.hpp | 109 +++++++++++++++++++-
   branches/release/boost/spirit/home/lex/qi/plain_tokenid.hpp | 114 +++++++++++++++++++--
   branches/release/boost/spirit/home/lex/qi/plain_tokenid_mask.hpp | 20 ++-
   branches/release/boost/spirit/home/qi/binary/binary.hpp | 129 +++++++++++++++++++----
   branches/release/boost/spirit/home/support/attributes.hpp | 5
   branches/release/boost/spirit/home/support/common_terminals.hpp | 6 +
   branches/release/boost/spirit/home/support/detail/endian/endian.hpp | 154 +++++++++++++++++++++++++++-
   branches/release/boost/spirit/home/support/detail/lexer/parser/parser.hpp | 2
   branches/release/boost/spirit/home/support/detail/lexer/rules.hpp | 20 +++
   branches/release/boost/spirit/home/support/extended_variant.hpp | 31 +++++
   branches/release/boost/spirit/home/support/iterators/detail/combine_policies.hpp | 162 ++++++++++++++++++++----------
   branches/release/boost/spirit/home/support/iterators/multi_pass.hpp | 22 ++--
   branches/release/boost/spirit/repository/home/karma/nonterminal/subrule.hpp | 10
   branches/release/libs/spirit/doc/index.idx | 20 +++
   branches/release/libs/spirit/doc/karma/binary.qbk | 172 +++++++++++++++++++++++++-------
   branches/release/libs/spirit/doc/qi/binary.qbk | 88 +++++++++++++---
   branches/release/libs/spirit/doc/qi/error_handling.qbk | 2
   branches/release/libs/spirit/doc/qi/quick_reference.qbk | 4
   branches/release/libs/spirit/doc/spirit2.qbk | 4
   branches/release/libs/spirit/doc/what_s_new.qbk | 44 ++++++--
   branches/release/libs/spirit/repository/doc/qi/seek.qbk | 32 ++---
   branches/release/libs/spirit/repository/doc/spirit2_repository.qbk | 3
   branches/release/libs/spirit/repository/example/karma/calc2_ast.hpp | 27 +++-
   branches/release/libs/spirit/repository/example/qi/seek.cpp | 46 +++-----
   branches/release/libs/spirit/test/Jamfile | 27 ++--
   branches/release/libs/spirit/test/karma/binary1.cpp | 20 +++
   branches/release/libs/spirit/test/karma/binary2.cpp | 26 ++++
   branches/release/libs/spirit/test/karma/binary3.cpp | 40 +++++++
   branches/release/libs/spirit/test/qi/binary.cpp | 38 +++++++
   branches/release/libs/spirit/test/qi/symbols1.cpp | 10 +
   branches/release/libs/spirit/test/qi/test.hpp | 52 +++++++++
   42 files changed, 1560 insertions(+), 539 deletions(-)

Modified: branches/release/boost/spirit/home/karma/binary/binary.hpp
==============================================================================
--- branches/release/boost/spirit/home/karma/binary/binary.hpp (original)
+++ branches/release/boost/spirit/home/karma/binary/binary.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -27,6 +27,7 @@
 #include <boost/mpl/or.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_floating_point.hpp>
 #include <boost/config.hpp>
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -45,6 +46,19 @@
                                                                               \
 /***/
 
+#define BOOST_SPIRIT_ENABLE_BINARY_IEEE754(name) \
+ template<> \
+ struct use_terminal<karma::domain, tag::name>: mpl::true_ {}; \
+ \
+ template<typename A0> \
+ struct use_terminal<karma::domain, terminal_ex<tag::name, \
+ fusion::vector1<A0> > >: is_floating_point<A0> {}; \
+ \
+ template<> \
+ struct use_lazy_terminal<karma::domain, tag::name, 1> : mpl::true_ {}; \
+ \
+/***/
+
 namespace boost { namespace spirit
 {
     ///////////////////////////////////////////////////////////////////////////
@@ -63,10 +77,16 @@
     BOOST_SPIRIT_ENABLE_BINARY(big_qword) // enables big_qword
     BOOST_SPIRIT_ENABLE_BINARY(little_qword) // enables little_qword
 #endif
-
+ BOOST_SPIRIT_ENABLE_BINARY_IEEE754(bin_float)
+ BOOST_SPIRIT_ENABLE_BINARY_IEEE754(big_bin_float)
+ BOOST_SPIRIT_ENABLE_BINARY_IEEE754(little_bin_float)
+ BOOST_SPIRIT_ENABLE_BINARY_IEEE754(bin_double)
+ BOOST_SPIRIT_ENABLE_BINARY_IEEE754(big_bin_double)
+ BOOST_SPIRIT_ENABLE_BINARY_IEEE754(little_bin_double)
 }}
 
 #undef BOOST_SPIRIT_ENABLE_BINARY
+#undef BOOST_SPIRIT_ENABLE_BINARY_IEEE754
 
 ///////////////////////////////////////////////////////////////////////////////
 namespace boost { namespace spirit { namespace karma
@@ -84,6 +104,12 @@
     using boost::spirit::big_qword;
     using boost::spirit::little_qword;
 #endif
+ using boost::spirit::bin_float;
+ using boost::spirit::big_bin_float;
+ using boost::spirit::little_bin_float;
+ using boost::spirit::bin_double;
+ using boost::spirit::big_bin_double;
+ using boost::spirit::little_bin_double;
 #endif
 
     using boost::spirit::byte_type;
@@ -98,6 +124,12 @@
     using boost::spirit::big_qword_type;
     using boost::spirit::little_qword_type;
 #endif
+ using boost::spirit::bin_float_type;
+ using boost::spirit::big_bin_float_type;
+ using boost::spirit::little_bin_float_type;
+ using boost::spirit::bin_double_type;
+ using boost::spirit::big_bin_double_type;
+ using boost::spirit::little_bin_double_type;
 
     namespace detail
     {
@@ -141,6 +173,26 @@
         };
 #endif
 
+ template <int bits>
+ struct floating_point
+ {
+ BOOST_SPIRIT_ASSERT_MSG(
+ bits == 32 || bits == 64,
+ not_supported_binary_size, ());
+ };
+
+ template <>
+ struct floating_point<32>
+ {
+ typedef float type;
+ };
+
+ template <>
+ struct floating_point<64>
+ {
+ typedef double type;
+ };
+
         ///////////////////////////////////////////////////////////////////////
         template <BOOST_SCOPED_ENUM(boost::endian::endianness) bits>
         struct what;
@@ -174,14 +226,12 @@
     }
 
     ///////////////////////////////////////////////////////////////////////////
- template <BOOST_SCOPED_ENUM(boost::endian::endianness) endian, int bits>
+ template <typename T, BOOST_SCOPED_ENUM(boost::endian::endianness) endian, int bits>
     struct any_binary_generator
- : primitive_generator<any_binary_generator<endian, bits> >
+ : primitive_generator<any_binary_generator<T, endian, bits> >
     {
         template <typename Context, typename Unused = unused_type>
- struct attribute
- : karma::detail::integer<bits>
- {};
+ struct attribute: T {};
 
         template <
             typename OutputIterator, typename Context, typename Delimiter
@@ -195,16 +245,14 @@
             // 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::endian::endian<
- endian, typename karma::detail::integer<bits>::type, bits
- > p;
+ boost::endian::endian<endian, typename T::type, bits> p;
 
 #if defined(BOOST_MSVC)
 // warning C4244: 'argument' : conversion from 'const int' to 'foo', possible loss of data
 #pragma warning(push)
 #pragma warning(disable: 4244)
 #endif
- typedef typename karma::detail::integer<bits>::type attribute_type;
+ typedef typename T::type attribute_type;
             p = traits::extract_from<attribute_type>(attr, context);
 #if defined(BOOST_MSVC)
 #pragma warning(pop)
@@ -245,9 +293,9 @@
     };
 
     ///////////////////////////////////////////////////////////////////////////
- template <BOOST_SCOPED_ENUM(boost::endian::endianness) endian, int bits>
+ template <typename T, BOOST_SCOPED_ENUM(boost::endian::endianness) endian, int bits>
     struct literal_binary_generator
- : primitive_generator<literal_binary_generator<endian, bits> >
+ : primitive_generator<literal_binary_generator<T, endian, bits> >
     {
         template <typename Context, typename Unused>
         struct attribute
@@ -255,15 +303,15 @@
             typedef unused_type type;
         };
 
- template <typename T>
- literal_binary_generator(T const& t)
+ template <typename V>
+ literal_binary_generator(V const& v)
         {
 #if defined(BOOST_MSVC)
 // warning C4244: 'argument' : conversion from 'const int' to 'foo', possible loss of data
 #pragma warning(push)
 #pragma warning(disable: 4244)
 #endif
- data_ = t;
+ data_ = v;
 #if defined(BOOST_MSVC)
 #pragma warning(pop)
 #endif
@@ -296,9 +344,8 @@
             return karma::detail::what<endian>::is();
         }
 
- typedef boost::endian::endian<
- endian, typename karma::detail::integer<bits>::type, bits
- > data_type;
+ typedef boost::endian::endian<endian, typename T::type,
+ bits> data_type;
 
         data_type data_;
     };
@@ -308,11 +355,11 @@
     ///////////////////////////////////////////////////////////////////////////
     namespace detail
     {
- template <BOOST_SCOPED_ENUM(boost::endian::endianness) endian
+ template <typename T, BOOST_SCOPED_ENUM(boost::endian::endianness) endian
           , int bits>
         struct basic_binary
         {
- typedef any_binary_generator<endian, bits> result_type;
+ typedef any_binary_generator<T, endian, bits> result_type;
 
             result_type operator()(unused_type, unused_type) const
             {
@@ -320,11 +367,11 @@
             }
         };
 
- template <typename Modifiers
+ template <typename Modifiers, typename T
           , BOOST_SCOPED_ENUM(boost::endian::endianness) endian, int bits>
         struct basic_binary_literal
         {
- typedef literal_binary_generator<endian, bits> result_type;
+ typedef literal_binary_generator<T, endian, bits> result_type;
 
             template <typename Terminal>
             result_type operator()(Terminal const& term, unused_type) const
@@ -337,12 +384,13 @@
 #define BOOST_SPIRIT_MAKE_BINARY_PRIMITIVE(name, endiantype, bits) \
     template <typename Modifiers> \
     struct make_primitive<tag::name, Modifiers> \
- : detail::basic_binary<boost::endian::endianness::endiantype, bits> {}; \
+ : detail::basic_binary<detail::integer<bits>, \
+ 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 \
+ : detail::basic_binary_literal<Modifiers, detail::integer<bits> \
         , boost::endian::endianness::endiantype, bits> {}; \
                                                                               \
     /***/
@@ -362,6 +410,29 @@
 
 #undef BOOST_SPIRIT_MAKE_BINARY_PRIMITIVE
 
+#define BOOST_SPIRIT_MAKE_BINARY_IEEE754_PRIMITIVE(name, endiantype, bits) \
+ template <typename Modifiers> \
+ struct make_primitive<tag::name, Modifiers> \
+ : detail::basic_binary<detail::floating_point<bits>, \
+ 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, detail::floating_point<bits> \
+ , boost::endian::endianness::endiantype, bits> {}; \
+ \
+ /***/
+
+ BOOST_SPIRIT_MAKE_BINARY_IEEE754_PRIMITIVE(bin_float, native, 32)
+ BOOST_SPIRIT_MAKE_BINARY_IEEE754_PRIMITIVE(big_bin_float, big, 32)
+ BOOST_SPIRIT_MAKE_BINARY_IEEE754_PRIMITIVE(little_bin_float, little, 32)
+ BOOST_SPIRIT_MAKE_BINARY_IEEE754_PRIMITIVE(bin_double, native, 64)
+ BOOST_SPIRIT_MAKE_BINARY_IEEE754_PRIMITIVE(big_bin_double, big, 64)
+ BOOST_SPIRIT_MAKE_BINARY_IEEE754_PRIMITIVE(little_bin_double, little, 64)
+
+#undef BOOST_SPIRIT_MAKE_BINARY_IEEE754_PRIMITIVE
+
 }}}
 
 #endif

Modified: branches/release/boost/spirit/home/karma/detail/extract_from.hpp
==============================================================================
--- branches/release/boost/spirit/home/karma/detail/extract_from.hpp (original)
+++ branches/release/boost/spirit/home/karma/detail/extract_from.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -23,8 +23,8 @@
 namespace boost { namespace spirit { namespace traits
 {
     ///////////////////////////////////////////////////////////////////////////
- // This file contains attribute extraction utilities. The utilities
- // provided also accept spirit's unused_type; all no-ops. Compiler
+ // This file contains attribute extraction utilities. The utilities
+ // provided also accept spirit's unused_type; all no-ops. Compiler
     // optimization will easily strip these away.
     ///////////////////////////////////////////////////////////////////////////
 
@@ -33,13 +33,13 @@
         ///////////////////////////////////////////////////////////////////////
         // extract first and second element of a fusion sequence
         template <typename T>
- struct add_const_ref
- : add_reference<typename add_const<T>::type>
+ struct add_const_ref
+ : add_reference<typename add_const<T>::type>
         {};
 
         template <typename T, int N>
- struct value_at_c
- : add_const_ref<typename fusion::result_of::value_at_c<T, N>::type>
+ struct value_at_c
+ : add_const_ref<typename fusion::result_of::value_at_c<T, N>::type>
         {};
     }
 
@@ -47,7 +47,7 @@
     template <typename Attribute, typename Exposed, typename Enable/*= void*/>
     struct extract_from_attribute
     {
- typedef typename traits::one_element_sequence<Attribute>::type
+ typedef typename traits::one_element_sequence<Attribute>::type
             is_one_element_sequence;
 
         typedef typename mpl::eval_if<
@@ -63,7 +63,7 @@
         }
 
         // This handles the case where the attribute is a single element fusion
- // sequence. We silently extract the only element and treat it as the
+ // sequence. We silently extract the only element and treat it as the
         // attribute to generate output from.
         template <typename Context>
         static type call(Attribute const& attr, Context& ctx, mpl::true_)
@@ -78,7 +78,7 @@
         }
     };
 
- // This handles optional attributes.
+ // This handles optional attributes.
     template <typename Attribute, typename Exposed>
     struct extract_from_attribute<boost::optional<Attribute>, Exposed>
     {
@@ -103,7 +103,7 @@
         }
     };
 
- // This handles attributes wrapped inside a boost::ref().
+ // This handles attributes wrapped inside a boost::ref().
     template <typename Attribute, typename Exposed>
     struct extract_from_attribute<reference_wrapper<Attribute>, Exposed>
     {
@@ -120,14 +120,14 @@
     template <typename Attribute, typename Exposed, typename Enable>
     struct extract_from_container
     {
- typedef typename traits::container_value<Attribute const>::type
+ typedef typename traits::container_value<Attribute const>::type
             value_type;
- typedef typename is_convertible<value_type, Exposed>::type
+ typedef typename is_convertible<value_type, Exposed>::type
             is_convertible_to_value_type;
 
         typedef typename mpl::if_<
            mpl::or_<
- is_same<value_type, Exposed>, is_same<Attribute, Exposed> >
+ is_same<value_type, Exposed>, is_same<Attribute, Exposed> >
           , Exposed const&, Exposed
>::type type;
 
@@ -137,7 +137,7 @@
         static type call(Attribute const& attr, Context&, mpl::true_, Pred)
         {
             // return first element from container
- typedef typename traits::container_iterator<Attribute const>::type
+ typedef typename traits::container_iterator<Attribute const>::type
                 iterator_type;
 
             iterator_type it = traits::begin(attr);
@@ -176,7 +176,7 @@
         static type call(Attribute const& attr, Context& ctx)
         {
             typedef typename mpl::and_<
- traits::is_string<Exposed>, traits::is_string<Attribute>
+ traits::is_string<Exposed>, traits::is_string<Attribute>
>::type handle_strings;
 
             // return first element from container
@@ -208,7 +208,7 @@
             return extract_from_attribute<Attribute, Exposed>::call(attr, ctx);
         }
 
- // overload for containers (but not for variants or optionals
+ // overload for containers (but not for variants or optionals
         // holding containers)
         template <typename Exposed, typename Attribute, typename Context>
         inline typename spirit::result_of::extract_from<Exposed, Attribute>::type
@@ -230,7 +230,7 @@
         typedef typename mpl::and_<
             traits::is_container<Attribute>
           , traits::not_is_variant<Attribute>
- , traits::not_is_optional<Attribute>
+ , traits::not_is_optional<Attribute>
>::type is_not_wrapped_container;
 
         return detail::extract_from<Exposed>(attr, ctx

Modified: branches/release/boost/spirit/home/karma/detail/pass_container.hpp
==============================================================================
--- branches/release/boost/spirit/home/karma/detail/pass_container.hpp (original)
+++ branches/release/boost/spirit/home/karma/detail/pass_container.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -38,17 +38,17 @@
             Sequence
           , typename traits::is_weak_substitute<Attribute, ValueType>::type
           , typename mpl::not_<
- traits::is_weak_substitute<Attribute, ValueType>
+ traits::is_weak_substitute<Attribute, ValueType>
>::type>
     {};
 
- // pass_through_container: utility to check decide whether a provided
- // container attribute needs to be passed through to the current component
+ // pass_through_container: utility to check decide whether a provided
+ // container attribute needs to be passed through to the current component
     // or of we need to split the container by passing along instances of its
     // value type
 
- // if the expected attribute of the current component is neither a Fusion
- // sequence nor a container, we will pass through the provided container
+ // if the expected attribute of the current component is neither a Fusion
+ // sequence nor a container, we will pass through the provided container
     // only if its value type is not compatible with the component
     template <typename Container, typename ValueType, typename Attribute
       , typename Sequence, typename Enable = void>
@@ -58,9 +58,9 @@
 
     // Specialization for fusion sequences, in this case we check whether all
     // the types in the sequence are convertible to the lhs attribute.
- //
+ //
     // We return false if the rhs attribute itself is a fusion sequence, which
- // is compatible with the LHS sequence (we want to pass through this
+ // is compatible with the LHS sequence (we want to pass through this
     // attribute without it being split apart).
     template <typename Container, typename ValueType, typename Attribute
       , typename Sequence = mpl::true_>
@@ -71,7 +71,7 @@
     {};
 
     // If the value type of the container is not a Fusion sequence, we pass
- // through the container if each of the elements of the Attribute
+ // through the container if each of the elements of the Attribute
     // sequence is compatible with either the container or its value type.
     template <typename Container, typename ValueType, typename Attribute
       , typename Sequence
@@ -87,7 +87,7 @@
     };
 
     // If both, the Attribute and the value type of the provided container
- // are Fusion sequences, we pass the container only if the two
+ // are Fusion sequences, we pass the container only if the two
     // sequences are not compatible.
     template <typename Container, typename ValueType, typename Attribute
       , typename Sequence>
@@ -115,14 +115,14 @@
     // Specialization for containers
     //
     // If the value type of the attribute of the current component is not
- // a Fusion sequence, we have to pass through the provided container if
+ // a Fusion sequence, we have to pass through the provided container if
     // both are compatible.
     template <typename Container, typename ValueType, typename Attribute
       , typename Sequence, typename AttributeValueType
       , bool IsSequence = fusion::traits::is_sequence<AttributeValueType>::value>
     struct pass_through_container_container
       : mpl::or_<
- traits::is_weak_substitute<Container, Attribute>
+ traits::is_weak_substitute<Container, Attribute>
           , traits::is_weak_substitute<Container, AttributeValueType> >
     {};
 
@@ -148,16 +148,16 @@
 
     // Specialization for exposed optional attributes
     //
- // If the type embedded in the exposed optional is not a Fusion
+ // If the type embedded in the exposed optional is not a Fusion
     // sequence we pass through the container attribute if it is compatible
- // either to the optionals embedded type or to the containers value
+ // either to the optionals embedded type or to the containers value
     // type.
     template <typename Container, typename ValueType, typename Attribute
       , typename Sequence
       , bool IsSequence = fusion::traits::is_sequence<Attribute>::value>
     struct pass_through_container_optional
       : mpl::or_<
- traits::is_weak_substitute<Container, Attribute>
+ traits::is_weak_substitute<Container, Attribute>
           , traits::is_weak_substitute<ValueType, Attribute> >
     {};
 
@@ -175,7 +175,7 @@
     template <typename Container, typename ValueType, typename Attribute
       , typename Sequence>
     struct pass_through_container
- : pass_through_container_base<Container, ValueType, Attribute, Sequence>
+ : pass_through_container_base<Container, ValueType, Attribute, Sequence>
     {};
 
     // Handle optional attributes
@@ -184,7 +184,7 @@
     struct pass_through_container<
             Container, ValueType, boost::optional<Attribute>, Sequence>
       : pass_through_container_optional<
- Container, ValueType, Attribute, Sequence>
+ Container, ValueType, Attribute, Sequence>
     {};
 
     // If both, the containers value type and the exposed attribute type are
@@ -199,8 +199,8 @@
     {};
 
     // Specialization for exposed variant attributes
- //
- // We pass through the container attribute if at least one of the embedded
+ //
+ // We pass through the container attribute if at least one of the embedded
     // types in the variant requires to pass through the attribute
 
 #define BOOST_SPIRIT_PASS_THROUGH_CONTAINER(z, N, _) \
@@ -252,7 +252,7 @@
         typedef typename F::context_type context_type;
 
         pass_container(F const& f, Iterator begin, Iterator end)
- : f(f), iter(begin), end(end)
+ : f(f), iter(begin), end(end)
         {}
 
         bool is_at_end() const
@@ -271,7 +271,7 @@
         bool dispatch_container(Component const& component, mpl::false_) const
         {
             // get the next value to generate from container
- if (!is_at_end() && !f(component, traits::deref(iter)))
+ if (!is_at_end() && !f(component, traits::deref(iter)))
             {
                 // needs to return false as long as everything is ok
                 traits::next(iter);
@@ -282,8 +282,8 @@
             return true;
         }
 
- // this is for the case when the current element is able to handle an
- // attribute which is a container itself, this element will push its
+ // this is for the case when the current element is able to handle an
+ // attribute which is a container itself, this element will push its
         // data directly into the attribute container
         template <typename Component>
         bool dispatch_container(Component const& component, mpl::true_) const
@@ -292,7 +292,7 @@
         }
 
         ///////////////////////////////////////////////////////////////////////
- // this is for the case when the current element doesn't expect an
+ // this is for the case when the current element doesn't expect an
         // attribute
         template <typename Component>
         bool dispatch_attribute(Component const& component, mpl::false_) const
@@ -305,15 +305,15 @@
         bool dispatch_attribute(Component const& component, mpl::true_) const
         {
             typedef typename traits::container_value<Attr>::type value_type;
- typedef typename
+ typedef typename
                 traits::attribute_of<Component, context_type>::type
             lhs_attribute;
 
             // this predicate detects, whether the value type of the container
- // attribute is a substitute for the attribute of the current
- // element
+ // attribute is a substitute for the attribute of the current
+ // element
             typedef mpl::and_<
- traits::handles_container<Component, Attr, context_type>
+ traits::handles_container<Component, Attr, context_type>
               , traits::pass_through_container<
                     Attr, value_type, lhs_attribute, Sequence, karma::domain>
> predicate;
@@ -328,7 +328,7 @@
         {
             // we need to dispatch depending on the type of the attribute
             // of the current element (component). If this is has no attribute
- // we shouldn't use an element of the container but unused_type
+ // we shouldn't use an element of the container but unused_type
             // instead
             typedef traits::not_is_unused<
                 typename traits::attribute_of<Component, context_type>::type

Modified: branches/release/boost/spirit/home/karma/directive/center_alignment.hpp
==============================================================================
--- branches/release/boost/spirit/home/karma/directive/center_alignment.hpp (original)
+++ branches/release/boost/spirit/home/karma/directive/center_alignment.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -53,20 +53,20 @@
 
     // enables *lazy* center(d)[g], where d provides a generator
     template <>
- struct use_lazy_directive<karma::domain, tag::center, 1>
+ struct use_lazy_directive<karma::domain, tag::center, 1>
       : mpl::true_ {};
 
- // enables center(w, d)[g], where d is a generator and w is a maximum
+ // enables center(w, d)[g], where d is a generator and w is a maximum
     // width
     template <typename Width, typename Padding>
     struct use_directive<karma::domain
           , terminal_ex<tag::center, fusion::vector2<Width, Padding> > >
       : spirit::traits::matches<karma::domain, Padding> {};
 
- // enables *lazy* center(w, d)[g], where d provides a generator and w is
+ // enables *lazy* center(w, d)[g], where d provides a generator and w is
     // a maximum width
     template <>
- struct use_lazy_directive<karma::domain, tag::center, 2>
+ struct use_lazy_directive<karma::domain, tag::center, 2>
       : mpl::true_ {};
 
 }}
@@ -82,15 +82,15 @@
     namespace detail
     {
         ///////////////////////////////////////////////////////////////////////
- // The center_generate template function is used for all the
- // different flavors of the center[] directive.
+ // The center_generate template function is used for all the
+ // different flavors of the center[] directive.
         ///////////////////////////////////////////////////////////////////////
- template <typename OutputIterator, typename Context, typename Delimiter,
+ template <typename OutputIterator, typename Context, typename Delimiter,
             typename Attribute, typename Embedded, typename Padding>
- inline static bool
- center_generate(OutputIterator& sink, Context& ctx,
- Delimiter const& d, Attribute const& attr, Embedded const& e,
- unsigned int const width, Padding const& p)
+ inline static bool
+ center_generate(OutputIterator& sink, Context& ctx,
+ Delimiter const& d, Attribute const& attr, Embedded const& e,
+ unsigned int const width, Padding const& p)
         {
 #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
             e; // suppresses warning: C4100: 'e' : unreferenced formal parameter
@@ -99,7 +99,7 @@
             detail::enable_buffering<OutputIterator> buffering(sink, width);
             bool r = false;
 
- // first generate the embedded output
+ // first generate the embedded output
             {
                 detail::disable_counting<OutputIterator> nocounting(sink);
                 r = e.generate(sink, ctx, d, attr);
@@ -111,7 +111,7 @@
             detail::enable_counting<OutputIterator> counting(sink);
 
             std::size_t const pre = width - (buffering.buffer_size() + width)/2;
- while (r && counting.count() < pre)
+ while (r && counting.count() < pre)
                 r = p.generate(sink, ctx, unused, unused);
 
             if (r) {
@@ -119,7 +119,7 @@
                 buffering.buffer_copy();
 
                 // generate the right padding
- while (r && counting.count() < width)
+ while (r && counting.count() < width)
                     r = p.generate(sink, ctx, unused, unused);
             }
             return r;
@@ -185,12 +185,12 @@
 
         typedef mpl::int_<
             generator_properties::countingbuffer |
- subject_type::properties::value | padding_type::properties::value
+ subject_type::properties::value | padding_type::properties::value
> properties;
 
         template <typename Context, typename Iterator>
         struct attribute
- : traits::attribute_of<Subject, Context, Iterator>::type
+ : traits::attribute_of<Subject, Context, Iterator>
         {};
 
         padding_center_alignment(Subject const& subject, Padding const& padding

Modified: branches/release/boost/spirit/home/karma/directive/duplicate.hpp
==============================================================================
--- branches/release/boost/spirit/home/karma/directive/duplicate.hpp (original)
+++ branches/release/boost/spirit/home/karma/directive/duplicate.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -51,29 +51,29 @@
         template <typename T
           , bool IsSequence = fusion::traits::is_sequence<T>::value>
         struct attribute_count
- : fusion::result_of::size<T>
+ : fusion::result_of::size<T>
         {};
 
         template <>
- struct attribute_count<unused_type, false>
- : mpl::int_<0>
+ struct attribute_count<unused_type, false>
+ : mpl::int_<0>
         {};
 
         template <typename T>
- struct attribute_count<T, false>
- : mpl::int_<1>
+ struct attribute_count<T, false>
+ : mpl::int_<1>
         {};
 
         ///////////////////////////////////////////////////////////////////////
         template <typename T
           , bool IsSequence = fusion::traits::is_sequence<T>::value>
- struct first_attribute_of_subject
- : fusion::result_of::at_c<T, 0>
+ struct first_attribute_of_subject
+ : fusion::result_of::at_c<T, 0>
         {};
 
         template <typename T>
- struct first_attribute_of_subject<T, false>
- : mpl::identity<T>
+ struct first_attribute_of_subject<T, false>
+ : mpl::identity<T>
         {};
 
         template <typename T, typename Context, typename Iterator>
@@ -93,20 +93,20 @@
 
             static type call(T const& t)
             {
- return fusion::make_cons(cref(t)
+ return fusion::make_cons(boost::cref(t)
                   , duplicate_sequence_attribute<Attribute, T, N-1>::call(t));
             }
         };
 
         template <typename Attribute, typename T>
- struct duplicate_sequence_attribute<Attribute, T, 1>
+ struct duplicate_sequence_attribute<Attribute, T, 1>
         {
             typedef typename fusion::result_of::make_cons<
                 reference_wrapper<T const> >::type type;
 
             static type call(T const& t)
             {
- return fusion::make_cons(cref(t));
+ return fusion::make_cons(boost::cref(t));
             }
         };
 
@@ -130,7 +130,7 @@
         };
 
         template <typename Attribute, typename T>
- struct duplicate_attribute<Attribute, T, 0, false>
+ struct duplicate_attribute<Attribute, T, 0, false>
         {
             typedef unused_type type;
 
@@ -155,12 +155,12 @@
     template <typename Attribute, typename T>
     inline typename detail::duplicate_attribute<Attribute, T>::type
     duplicate_attribute(T const& t)
- {
+ {
         return detail::duplicate_attribute<Attribute, T>::call(t);
     }
 
     ///////////////////////////////////////////////////////////////////////////
- // duplicate_directive duplicate its attribute for all elements of the
+ // duplicate_directive duplicate its attribute for all elements of the
     // subject generator without generating anything itself
     ///////////////////////////////////////////////////////////////////////////
     template <typename Subject>
@@ -182,7 +182,7 @@
         bool generate(OutputIterator& sink, Context& ctx, Delimiter const& d
           , Attribute const& attr) const
         {
- typedef typename traits::attribute_of<Subject, Context>::type
+ typedef typename traits::attribute_of<Subject, Context>::type
                 subject_attr_type;
             return subject.generate(sink, ctx, d
               , duplicate_attribute<subject_attr_type>(attr));

Modified: branches/release/boost/spirit/home/karma/nonterminal/rule.hpp
==============================================================================
--- branches/release/boost/spirit/home/karma/nonterminal/rule.hpp (original)
+++ branches/release/boost/spirit/home/karma/nonterminal/rule.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -436,7 +436,7 @@
             typename attribute_of<
                 karma::rule<IteratorA, T1, T2, T3, T4>
               , Context, IteratorB
- >::type, Attribute>
+ >::type, Attribute>
     {};
 }}}
 

Modified: branches/release/boost/spirit/home/karma/operator/alternative.hpp
==============================================================================
--- branches/release/boost/spirit/home/karma/operator/alternative.hpp (original)
+++ branches/release/boost/spirit/home/karma/operator/alternative.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -26,6 +26,7 @@
 #include <boost/fusion/include/for_each.hpp>
 #include <boost/mpl/accumulate.hpp>
 #include <boost/mpl/bitor.hpp>
+#include <boost/config.hpp>
 
 namespace boost { namespace spirit
 {
@@ -61,9 +62,11 @@
             };
 
             // never called, but needed for decltype-based result_of (C++0x)
+#ifndef BOOST_NO_RVALUE_REFERENCES
             template <typename Element>
             typename result<element_properties(Element)>::type
- operator()(Element&) const;
+ operator()(Element&&) const;
+#endif
         };
 
         typedef typename mpl::accumulate<

Modified: branches/release/boost/spirit/home/karma/operator/sequence.hpp
==============================================================================
--- branches/release/boost/spirit/home/karma/operator/sequence.hpp (original)
+++ branches/release/boost/spirit/home/karma/operator/sequence.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -37,6 +37,7 @@
 #include <boost/mpl/not.hpp>
 #include <boost/fusion/include/transform.hpp>
 #include <boost/mpl/accumulate.hpp>
+#include <boost/config.hpp>
 
 ///////////////////////////////////////////////////////////////////////////////
 namespace boost { namespace spirit
@@ -72,9 +73,11 @@
             };
 
             // never called, but needed for decltype-based result_of (C++0x)
+#ifndef BOOST_NO_RVALUE_REFERENCES
             template <typename Element>
             typename result<element_properties(Element)>::type
- operator()(Element&) const;
+ operator()(Element&&) const;
+#endif
         };
 
         typedef typename mpl::accumulate<
@@ -135,14 +138,14 @@
                 OutputIterator, Context, Delimiter> fail_function;
             typedef traits::attribute_not_unused<Context> predicate;
 
- // wrap the attribute in a tuple if it is not a tuple or if the
+ // wrap the attribute in a tuple if it is not a tuple or if the
             // attribute of this sequence is a single element tuple
             typedef typename attribute<Context>::type_ attr_type_;
             typename traits::wrap_if_not_tuple<Attribute
               , typename mpl::and_<
                     traits::one_element_sequence<attr_type_>
                   , mpl::not_<traits::one_element_sequence<Attribute> >
- >::type
+ >::type
>::type attr(attr_);
 
             // return false if *any* of the generators fail
@@ -152,12 +155,12 @@
             typedef typename traits::attribute_size<Attribute>::type size_type;
 
             // fail generating if sequences have not the same (logical) length
- return !r && (!Strict::value ||
- // This ignores container element count (which is not good),
- // but allows valid attributes to succeed. This will lead to
+ return !r && (!Strict::value ||
+ // This ignores container element count (which is not good),
+ // but allows valid attributes to succeed. This will lead to
                 // false positives (failing generators, even if they shouldn't)
- // if the embedded component is restricting the number of
- // container elements it consumes (i.e. repeat). This solution
+ // if the embedded component is restricting the number of
+ // container elements it consumes (i.e. repeat). This solution
                 // is not optimal but much better than letting _all_ repetitive
                 // components fail.
                 Pred1::value ||
@@ -181,17 +184,17 @@
                 typename add_const<Attribute>::type
>::type iterator_type;
 
- typedef
- typename traits::make_indirect_iterator<iterator_type>::type
+ typedef
+ typename traits::make_indirect_iterator<iterator_type>::type
             indirect_iterator_type;
             typedef detail::pass_container<
- fail_function, Attribute, indirect_iterator_type, mpl::true_>
+ fail_function, Attribute, indirect_iterator_type, mpl::true_>
             pass_container;
 
             iterator_type begin = traits::begin(attr_);
             iterator_type end = traits::end(attr_);
 
- pass_container pass(fail_function(sink, ctx, d),
+ pass_container pass(fail_function(sink, ctx, d),
                 indirect_iterator_type(begin), indirect_iterator_type(end));
             bool r = fusion::any(elements, pass);
 
@@ -207,11 +210,11 @@
         bool generate(OutputIterator& sink, Context& ctx, Delimiter const& d
           , Attribute const& attr) const
         {
- typedef typename traits::is_container<Attribute>::type
+ typedef typename traits::is_container<Attribute>::type
                 is_container;
 
             typedef typename attribute<Context>::type_ attr_type_;
- typedef typename traits::one_element_sequence<attr_type_>::type
+ typedef typename traits::one_element_sequence<attr_type_>::type
                 is_one_element_sequence;
 
             return generate_impl(sink, ctx, d, attr, is_container()
@@ -231,7 +234,7 @@
     };
 
     template <typename Elements>
- struct sequence
+ struct sequence
       : base_sequence<Elements, mpl::false_, sequence<Elements> >
     {
         typedef base_sequence<Elements, mpl::false_, sequence> base_sequence_;
@@ -241,10 +244,10 @@
     };
 
     template <typename Elements>
- struct strict_sequence
+ struct strict_sequence
       : base_sequence<Elements, mpl::true_, strict_sequence<Elements> >
     {
- typedef base_sequence<Elements, mpl::true_, strict_sequence>
+ typedef base_sequence<Elements, mpl::true_, strict_sequence>
             base_sequence_;
 
         strict_sequence(Elements const& subject)
@@ -257,12 +260,12 @@
     namespace detail
     {
         template <typename Elements, bool strict_mode = false>
- struct make_sequence
+ struct make_sequence
           : make_nary_composite<Elements, sequence>
         {};
 
         template <typename Elements>
- struct make_sequence<Elements, true>
+ struct make_sequence<Elements, true>
           : make_nary_composite<Elements, strict_sequence>
         {};
     }
@@ -280,7 +283,7 @@
     {
         typedef iterator_range<detail::indirect_iterator<Iterator> > type;
     };
-}}}
+}}}
 
 namespace boost { namespace spirit { namespace traits
 {

Modified: branches/release/boost/spirit/home/lex/lexer/lexertl/generate_static.hpp
==============================================================================
--- branches/release/boost/spirit/home/lex/lexer/lexertl/generate_static.hpp (original)
+++ branches/release/boost/spirit/home/lex/lexer/lexertl/generate_static.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -1,7 +1,7 @@
 // Copyright (c) 2008-2009 Ben Hanson
 // Copyright (c) 2008-2011 Hartmut Kaiser
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
+//
+// 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 !defined(BOOST_SPIRIT_LEX_LEXERTL_GENERATE_CPP_FEB_10_2008_0855PM)
@@ -22,33 +22,83 @@
 #include <boost/lexical_cast.hpp>
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace boost { namespace spirit { namespace lex { namespace lexertl
+namespace boost { namespace spirit { namespace lex { namespace lexertl
 {
     namespace detail
     {
 
+ ///////////////////////////////////////////////////////////////////////////
+ template <typename CharT>
+ struct string_lit;
+
+ template <>
+ struct string_lit<char>
+ {
+ static char get(char c) { return c; }
+ static std::string get(char const* str = "") { return str; }
+ };
+
+ template <>
+ struct string_lit<wchar_t>
+ {
+ static wchar_t get(char c)
+ {
+ typedef std::ctype<wchar_t> ctype_t;
+ return std::use_facet<ctype_t>(std::locale()).widen(c);
+ }
+ static std::basic_string<wchar_t> get(char const* source = "")
+ {
+ using namespace std; // some systems have size_t in ns std
+ size_t len = strlen(source);
+ std::auto_ptr<wchar_t> result (new wchar_t[len+1]);
+ result.get()[len] = '\0';
+
+ // working with wide character streams is supported only if the
+ // platform provides the std::ctype<wchar_t> facet
+ BOOST_ASSERT(std::has_facet<std::ctype<wchar_t> >(std::locale()));
+
+ std::use_facet<std::ctype<wchar_t> >(std::locale())
+ .widen(source, source + len, result.get());
+ return result.get();
+ }
+ };
+
+ template <typename Char>
+ inline Char L(char c)
+ {
+ return string_lit<Char>::get(c);
+ }
+
+ template <typename Char>
+ inline std::basic_string<Char> L(char const* c = "")
+ {
+ return string_lit<Char>::get(c);
+ }
+
+ ///////////////////////////////////////////////////////////////////////////
+ template <typename Char>
     inline bool
- generate_delimiter(std::ostream &os_)
+ generate_delimiter(std::basic_ostream<Char> &os_)
     {
- os_ << std::string(80, '/') << "\n";
+ os_ << std::basic_string<Char>(80, '/') << "\n";
         return os_.good();
     }
 
     ///////////////////////////////////////////////////////////////////////////
- // Generate a table of the names of the used lexer states, which is a bit
- // tricky, because the table stored with the rules is sorted based on the
+ // Generate a table of the names of the used lexer states, which is a bit
+ // tricky, because the table stored with the rules is sorted based on the
     // names, but we need it sorted using the state ids.
     template <typename Char>
- inline bool
+ inline bool
     generate_cpp_state_info (boost::lexer::basic_rules<Char> const& rules_
- , std::ostream &os_, char const* name_suffix)
+ , std::basic_ostream<Char> &os_, Char const* name_suffix)
     {
- // we need to re-sort the state names in ascending order of the state
+ // we need to re-sort the state names in ascending order of the state
         // ids, filling possible gaps in between later
- typedef typename
+ typedef typename
             boost::lexer::basic_rules<Char>::string_size_t_map::const_iterator
         state_iterator;
- typedef std::map<std::size_t, char const*> reverse_state_map_type;
+ typedef std::map<std::size_t, Char const*> reverse_state_map_type;
 
         reverse_state_map_type reverse_state_map;
         state_iterator send = rules_.statemap().end();
@@ -60,7 +110,8 @@
 
         generate_delimiter(os_);
         os_ << "// this table defines the names of the lexer states\n";
- os_ << "char const* const lexer_state_names"
+ os_ << boost::lexer::detail::strings<Char>::char_name()
+ << " const* const lexer_state_names"
             << (name_suffix[0] ? "_" : "") << name_suffix
             << "[" << rules_.statemap().size() << "] = \n{\n";
 
@@ -73,7 +124,9 @@
             {
                 os_ << " 0, // \"<undefined state>\"\n";
             }
- os_ << " \"" << (*rit).second << "\"";
+ os_ << " "
+ << boost::lexer::detail::strings<Char>::char_prefix()
+ << "\"" << (*rit).second << "\"";
             if (++rit != rend)
                 os_ << ",\n";
             else
@@ -83,17 +136,18 @@
 
         generate_delimiter(os_);
         os_ << "// this variable defines the number of lexer states\n";
- os_ << "std::size_t const lexer_state_count"
+ os_ << "std::size_t const lexer_state_count"
             << (name_suffix[0] ? "_" : "") << name_suffix
             << " = " << rules_.statemap().size() << ";\n\n";
         return os_.good();
     }
 
- inline bool
- generate_cpp_state_table (std::ostream &os_, char const* name_suffix
- , bool bol, bool eol)
+ template <typename Char>
+ inline bool
+ generate_cpp_state_table (std::basic_ostream<Char> &os_
+ , Char const* name_suffix, bool bol, bool eol)
     {
- std::string suffix(name_suffix[0] ? "_" : "");
+ std::basic_string<Char> suffix(L<Char>(name_suffix[0] ? "_" : ""));
         suffix += name_suffix;
 
         generate_delimiter(os_);
@@ -102,7 +156,8 @@
         os_ << " // version number and feature-set of compatible static lexer engine\n";
         os_ << " enum\n";
         os_ << " {\n static_version = "
- << boost::lexical_cast<std::string>(SPIRIT_STATIC_LEXER_VERSION) << ",\n";
+ << boost::lexical_cast<std::basic_string<Char> >(SPIRIT_STATIC_LEXER_VERSION)
+ << ",\n";
         os_ << " supports_bol = " << std::boolalpha << bol << ",\n";
         os_ << " supports_eol = " << std::boolalpha << eol << "\n";
         os_ << " };\n\n";
@@ -110,13 +165,14 @@
         os_ << " static std::size_t state_count()\n";
         os_ << " {\n return lexer_state_count" << suffix << "; \n }\n\n";
         os_ << " // return the name of the lexer state as given by 'idx'\n";
- os_ << " static char const* state_name(std::size_t idx)\n";
+ os_ << " static " << boost::lexer::detail::strings<Char>::char_name()
+ << " const* state_name(std::size_t idx)\n";
         os_ << " {\n return lexer_state_names" << suffix << "[idx]; \n }\n\n";
         os_ << " // return the next matched token\n";
         os_ << " template<typename Iterator>\n";
         os_ << " static std::size_t next(std::size_t &start_state_, bool& bol_\n";
         os_ << " , Iterator &start_token_, Iterator const& end_, std::size_t& unique_id_)\n";
- os_ << " {\n return next_token" << suffix
+ os_ << " {\n return next_token" << suffix
             << "(start_state_, bol_, start_token_, end_, unique_id_);\n }\n";
         os_ << "};\n\n";
         return os_.good();
@@ -125,8 +181,8 @@
     ///////////////////////////////////////////////////////////////////////////
     // generate function body based on traversing the DFA tables
     template <typename Char>
- bool generate_function_body_dfa(std::ostream & os_
- , boost::lexer::basic_state_machine<Char> const &sm_)
+ bool generate_function_body_dfa(std::basic_ostream<Char>& os_
+ , boost::lexer::basic_state_machine<Char> const &sm_)
     {
         std::size_t const dfas_ = sm_.data()._dfa->size();
         std::size_t const lookups_ = sm_.data()._lookup->front()->size();
@@ -147,7 +203,7 @@
                 std::size_t const* lookup_ = &sm_.data()._lookup[state_]->front();
                 std::size_t const* dfa_ = &sm_.data()._dfa[state_]->front();
 
- os_ << " static std::size_t const lookup" << state_
+ os_ << " static std::size_t const lookup" << state_
                     << "_[" << lookups_ << "] = {\n ";
                 for (/**/; i_ < count_; ++i_)
                 {
@@ -203,7 +259,7 @@
             std::size_t count_ = sm_.data()._dfa_alphabet.size();
             std::size_t i_ = 1;
 
- os_ << " static std::size_t const* lookup_arr_[" << count_
+ os_ << " static std::size_t const* lookup_arr_[" << count_
                 << "] = { lookup0_";
             for (i_ = 1; i_ < count_; ++i_)
             {
@@ -211,7 +267,7 @@
             }
             os_ << " };\n";
 
- os_ << " static std::size_t const dfa_alphabet_arr_["
+ os_ << " static std::size_t const dfa_alphabet_arr_["
                 << count_ << "] = { ";
             os_ << sm_.data()._dfa_alphabet.front ();
             for (i_ = 1; i_ < count_; ++i_)
@@ -220,7 +276,7 @@
             }
             os_ << " };\n";
 
- os_ << " static std::size_t const* dfa_arr_[" << count_
+ os_ << " static std::size_t const* dfa_arr_[" << count_
                 << "] = { ";
             os_ << "dfa0_";
             for (i_ = 1; i_ < count_; ++i_)
@@ -255,9 +311,9 @@
             }
             os_ << " };\n";
 
- os_ << " static std::size_t const dfa_alphabet_ = "
+ os_ << " static std::size_t const dfa_alphabet_ = "
                 << sm_.data()._dfa_alphabet.front () << ";\n";
- os_ << " static std::size_t const dfa_["
+ os_ << " static std::size_t const dfa_["
                 << sm_.data()._dfa[0]->size () << "] = {\n ";
             count_ = sm_.data()._dfa[0]->size () / 8;
             for (i_ = 0; i_ < count_; ++i_)
@@ -534,10 +590,10 @@
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename Char>
- inline std::string get_charlit(Char ch)
+ inline std::basic_string<Char> get_charlit(Char ch)
     {
         std::basic_string<Char> result;
- boost::lexer::basic_string_token<Char>::escape_char (ch, result);
+ boost::lexer::basic_string_token<Char>::escape_char(ch, result);
         return result;
     }
 
@@ -573,8 +629,8 @@
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename Char>
- bool generate_function_body_switch(std::ostream & os_
- , boost::lexer::basic_state_machine<Char> const &sm_)
+ bool generate_function_body_switch(std::basic_ostream<Char> & os_
+ , boost::lexer::basic_state_machine<Char> const &sm_)
     {
         typedef typename boost::lexer::basic_state_machine<Char>::iterator
             iterator_type;
@@ -622,7 +678,7 @@
         os_ << " Iterator end_token_ = start_token_;\n";
         os_ << '\n';
 
- os_ << " " << ((lookups_ == 256) ? "char" : "wchar_t")
+ os_ << " " << ((lookups_ == 256) ? "char" : "wchar_t")
             << " ch_ = 0;\n\n";
 
         if (dfas_ > 1)
@@ -679,7 +735,7 @@
                     if (transitions_) os_ << '\n';
                 }
 
- if (t_ < transitions_ ||
+ if (t_ < transitions_ ||
                     iter_->bol_index != boost::lexer::npos ||
                     iter_->eol_index != boost::lexer::npos)
                 {
@@ -687,12 +743,12 @@
                     os_ << " ch_ = *curr_;\n";
                     if (iter_->bol_index != boost::lexer::npos)
                     {
- os_ << "\n if (bol) goto state" << dfa_ << '_'
+ os_ << "\n if (bol) goto state" << dfa_ << '_'
                             << iter_->bol_index << ";\n";
                     }
                     if (iter_->eol_index != boost::lexer::npos)
                     {
- os_ << "\n if (ch_ == '\n') goto state" << dfa_
+ os_ << "\n if (ch_ == '\n') goto state" << dfa_
                             << '_' << iter_->eol_index << ";\n";
                     }
                     os_ << " ++curr_;\n";
@@ -700,10 +756,10 @@
 
                 for (/**/; t_ < transitions_; ++t_)
                 {
- char const *ptr_ = iter_->token._charset.c_str();
- char const *end_ = ptr_ + iter_->token._charset.size();
- char start_char_ = 0;
- char curr_char_ = 0;
+ Char const *ptr_ = iter_->token._charset.c_str();
+ Char const *end_ = ptr_ + iter_->token._charset.size();
+ Char start_char_ = 0;
+ Char curr_char_ = 0;
                     bool range_ = false;
                     bool first_char_ = true;
 
@@ -727,7 +783,7 @@
                             {
                                 os_ << ((iter_->token._negated) ? " && " : " || ");
                             }
- else
+ else
                             {
                                 first_char_ = false;
                             }
@@ -738,20 +794,20 @@
                                     os_ << "!";
                                 }
                                 os_ << "(ch_ >= '" << get_charlit(start_char_)
- << "' && ch_ <= '"
+ << "' && ch_ <= '"
                                     << get_charlit(curr_char_) << "')";
                                 range_ = false;
                             }
                             else
                             {
- os_ << "ch_ "
+ os_ << "ch_ "
                                     << ((iter_->token._negated) ? "!=" : "==")
                                     << " '" << get_charlit(curr_char_) << "'";
                             }
                         }
                     }
 
- os_ << ") goto state" << dfa_ << '_' << iter_->goto_state
+ os_ << ") goto state" << dfa_ << '_' << iter_->goto_state
                         << ";\n";
                     ++iter_;
                 }
@@ -818,10 +874,11 @@
     ///////////////////////////////////////////////////////////////////////////
     // Generate a tokenizer for the given state machine.
     template <typename Char, typename F>
- inline bool
+ inline bool
     generate_cpp (boost::lexer::basic_state_machine<Char> const& sm_
       , boost::lexer::basic_rules<Char> const& rules_
- , std::ostream &os_, char const* name_suffix, F generate_function_body)
+ , std::basic_ostream<Char> &os_, Char const* name_suffix
+ , F generate_function_body)
     {
         if (sm_.data()._lookup->empty())
             return false;
@@ -838,14 +895,15 @@
             "http://www.boost.org/LICENSE_1_0.txt)\n\n";
         os_ << "// Auto-generated by boost::lexer, do not edit\n\n";
 
- std::string guard(name_suffix);
- guard += name_suffix[0] ? "_" : "";
- guard += __DATE__ "_" __TIME__;
- std::string::size_type p = guard.find_first_of(": ");
- while (std::string::npos != p)
+ std::basic_string<Char> guard(name_suffix);
+ guard += L<Char>(name_suffix[0] ? "_" : "");
+ guard += L<Char>(__DATE__ "_" __TIME__);
+ typename std::basic_string<Char>::size_type p =
+ guard.find_first_of(L<Char>(": "));
+ while (std::string::npos != p)
         {
- guard.replace(p, 1, "_");
- p = guard.find_first_of(": ", p);
+ guard.replace(p, 1, L<Char>("_"));
+ p = guard.find_first_of(L<Char>(": "), p);
         }
         boost::to_upper(guard);
 
@@ -868,14 +926,14 @@
         generate_delimiter(os_);
         os_ << "// this function returns the next matched token\n";
         os_ << "template<typename Iterator>\n";
- os_ << "std::size_t next_token" << (name_suffix[0] ? "_" : "")
+ os_ << "std::size_t next_token" << (name_suffix[0] ? "_" : "")
             << name_suffix << " (";
 
         if (dfas_ > 1)
         {
             os_ << "std::size_t& start_state_, ";
         }
- else
+ else
         {
             os_ << "std::size_t& /*start_state_*/, ";
         }
@@ -883,7 +941,7 @@
         {
             os_ << "bool& bol_, ";
         }
- else
+ else
         {
             os_ << "bool& /*bol_*/, ";
         }
@@ -896,7 +954,7 @@
             return false;
         os_ << "}\n\n";
 
- if (!generate_cpp_state_table(os_, name_suffix
+ if (!generate_cpp_state_table<Char>(os_, name_suffix
             , sm_.data()._seen_BOL_assertion, sm_.data()._seen_EOL_assertion))
         {
             return false;
@@ -913,9 +971,10 @@
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename Lexer, typename F>
- inline bool
- generate_static(Lexer const& lexer, std::ostream& os
- , char const* name_suffix, F f)
+ inline bool
+ generate_static(Lexer const& lexer
+ , std::basic_ostream<typename Lexer::char_type>& os
+ , typename Lexer::char_type const* name_suffix, F f)
     {
         if (!lexer.init_dfa(true)) // always minimize DFA for static lexers
             return false;
@@ -924,12 +983,14 @@
     }
 
     ///////////////////////////////////////////////////////////////////////////
- // deprecated function, will be removed in the future (this has been
+ // deprecated function, will be removed in the future (this has been
     // replaced by the function generate_static_dfa - see below).
     template <typename Lexer>
- inline bool
- generate_static(Lexer const& lexer, std::ostream& os
- , char const* name_suffix = "")
+ inline bool
+ generate_static(Lexer const& lexer
+ , std::basic_ostream<typename Lexer::char_type>& os
+ , typename Lexer::char_type const* name_suffix =
+ detail::L<typename Lexer::char_type>())
     {
         return generate_static(lexer, os, name_suffix
           , &detail::generate_function_body_dfa<typename Lexer::char_type>);
@@ -937,9 +998,11 @@
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename Lexer>
- inline bool
- generate_static_dfa(Lexer const& lexer, std::ostream& os
- , char const* name_suffix = "")
+ inline bool
+ generate_static_dfa(Lexer const& lexer
+ , std::basic_ostream<typename Lexer::char_type>& os
+ , typename Lexer::char_type const* name_suffix =
+ detail::L<typename Lexer::char_type>())
     {
         return generate_static(lexer, os, name_suffix
           , &detail::generate_function_body_dfa<typename Lexer::char_type>);
@@ -947,9 +1010,11 @@
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename Lexer>
- inline bool
- generate_static_switch(Lexer const& lexer, std::ostream& os
- , char const* name_suffix = "")
+ inline bool
+ generate_static_switch(Lexer const& lexer
+ , std::basic_ostream<typename Lexer::char_type>& os
+ , typename Lexer::char_type const* name_suffix =
+ detail::L<typename Lexer::char_type>())
     {
         return generate_static(lexer, os, name_suffix
           , &detail::generate_function_body_switch<typename Lexer::char_type>);

Modified: branches/release/boost/spirit/home/lex/lexer/lexertl/lexer.hpp
==============================================================================
--- branches/release/boost/spirit/home/lex/lexer/lexertl/lexer.hpp (original)
+++ branches/release/boost/spirit/home/lex/lexer/lexertl/lexer.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -1,6 +1,6 @@
 // Copyright (c) 2001-2011 Hartmut Kaiser
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
+//
+// 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 !defined(BOOST_SPIRIT_LEX_LEXER_MAR_17_2007_0139PM)
@@ -28,13 +28,13 @@
 #include <boost/foreach.hpp>
 
 namespace boost { namespace spirit { namespace lex { namespace lexertl
-{
+{
     ///////////////////////////////////////////////////////////////////////////
     namespace detail
     {
         ///////////////////////////////////////////////////////////////////////
         // The must_escape function checks if the given character value needs
- // to be preceded by a backslash character to disable its special
+ // to be preceded by a backslash character to disable its special
         // meaning in the context of a regular expression
         ///////////////////////////////////////////////////////////////////////
         template <typename Char>
@@ -60,15 +60,15 @@
         }
 
         ///////////////////////////////////////////////////////////////////////
- // The escape function returns the string representation of the given
- // character value, possibly escaped with a backslash character, to
+ // The escape function returns the string representation of the given
+ // character value, possibly escaped with a backslash character, to
         // allow it being safely used in a regular expression definition.
         ///////////////////////////////////////////////////////////////////////
         template <typename Char>
- inline std::basic_string<Char> escape(Char ch)
- {
+ inline std::basic_string<Char> escape(Char ch)
+ {
             std::basic_string<Char> result(1, ch);
- if (detail::must_escape(ch))
+ if (detail::must_escape(ch))
             {
                 typedef typename std::basic_string<Char>::size_type size_type;
                 result.insert((size_type)0, 1, '\\');
@@ -77,7 +77,7 @@
         }
 
         ///////////////////////////////////////////////////////////////////////
- //
+ //
         ///////////////////////////////////////////////////////////////////////
         inline boost::lexer::regex_flags map_flags(unsigned int flags)
         {
@@ -93,31 +93,33 @@
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename Lexer, typename F>
- bool generate_static(Lexer const&, std::ostream&, char const*, F);
+ bool generate_static(Lexer const&
+ , std::basic_ostream<typename Lexer::char_type>&
+ , typename Lexer::char_type const*, F);
 
     ///////////////////////////////////////////////////////////////////////////
     //
- // Every lexer type to be used as a lexer for Spirit has to conform to
+ // Every lexer type to be used as a lexer for Spirit has to conform to
     // the following public interface:
     //
- // typedefs:
+ // typedefs:
     // iterator_type The type of the iterator exposed by this lexer.
- // token_type The type of the tokens returned from the exposed
+ // token_type The type of the tokens returned from the exposed
     // iterators.
     //
     // functions:
     // default constructor
- // Since lexers are instantiated as base classes
- // only it might be a good idea to make this
+ // Since lexers are instantiated as base classes
+ // only it might be a good idea to make this
     // constructor protected.
     // begin, end Return a pair of iterators, when dereferenced
- // returning the sequence of tokens recognized in
- // the input stream given as the parameters to the
+ // returning the sequence of tokens recognized in
+ // the input stream given as the parameters to the
     // begin() function.
- // add_token Should add the definition of a token to be
+ // add_token Should add the definition of a token to be
     // recognized by this lexer.
     // clear Should delete all current token definitions
- // associated with the given state of this lexer
+ // associated with the given state of this lexer
     // object.
     //
     // template parameters:
@@ -126,25 +128,25 @@
     // Token The type of the tokens to be returned from the
     // exposed token iterator.
     // Functor The type of the InputPolicy to use to instantiate
- // the multi_pass iterator type to be used as the
+ // the multi_pass iterator type to be used as the
     // token iterator (returned from begin()/end()).
     //
     ///////////////////////////////////////////////////////////////////////////
 
     ///////////////////////////////////////////////////////////////////////////
     //
- // The lexer class is a implementation of a Spirit.Lex lexer on
- // top of Ben Hanson's lexertl library as outlined above (For more
+ // The lexer class is a implementation of a Spirit.Lex lexer on
+ // top of Ben Hanson's lexertl library as outlined above (For more
     // information about lexertl go here: http://www.benhanson.net/lexertl.html).
     //
- // This class is supposed to be used as the first and only template
+ // This class is supposed to be used as the first and only template
     // parameter while instantiating instances of a lex::lexer class.
     //
     ///////////////////////////////////////////////////////////////////////////
     template <typename Token = token<>
       , typename Iterator = typename Token::iterator_type
       , typename Functor = functor<Token, lexertl::detail::data, Iterator> >
- class lexer
+ class lexer
     {
     private:
         struct dummy { void true_() {} };
@@ -156,13 +158,13 @@
         operator safe_bool() const
             { return initialized_dfa_ ? &dummy::true_ : 0; }
 
- typedef typename boost::detail::iterator_traits<Iterator>::value_type
+ typedef typename boost::detail::iterator_traits<Iterator>::value_type
             char_type;
         typedef std::basic_string<char_type> string_type;
 
         typedef boost::lexer::basic_rules<char_type> basic_rules_type;
 
- // Every lexer type to be used as a lexer for Spirit has to conform to
+ // Every lexer type to be used as a lexer for Spirit has to conform to
         // a public interface .
         typedef Token token_type;
         typedef typename Token::id_type id_type;
@@ -170,7 +172,7 @@
 
     private:
         // this type is purely used for the iterator_type construction below
- struct iterator_data_type
+ struct iterator_data_type
         {
             typedef typename Functor::semantic_actions_type semantic_actions_type;
 
@@ -195,7 +197,7 @@
         // tokens.
         iterator_type begin(Iterator& first, Iterator const& last
           , char_type const* initial_state = 0) const
- {
+ {
             if (!init_dfa()) // never minimize DFA for dynamic lexers
                 return iterator_type();
 
@@ -203,16 +205,16 @@
             return iterator_type(iterator_data, first, last, initial_state);
         }
 
- // Return the end iterator usable to stop iterating over the generated
+ // Return the end iterator usable to stop iterating over the generated
         // tokens.
         iterator_type end() const
- {
- return iterator_type();
+ {
+ return iterator_type();
         }
 
     protected:
         // Lexer instances can be created by means of a derived class only.
- lexer(unsigned int flags)
+ lexer(unsigned int flags)
           : flags_(detail::map_flags(flags))
           , rules_(flags_)
           , initialized_dfa_(false)
@@ -220,7 +222,7 @@
 
     public:
         // interface for token definition management
- std::size_t add_token(char_type const* state, char_type tokendef,
+ std::size_t add_token(char_type const* state, char_type tokendef,
             std::size_t token_id, char_type const* targetstate)
         {
             add_state(state);
@@ -234,7 +236,7 @@
                 add_state(targetstate);
             return rules_.add(state, detail::escape(tokendef), token_id, targetstate);
         }
- std::size_t add_token(char_type const* state, string_type const& tokendef,
+ std::size_t add_token(char_type const* state, string_type const& tokendef,
             std::size_t token_id, char_type const* targetstate)
         {
             add_state(state);
@@ -269,7 +271,7 @@
         }
         std::size_t add_state(char_type const* state)
         {
- if (state == all_states())
+ if (state == all_states())
                 return all_states_id;
 
             std::size_t stateid = rules_.state(state);
@@ -279,12 +281,12 @@
             }
             return stateid;
         }
- string_type initial_state() const
- {
+ string_type initial_state() const
+ {
             return string_type(rules_.initial());
         }
- string_type all_states() const
- {
+ string_type all_states() const
+ {
             return string_type(rules_.all_states());
         }
 
@@ -293,14 +295,14 @@
         void add_action(std::size_t unique_id, std::size_t state, F act)
         {
             // If you see an error here stating add_action is not a member of
- // fusion::unused_type then you are probably having semantic actions
+ // fusion::unused_type then you are probably having semantic actions
             // attached to at least one token in the lexer definition without
             // using the lex::lexertl::actor_lexer<> as its base class.
             typedef typename Functor::wrap_action_type wrapper_type;
             if (state == all_states_id) {
                 // add the action to all known states
- typedef typename
- basic_rules_type::string_size_t_map::value_type
+ typedef typename
+ basic_rules_type::string_size_t_map::value_type
                 state_type;
 
                 std::size_t states = rules_.statemap().size();
@@ -320,8 +322,8 @@
 // actions_.add_action(unique_id, add_state(state), wrapper_type::call(act));
 // }
 
- // We do not minimize the state machine by default anymore because
- // Ben said: "If you can afford to generate a lexer at runtime, there
+ // We do not minimize the state machine by default anymore because
+ // Ben said: "If you can afford to generate a lexer at runtime, there
         // is little point in calling minimise."
         // Go figure.
         bool init_dfa(bool minimize = false) const
@@ -356,26 +358,28 @@
         mutable bool initialized_dfa_;
 
         // generator functions must be able to access members directly
- template <typename Lexer, typename F>
- friend bool generate_static(Lexer const&, std::ostream&, char const*, F);
+ template <typename Lexer, typename F>
+ friend bool generate_static(Lexer const&
+ , std::basic_ostream<typename Lexer::char_type>&
+ , typename Lexer::char_type const*, F);
     };
 
     ///////////////////////////////////////////////////////////////////////////
     //
- // The actor_lexer class is another implementation of a Spirit.Lex
- // lexer on top of Ben Hanson's lexertl library as outlined above (For
- // more information about lexertl go here:
+ // The actor_lexer class is another implementation of a Spirit.Lex
+ // lexer on top of Ben Hanson's lexertl library as outlined above (For
+ // more information about lexertl go here:
     // http://www.benhanson.net/lexertl.html).
     //
     // The only difference to the lexer class above is that token_def
- // definitions may have semantic (lexer) actions attached while being
+ // definitions may have semantic (lexer) actions attached while being
     // defined:
     //
     // int w;
     // token_def word = "[^ \t\n]+";
     // self = word[++ref(w)]; // see example: word_count_lexer
     //
- // This class is supposed to be used as the first and only template
+ // This class is supposed to be used as the first and only template
     // parameter while instantiating instances of a lex::lexer class.
     //
     ///////////////////////////////////////////////////////////////////////////
@@ -386,7 +390,7 @@
     {
     protected:
         // Lexer instances can be created by means of a derived class only.
- actor_lexer(unsigned int flags)
+ actor_lexer(unsigned int flags)
           : lexer<Token, Iterator, Functor>(flags) {}
     };
 

Modified: branches/release/boost/spirit/home/lex/qi/plain_raw_token.hpp
==============================================================================
--- branches/release/boost/spirit/home/lex/qi/plain_raw_token.hpp (original)
+++ branches/release/boost/spirit/home/lex/qi/plain_raw_token.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -1,6 +1,6 @@
 // Copyright (c) 2001-2011 Hartmut Kaiser
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
+//
+// 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 !defined(BOOST_SPIRIT_LEX_PLAIN_RAW_TOKEN_JUN_03_2011_0853PM)
@@ -25,6 +25,7 @@
 #include <boost/mpl/or.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/is_enum.hpp>
+#include <boost/lexical_cast.hpp>
 
 namespace boost { namespace spirit
 {
@@ -59,7 +60,7 @@
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename TokenId>
- struct plain_raw_token
+ struct plain_raw_token
       : primitive_parser<plain_raw_token<TokenId> >
     {
         template <typename Context, typename Iterator>
@@ -80,16 +81,16 @@
             qi::skip_over(first, last, skipper); // always do a pre-skip
 
             if (first != last) {
- // simply match the token id with the id this component has
+ // simply match the token id with the id this component has
                 // been initialized with
 
- typedef typename
- boost::detail::iterator_traits<Iterator>::value_type
+ typedef typename
+ boost::detail::iterator_traits<Iterator>::value_type
                 token_type;
                 typedef typename token_type::id_type id_type;
 
                 token_type const& t = *first;
- if (std::size_t(~0) == id || id_type(id) == t.id()) {
+ if (id_type(~0) == id_type(id) || id_type(id) == t.id()) {
                     spirit::traits::assign_to(t, attr);
                     ++first;
                     return true;
@@ -101,7 +102,8 @@
         template <typename Context>
         info what(Context& /*context*/) const
         {
- return info("token");
+ return info("raw_token",
+ "raw_token(" + boost::lexical_cast<utf8_string>(id) + ")");
         }
 
         TokenId id;

Modified: branches/release/boost/spirit/home/lex/qi/plain_token.hpp
==============================================================================
--- branches/release/boost/spirit/home/lex/qi/plain_token.hpp (original)
+++ branches/release/boost/spirit/home/lex/qi/plain_token.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -1,6 +1,6 @@
 // Copyright (c) 2001-2011 Hartmut Kaiser
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
+//
+// 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 !defined(BOOST_SPIRIT_LEX_PLAIN_TOKEN_NOV_11_2007_0451PM)
@@ -23,8 +23,10 @@
 #include <boost/fusion/include/vector.hpp>
 #include <boost/fusion/include/at.hpp>
 #include <boost/mpl/or.hpp>
+#include <boost/mpl/and.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/is_enum.hpp>
+#include <boost/lexical_cast.hpp>
 
 namespace boost { namespace spirit
 {
@@ -43,12 +45,26 @@
       , terminal_ex<tag::token, fusion::vector1<A0> >
> : mpl::or_<is_integral<A0>, is_enum<A0> > {};
 
+ // enables token(idmin, idmax)
+ template <typename A0, typename A1>
+ struct use_terminal<qi::domain
+ , terminal_ex<tag::token, fusion::vector2<A0, A1> >
+ > : mpl::and_<
+ mpl::or_<is_integral<A0>, is_enum<A0> >
+ , mpl::or_<is_integral<A1>, is_enum<A1> >
+ > {};
+
     // enables *lazy* token(id)
     template <>
     struct use_lazy_terminal<
         qi::domain, tag::token, 1
> : mpl::true_ {};
 
+ // enables *lazy* token(idmin, idmax)
+ template <>
+ struct use_lazy_terminal<
+ qi::domain, tag::token, 2
+ > : mpl::true_ {};
 }}
 
 namespace boost { namespace spirit { namespace qi
@@ -60,7 +76,7 @@
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename TokenId>
- struct plain_token
+ struct plain_token
       : primitive_parser<plain_token<TokenId> >
     {
         template <typename Context, typename Iterator>
@@ -82,16 +98,16 @@
             qi::skip_over(first, last, skipper); // always do a pre-skip
 
             if (first != last) {
- // simply match the token id with the id this component has
+ // simply match the token id with the id this component has
                 // been initialized with
 
- typedef typename
- boost::detail::iterator_traits<Iterator>::value_type
+ typedef typename
+ boost::detail::iterator_traits<Iterator>::value_type
                 token_type;
                 typedef typename token_type::id_type id_type;
 
                 token_type const& t = *first;
- if (std::size_t(~0) == id || id_type(id) == t.id()) {
+ if (id_type(~0) == id_type(id) || id_type(id) == t.id()) {
                     spirit::traits::assign_to(t, attr);
                     ++first;
                     return true;
@@ -103,13 +119,71 @@
         template <typename Context>
         info what(Context& /*context*/) const
         {
- return info("token");
+ return info("token",
+ "token(" + boost::lexical_cast<utf8_string>(id) + ")");
         }
 
         TokenId id;
     };
 
     ///////////////////////////////////////////////////////////////////////////
+ template <typename TokenId>
+ struct plain_token_range
+ : primitive_parser<plain_token_range<TokenId> >
+ {
+ template <typename Context, typename Iterator>
+ struct attribute
+ {
+ typedef typename Iterator::base_iterator_type iterator_type;
+ typedef iterator_range<iterator_type> type;
+ };
+
+ plain_token_range(TokenId const& idmin, TokenId const& idmax)
+ : idmin(idmin), idmax(idmax) {}
+
+ template <typename Iterator, typename Context
+ , typename Skipper, typename Attribute>
+ bool parse(Iterator& first, Iterator const& last
+ , Context& /*context*/, Skipper const& skipper
+ , Attribute& attr) const
+ {
+ qi::skip_over(first, last, skipper); // always do a pre-skip
+
+ if (first != last) {
+ // simply match the token id with the id this component has
+ // been initialized with
+
+ typedef typename
+ boost::detail::iterator_traits<Iterator>::value_type
+ token_type;
+ typedef typename token_type::id_type id_type;
+
+ token_type const& t = *first;
+ if (id_type(idmin) >= t.id() && id_type(idmin) <= t.id())
+ {
+ spirit::traits::assign_to(t, attr);
+ ++first;
+ return true;
+ }
+ }
+ return false;
+ }
+
+ template <typename Context>
+ info what(Context& /*context*/) const
+ {
+ return info("token_range"
+ , "token(" +
+ boost::lexical_cast<utf8_string>(idmin) + ", " +
+ boost::lexical_cast<utf8_string>(idmax) + ")"
+ );
+ return info("token_range");
+ }
+
+ TokenId idmin, idmax;
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
     // Parser generators: make_xxx function (objects)
     ///////////////////////////////////////////////////////////////////////////
     template <typename Modifiers>
@@ -135,6 +209,20 @@
             return result_type(fusion::at_c<0>(term.args));
         }
     };
+
+ template <typename Modifiers, typename TokenId>
+ struct make_primitive<terminal_ex<tag::token, fusion::vector2<TokenId, TokenId> >
+ , Modifiers>
+ {
+ typedef plain_token_range<TokenId> result_type;
+
+ template <typename Terminal>
+ result_type operator()(Terminal const& term, unused_type) const
+ {
+ return result_type(fusion::at_c<0>(term.args)
+ , fusion::at_c<1>(term.args));
+ }
+ };
 }}}
 
 namespace boost { namespace spirit { namespace traits
@@ -144,6 +232,11 @@
     struct handles_container<qi::plain_token<Idtype>, Attr, Context, Iterator>
       : mpl::true_
     {};
+
+ template<typename Idtype, typename Attr, typename Context, typename Iterator>
+ struct handles_container<qi::plain_token_range<Idtype>, Attr, Context, Iterator>
+ : mpl::true_
+ {};
 }}}
 
 #endif

Modified: branches/release/boost/spirit/home/lex/qi/plain_tokenid.hpp
==============================================================================
--- branches/release/boost/spirit/home/lex/qi/plain_tokenid.hpp (original)
+++ branches/release/boost/spirit/home/lex/qi/plain_tokenid.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -1,6 +1,6 @@
 // Copyright (c) 2001-2011 Hartmut Kaiser
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
+//
+// 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 !defined(BOOST_SPIRIT_LEX_PLAIN_TOKENID_NOV_26_2010_0944AM)
@@ -23,8 +23,10 @@
 #include <boost/fusion/include/vector.hpp>
 #include <boost/fusion/include/at.hpp>
 #include <boost/mpl/or.hpp>
+#include <boost/mpl/and.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/is_enum.hpp>
+#include <boost/lexical_cast.hpp>
 
 namespace boost { namespace spirit
 {
@@ -43,11 +45,26 @@
       , terminal_ex<tag::tokenid, fusion::vector1<A0> >
> : mpl::or_<is_integral<A0>, is_enum<A0> > {};
 
+ // enables tokenid(idmin, idmax)
+ template <typename A0, typename A1>
+ struct use_terminal<qi::domain
+ , terminal_ex<tag::tokenid, fusion::vector2<A0, A1> >
+ > : mpl::and_<
+ mpl::or_<is_integral<A0>, is_enum<A0> >
+ , mpl::or_<is_integral<A1>, is_enum<A1> >
+ > {};
+
     // enables *lazy* tokenid(id)
     template <>
     struct use_lazy_terminal<
         qi::domain, tag::tokenid, 1
> : mpl::true_ {};
+
+ // enables *lazy* tokenid(idmin, idmax)
+ template <>
+ struct use_lazy_terminal<
+ qi::domain, tag::tokenid, 2
+ > : mpl::true_ {};
 }}
 
 namespace boost { namespace spirit { namespace qi
@@ -58,11 +75,11 @@
     using spirit::tokenid_type;
 
     ///////////////////////////////////////////////////////////////////////////
- // The plain_tokenid represents a simple token defined by the lexer inside
- // a Qi grammar. The difference to plain_token is that it exposes the
+ // The plain_tokenid represents a simple token defined by the lexer inside
+ // a Qi grammar. The difference to plain_token is that it exposes the
     // matched token id instead of the iterator_range of the matched input.
     template <typename TokenId>
- struct plain_tokenid
+ struct plain_tokenid
       : primitive_parser<plain_tokenid<TokenId> >
     {
         template <typename Context, typename Iterator>
@@ -83,16 +100,16 @@
             qi::skip_over(first, last, skipper); // always do a pre-skip
 
             if (first != last) {
- // simply match the token id with the id this component has
+ // simply match the token id with the id this component has
                 // been initialized with
 
- typedef typename
- boost::detail::iterator_traits<Iterator>::value_type
+ typedef typename
+ boost::detail::iterator_traits<Iterator>::value_type
                 token_type;
                 typedef typename token_type::id_type id_type;
 
                 token_type const& t = *first;
- if (std::size_t(~0) == id || id_type(id) == t.id()) {
+ if (id_type(~0) == id_type(id) || id_type(id) == t.id()) {
                     spirit::traits::assign_to(id, attr);
                     ++first;
                     return true;
@@ -104,17 +121,73 @@
         template <typename Context>
         info what(Context& /*context*/) const
         {
- return info("tokenid");
+ return info("tokenid",
+ "tokenid(" + boost::lexical_cast<utf8_string>(id) + ")");
         }
 
         TokenId id;
     };
 
     ///////////////////////////////////////////////////////////////////////////
+ template <typename TokenId>
+ struct plain_tokenid_range
+ : primitive_parser<plain_tokenid_range<TokenId> >
+ {
+ template <typename Context, typename Iterator>
+ struct attribute
+ {
+ typedef TokenId type;
+ };
+
+ plain_tokenid_range(TokenId const& idmin, TokenId const& idmax)
+ : idmin(idmin), idmax(idmax) {}
+
+ template <typename Iterator, typename Context
+ , typename Skipper, typename Attribute>
+ bool parse(Iterator& first, Iterator const& last
+ , Context& /*context*/, Skipper const& skipper
+ , Attribute& attr) const
+ {
+ qi::skip_over(first, last, skipper); // always do a pre-skip
+
+ if (first != last) {
+ // simply match the token id with the id this component has
+ // been initialized with
+
+ typedef typename
+ boost::detail::iterator_traits<Iterator>::value_type
+ token_type;
+ typedef typename token_type::id_type id_type;
+
+ token_type const& t = *first;
+ if (id_type(idmin) >= t.id() && id_type(idmin) <= t.id())
+ {
+ spirit::traits::assign_to(t.id(), attr);
+ ++first;
+ return true;
+ }
+ }
+ return false;
+ }
+
+ template <typename Context>
+ info what(Context& /*context*/) const
+ {
+ return info("tokenid_range"
+ , "token(" +
+ boost::lexical_cast<utf8_string>(idmin) + ", " +
+ boost::lexical_cast<utf8_string>(idmax) + ")"
+ );
+ }
+
+ TokenId idmin, idmax;
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
     // Parser generators: make_xxx function (objects)
     ///////////////////////////////////////////////////////////////////////////
     template <typename Modifiers>
- struct make_primitive<tag::tokenid, Modifiers>
+ struct make_primitive<tag::tokenid, Modifiers>
     {
         typedef plain_tokenid<std::size_t> result_type;
 
@@ -136,6 +209,20 @@
             return result_type(fusion::at_c<0>(term.args));
         }
     };
+
+ template <typename Modifiers, typename TokenId>
+ struct make_primitive<terminal_ex<tag::tokenid, fusion::vector2<TokenId, TokenId> >
+ , Modifiers>
+ {
+ typedef plain_tokenid_range<TokenId> result_type;
+
+ template <typename Terminal>
+ result_type operator()(Terminal const& term, unused_type) const
+ {
+ return result_type(fusion::at_c<0>(term.args)
+ , fusion::at_c<1>(term.args));
+ }
+ };
 }}}
 
 namespace boost { namespace spirit { namespace traits
@@ -145,6 +232,11 @@
     struct handles_container<qi::plain_tokenid<Idtype>, Attr, Context, Iterator>
       : mpl::true_
     {};
+
+ template<typename Idtype, typename Attr, typename Context, typename Iterator>
+ struct handles_container<qi::plain_tokenid_range<Idtype>, Attr, Context, Iterator>
+ : mpl::true_
+ {};
 }}}
 
 #endif

Modified: branches/release/boost/spirit/home/lex/qi/plain_tokenid_mask.hpp
==============================================================================
--- branches/release/boost/spirit/home/lex/qi/plain_tokenid_mask.hpp (original)
+++ branches/release/boost/spirit/home/lex/qi/plain_tokenid_mask.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -1,6 +1,6 @@
 // Copyright (c) 2001-2011 Hartmut Kaiser
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
+//
+// 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 !defined(BOOST_SPIRIT_LEX_PLAIN_TOKENID_MASK_JUN_03_2011_0929PM)
@@ -25,6 +25,7 @@
 #include <boost/mpl/or.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/is_enum.hpp>
+#include <boost/lexical_cast.hpp>
 
 namespace boost { namespace spirit
 {
@@ -53,8 +54,8 @@
     using spirit::tokenid_mask_type;
 
     ///////////////////////////////////////////////////////////////////////////
- // The plain_tokenid represents a simple token defined by the lexer inside
- // a Qi grammar. The difference to plain_token is that it exposes the
+ // The plain_tokenid represents a simple token defined by the lexer inside
+ // a Qi grammar. The difference to plain_token is that it exposes the
     // matched token id instead of the iterator_range of the matched input.
     // Additionally it applies the given mask to the matched token id.
     template <typename Mask>
@@ -79,16 +80,16 @@
             qi::skip_over(first, last, skipper); // always do a pre-skip
 
             if (first != last) {
- // simply match the token id with the mask this component has
+ // simply match the token id with the mask this component has
                 // been initialized with
 
- typedef typename
- boost::detail::iterator_traits<Iterator>::value_type
+ typedef typename
+ boost::detail::iterator_traits<Iterator>::value_type
                 token_type;
                 typedef typename token_type::id_type id_type;
 
                 token_type const& t = *first;
- if ((t.id() & mask) == id_type(mask))
+ if ((t.id() & mask) == id_type(mask))
                 {
                     spirit::traits::assign_to(t.id(), attr);
                     ++first;
@@ -101,7 +102,8 @@
         template <typename Context>
         info what(Context& /*context*/) const
         {
- return info("tokenid_mask");
+ return info("tokenid_mask",
+ "tokenid_mask(" + boost::lexical_cast<utf8_string>(mask) + ")");
         }
 
         Mask mask;

Modified: branches/release/boost/spirit/home/qi/binary/binary.hpp
==============================================================================
--- branches/release/boost/spirit/home/qi/binary/binary.hpp (original)
+++ branches/release/boost/spirit/home/qi/binary/binary.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -25,6 +25,7 @@
 #include <boost/mpl/or.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_floating_point.hpp>
 #include <boost/config.hpp>
 
 #define BOOST_SPIRIT_ENABLE_BINARY(name) \
@@ -42,6 +43,19 @@
                                                                                 \
 /***/
 
+#define BOOST_SPIRIT_ENABLE_BINARY_IEEE754(name) \
+ template<> \
+ struct use_terminal<qi::domain, tag::name>: mpl::true_ {}; \
+ \
+ template<typename A0> \
+ struct use_terminal<qi::domain, terminal_ex<tag::name, \
+ fusion::vector1<A0> > >: is_floating_point<A0> {}; \
+ \
+ template<> \
+ struct use_lazy_terminal<qi::domain, tag::name, 1>: mpl::true_ {}; \
+ \
+/***/
+
 namespace boost { namespace spirit
 {
     ///////////////////////////////////////////////////////////////////////////
@@ -59,9 +73,16 @@
     BOOST_SPIRIT_ENABLE_BINARY(big_qword) // enables big_qword
     BOOST_SPIRIT_ENABLE_BINARY(little_qword) // enables little_qword
 #endif
+ BOOST_SPIRIT_ENABLE_BINARY_IEEE754(bin_float)
+ BOOST_SPIRIT_ENABLE_BINARY_IEEE754(big_bin_float)
+ BOOST_SPIRIT_ENABLE_BINARY_IEEE754(little_bin_float)
+ BOOST_SPIRIT_ENABLE_BINARY_IEEE754(bin_double)
+ BOOST_SPIRIT_ENABLE_BINARY_IEEE754(big_bin_double)
+ BOOST_SPIRIT_ENABLE_BINARY_IEEE754(little_bin_double)
 }}
 
 #undef BOOST_SPIRIT_ENABLE_BINARY
+#undef BOOST_SPIRIT_ENABLE_BINARY_IEEE754
 
 namespace boost { namespace spirit { namespace qi
 {
@@ -78,6 +99,12 @@
     using boost::spirit::big_qword;
     using boost::spirit::little_qword;
 #endif
+ using boost::spirit::bin_float;
+ using boost::spirit::big_bin_float;
+ using boost::spirit::little_bin_float;
+ using boost::spirit::bin_double;
+ using boost::spirit::big_bin_double;
+ using boost::spirit::little_bin_double;
 #endif
 
     using boost::spirit::byte_type;
@@ -92,6 +119,12 @@
     using boost::spirit::big_qword_type;
     using boost::spirit::little_qword_type;
 #endif
+ using boost::spirit::bin_float_type;
+ using boost::spirit::big_bin_float_type;
+ using boost::spirit::little_bin_float_type;
+ using boost::spirit::bin_double_type;
+ using boost::spirit::big_bin_double_type;
+ using boost::spirit::little_bin_double_type;
 
     namespace detail
     {
@@ -139,6 +172,28 @@
         };
 #endif
 
+ template <int bits>
+ struct floating_point
+ {
+ BOOST_SPIRIT_ASSERT_MSG(
+ bits == 32 || bits == 64,
+ not_supported_binary_size, ());
+ };
+
+ template <>
+ struct floating_point<32>
+ {
+ enum { size = 4 };
+ typedef float type;
+ };
+
+ template <>
+ struct floating_point<64>
+ {
+ enum { size = 8 };
+ typedef double type;
+ };
+
         ///////////////////////////////////////////////////////////////////////
         template <BOOST_SCOPED_ENUM(boost::endian::endianness) bits>
         struct what;
@@ -172,15 +227,14 @@
     }
 
     ///////////////////////////////////////////////////////////////////////////
- template <BOOST_SCOPED_ENUM(boost::endian::endianness) endian, int bits>
- struct any_binary_parser : primitive_parser<any_binary_parser<endian, bits> >
+ template <typename T, BOOST_SCOPED_ENUM(boost::endian::endianness) endian, int bits>
+ struct any_binary_parser : primitive_parser<any_binary_parser<T, endian, bits> >
     {
         template <typename Context, typename Iterator>
         struct attribute
         {
- typedef boost::endian::endian<
- endian, typename qi::detail::integer<bits>::type, bits
- > type;
+ typedef boost::endian::endian<endian, typename T::type,
+ bits> type;
         };
 
         template <typename Iterator, typename Context
@@ -215,10 +269,10 @@
     };
 
     ///////////////////////////////////////////////////////////////////////////
- template <typename Int
+ template <typename V, typename T
       , BOOST_SCOPED_ENUM(boost::endian::endianness) endian, int bits>
     struct binary_lit_parser
- : primitive_parser<binary_lit_parser<Int, endian, bits> >
+ : primitive_parser<binary_lit_parser<V, T, endian, bits> >
     {
         template <typename Context, typename Iterator>
         struct attribute
@@ -226,7 +280,7 @@
             typedef unused_type type;
         };
 
- binary_lit_parser(Int n)
+ binary_lit_parser(V n)
           : n(n) {}
 
         template <typename Iterator, typename Context
@@ -241,8 +295,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::endian::endian<
- endian, typename qi::detail::integer<bits>::type, bits> attr_;
+ boost::endian::endian<endian, typename T::type, bits> attr_;
 
 #if defined(BOOST_MSVC)
 // warning C4244: 'argument' : conversion from 'const int' to 'foo', possible loss of data
@@ -274,27 +327,27 @@
             return info(qi::detail::what<endian>::is());
         }
 
- Int n;
+ V n;
     };
 
     ///////////////////////////////////////////////////////////////////////////
     // Parser generators: make_xxx function (objects)
     ///////////////////////////////////////////////////////////////////////////
- template <BOOST_SCOPED_ENUM(boost::endian::endianness) endian, int bits>
+ template <typename T, BOOST_SCOPED_ENUM(boost::endian::endianness) endian, int bits>
     struct make_binary_parser
     {
- typedef any_binary_parser<endian, bits> result_type;
+ typedef any_binary_parser<T, endian, bits> result_type;
         result_type operator()(unused_type, unused_type) const
         {
             return result_type();
         }
     };
 
- template <typename Int
+ template <typename V, typename T
       , BOOST_SCOPED_ENUM(boost::endian::endianness) endian, int bits>
     struct make_binary_lit_parser
     {
- typedef binary_lit_parser<Int, endian, bits> result_type;
+ typedef binary_lit_parser<V, T, endian, bits> result_type;
         template <typename Terminal>
         result_type operator()(Terminal const& term, unused_type) const
         {
@@ -302,16 +355,18 @@
         }
     };
 
-#define BOOST_SPIRIT_MAKE_BINARY_PRIMITIVE(name, endiantype, bits) \
- template <typename Modifiers> \
- struct make_primitive<tag::name, Modifiers> \
- : 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::endian::endianness::endiantype, bits> {};\
- \
+#define BOOST_SPIRIT_MAKE_BINARY_PRIMITIVE(name, endiantype, bits) \
+ template <typename Modifiers> \
+ struct make_primitive<tag::name, Modifiers> \
+ : make_binary_parser<detail::integer<bits>, \
+ 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, detail::integer<bits>, \
+ boost::endian::endianness::endiantype, bits> {}; \
+ \
     /***/
 
     BOOST_SPIRIT_MAKE_BINARY_PRIMITIVE(byte_, native, 8)
@@ -329,6 +384,30 @@
 
 #undef BOOST_SPIRIT_MAKE_BINARY_PRIMITIVE
 
+#define BOOST_SPIRIT_MAKE_BINARY_IEEE754_PRIMITIVE(name, endiantype, bits) \
+ template<typename Modifiers> \
+ struct make_primitive<tag::name, Modifiers> \
+ : make_binary_parser<detail::floating_point<bits>, \
+ 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, detail::floating_point<bits>, \
+ boost::endian::endianness::endiantype, \
+ bits> {}; \
+ \
+ /***/
+
+ BOOST_SPIRIT_MAKE_BINARY_IEEE754_PRIMITIVE(bin_float, native, 32)
+ BOOST_SPIRIT_MAKE_BINARY_IEEE754_PRIMITIVE(big_bin_float, big, 32)
+ BOOST_SPIRIT_MAKE_BINARY_IEEE754_PRIMITIVE(little_bin_float, little, 32)
+ BOOST_SPIRIT_MAKE_BINARY_IEEE754_PRIMITIVE(bin_double, native, 64)
+ BOOST_SPIRIT_MAKE_BINARY_IEEE754_PRIMITIVE(big_bin_double, big, 64)
+ BOOST_SPIRIT_MAKE_BINARY_IEEE754_PRIMITIVE(little_bin_double, little, 64)
+
+#undef BOOST_SPIRIT_MAKE_BINARY_IEEE754_PRIMITIVE
+
 }}}
 
 #endif

Modified: branches/release/boost/spirit/home/support/attributes.hpp
==============================================================================
--- branches/release/boost/spirit/home/support/attributes.hpp (original)
+++ branches/release/boost/spirit/home/support/attributes.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -45,6 +45,7 @@
 #include <boost/utility/enable_if.hpp>
 #include <boost/variant.hpp>
 #include <boost/range/iterator_range.hpp>
+#include <boost/config.hpp>
 #include <vector>
 #include <utility>
 #include <ios>
@@ -747,9 +748,11 @@
             };
 
             // never called, but needed for decltype-based result_of (C++0x)
+#ifndef BOOST_NO_RVALUE_REFERENCES
             template <typename Element>
             typename result<element_attribute(Element)>::type
- operator()(Element&) const;
+ operator()(Element&&) const;
+#endif
         };
 
         // Compute the list of attributes of all sub-components

Modified: branches/release/boost/spirit/home/support/common_terminals.hpp
==============================================================================
--- branches/release/boost/spirit/home/support/common_terminals.hpp (original)
+++ branches/release/boost/spirit/home/support/common_terminals.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -116,6 +116,12 @@
         ( qword, qword_type )
         ( big_qword, big_qword_type )
         ( little_qword, little_qword_type )
+ ( bin_float, bin_float_type )
+ ( big_bin_float, big_bin_float_type )
+ ( little_bin_float, little_bin_float_type )
+ ( bin_double, bin_double_type )
+ ( big_bin_double, big_bin_double_type )
+ ( little_bin_double, little_bin_double_type )
         ( skip, skip_type )
         ( delimit, delimit_type )
         ( stream, stream_type )

Modified: branches/release/boost/spirit/home/support/detail/endian/endian.hpp
==============================================================================
--- branches/release/boost/spirit/home/support/detail/endian/endian.hpp (original)
+++ branches/release/boost/spirit/home/support/detail/endian/endian.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -122,6 +122,44 @@
         (static_cast<const unsigned char*>(bytes) + n_bytes);
     }
 
+ template <>
+ inline
+ float load_big_endian<float, 4>(const void* bytes)
+ {
+ const unsigned char *b = reinterpret_cast<const unsigned char *>(
+ bytes);
+ b += 3;
+
+ float value;
+ unsigned char *v = reinterpret_cast<unsigned char *>(&value);
+
+ for(std::size_t i = 0; i < 4; ++i)
+ {
+ *v++ = *b--;
+ }
+
+ return value;
+ }
+
+ template <>
+ inline
+ double load_big_endian<double, 8>(const void* bytes)
+ {
+ const unsigned char *b = reinterpret_cast<const unsigned char *>(
+ bytes);
+ b += 7;
+
+ double value;
+ unsigned char *v = reinterpret_cast<unsigned char *>(&value);
+
+ for(std::size_t i = 0; i < 8; ++i)
+ {
+ *v++ = *b--;
+ }
+
+ return value;
+ }
+
     template <typename T, std::size_t n_bytes>
     inline
     T load_little_endian(const void* bytes)
@@ -130,6 +168,42 @@
         (static_cast<const unsigned char*>(bytes));
     }
 
+ template <>
+ inline
+ float load_little_endian<float, 4>(const void* bytes)
+ {
+ const unsigned char *b = reinterpret_cast<const unsigned char *>(
+ bytes);
+
+ float value;
+ unsigned char *v = reinterpret_cast<unsigned char *>(&value);
+
+ for(std::size_t i = 0; i < 4; ++i)
+ {
+ *v++ = *b++;
+ }
+
+ return value;
+ }
+
+ template <>
+ inline
+ double load_little_endian<double, 8>(const void* bytes)
+ {
+ const unsigned char *b = reinterpret_cast<const unsigned char *>(
+ bytes);
+
+ double value;
+ unsigned char *v = reinterpret_cast<unsigned char *>(&value);
+
+ for(std::size_t i = 0; i < 8; ++i)
+ {
+ *v++ = *b++;
+ }
+
+ return value;
+ }
+
     template <typename T, std::size_t n_bytes>
     inline
     void store_big_endian(void* bytes, T value)
@@ -138,6 +212,38 @@
         (static_cast<char*>(bytes) + n_bytes, value);
     }
 
+ template <>
+ inline
+ void store_big_endian<float, 4>(void* bytes, float value)
+ {
+ unsigned char *b = reinterpret_cast<unsigned char *>(bytes);
+ b += 3;
+
+ const unsigned char *v = reinterpret_cast<const unsigned char *>(
+ &value);
+
+ for(std::size_t i = 0; i < 4; ++i)
+ {
+ *b-- = *v++;
+ }
+ }
+
+ template <>
+ inline
+ void store_big_endian<double, 8>(void* bytes, double value)
+ {
+ unsigned char *b = reinterpret_cast<unsigned char *>(bytes);
+ b += 7;
+
+ const unsigned char *v = reinterpret_cast<const unsigned char *>(
+ &value);
+
+ for(std::size_t i = 0; i < 8; ++i)
+ {
+ *b-- = *v++;
+ }
+ }
+
     template <typename T, std::size_t n_bytes>
     inline
     void store_little_endian(void* bytes, T value)
@@ -146,6 +252,36 @@
         (static_cast<char*>(bytes), value);
     }
 
+ template <>
+ inline
+ void store_little_endian<float, 4>(void* bytes, float value)
+ {
+ unsigned char *b = reinterpret_cast<unsigned char *>(bytes);
+
+ const unsigned char *v = reinterpret_cast<const unsigned char *>(
+ &value);
+
+ for(std::size_t i = 0; i < 4; ++i)
+ {
+ *b++ = *v++;
+ }
+ }
+
+ template <>
+ inline
+ void store_little_endian<double, 8>(void* bytes, double value)
+ {
+ unsigned char *b = reinterpret_cast<unsigned char *>(bytes);
+
+ const unsigned char *v = reinterpret_cast<const unsigned char *>(
+ &value);
+
+ for(std::size_t i = 0; i < 8; ++i)
+ {
+ *b++ = *v++;
+ }
+ }
+
   } // namespace detail
 
   namespace endian
@@ -181,7 +317,7 @@
 # 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";
@@ -191,7 +327,7 @@
 # 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";
@@ -213,7 +349,7 @@
 # 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";
@@ -223,7 +359,7 @@
 # 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";
@@ -250,7 +386,7 @@
         explicit endian(T val) { detail::store_little_endian<T, n_bits/8>(m_value, val); }
 # endif
 # endif
-# ifdef BOOST_BIG_ENDIAN
+# 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
@@ -281,13 +417,13 @@
         explicit endian(T val) { detail::store_big_endian<T, sizeof(T)>(&m_value, val); }
 # endif
 # endif
-# ifdef BOOST_BIG_ENDIAN
+# ifdef BOOST_BIG_ENDIAN
         endian & operator=(T val) { m_value = val; return *this; }
         operator T() const { return m_value; }
-# else
+# 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
+# endif
       private:
         T m_value;
     };
@@ -385,7 +521,7 @@
 #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

Modified: branches/release/boost/spirit/home/support/detail/lexer/parser/parser.hpp
==============================================================================
--- branches/release/boost/spirit/home/support/detail/lexer/parser/parser.hpp (original)
+++ branches/release/boost/spirit/home/support/detail/lexer/parser/parser.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -87,7 +87,7 @@
             default:
                 std::ostringstream ss_;
 
- ss_ << "A syntax error occurred: '" <<
+ ss_ << "A syntax error occured: '" <<
                     lhs_token_.precedence_string () <<
                     "' against '" << rhs_token_.precedence_string () <<
                     "' at index " << state_.index () << ".";

Modified: branches/release/boost/spirit/home/support/detail/lexer/rules.hpp
==============================================================================
--- branches/release/boost/spirit/home/support/detail/lexer/rules.hpp (original)
+++ branches/release/boost/spirit/home/support/detail/lexer/rules.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -44,6 +44,16 @@
         {
             return "*";
         }
+
+ static const char *char_name ()
+ {
+ return "char";
+ }
+
+ static const char *char_prefix ()
+ {
+ return "";
+ }
     };
 
     template <>
@@ -63,6 +73,16 @@
         {
             return L"*";
         }
+
+ static const char *char_name ()
+ {
+ return "wchar_t";
+ }
+
+ static const char *char_prefix ()
+ {
+ return "L";
+ }
     };
 }
 

Modified: branches/release/boost/spirit/home/support/extended_variant.hpp
==============================================================================
--- branches/release/boost/spirit/home/support/extended_variant.hpp (original)
+++ branches/release/boost/spirit/home/support/extended_variant.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -81,4 +81,35 @@
     };
 }}
 
+namespace boost
+{
+ template <typename T, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+ inline T const&
+ get(boost::spirit::extended_variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& x)
+ {
+ return boost::get<T>(x.get());
+ }
+
+ template <typename T, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+ inline T&
+ get(boost::spirit::extended_variant<BOOST_VARIANT_ENUM_PARAMS(T)>& x)
+ {
+ return boost::get<T>(x.get());
+ }
+
+ template <typename T, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+ inline T const*
+ get(boost::spirit::extended_variant<BOOST_VARIANT_ENUM_PARAMS(T)> const* x)
+ {
+ return boost::get<T>(&x->get());
+ }
+
+ template <typename T, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+ inline T*
+ get(boost::spirit::extended_variant<BOOST_VARIANT_ENUM_PARAMS(T)>* x)
+ {
+ return boost::get<T>(&x->get());
+ }
+}
+
 #endif

Modified: branches/release/boost/spirit/home/support/iterators/detail/combine_policies.hpp
==============================================================================
--- branches/release/boost/spirit/home/support/iterators/detail/combine_policies.hpp (original)
+++ branches/release/boost/spirit/home/support/iterators/detail/combine_policies.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -1,5 +1,5 @@
-// Copyright (c) 2001-2011 Hartmut Kaiser
-//
+// Copyright (c) 2001-2012 Hartmut Kaiser
+//
 // 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)
 
@@ -12,21 +12,21 @@
 namespace boost { namespace spirit { namespace iterator_policies
 {
     ///////////////////////////////////////////////////////////////////////////
- // The purpose of the multi_pass_unique template is to eliminate
- // empty policy classes (policies not containing any data items) from the
- // multiple inheritance chain. This is necessary since some compilers
- // fail to apply the empty base optimization if multiple inheritance is
+ // The purpose of the multi_pass_unique template is to eliminate
+ // empty policy classes (policies not containing any data items) from the
+ // multiple inheritance chain. This is necessary since some compilers
+ // fail to apply the empty base optimization if multiple inheritance is
     // involved.
- // Additionally this can be used to combine separate policies into one
+ // Additionally this can be used to combine separate policies into one
     // single multi_pass_policy as required by the multi_pass template
     ///////////////////////////////////////////////////////////////////////////
 
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
- // without partial template specialization there is nothing much to do in
+ // without partial template specialization there is nothing much to do in
     // terms of empty base optimization anyways...
- template <typename T, typename Ownership, typename Checking,
+ template <typename T, typename Ownership, typename Checking,
         typename Input, typename Storage>
- struct multi_pass_unique
+ struct multi_pass_unique
       : Ownership, Checking, Input, Storage
     {
         multi_pass_unique() {}
@@ -41,13 +41,21 @@
             Input::destroy(mp);
             Storage::destroy(mp);
         }
- void swap(multi_pass_unique& x)
+
+ void swap(multi_pass_unique& x)
         {
             this->Ownership::swap(x);
             this->Checking::swap(x);
             this->Input::swap(x);
             this->Storage::swap(x);
         }
+
+ template <typename MultiPass>
+ inline static void clear_queue(MultiPass& mp)
+ {
+ Checking::clear_queue(mp);
+ Storage::clear_queue(mp);
+ }
     };
 #else
     ///////////////////////////////////////////////////////////////////////////
@@ -78,15 +86,23 @@
             Input::destroy(mp);
             Storage::destroy(mp);
         }
- void swap(multi_pass_unique& x)
+
+ void swap(multi_pass_unique& x)
         {
             this->Ownership::swap(x);
             this->Checking::swap(x);
             this->Input::swap(x);
             this->Storage::swap(x);
         }
+
+ template <typename MultiPass>
+ inline static void clear_queue(MultiPass& mp)
+ {
+ Checking::clear_queue(mp);
+ Storage::clear_queue(mp);
+ }
     };
-
+
     ///////////////////////////////////////////////////////////////////////////
     template <typename T, typename Ownership, typename Checking
       , typename Input, typename Storage>
@@ -105,13 +121,21 @@
             Input::destroy(mp);
             Storage::destroy(mp);
         }
- void swap(multi_pass_unique& x)
+
+ void swap(multi_pass_unique& x)
         {
             this->Ownership::swap(x);
             this->Checking::swap(x);
             this->Storage::swap(x);
         }
 
+ template <typename MultiPass>
+ inline static void clear_queue(MultiPass& mp)
+ {
+ Checking::clear_queue(mp);
+ Storage::clear_queue(mp);
+ }
+
         // implement input policy functions by forwarding to the Input type
         template <typename MultiPass>
         inline static void advance_input(MultiPass& mp)
@@ -148,21 +172,25 @@
             Input::destroy(mp);
             Storage::destroy(mp);
         }
- void swap(multi_pass_unique& x)
+
+ void swap(multi_pass_unique& x)
         {
             this->Ownership::swap(x);
             this->Input::swap(x);
             this->Storage::swap(x);
         }
 
- // checking policy functions are forwarded to the Checking type
         template <typename MultiPass>
- inline static void docheck(MultiPass const& mp)
- { Checking::docheck(mp); }
+ inline static void clear_queue(MultiPass& mp)
+ {
+ Checking::clear_queue(mp);
+ Storage::clear_queue(mp);
+ }
 
+ // checking policy functions are forwarded to the Checking type
         template <typename MultiPass>
- inline static void clear_queue(MultiPass& mp)
- { Checking::clear_queue(mp); }
+ inline static void docheck(MultiPass const& mp)
+ { Checking::docheck(mp); }
     };
 
     ///////////////////////////////////////////////////////////////////////////
@@ -182,12 +210,20 @@
             Input::destroy(mp);
             Storage::destroy(mp);
         }
- void swap(multi_pass_unique& x)
+
+ void swap(multi_pass_unique& x)
         {
             this->Ownership::swap(x);
             this->Storage::swap(x);
         }
 
+ template <typename MultiPass>
+ inline static void clear_queue(MultiPass& mp)
+ {
+ Checking::clear_queue(mp);
+ Storage::clear_queue(mp);
+ }
+
         // implement input policy functions by forwarding to the Input type
         template <typename MultiPass>
         inline static void advance_input(MultiPass& mp)
@@ -207,12 +243,8 @@
 
         // checking policy functions are forwarded to the Checking type
         template <typename MultiPass>
- inline static void docheck(MultiPass const& mp)
+ inline static void docheck(MultiPass const& mp)
             { Checking::docheck(mp); }
-
- template <typename MultiPass>
- inline static void clear_queue(MultiPass& mp)
- { Checking::clear_queue(mp); }
     };
 
     ///////////////////////////////////////////////////////////////////////////
@@ -233,16 +265,24 @@
             Input::destroy(mp);
             Storage::destroy(mp);
         }
- void swap(multi_pass_unique& x)
+
+ void swap(multi_pass_unique& x)
         {
             this->Checking::swap(x);
             this->Input::swap(x);
             this->Storage::swap(x);
         }
 
+ template <typename MultiPass>
+ inline static void clear_queue(MultiPass& mp)
+ {
+ Checking::clear_queue(mp);
+ Storage::clear_queue(mp);
+ }
+
         // ownership policy functions are forwarded to the Ownership type
         template <typename MultiPass>
- inline static void clone(MultiPass& mp)
+ inline static void clone(MultiPass& mp)
             { Ownership::clone(mp); }
 
         template <typename MultiPass>
@@ -271,12 +311,20 @@
             Input::destroy(mp);
             Storage::destroy(mp);
         }
- void swap(multi_pass_unique& x)
+
+ void swap(multi_pass_unique& x)
         {
             this->Checking::swap(x);
             this->Storage::swap(x);
         }
 
+ template <typename MultiPass>
+ inline static void clear_queue(MultiPass& mp)
+ {
+ Checking::clear_queue(mp);
+ Storage::clear_queue(mp);
+ }
+
         // implement input policy functions by forwarding to the Input type
         template <typename MultiPass>
         inline static void advance_input(MultiPass& mp)
@@ -296,7 +344,7 @@
 
         // ownership policy functions are forwarded to the Ownership type
         template <typename MultiPass>
- inline static void clone(MultiPass& mp)
+ inline static void clone(MultiPass& mp)
             { Ownership::clone(mp); }
 
         template <typename MultiPass>
@@ -325,24 +373,28 @@
             Input::destroy(mp);
             Storage::destroy(mp);
         }
- void swap(multi_pass_unique& x)
+
+ void swap(multi_pass_unique& x)
         {
             this->Input::swap(x);
             this->Storage::swap(x);
         }
 
- // checking policy functions are forwarded to the Checking type
         template <typename MultiPass>
- inline static void docheck(MultiPass const& mp)
- { Checking::docheck(mp); }
+ inline static void clear_queue(MultiPass& mp)
+ {
+ Checking::clear_queue(mp);
+ Storage::clear_queue(mp);
+ }
 
+ // checking policy functions are forwarded to the Checking type
         template <typename MultiPass>
- inline static void clear_queue(MultiPass& mp)
- { Checking::clear_queue(mp); }
+ inline static void docheck(MultiPass const& mp)
+ { Checking::docheck(mp); }
 
         // ownership policy functions are forwarded to the Ownership type
         template <typename MultiPass>
- inline static void clone(MultiPass& mp)
+ inline static void clone(MultiPass& mp)
             { Ownership::clone(mp); }
 
         template <typename MultiPass>
@@ -370,11 +422,19 @@
             Input::destroy(mp);
             Storage::destroy(mp);
         }
- void swap(multi_pass_unique& x)
+
+ void swap(multi_pass_unique& x)
         {
             this->Storage::swap(x);
         }
 
+ template <typename MultiPass>
+ inline static void clear_queue(MultiPass& mp)
+ {
+ Checking::clear_queue(mp);
+ Storage::clear_queue(mp);
+ }
+
         // implement input policy functions by forwarding to the Input type
         template <typename MultiPass>
         inline static void advance_input(MultiPass& mp)
@@ -394,16 +454,12 @@
 
         // checking policy functions are forwarded to the Checking type
         template <typename MultiPass>
- inline static void docheck(MultiPass const& mp)
+ inline static void docheck(MultiPass const& mp)
             { Checking::docheck(mp); }
 
- template <typename MultiPass>
- inline static void clear_queue(MultiPass& mp)
- { Checking::clear_queue(mp); }
-
         // ownership policy functions are forwarded to the Ownership type
         template <typename MultiPass>
- inline static void clone(MultiPass& mp)
+ inline static void clone(MultiPass& mp)
             { Ownership::clone(mp); }
 
         template <typename MultiPass>
@@ -417,7 +473,7 @@
 #endif
 
     ///////////////////////////////////////////////////////////////////////////
- // the multi_pass_shared structure is used to combine the shared data items
+ // the multi_pass_shared structure is used to combine the shared data items
     // of all policies into one single structure
     ///////////////////////////////////////////////////////////////////////////
     template<typename T, typename Ownership, typename Checking, typename Input
@@ -451,7 +507,7 @@
         {
             typedef typename Ownership::unique ownership_policy;
             typedef typename Checking::unique checking_policy;
- typedef typename Input::BOOST_NESTED_TEMPLATE unique<T>
+ typedef typename Input::BOOST_NESTED_TEMPLATE unique<T>
                 input_policy;
             typedef typename Storage::BOOST_NESTED_TEMPLATE unique<
                 typename input_policy::value_type> storage_policy;
@@ -470,26 +526,26 @@
           , typename Ownership::shared, typename Checking::shared
           , typename Input::BOOST_NESTED_TEMPLATE shared<T>
           , typename Storage::BOOST_NESTED_TEMPLATE shared<
- typename Input::BOOST_NESTED_TEMPLATE unique<T>::value_type> >
+ typename Input::BOOST_NESTED_TEMPLATE unique<T>::value_type> >
         {
             typedef typename Ownership::shared ownership_policy;
             typedef typename Checking::shared checking_policy;
- typedef typename Input::BOOST_NESTED_TEMPLATE shared<T>
+ typedef typename Input::BOOST_NESTED_TEMPLATE shared<T>
                 input_policy;
             typedef typename Storage::BOOST_NESTED_TEMPLATE shared<
- typename Input::BOOST_NESTED_TEMPLATE unique<T>::value_type>
+ typename Input::BOOST_NESTED_TEMPLATE unique<T>::value_type>
             storage_policy;
 
             typedef multi_pass_shared<T, ownership_policy, checking_policy
               , input_policy, storage_policy> shared_base_type;
 
- explicit shared(T& input)
+ explicit shared(T& input)
               : shared_base_type(input), inhibit_clear_queue_(false) {}
- explicit shared(T const& input)
+ explicit shared(T const& input)
               : shared_base_type(input), inhibit_clear_queue_(false) {}
 
- // This is needed for the correct implementation of expectation
- // points. Normally expectation points flush any multi_pass
+ // This is needed for the correct implementation of expectation
+ // points. Normally expectation points flush any multi_pass
             // iterator they may act on, but if the corresponding error handler
             // is of type 'retry' no flushing of the internal buffers should be
             // executed (even if explicitly requested).

Modified: branches/release/boost/spirit/home/support/iterators/multi_pass.hpp
==============================================================================
--- branches/release/boost/spirit/home/support/iterators/multi_pass.hpp (original)
+++ branches/release/boost/spirit/home/support/iterators/multi_pass.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -1,7 +1,7 @@
 // Copyright (c) 2001, Daniel C. Nuffer
 // Copyright (c) 2001-2011 Hartmut Kaiser
 // http://spirit.sourceforge.net/
-//
+//
 // 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)
 
@@ -16,13 +16,13 @@
 #include <boost/detail/workaround.hpp>
 #include <boost/utility/base_from_member.hpp>
 
-namespace boost { namespace spirit
+namespace boost { namespace spirit
 {
     ///////////////////////////////////////////////////////////////////////////
     // The default multi_pass instantiation uses a ref-counted std_deque scheme.
     ///////////////////////////////////////////////////////////////////////////
     template<typename T, typename Policies>
- class multi_pass
+ class multi_pass
       : private boost::base_from_member<
             typename Policies::BOOST_NESTED_TEMPLATE shared<T>*>
       , public Policies::BOOST_NESTED_TEMPLATE unique<T>
@@ -32,14 +32,14 @@
     {
     private:
         // unique and shared data types
- typedef typename Policies::BOOST_NESTED_TEMPLATE unique<T>
+ typedef typename Policies::BOOST_NESTED_TEMPLATE unique<T>
             policies_base_type;
- typedef typename Policies::BOOST_NESTED_TEMPLATE shared<T>
+ typedef typename Policies::BOOST_NESTED_TEMPLATE shared<T>
             shared_data_type;
 
         typedef boost::base_from_member<shared_data_type*> member_base;
 
- // define the types the standard embedded iterator typedefs are taken
+ // define the types the standard embedded iterator typedefs are taken
         // from
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
         typedef typename iterator_base_creator<Input, T>::type iterator_type;
@@ -56,7 +56,7 @@
         typedef typename iterator_type::reference reference;
         typedef typename iterator_type::pointer pointer;
 
- multi_pass() : member_base((shared_data_type*)0) {}
+ multi_pass() : member_base(static_cast<shared_data_type*>(0)) {}
 
         explicit multi_pass(T& input)
           : member_base(new shared_data_type(input)), policies_base_type(input) {}
@@ -77,7 +77,7 @@
         // checking code that isn't required by the standard.
         // The workaround is to provide an additional constructor that
         // ignores its int argument and behaves like the default constructor.
- multi_pass(int) : member_base((shared_data_type*)0) {}
+ multi_pass(int) : member_base(static_cast<shared_data_type*>(0)) {}
 #endif // BOOST_WORKAROUND(__GLIBCPP__, == 20020514)
 
         ~multi_pass()
@@ -126,7 +126,7 @@
             return tmp;
         }
 
- void clear_queue(BOOST_SCOPED_ENUM(traits::clear_mode) mode =
+ void clear_queue(BOOST_SCOPED_ENUM(traits::clear_mode) mode =
             traits::clear_mode::clear_if_enabled)
         {
             if (mode == traits::clear_mode::clear_always || !inhibit_clear_queue())
@@ -214,7 +214,7 @@
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename T, typename Policies>
- inline void
+ inline void
     swap(multi_pass<T, Policies> &x, multi_pass<T, Policies> &y)
     {
         x.swap(y);
@@ -247,6 +247,6 @@
 
 }} // namespace boost::spirit
 
-#endif
+#endif
 
 

Modified: branches/release/boost/spirit/repository/home/karma/nonterminal/subrule.hpp
==============================================================================
--- branches/release/boost/spirit/repository/home/karma/nonterminal/subrule.hpp (original)
+++ branches/release/boost/spirit/repository/home/karma/nonterminal/subrule.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -1,6 +1,6 @@
 // Copyright (c) 2009 Francois Barel
 // Copyright (c) 2001-2011 Joel de Guzman
-// Copyright (c) 2001-2011 Hartmut Kaiser
+// Copyright (c) 2001-2012 Hartmut Kaiser
 //
 // 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)
@@ -207,8 +207,8 @@
             // trying to use a subrule which has inherited attributes,
             // without passing values for them.
             context_type context(*this
- , traits::pre_transform<subrule_attr_type>(
- make_attribute::call(attr)));
+ , traits::pre_transform<karma::domain, subrule_attr_type>(
+ make_attribute::call(attr)));
 
             return def.binder(sink, context, delimiter);
         }
@@ -242,8 +242,8 @@
             // trying to use a subrule which has inherited attributes,
             // passing values of incompatible types for them.
             context_type context(*this
- , traits::pre_transform<subrule_attr_type>(
- make_attribute::call(attr)), params, caller_context);
+ , traits::pre_transform<karma::domain, subrule_attr_type>(
+ make_attribute::call(attr)), params, caller_context);
 
             return def.binder(sink, context, delimiter);
         }

Modified: branches/release/libs/spirit/doc/index.idx
==============================================================================
--- branches/release/libs/spirit/doc/index.idx (original)
+++ branches/release/libs/spirit/doc/index.idx 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -6,8 +6,8 @@
 # http://www.boost.org/LICENSE_1_0.txt)
 #==============================================================================
 
-#!scan-path "../../../boost/spirit/home/qi" ".*hpp" true
-#!scan-path "../../../boost/spirit/home/karma" ".*hpp" true
+#!scan-path "../../../boost/spirit/home/qi" ".*hpp" true
+#!scan-path "../../../boost/spirit/home/karma" ".*hpp" true
 
 ###############################################################################
 # Qi API
@@ -41,7 +41,7 @@
 auto_ "" ".*karma.reference.auto.*" karma_index
 
 # auxiliary parsers/generators
-attr "" ".*qi.reference.auxiliary.attr\..*" qi_index
+attr "" ".*qi.reference.auxiliary.attr" qi_index
 attr_cast "" ".*qi.reference.auxiliary.attr_cast.*" qi_index
 eol "" ".*qi.reference.auxiliary.eol.*" qi_index
 eoi "" ".*qi.reference.auxiliary.eoi.*" qi_index
@@ -59,23 +59,35 @@
 word "" ".*qi.reference.binary.binary_native.*" qi_index
 dword "" ".*qi.reference.binary.binary_native.*" qi_index
 qword "" ".*qi.reference.binary.binary_native.*" qi_index
+bin_float "" ".*qi.reference.binary.binary_native.*" qi_index
+bin_double "" ".*qi.reference.binary.binary_native.*" qi_index
 little_word "" ".*qi.reference.binary.binary_little.*" qi_index
 little_dword "" ".*qi.reference.binary.binary_little.*" qi_index
 little_qword "" ".*qi.reference.binary.binary_little.*" qi_index
+little_bin_float "" ".*qi.reference.binary.binary_little.*" qi_index
+little_bin_double "" ".*qi.reference.binary.binary_little.*" qi_index
 big_word "" ".*qi.reference.binary.binary_big.*" qi_index
 big_dword "" ".*qi.reference.binary.binary_big.*" qi_index
 big_qword "" ".*qi.reference.binary.binary_big.*" qi_index
+big_bin_float "" ".*qi.reference.binary.binary_big.*" qi_index
+big_bin_double "" ".*qi.reference.binary.binary_big.*" qi_index
 
 byte_ "" ".*karma.reference.binary.binary_native.*" karma_index
 word "" ".*karma.reference.binary.binary_native.*" karma_index
 dword "" ".*karma.reference.binary.binary_native.*" karma_index
 qword "" ".*karma.reference.binary.binary_native.*" karma_index
+bin_float "" ".*karma.reference.binary.binary_native.*" karma_index
+bin_double "" ".*karma.reference.binary.binary_native.*" karma_index
 little_word "" ".*karma.reference.binary.binary_little.*" karma_index
 little_dword "" ".*karma.reference.binary.binary_little.*" karma_index
 little_qword "" ".*karma.reference.binary.binary_little.*" karma_index
+little_bin_float "" ".*karma.reference.binary.binary_little.*" karma_index
+little_bin_double "" ".*karma.reference.binary.binary_little.*" karma_index
 big_word "" ".*karma.reference.binary.binary_big.*" karma_index
 big_dword "" ".*karma.reference.binary.binary_big.*" karma_index
 big_qword "" ".*karma.reference.binary.binary_big.*" karma_index
+big_bin_float "" ".*karma.reference.binary.binary_big.*" karma_index
+big_bin_double "" ".*karma.reference.binary.binary_big.*" karma_index
 
 # char parsers/generators
 char_ "" ".*qi.reference.char\..*" qi_index
@@ -269,7 +281,7 @@
 _pass "" ".*karma.quick_reference.phoenix.*" karma_index
 
 ###############################################################################
-#!exclude N
+#!exclude N
 #!exclude type iterator Auto call where: f info derived_type subject_type
 #!exclude if floatfield precision trailing_zeros force_sign in pointer
 #!exclude result_type value_type difference_type assign clear

Modified: branches/release/libs/spirit/doc/karma/binary.qbk
==============================================================================
--- branches/release/libs/spirit/doc/karma/binary.qbk (original)
+++ branches/release/libs/spirit/doc/karma/binary.qbk 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -44,6 +44,8 @@
     [[`boost::spirit::word // alias: boost::spirit::karma::word` ]]
     [[`boost::spirit::dword // alias: boost::spirit::karma::dword` ]]
     [[`boost::spirit::qword // alias: boost::spirit::karma::qword` ]]
+ [[`boost::spirit::bin_float // alias: boost::spirit::karma::bin_float` ]]
+ [[`boost::spirit::bin_double // alias: boost::spirit::karma::bin_double` ]]
 ]
 
 [note The generators `qword` and `qword(qw)` are only available on
@@ -67,6 +69,12 @@
     [[`qw`] [A 64 bit binary value or a __karma_lazy_argument__ that
                evaluates to a 64 bit binary value. This value is always
                interpreted using native endianness.]]
+ [[`f`] [A float binary value or a __karma_lazy_argument__ that
+ evaluates to a float binary value. This value is always
+ interpreted using native endianness.]]
+ [[`d`] [A double binary value or a __karma_lazy_argument__ that
+ evaluates to a double binary value. This value is always
+ interpreted using native endianness.]]
 ]
 
 [heading Expression Semantics]
@@ -95,6 +103,14 @@
                              in native endian representation. This generator
                              never fails (unless the underlying output stream
                              reports an error).]]
+ [[`bin_float`] [Output the binary representation of the mandatory
+ float attribute in native endian representation.
+ This generator never fails (unless the underlying
+ output stream reports an error).]]
+ [[`bin_double`] [Output the binary representation of the mandatory
+ double attribute in native endian representation.
+ This generator never fails (unless the underlying
+ output stream reports an error).]]
     [[`byte_(b)`] [Output the binary representation of the least
                              significant byte of the immediate parameter. This
                              generator never fails (unless the underlying
@@ -114,6 +130,14 @@
                              in native endian representation. This generator
                              never fails (unless the underlying output stream
                              reports an error).]]
+ [[`bin_float(f)`] [Output the binary representation of the immediate
+ float parameter in native endian representation.
+ This generator never fails (unless the underlying
+ output stream reports an error).]]
+ [[`bin_double(d)`] [Output the binary representation of the immediate
+ double parameter in native endian representation.
+ This generator never fails (unless the underlying
+ output stream reports an error).]]
 ]
 
 [heading Attributes]
@@ -128,10 +152,16 @@
                              (otherwise compilation will fail)]]
     [[`qword`] [`boost::uint_least64_t`, attribute is mandatory
                              (otherwise compilation will fail)]]
+ [[`bin_float`] [`float`, attribute is mandatory
+ (otherwise compilation will fail)]]
+ [[`bin_double`] [`double`, attribute is mandatory
+ (otherwise compilation will fail)]]
     [[`byte_(b)`] [__unused__]]
     [[`word(w)`] [__unused__]]
     [[`dword(dw)`] [__unused__]]
     [[`qword(qw)`] [__unused__]]
+ [[`bin_float(f)`] [__unused__]]
+ [[`bin_double(d)`] [__unused__]]
 ]
 
 [note In addition to their usual attribute of type `Attrib` all listed generators
@@ -192,6 +222,8 @@
     [[`boost::spirit::little_word // alias: boost::spirit::karma::little_word` ]]
     [[`boost::spirit::little_dword // alias: boost::spirit::karma::little_dword` ]]
     [[`boost::spirit::little_qword // alias: boost::spirit::karma::little_qword` ]]
+ [[`boost::spirit::little_bin_float // alias: boost::spirit::karma::little_bin_float` ]]
+ [[`boost::spirit::little_bin_double // alias: boost::spirit::karma::little_bin_double` ]]
 ]
 
 [note The generators `little_qword` and `little_qword(qw)` are only available on
@@ -213,6 +245,12 @@
     [[`qw`] [A 64 bit binary value or a __karma_lazy_argument__ that
                evaluates to a 64 bit binary value. This value is always
                interpreted using native endianness.]]
+ [[`f`] [A float binary value or a __karma_lazy_argument__ that
+ evaluates to a float binary value. This value is always
+ interpreted using native endianness.]]
+ [[`d`] [A double binary value or a __karma_lazy_argument__ that
+ evaluates to a double binary value. This value is always
+ interpreted using native endianness.]]
 ]
 
 [heading Expression Semantics]
@@ -221,52 +259,74 @@
 not defined in __primitive_generator_concept__.
 
 [table
- [[Expression] [Description]]
- [[`little_word`] [Output the binary representation of the least
- significant 16 bits of the mandatory attribute
- in little endian representation. This generator
- never fails (unless the underlying output stream
- reports an error).]]
- [[`little_dword`] [Output the binary representation of the least
- significant 32 bits of the mandatory attribute
- in little endian representation. This generator
- never fails (unless the underlying output stream
- reports an error).]]
- [[`little_qword`] [Output the binary representation of the least
- significant 64 bits of the mandatory attribute
- in little endian representation. This generator
- never fails (unless the underlying output stream
- reports an error).]]
- [[`little_word(w)`] [Output the binary representation of the least
- significant 16 bits of the immediate parameter
- in little endian representation. This generator
- never fails (unless the underlying output stream
- reports an error).]]
- [[`little_dword(dw)`] [Output the binary representation of the least
- significant 32 bits of the immediate parameter
- in little endian representation. This generator
- never fails (unless the underlying output stream
- reports an error).]]
- [[`little_qword(qw)`] [Output the binary representation of the least
- significant 64 bits of the immediate parameter
- in little endian representation. This generator
- never fails (unless the underlying output stream
- reports an error).]]
+ [[Expression] [Description]]
+ [[`little_word`] [Output the binary representation of the least
+ significant 16 bits of the mandatory attribute
+ in little endian representation. This generator
+ never fails (unless the underlying output stream
+ reports an error).]]
+ [[`little_dword`] [Output the binary representation of the least
+ significant 32 bits of the mandatory attribute
+ in little endian representation. This generator
+ never fails (unless the underlying output stream
+ reports an error).]]
+ [[`little_qword`] [Output the binary representation of the least
+ significant 64 bits of the mandatory attribute
+ in little endian representation. This generator
+ never fails (unless the underlying output stream
+ reports an error).]]
+ [[`little_bin_float`] [Output the binary representation of the mandatory
+ float attribute in little endian representation.
+ This generator never fails (unless the underlying
+ output stream reports an error).]]
+ [[`little_bin_double`] [Output the binary representation of the mandatory
+ double attribute in little endian representation.
+ This generator never fails (unless the underlying
+ output stream reports an error).]]
+ [[`little_word(w)`] [Output the binary representation of the least
+ significant 16 bits of the immediate parameter
+ in little endian representation. This generator
+ never fails (unless the underlying output stream
+ reports an error).]]
+ [[`little_dword(dw)`] [Output the binary representation of the least
+ significant 32 bits of the immediate parameter
+ in little endian representation. This generator
+ never fails (unless the underlying output stream
+ reports an error).]]
+ [[`little_qword(qw)`] [Output the binary representation of the least
+ significant 64 bits of the immediate parameter
+ in little endian representation. This generator
+ never fails (unless the underlying output stream
+ reports an error).]]
+ [[`little_bin_float(f)`] [Output the binary representation of the immediate
+ float parameter in little endian representation.
+ This generator never fails (unless the underlying
+ output stream reports an error).]]
+ [[`little_bin_double(d)`] [Output the binary representation of the immediate
+ double parameter in little endian representation.
+ This generator never fails (unless the underlying
+ output stream reports an error).]]
 ]
 
 [heading Attributes]
 
 [table
- [[Expression] [Attribute]]
- [[`little_word`] [`boost::uint_least16_t`, attribute is mandatory
- (otherwise compilation will fail)]]
- [[`little_dword`] [`boost::uint_least32_t`, attribute is mandatory
- (otherwise compilation will fail)]]
- [[`little_qword`] [`boost::uint_least64_t`, attribute is mandatory
- (otherwise compilation will fail)]]
- [[`little_word(w)`] [__unused__]]
- [[`little_dword(dw)`] [__unused__]]
- [[`little_qword(qw)`] [__unused__]]
+ [[Expression] [Attribute]]
+ [[`little_word`] [`boost::uint_least16_t`, attribute is mandatory
+ (otherwise compilation will fail)]]
+ [[`little_dword`] [`boost::uint_least32_t`, attribute is mandatory
+ (otherwise compilation will fail)]]
+ [[`little_qword`] [`boost::uint_least64_t`, attribute is mandatory
+ (otherwise compilation will fail)]]
+ [[`little_bin_float`] [`float`, attribute is mandatory
+ (otherwise compilation will fail)]]
+ [[`little_bin_double`] [`double`, attribute is mandatory
+ (otherwise compilation will fail)]]
+ [[`little_word(w)`] [__unused__]]
+ [[`little_dword(dw)`] [__unused__]]
+ [[`little_qword(qw)`] [__unused__]]
+ [[`little_bin_float(f)`] [__unused__]]
+ [[`little_bin_double(d)`] [__unused__]]
 ]
 
 [heading Complexity]
@@ -315,6 +375,8 @@
     [[`boost::spirit::big_word // alias: boost::spirit::karma::big_word` ]]
     [[`boost::spirit::big_dword // alias: boost::spirit::karma::big_dword` ]]
     [[`boost::spirit::big_qword // alias: boost::spirit::karma::big_qword` ]]
+ [[`boost::spirit::big_bin_float // alias: boost::spirit::karma::big_bin_float` ]]
+ [[`boost::spirit::big_bin_double // alias: boost::spirit::karma::big_bin_double` ]]
 ]
 
 [note The generators `big_qword` and `big_qword(qw)` are only available on
@@ -336,6 +398,12 @@
     [[`qw`] [A 64 bit binary value or a __karma_lazy_argument__ that
                evaluates to a 64 bit binary value. This value is always
                interpreted using native endianness.]]
+ [[`f`] [A float binary value or a __karma_lazy_argument__ that
+ evaluates to a float binary value. This value is always
+ interpreted using native endianness.]]
+ [[`d`] [A double binary value or a __karma_lazy_argument__ that
+ evaluates to a double binary value. This value is always
+ interpreted using native endianness.]]
 ]
 
 [heading Expression Semantics]
@@ -360,6 +428,14 @@
                              in big endian representation. This generator
                              never fails (unless the underlying output stream
                              reports an error).]]
+ [[`big_bin_float`] [Output the binary representation of the mandatory
+ float attribute in big endian representation.
+ This generator never fails (unless the underlying
+ output stream reports an error).]]
+ [[`big_bin_double`] [Output the binary representation of the mandatory
+ double attribute in big endian representation.
+ This generator never fails (unless the underlying
+ output stream reports an error).]]
     [[`big_word(w)`] [Output the binary representation of the least
                              significant 16 bits of the immediate parameter
                              in big endian representation. This generator
@@ -375,6 +451,14 @@
                              in big endian representation. This generator
                              never fails (unless the underlying output stream
                              reports an error).]]
+ [[`big_bin_float(f)`] [Output the binary representation of the immediate
+ float parameter in big endian representation.
+ This generator never fails (unless the underlying
+ output stream reports an error).]]
+ [[`big_bin_double(d)`] [Output the binary representation of the immediate
+ double parameter in big endian representation.
+ This generator never fails (unless the underlying
+ output stream reports an error).]]
 ]
 
 [heading Attributes]
@@ -387,9 +471,15 @@
                              (otherwise compilation will fail)]]
     [[`big_qword`] [`boost::uint_least64_t`, attribute is mandatory
                              (otherwise compilation will fail)]]
+ [[`big_bin_float`] [`float`, attribute is mandatory
+ (otherwise compilation will fail)]]
+ [[`big_bin_double`] [`double`, attribute is mandatory
+ (otherwise compilation will fail)]]
     [[`big_word(w)`] [__unused__]]
     [[`big_dword(dw)`] [__unused__]]
     [[`big_qword(qw)`] [__unused__]]
+ [[`big_bin_float(f)`] [__unused__]]
+ [[`big_bin_double(d)`] [__unused__]]
 ]
 
 [heading Complexity]

Modified: branches/release/libs/spirit/doc/qi/binary.qbk
==============================================================================
--- branches/release/libs/spirit/doc/qi/binary.qbk (original)
+++ branches/release/libs/spirit/doc/qi/binary.qbk 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -43,6 +43,8 @@
     [[`boost::spirit::word // alias: boost::spirit::qi::word`]]
     [[`boost::spirit::dword // alias: boost::spirit::qi::dword`]]
     [[`boost::spirit::qword // alias: boost::spirit::qi::qword`]]
+ [[`boost::spirit::bin_float // alias: boost::spirit::qi::bin_float`]]
+ [[`boost::spirit::bin_double // alias: boost::spirit::qi::bin_double`]]
 ]
 
 [note `qword` is only available on platforms where the preprocessor
@@ -66,6 +68,12 @@
     [[`qw`] [A 64 bit binary value or a __qi_lazy_argument__ that
                evaluates to a 64 bit binary value. This value is always
                in native endian.]]
+ [[`f`] [A float binary value or a __qi_lazy_argument__ that
+ evaluates to a float binary value. This value is always
+ in native endian.]]
+ [[`d`] [A double binary value or a __qi_lazy_argument__ that
+ evaluates to a double binary value. This value is always
+ in native endian.]]
 ]
 
 [heading Expression Semantics]
@@ -79,10 +87,14 @@
     [[`word`] [Matches any 16 bit native endian binary.]]
     [[`dword`] [Matches any 32 bit native endian binary.]]
     [[`qword`] [Matches any 64 bit native endian binary.]]
+ [[`bin_float`] [Matches any float native endian binary.]]
+ [[`bin_double`] [Matches any double native endian binary.]]
     [[`byte_(b)`] [Matches an exact 8 bit native endian binary.]]
     [[`word(w)`] [Matches an exact 16 bit native endian binary.]]
     [[`dword(dw)`] [Matches an exact 32 bit native endian binary.]]
     [[`qword(qw)`] [Matches an exact 64 bit native endian binary.]]
+ [[`bin_float(f)`] [Matches an exact float native endian binary.]]
+ [[`bin_double(d)`] [Matches an exact double native endian binary.]]
 ]
 
 [heading Attributes]
@@ -93,10 +105,14 @@
     [[`word`] [`boost::uint_least16_t`]]
     [[`dword`] [`boost::uint_least32_t`]]
     [[`qword`] [`boost::uint_least64_t`]]
+ [[`bin_float`] [`float`]]
+ [[`bin_double`] [`double`]]
     [[`byte_(b)`] [__unused__]]
     [[`word(w)`] [__unused__]]
     [[`dword(dw)`] [__unused__]]
     [[`qword(qw)`] [__unused__]]
+ [[`bin_float(f)`] [__unused__]]
+ [[`bin_double(d)`] [__unused__]]
 ]
 
 [heading Complexity]
@@ -131,9 +147,11 @@
 
 [table
     [[Name]]
- [[`boost::spirit::little_word // alias: boost::spirit::qi::little_word` ]]
- [[`boost::spirit::little_dword // alias: boost::spirit::qi::little_dword` ]]
- [[`boost::spirit::little_qword // alias: boost::spirit::qi::little_qword` ]]
+ [[`boost::spirit::little_word // alias: boost::spirit::qi::little_word` ]]
+ [[`boost::spirit::little_dword // alias: boost::spirit::qi::little_dword` ]]
+ [[`boost::spirit::little_qword // alias: boost::spirit::qi::little_qword` ]]
+ [[`boost::spirit::little_bin_float // alias: boost::spirit::qi::little_bin_float` ]]
+ [[`boost::spirit::little_bin_double // alias: boost::spirit::qi::little_bin_double` ]]
 ]
 
 [note `little_qword` is only available on platforms where the
@@ -155,6 +173,12 @@
     [[`qw`] [A 64 bit binary value or a __qi_lazy_argument__ that
                evaluates to a 64 bit binary value. This value is always
                in native endian.]]
+ [[`f`] [A float binary value or a __qi_lazy_argument__ that
+ evaluates to a float binary value. This value is always
+ in native endian.]]
+ [[`d`] [A double binary value or a __qi_lazy_argument__ that
+ evaluates to a double binary value. This value is always
+ in native endian.]]
 ]
 
 [heading Expression Semantics]
@@ -163,25 +187,33 @@
 not defined in __primitive_parser_concept__.
 
 [table
- [[Expression] [Description]]
- [[`little_word`] [Matches any 16 bit little endian binary.]]
- [[`little_dword`] [Matches any 32 bit little endian binary.]]
- [[`little_qword`] [Matches any 64 bit little endian binary.]]
- [[`little_word(w)`] [Matches an exact 16 bit little endian binary.]]
- [[`little_dword(dw)`] [Matches an exact 32 bit little endian binary.]]
- [[`little_qword(qw)`] [Matches an exact 32 bit little endian binary.]]
+ [[Expression] [Description]]
+ [[`little_word`] [Matches any 16 bit little endian binary.]]
+ [[`little_dword`] [Matches any 32 bit little endian binary.]]
+ [[`little_qword`] [Matches any 64 bit little endian binary.]]
+ [[`little_bin_float`] [Matches any float little endian binary.]]
+ [[`little_bin_double`] [Matches any double little endian binary.]]
+ [[`little_word(w)`] [Matches an exact 16 bit little endian binary.]]
+ [[`little_dword(dw)`] [Matches an exact 32 bit little endian binary.]]
+ [[`little_qword(qw)`] [Matches an exact 32 bit little endian binary.]]
+ [[`little_bin_float(f)`] [Matches an exact float little endian binary.]]
+ [[`little_bin_double(d)`] [Matches an exact double little endian binary.]]
 ]
 
 [heading Attributes]
 
 [table
- [[Expression] [Attribute]]
- [[`little_word`] [`boost::uint_least16_t`]]
- [[`little_dword`] [`boost::uint_least32_t`]]
- [[`little_qword`] [`boost::uint_least64_t`]]
- [[`little_word(w)`] [__unused__]]
- [[`little_dword(dw)`] [__unused__]]
- [[`little_qword(qw)`] [__unused__]]
+ [[Expression] [Attribute]]
+ [[`little_word`] [`boost::uint_least16_t`]]
+ [[`little_dword`] [`boost::uint_least32_t`]]
+ [[`little_qword`] [`boost::uint_least64_t`]]
+ [[`little_bin_float`] [`float`]]
+ [[`little_bin_double`] [`double`]]
+ [[`little_word(w)`] [__unused__]]
+ [[`little_dword(dw)`] [__unused__]]
+ [[`little_qword(qw)`] [__unused__]]
+ [[`little_bin_float(f)`] [__unused__]]
+ [[`little_bin_double(d)`] [__unused__]]
 ]
 
 [heading Complexity]
@@ -216,9 +248,11 @@
 
 [table
     [[Name]]
- [[`boost::spirit::big_word // alias: boost::spirit::qi::big_word` ]]
- [[`boost::spirit::big_dword // alias: boost::spirit::qi::big_dword` ]]
- [[`boost::spirit::big_qword // alias: boost::spirit::qi::big_qword` ]]
+ [[`boost::spirit::big_word // alias: boost::spirit::qi::big_word` ]]
+ [[`boost::spirit::big_dword // alias: boost::spirit::qi::big_dword` ]]
+ [[`boost::spirit::big_qword // alias: boost::spirit::qi::big_qword` ]]
+ [[`boost::spirit::big_bin_float // alias: boost::spirit::qi::big_bin_float` ]]
+ [[`boost::spirit::big_bin_double // alias: boost::spirit::qi::big_bin_double` ]]
 ]
 
 [note `big_qword` is only available on platforms where the
@@ -240,6 +274,12 @@
     [[`qw`] [A 64 bit binary value or a __qi_lazy_argument__ that
                 evaluates to a 64 bit binary value. This value is always
                 in native endian.]]
+ [[`f`] [A float binary value or a __qi_lazy_argument__ that
+ evaluates to a float binary value. This value is always
+ in native endian.]]
+ [[`d`] [A double binary value or a __qi_lazy_argument__ that
+ evaluates to a double binary value. This value is always
+ in native endian.]]
 ]
 
 [heading Expression Semantics]
@@ -252,9 +292,13 @@
     [[`big_word`] [Matches any 16 bit big endian binary.]]
     [[`big_dword`] [Matches any 32 bit big endian binary.]]
     [[`big_qword`] [Matches any 64 bit big endian binary.]]
+ [[`big_bin_float`] [Matches any float big endian binary.]]
+ [[`big_bin_double`] [Matches any double big endian binary.]]
     [[`big_word(w)`] [Matches an exact 16 bit big endian binary.]]
     [[`big_dword(dw)`] [Matches an exact 32 bit big endian binary.]]
     [[`big_qword(qw)`] [Matches an exact 32 bit big endian binary.]]
+ [[`big_bin_float(f)`] [Matches an exact float big endian binary.]]
+ [[`big_bin_double(d)`] [Matches an exact double big endian binary.]]
 ]
 
 [heading Attributes]
@@ -264,9 +308,13 @@
     [[`big_word`] [`boost::uint_least16_t`]]
     [[`big_dword`] [`boost::uint_least32_t`]]
     [[`big_qword`] [`boost::uint_least64_t`]]
+ [[`big_bin_float`] [`float`]]
+ [[`big_bin_double`] [`double`]]
     [[`big_word(w)`] [__unused__]]
     [[`big_dword(dw)`] [__unused__]]
     [[`big_qword(qw)`] [__unused__]]
+ [[`big_bin_float(f)`] [__unused__]]
+ [[`big_bin_double(d)`] [__unused__]]
 ]
 
 [heading Complexity]

Modified: branches/release/libs/spirit/doc/qi/error_handling.qbk
==============================================================================
--- branches/release/libs/spirit/doc/qi/error_handling.qbk (original)
+++ branches/release/libs/spirit/doc/qi/error_handling.qbk 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -80,7 +80,7 @@
     [[Arg] [Description]]
     [[first] [The position of the iterator when the rule with the handler was entered.]]
     [[last] [The end of input.]]
- [[error-pos] [The actual position of the iterator where the error occurred.]]
+ [[error-pos] [The actual position of the iterator where the error occured.]]
     [[what] [What failed: a string describing the failure.]]
 ]
 

Modified: branches/release/libs/spirit/doc/qi/quick_reference.qbk
==============================================================================
--- branches/release/libs/spirit/doc/qi/quick_reference.qbk (original)
+++ branches/release/libs/spirit/doc/qi/quick_reference.qbk 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -93,10 +93,10 @@
     [[[qi_real_number `float_(num)`]] [`float`] [Parse a floating point number into a `float`,
                                                             a number is matched only if it's `num`]]
     [[[qi_real_number `double_`]] [`double`] [Parse a floating point number into a `double`]]
- [[[qi_real_number `double_`]] [`double`] [Parse a floating point number into a `double`,
+ [[[qi_real_number `double_(num)`]] [`double`] [Parse a floating point number into a `double`,
                                                             a number is matched only if it's `num`]]
     [[[qi_real_number `long_double`]] [`long double`] [Parse a floating point number into a `long double`]]
- [[[qi_real_number `long_double`]] [`long double`] [Parse a floating point number into a `long double`,
+ [[[qi_real_number `long_double(num)`]] [`long double`] [Parse a floating point number into a `long double`,
                                                             a number is matched only if it's `num`]]
 
     [[[qi_unsigned_int `bin`]] [`unsigned`] [Parse a binary integer into an `unsigned`]]

Modified: branches/release/libs/spirit/doc/spirit2.qbk
==============================================================================
--- branches/release/libs/spirit/doc/spirit2.qbk (original)
+++ branches/release/libs/spirit/doc/spirit2.qbk 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -8,7 +8,7 @@
 
 [article Spirit
     [quickbook 1.5]
- [version 2.5.1]
+ [version 2.5.2]
     [authors [de Guzman, Joel], [Kaiser, Hartmut]]
     [copyright 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 Joel de Guzman, Hartmut Kaiser]
     [/ purpose Parser and Generator Library]
@@ -23,7 +23,7 @@
 
 [/ Some links ]
 
-[def __version__ V2.5.1]
+[def __version__ V2.5.2]
 
 [def __spirit__ [@http://boost-spirit.com Spirit]]
 [def __spirit_list__ [@http://www.nabble.com/The-Spirit-Parser-Library-f3430.html Spirit General List]]

Modified: branches/release/libs/spirit/doc/what_s_new.qbk
==============================================================================
--- branches/release/libs/spirit/doc/what_s_new.qbk (original)
+++ branches/release/libs/spirit/doc/what_s_new.qbk 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -9,25 +9,47 @@
 [section What's New]
 
 [/////////////////////////////////////////////////////////////////////////////]
+[section:spirit_2_5_2 Spirit V2.5.2]
+
+[heading What's changed from V2.5.1 (Boost V1.48.0) to V2.5.2 (Boost V1.49.0)]
+
+* Integrated Vitaly Budovski's patch to add binary floating point parsers and
+ generators.
+* Fixed #6253: `lex::lexertl::generate_static_dfa` compiler errors if lexer has
+ wchar_t as underlying stream type.
+* Added the possibility to match a token range when parsing with a lexer by
+ using `qi::token(min, max)`, or `qi::tokenid(min, max)`. Both parsers match
+ any token with a token id in the range [min, max].
+* Fixed a problem in [karma_align `center`]`(num)[a]` and
+ [karma_align `center`]`(num, g)[a]` if used inside a compound generator (such
+ as sequences, Kleene, list, or plus.
+* Fixed `karma::subrule` from the [@../../repository/doc/html/index.html repository]
+ (thanks to Lee Clagett for submitting a patch).
+* Fixed __karma__ examples (thanks to Lee Clagett for submitting a patch).
+* Fixed #6368: [multi_pass] clear_queue isn't forwarded to the storage policy.
+
+[endsect]
+
+[/////////////////////////////////////////////////////////////////////////////]
 [section:spirit_2_5_1 Spirit V2.5.1]
 
 [heading What's changed from V2.5 (Boost V1.47.0) to V2.5.1 (Boost V1.48.0)]
 
-* The `spirit::istream_iterator` (see __multi_pass__) now checks at
+* The `spirit::istream_iterator` (see __multi_pass__) now checks at
   construction time whether the underlying stream has reached eof (end of file).
-* __qi__ now properly collapses attributes generated from optionals embedded
+* __qi__ now properly collapses attributes generated from optionals embedded
   inside another optional parser (i.e. `-('(' > -int_ >> ')'). That means that
- attributes like `boost::optiona<boost::optional<int> >` will be collapsed
- to `boost::optional<int>`. Thanks to Peter Schueller for reporting that
+ attributes like `boost::optional<boost::optional<int> >` will be collapsed
+ to `boost::optional<int>`. Thanks to Peter Schueller for reporting that
   problem.
-* Actions attached to binary parsers now properly propagate the parser's
+* Actions attached to binary parsers now properly propagate the parser's
   attribute. Thanks to Mathias Born for reporting this issue.
 
 [heading Bug Fixes in Lex]
 
-* Fixed Boost ticket #5701: lexertl token_value_type returns const unused for
+* Fixed Boost ticket #5701: lexertl token_value_type returns const unused for
   nonconst ref.
-* Fixed a problem in the lexer (position_token) causing problems with enabled
+* Fixed a problem in the lexer (position_token) causing problems with enabled
   parser debugging (MSVC2010).
 
 [endsect]
@@ -79,7 +101,7 @@
   This change unifies the handling of the `_val` placeholder allowing to use it
   everywhere, not only in semantic actions attached to the right hand sides of
   a rule.
-* Added support for __karma__ [unsigned_int unsigned numeric generators] with
+* Added support for __karma__ [unsigned_int unsigned numeric generators] with
   arbitrary radix values in the (inclusive) range from `2` .. `36`.
 
 [heading Bug Fixes in Qi or Karma]
@@ -122,14 +144,14 @@
   using `lex::char_` and `lex::string`. Both primitives now accept a second
   parameter which will be interpreted as the requested token id for any token
   generated from this definition.
-* Added a new token type `lex::lexertl::position_token<>`, which is essentially
+* Added a new token type `lex::lexertl::position_token<>`, which is essentially
   plup-in compatible with the existing `lex::lexertl::token<>` class. However
- it additionally stores the pair of iterators pointing to the underlying
+ it additionally stores the pair of iterators pointing to the underlying
   matched input sequence as an iterator_range.
 
 [heading Bug Fixes in Lex]
 
-* Fixed a problem with associating token definitions with all states (using
+* Fixed a problem with associating token definitions with all states (using
   `"*"` as the state name) when actions were attached to them.
 
 [heading Making Stuff Work]

Modified: branches/release/libs/spirit/repository/doc/qi/seek.qbk
==============================================================================
--- branches/release/libs/spirit/repository/doc/qi/seek.qbk (original)
+++ branches/release/libs/spirit/repository/doc/qi/seek.qbk 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -59,21 +59,31 @@
 
 [heading Complexity]
 
-[:The complexity is defined by the complexity of the subject parser, `a`]
+[:The overall complexity is defined by the complexity of its subject
+parser. The complexity of `seek` itself is O(N), where N is the number
+of unsuccessful matches.]
+
+[note *seeking sequence with skipping*
+
+Using `seek[a >> b]` with skipping is inefficient, because when sequence fails, the backtracked position is non-skipped.
+The solution is to ensure the input will always be pre-skipped, for example:
+``
+ seek[lexeme[skip[a >> b]]]
+``
+does the trick.]
 
 [heading Example]
 
 [import ../../example/qi/seek.cpp]
 
-The following example shows a simple use case of the `seek[]` directive, seeking
-all the ints preceding by `'#'`.
+The following example shows a simple use case of the `seek[]` directive, parsing C-style comment.
 (For the full source of the example, see [@../../example/qi/seek.cpp seek.cpp])
 
 Some namespace aliases:
 
 [reference_qi_seek_namespace]
 
-The input iterators and the attribute to store the result:
+The input string and its iterators:
 
 [reference_qi_seek_vars]
 
@@ -81,18 +91,4 @@
 
 [reference_qi_seek_parse]
 
-Input:
-
-[pre
-1 will not be outputted while #2, ##3 and # 4 will.
-]
-
-Output:
-
-[pre
---------------------------------
-Parsing succeeded, got: \[ 2, 3, 4 \]
----------------------------------
-]
-
 [endsect]

Modified: branches/release/libs/spirit/repository/doc/spirit2_repository.qbk
==============================================================================
--- branches/release/libs/spirit/repository/doc/spirit2_repository.qbk (original)
+++ branches/release/libs/spirit/repository/doc/spirit2_repository.qbk 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -44,6 +44,7 @@
 [def __qi_confix__ [link spirit_repository.qi_components.directives.confix `confix`]]
 [def __qi_keywords__ [link spirit_repository.qi_components.operators.keyword_list keyword_list]]
 [def __qi_keywords_list__ [link spirit_repository.qi_components.directives.kwd `kwd()[]`]]
+[def __qi_seek__ [link spirit_repository.qi_components.directives.seek `seek[]`]]
 
 [def __karma_subrule__ [link spirit_repository.karma_components.nonterminal.subrule `subrule`]]
 
@@ -104,6 +105,8 @@
 
 [include preface.qbk]
 
+[include what_s_new.qbk]
+
 [include qi.qbk]
 
 [include karma.qbk]

Modified: branches/release/libs/spirit/repository/example/karma/calc2_ast.hpp
==============================================================================
--- branches/release/libs/spirit/repository/example/karma/calc2_ast.hpp (original)
+++ branches/release/libs/spirit/repository/example/karma/calc2_ast.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -1,6 +1,6 @@
 /*=============================================================================
     Copyright (c) 2001-2010 Joel de Guzman
- Copyright (c) 2001-2010 Hartmut Kaiser
+ Copyright (c) 2001-2012 Hartmut Kaiser
 
     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)
@@ -19,10 +19,11 @@
 #define SPIRIT_EXAMPLE_CALC2_AST_APR_30_2008_1011AM
 
 #include <boost/variant.hpp>
-#include <boost/variant/get.hpp>
 #include <boost/spirit/include/phoenix_operator.hpp>
 #include <boost/spirit/include/phoenix_function.hpp>
 #include <boost/spirit/include/phoenix_statement.hpp>
+#include <boost/spirit/home/karma/domain.hpp>
+#include <boost/spirit/include/support_attributes_fwd.hpp>
 
 ///////////////////////////////////////////////////////////////////////////////
 // Our AST
@@ -42,7 +43,7 @@
>
     type;
 
- // expose variant types
+ // expose variant types
     typedef type::types types;
 
     // expose variant functionality
@@ -82,16 +83,26 @@
         return boost::get<T>(expr.expr);
     }
 
- // the specialization below tells Spirit to handle expression_ast as if it
+ // the specialization below tells Spirit to handle expression_ast as if it
     // where a 'real' variant
     namespace spirit { namespace traits
     {
- template <typename T>
- struct not_is_variant;
-
+ // the specialization below tells Spirit to handle expression_ast as
+ // if it where a 'real' variant (if used with Spirit.Karma)
         template <>
- struct not_is_variant<expression_ast>
+ struct not_is_variant<expression_ast, karma::domain>
           : mpl::false_ {};
+
+ // the specialization of variant_which allows to generically extract
+ // the current type stored in the given variant like type
+ template <>
+ struct variant_which<expression_ast>
+ {
+ static int call(expression_ast const& v)
+ {
+ return v.which();
+ }
+ };
     }}
 }
 

Modified: branches/release/libs/spirit/repository/example/qi/seek.cpp
==============================================================================
--- branches/release/libs/spirit/repository/example/qi/seek.cpp (original)
+++ branches/release/libs/spirit/repository/example/qi/seek.cpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -5,15 +5,13 @@
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //////////////////////////////////////////////////////////////////////////////*/
 
-// [ Jamboree May 3, 2011 ] first ver.
-// [ Jamboree Aug 13, 2011 ] minor change.
+// [ Jamboree Oct 27, 2011 ] new example.
 
 
 #include <cstdlib>
 #include <iostream>
 
 #include <boost/spirit/include/qi.hpp>
-#include <boost/spirit/include/karma.hpp>
 #include <boost/spirit/repository/include/qi_seek.hpp>
 
 
@@ -21,36 +19,30 @@
 {
     //[reference_qi_seek_namespace
     namespace qi = boost::spirit::qi;
- namespace ka = boost::spirit::karma;
     namespace repo = boost::spirit::repository;
     //]
-
- std::string line;
+
     typedef std::string::const_iterator iterator;
 
- while (std::cout << ">>> ", std::getline(std::cin, line))
+ //[reference_qi_seek_vars
+ std::string str("/*C-style comment*/");
+ iterator it = str.begin();
+ iterator end = str.end();
+ //]
+
+ //[reference_qi_seek_parse
+ if (qi::parse(it, end, "/*" >> repo::qi::seek["*/"]))
     {
- //[reference_qi_seek_vars
- iterator it = line.begin();
- iterator end = line.end();
- std::vector<int> val;
- //]
-
- //[reference_qi_seek_parse
- if (qi::phrase_parse(it, end, +repo::qi::seek["#" >> qi::int_], qi::space, val))
- {
- std::cout << "-------------------------------- \n";
- std::cout << "Parsing succeeded, got: "
- << ka::format("[ " << ka::int_ % ", " << " ]\n", val);
- std::cout << "---------------------------------\n";
- }//]
- else
- {
- std::cout << "-------------------------------- \n";
- std::cout << "Parsing failed, rest: " << std::string(it, end) << "\n";
- std::cout << "-------------------------------- \n";
- }
+ std::cout << "-------------------------------- \n";
+ std::cout << "Parsing succeeded.\n";
+ std::cout << "---------------------------------\n";
     }
+ else
+ {
+ std::cout << "-------------------------------- \n";
+ std::cout << "Unterminated /* comment.\n";
+ std::cout << "-------------------------------- \n";
+ }//]
 
     return EXIT_SUCCESS;
 }

Modified: branches/release/libs/spirit/test/Jamfile
==============================================================================
--- branches/release/libs/spirit/test/Jamfile (original)
+++ branches/release/libs/spirit/test/Jamfile 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -1,6 +1,6 @@
 #==============================================================================
 # Copyright (c) 2001-2011 Joel de Guzman
-# Copyright (c) 2001-2011 Hartmut Kaiser
+# Copyright (c) 2001-2012 Hartmut Kaiser
 # Copyright (c) 2011 Bryce Lelbach
 #
 # Use, modification and distribution is subject to the Boost Software
@@ -15,9 +15,9 @@
 
 ###############################################################################
 # new feature definition allowing to switch between Phoenix V2 and V3 tests
-feature.feature phoenix_v3
+feature.feature phoenix_v3
     : off on
- : composite propagated
+ : composite propagated
     ;
 
 feature.compose <phoenix_v3>on
@@ -33,10 +33,10 @@
     :
     :
     ;
-
+
 v2_tests = ;
 v3_tests = ;
-
+
 rule run ( sources + : args * : input-files * : requirements * : target-name ? : default-build * )
 {
     target-name ?= $(sources[1]:D=:S=) ;
@@ -57,7 +57,7 @@
     v2_tests += [ testing.compile-fail $(sources) : $(requirements) : $(target-name)-p2 ] ;
     v3_tests += [ testing.compile-fail $(sources) : $(requirements) <phoenix_v3>on : $(target-name)-p3 ] ;
 }
-
+
 ###############################################################################
 path-constant LEX_DIR : $(BOOST_ROOT)/libs/spirit/test/lex ;
 
@@ -249,6 +249,7 @@
      [ run karma/regression_optional_double.cpp : : : : karma_regression_optional_double ]
      [ run karma/regression_semantic_action_attribute.cpp : : : : karma_regression_semantic_action_attribute ]
      [ run karma/regression_real_scientific.cpp : : : : karma_regression_real_scientific ]
+ [ run karma/regression_center_alignment.cpp : : : : karma_regression_center_alignment ]
 
     ;
 
@@ -282,13 +283,13 @@
      [ run lex/regression_basic_lexer.cpp : : : : lex_regression_basic_lexer ]
      [ run lex/regression_matlib_dynamic.cpp : : : : lex_regression_matlib_dynamic ]
      [ run lex/regression_matlib_generate.cpp : $(LEX_DIR)/matlib_static.h : : : lex_regression_matlib_generate ]
- [ run lex/regression_matlib_static.cpp : : :
+ [ run lex/regression_matlib_static.cpp : : :
        <phoenix_v3>on:<dependency>.//lex_regression_matlib_generate-p3
        <phoenix_v3>off:<dependency>.//lex_regression_matlib_generate-p2
        : lex_regression_matlib_static ]
      [ run lex/regression_matlib_generate_switch.cpp : $(LEX_DIR)/matlib_static_switch.h : : : lex_regression_matlib_generate_switch ]
- [ run lex/regression_matlib_switch.cpp : : :
- <phoenix_v3>on:<dependency>.//lex_regression_matlib_generate_switch-p3
+ [ run lex/regression_matlib_switch.cpp : : :
+ <phoenix_v3>on:<dependency>.//lex_regression_matlib_generate_switch-p3
        <phoenix_v3>off:<dependency>.//lex_regression_matlib_generate_switch-p2
          : lex_regression_matlib_switch ]
      [ run lex/regression_word_count.cpp : : : : lex_regression_word_count ]
@@ -298,6 +299,7 @@
      [ run lex/regression_file_iterator2.cpp : : : : lex_regression_file_iterator2 ]
      [ run lex/regression_file_iterator3.cpp : : : : lex_regression_file_iterator3 ]
      [ run lex/regression_file_iterator4.cpp : : : : lex_regression_file_iterator4 ]
+ [ run lex/regression_static_wide_6253.cpp : : : : regression_static_wide_6253 ]
 
     ;
 
@@ -330,8 +332,9 @@
 # while running the regerssion tests.
 #
 # If you want to avoid running tests for both Phoenix V2 and V3 by default
-# then simply uncomment the following 'explicit' command. If no target is
+# then simply uncomment the following 'explicit' command. If no target is
 # specified, only the V2 tests will be run.
-#
-# explicit test_using_phoenix_v2 test_using_phoenix_v3 ;
+#
+
+explicit test_using_phoenix_v2 test_using_phoenix_v3 ;
 

Modified: branches/release/libs/spirit/test/karma/binary1.cpp
==============================================================================
--- branches/release/libs/spirit/test/karma/binary1.cpp (original)
+++ branches/release/libs/spirit/test/karma/binary1.cpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -39,6 +39,9 @@
         BOOST_TEST(binary_test("\x81\x02\x03\x04\x05\x06\x07\x08", 8, qword,
             0x0807060504030281LL));
 #endif
+ BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, bin_float, 1.0f));
+ BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8,
+ bin_double, 1.0));
 
         BOOST_TEST(binary_test_delimited("\x01\x00\x00\x00", 4, byte_, 0x01, pad(4)));
         BOOST_TEST(binary_test_delimited("\x01\x02\x00\x00", 4, word, 0x0201, pad(4)));
@@ -47,6 +50,10 @@
         BOOST_TEST(binary_test_delimited("\x01\x02\x03\x04\x05\x06\x07\x08\x00\x00", 10,
             qword, 0x0807060504030201LL, pad(10)));
 #endif
+ BOOST_TEST(binary_test_delimited("\x00\x00\x80\x3f", 4, bin_float,
+ 1.0f, pad(4)));
+ BOOST_TEST(binary_test_delimited("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8,
+ bin_double, 1.0, pad(8)));
 
 #else // BOOST_LITTLE_ENDIAN
 
@@ -62,6 +69,9 @@
         BOOST_TEST(binary_test("\x81\x02\x03\x04\x05\x06\x07\x08", 8, qword,
             0x8102030405060708LL));
 #endif
+ BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, bin_float, 1.0f));
+ BOOST_TEST(binary_test("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8,
+ bin_double, 1.0));
 
         BOOST_TEST(binary_test_delimited("\x01\x00\x00\x00", 4, byte_, 0x01, pad(4)));
         BOOST_TEST(binary_test_delimited("\x01\x02\x00\x00", 4, word, 0x0102, pad(4)));
@@ -70,6 +80,10 @@
         BOOST_TEST(binary_test_delimited("\x01\x02\x03\x04\x05\x06\x07\x08\x00\x00", 10,
             qword, 0x0102030405060708LL, pad(10)));
 #endif
+ BOOST_TEST(binary_test_delimited("\x3f\x80\x00\x00", 4, bin_float,
+ 1.0f, pad(4)));
+ BOOST_TEST(binary_test_delimited("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8,
+ bin_double, 1.0, pad(8)));
 #endif
     }
 
@@ -82,6 +96,9 @@
         BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x08", 8,
             qword(0x0807060504030201LL)));
 #endif
+ BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, bin_float(1.0f)));
+ BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8,
+ bin_double(1.0)));
 #else
         BOOST_TEST(binary_test("\x01", 1, byte_(0x01)));
         BOOST_TEST(binary_test("\x01\x02", 2, word(0x0102)));
@@ -90,6 +107,9 @@
         BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x08", 8,
             qword(0x0102030405060708LL)));
 #endif
+ BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, bin_float(1.0f)));
+ BOOST_TEST(binary_test("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8,
+ bin_double(1.0)));
 #endif
     }
 

Modified: branches/release/libs/spirit/test/karma/binary2.cpp
==============================================================================
--- branches/release/libs/spirit/test/karma/binary2.cpp (original)
+++ branches/release/libs/spirit/test/karma/binary2.cpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -38,6 +38,11 @@
         BOOST_TEST(binary_test_delimited("\x01\x02\x03\x04\x05\x06\x07\x08\x00\x00",
             10, big_qword, 0x0102030405060708LL, pad(10)));
 #endif
+ BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, big_bin_float, 1.0f));
+ BOOST_TEST(binary_test("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8,
+ big_bin_double, 1.0));
+ BOOST_TEST(binary_test_delimited("\x3f\xf0\x00\x00\x00\x00\x00\x00\x00\x00",
+ 10, big_bin_double, 1.0, pad(10)));
     }
 
     {
@@ -49,6 +54,11 @@
         BOOST_TEST(binary_test_delimited("\x01\x02\x03\x04\x05\x06\x07\x08\x00\x00",
             10, big_qword(0x0102030405060708LL), pad(10)));
 #endif
+ BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, big_bin_float(1.0f)));
+ BOOST_TEST(binary_test("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8,
+ big_bin_double(1.0)));
+ BOOST_TEST(binary_test_delimited("\x3f\xf0\x00\x00\x00\x00\x00\x00\x00\x00",
+ 10, big_bin_double(1.0), pad(10)));
     }
 
     { // test little endian binaries
@@ -64,6 +74,11 @@
         BOOST_TEST(binary_test_delimited("\x01\x02\x03\x04\x05\x06\x07\x08\x00\x00",
             10, little_qword, 0x0807060504030201LL, pad(10)));
 #endif
+ BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, little_bin_float, 1.0f));
+ BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8,
+ little_bin_double, 1.0));
+ BOOST_TEST(binary_test_delimited("\x00\x00\x00\x00\x00\x00\xf0\x3f\x00\x00",
+ 10, little_bin_double, 1.0, pad(10)));
     }
 
     {
@@ -75,12 +90,19 @@
         BOOST_TEST(binary_test_delimited("\x01\x02\x03\x04\x05\x06\x07\x08\x00\x00",
             10, little_qword(0x0807060504030201LL), pad(10)));
 #endif
+ BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, little_bin_float(1.0f)));
+ BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8,
+ little_bin_double(1.0)));
+ BOOST_TEST(binary_test_delimited("\x00\x00\x00\x00\x00\x00\xf0\x3f\x00\x00",
+ 10, little_bin_double(1.0), pad(10)));
     }
 
     { // test native endian binaries
         boost::optional<boost::uint8_t> v8;
         boost::optional<boost::uint16_t> v16;
         boost::optional<boost::uint32_t> v32;
+ boost::optional<float> vf;
+ boost::optional<double> vd;
 
 #ifdef BOOST_LITTLE_ENDIAN
 
@@ -91,6 +113,8 @@
         boost::optional<boost::uint64_t> v64;
         BOOST_TEST(!binary_test("", 8, qword, v64));
 #endif
+ BOOST_TEST(!binary_test("", 4, bin_float, vf));
+ BOOST_TEST(!binary_test("", 8, bin_double, vd));
 
 #else // BOOST_LITTLE_ENDIAN
 
@@ -101,6 +125,8 @@
         boost::optional<boost::uint64_t> v64;
         BOOST_TEST(!binary_test("", 8, qword, v64));
 #endif
+ BOOST_TEST(!binary_test("", 4, bin_float, vf));
+ BOOST_TEST(!binary_test("", 8, bin_double, vd));
 
 #endif
     }

Modified: branches/release/libs/spirit/test/karma/binary3.cpp
==============================================================================
--- branches/release/libs/spirit/test/karma/binary3.cpp (original)
+++ branches/release/libs/spirit/test/karma/binary3.cpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -38,6 +38,11 @@
         boost::optional<boost::uint64_t> v64 (0x0807060504030201LL);
         BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x08", 8, qword, v64));
 #endif
+ boost::optional<float> vf(1.0f);
+ BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, bin_float, vf));
+ boost::optional<double> vd(1.0);
+ BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8,
+ bin_double, vd));
 
 #else // BOOST_LITTLE_ENDIAN
 
@@ -51,6 +56,11 @@
         boost::optional<boost::uint64_t> v64 (0x0102030405060708LL);
         BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x08", 8, qword, v64));
 #endif
+ boost::optional<float> vf(1.0f);
+ BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, bin_float, vf));
+ boost::optional<double> vd(1.0);
+ BOOST_TEST(binary_test("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8,
+ bin_double, vd));
 
 #endif
     }
@@ -89,6 +99,21 @@
         BOOST_TEST(binary_test("\x02\x02\x03\x04\x05\x06\x07\x08", 8, qword,
             ++phoenix::ref(v64)));
 #endif
+ BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, bin_float,
+ phoenix::val(1.0f)));
+ float vf(1.0f);
+ BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, bin_float,
+ phoenix::ref(vf)));
+ BOOST_TEST(binary_test("\x00\x00\x00\x40", 4, bin_float,
+ ++phoenix::ref(vf)));
+
+ BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8,
+ bin_double, phoenix::val(1.0)));
+ double vd(1.0);
+ BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8,
+ bin_double, phoenix::ref(vd)));
+ BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\x00\x40", 8,
+ bin_double, ++phoenix::ref(vd)));
 
 #else // BOOST_LITTLE_ENDIAN
 
@@ -119,6 +144,21 @@
         BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x09", 8, qword,
             ++phoenix::ref(v64)));
 #endif
+ BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, bin_float,
+ phoenix::val(1.0f)));
+ float vf(1.0f);
+ BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, bin_float,
+ phoenix::ref(vf)));
+ BOOST_TEST(binary_test("\x40\x00\x00\x00", 4, bin_float,
+ ++phoenix::ref(vf)));
+
+ BOOST_TEST(binary_test("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8,
+ bin_double, phoenix::val(1.0)));
+ double vd(1.0);
+ BOOST_TEST(binary_test("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8,
+ bin_double, phoenix::ref(vd)));
+ BOOST_TEST(binary_test("\x40\x00\x00\x00\x00\x00\x00\x00", 8,
+ bin_double, ++phoenix::ref(vd)));
 
 #endif
     }

Modified: branches/release/libs/spirit/test/qi/binary.cpp
==============================================================================
--- branches/release/libs/spirit/test/qi/binary.cpp (original)
+++ branches/release/libs/spirit/test/qi/binary.cpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -16,6 +16,8 @@
 {
     using spirit_test::test_attr;
     using spirit_test::test;
+ using spirit_test::binary_test;
+ using spirit_test::binary_test_attr;
 
     using boost::spirit::qi::byte_;
     using boost::spirit::qi::word;
@@ -29,6 +31,12 @@
     using boost::spirit::qi::big_qword;
     using boost::spirit::qi::little_qword;
 #endif
+ using boost::spirit::qi::bin_float;
+ using boost::spirit::qi::big_bin_float;
+ using boost::spirit::qi::little_bin_float;
+ using boost::spirit::qi::bin_double;
+ using boost::spirit::qi::big_bin_double;
+ using boost::spirit::qi::little_bin_double;
 
     boost::uint8_t uc;
     boost::uint16_t us;
@@ -36,6 +44,8 @@
 #ifdef BOOST_HAS_LONG_LONG
     boost::uint64_t ul;
 #endif
+ float f;
+ double d;
 
     { // test native endian binaries
 #ifdef BOOST_LITTLE_ENDIAN
@@ -46,6 +56,10 @@
         BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", qword, ul) &&
             ul == 0x0807060504030201LL);
 #endif
+ BOOST_TEST(binary_test_attr("\x00\x00\x80\x3f", 4, bin_float, f) &&
+ f == 1.0f);
+ BOOST_TEST(binary_test_attr("\x00\x00\x00\x00\x00\x00\xf0\x3f",
+ 8, bin_double, d) && f == 1.0);
 #else
         BOOST_TEST(test_attr("\x01", byte_, uc) && uc == 0x01);
         BOOST_TEST(test_attr("\x01\x02", word, us) && us == 0x0102);
@@ -54,6 +68,10 @@
         BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", qword, ul) &&
             ul == 0x0102030405060708LL);
 #endif
+ BOOST_TEST(binary_test_attr("\x3f\x80\x00\x00", 4, bin_float, f) &&
+ f == 1.0f);
+ BOOST_TEST(binary_test_attr("\x3f\xf0\x00\x00\x00\x00\x00\x00",
+ 8, bin_double, d) && f == 1.0);
 #endif
     }
 
@@ -66,6 +84,9 @@
         BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
             qword(0x0807060504030201LL)));
 #endif
+ BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, bin_float(1.0f)));
+ BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8,
+ bin_double(1.0)));
 #else
         BOOST_TEST(test("\x01", byte_(0x01)));
         BOOST_TEST(test("\x01\x02", word(0x0102)));
@@ -74,6 +95,9 @@
         BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
             qword(0x0102030405060708LL)));
 #endif
+ BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, bin_float(1.0f)));
+ BOOST_TEST(binary_test("\x3f\x80\x00\x00\x00\x00\x00\x00", 8,
+ bin_double(1.0)));
 #endif
     }
 
@@ -84,6 +108,10 @@
         BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", big_qword, ul)
             && ul == 0x0102030405060708LL);
 #endif
+ BOOST_TEST(binary_test_attr("\x3f\x80\x00\x00", 4, big_bin_float, f) &&
+ f == 1.0f);
+ BOOST_TEST(binary_test_attr("\x3f\xf0\x00\x00\x00\x00\x00\x00",
+ 8, big_bin_double, d) && f == 1.0);
     }
 
     {
@@ -93,6 +121,9 @@
         BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
             big_qword(0x0102030405060708LL)));
 #endif
+ BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, big_bin_float(1.0f)));
+ BOOST_TEST(binary_test("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8,
+ big_bin_double(1.0)));
     }
 
     { // test little endian binaries
@@ -102,6 +133,10 @@
         BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", little_qword, ul)
             && ul == 0x0807060504030201LL);
 #endif
+ BOOST_TEST(binary_test_attr("\x00\x00\x80\x3f", 4,
+ little_bin_float, f) && f == 1.0f);
+ BOOST_TEST(binary_test_attr("\x00\x00\x00\x00\x00\x00\xf0\x3f",
+ 8, little_bin_double, d) && f == 1.0);
     }
 
     {
@@ -111,6 +146,9 @@
         BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
             little_qword(0x0807060504030201LL)));
 #endif
+ BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, little_bin_float(1.0f)));
+ BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8,
+ little_bin_double(1.0)));
     }
 
     return boost::report_errors();

Modified: branches/release/libs/spirit/test/qi/symbols1.cpp
==============================================================================
--- branches/release/libs/spirit/test/qi/symbols1.cpp (original)
+++ branches/release/libs/spirit/test/qi/symbols1.cpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -51,11 +51,12 @@
             ("Tutit")
             ("Kim")
             ("Joey")
+ ("Joeyboy")
         ;
 
         boost::mpl::true_ f = boost::mpl::bool_<boost::spirit::traits::is_parser<symbols<char, int> >::value>();
 
- // silence stupid compiler warnings
+ // silence stupid compiler warnings
         // i.e. MSVC warning C4189: 'f' : local variable is initialized but not referenced
         BOOST_TEST((f.value));
 
@@ -65,6 +66,7 @@
         BOOST_TEST((test("Tutit", sym)));
         BOOST_TEST((test("Kim", sym)));
         BOOST_TEST((test("Joey", sym)));
+ BOOST_TEST((test("Joeyboy", sym)));
         BOOST_TEST((!test("XXX", sym)));
 
         // test copy
@@ -159,12 +161,12 @@
         BOOST_TEST((test_attr("Joey", sym, i)));
         BOOST_TEST(i == 6);
         BOOST_TEST((!test_attr("XXX", sym, i)));
-
+
         // double add:
-
+
         sym.add("Joel", 265);
         BOOST_TEST((test_attr("Joel", sym, i)));
- BOOST_TEST(i == 1);
+ BOOST_TEST(i == 1);
     }
 
     { // actions

Modified: branches/release/libs/spirit/test/qi/test.hpp
==============================================================================
--- branches/release/libs/spirit/test/qi/test.hpp (original)
+++ branches/release/libs/spirit/test/qi/test.hpp 2012-01-09 09:36:46 EST (Mon, 09 Jan 2012)
@@ -44,6 +44,32 @@
             && (!full_match || (in == last));
     }
 
+ template <typename Char, typename Parser>
+ bool binary_test(Char const* in, std::size_t size, Parser const& p,
+ bool full_match = true)
+ {
+ // we don't care about the result of the "what" function.
+ // we only care that all parsers have it:
+ boost::spirit::qi::what(p);
+
+ Char const* last = in + size;
+ return boost::spirit::qi::parse(in, last, p)
+ && (!full_match || (in == last));
+ }
+
+ template <typename Char, typename Parser, typename Skipper>
+ bool binary_test(Char const* in, std::size_t size, Parser const& p,
+ Skipper const& s, bool full_match = true)
+ {
+ // we don't care about the result of the "what" function.
+ // we only care that all parsers have it:
+ boost::spirit::qi::what(p);
+
+ Char const* last = in + size;
+ return boost::spirit::qi::phrase_parse(in, last, p, s)
+ && (!full_match || (in == last));
+ }
+
     template <typename Char, typename Parser, typename Attr>
     bool test_attr(Char const* in, Parser const& p
         , Attr& attr, bool full_match = true)
@@ -74,6 +100,32 @@
             && (!full_match || (in == last));
     }
 
+ template <typename Char, typename Parser, typename Attr>
+ bool binary_test_attr(Char const* in, std::size_t size, Parser const& p,
+ Attr& attr, bool full_match = true)
+ {
+ // we don't care about the result of the "what" function.
+ // we only care that all parsers have it:
+ boost::spirit::qi::what(p);
+
+ Char const* last = in + size;
+ return boost::spirit::qi::parse(in, last, p, attr)
+ && (!full_match || (in == last));
+ }
+
+ template <typename Char, typename Parser, typename Attr, typename Skipper>
+ bool binary_test_attr(Char const* in, std::size_t size, Parser const& p,
+ Attr& attr, Skipper const& s, bool full_match = true)
+ {
+ // we don't care about the result of the "what" function.
+ // we only care that all parsers have it:
+ boost::spirit::qi::what(p);
+
+ Char const* last = in + size;
+ return boost::spirit::qi::phrase_parse(in, last, p, s, attr)
+ && (!full_match || (in == last));
+ }
+
     struct printer
     {
         typedef boost::spirit::utf8_string string;


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk