update boost

linx64/include/boost/spirit/home/x3/auxiliary/any_parser.hpp

@@ -35,8 +35,7 @@ namespace boost { namespace spirit { namespace x3
             traits::is_container<Attribute>::value;
 
     public:
-        any_parser()
-          : _content(nullptr) {}
+        any_parser() = default;
 
         template <typename Expr,
             typename Enable = typename enable_if<traits::is_parser<Expr>>::type>

linx64/include/boost/spirit/home/x3/auxiliary/attr.hpp

@@ -16,13 +16,32 @@
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/remove_cv.hpp>
 #include <boost/type_traits/remove_reference.hpp>
-#include <algorithm>
 #include <cstddef>
 #include <string>
 #include <utility>
 
 namespace boost { namespace spirit { namespace x3
 {
+
+namespace detail
+{
+    template <typename Value, std::size_t N
+      , typename = std::make_index_sequence<N>>
+    struct array_helper;
+
+    template <typename Value, std::size_t N, std::size_t... Is>
+    struct array_helper<Value, N, std::index_sequence<Is...>>
+    {
+        constexpr array_helper(Value const (&value)[N])
+            : value_{ value[Is]... } {}
+
+        constexpr array_helper(Value (&&value)[N])
+            : value_{ static_cast<Value&&>(value[Is])... } {}
+
+        Value value_[N];
+    };
+}
+
     template <typename Value>
     struct attr_parser : parser<attr_parser<Value>>
     {
@@ -33,9 +52,9 @@ namespace boost { namespace spirit { namespace x3
         static bool const handles_container =
             traits::is_container<attribute_type>::value;
         
-        attr_parser(Value const& value)
+        constexpr attr_parser(Value const& value)
           : value_(value) {}
-        attr_parser(Value&& value)
+        constexpr attr_parser(Value&& value)
           : value_(std::move(value)) {}
 
         template <typename Iterator, typename Context
@@ -49,30 +68,19 @@ namespace boost { namespace spirit { namespace x3
         }
 
         Value value_;
-
-    private:
-        // silence MSVC warning C4512: assignment operator could not be generated
-        attr_parser& operator= (attr_parser const&);
     };
     
     template <typename Value, std::size_t N>
     struct attr_parser<Value[N]> : parser<attr_parser<Value[N]>>
+      , detail::array_helper<Value, N>
     {
+        using detail::array_helper<Value, N>::array_helper;
+
         typedef Value attribute_type[N];
 
         static bool const has_attribute =
             !is_same<unused_type, attribute_type>::value;
         static bool const handles_container = true;
-        
-        attr_parser(Value const (&value)[N])
-        {
-            std::copy(value + 0, value + N, value_ + 0);
-        }
-
-        attr_parser(Value (&&value)[N])
-        {
-            std::move(value + 0, value + N, value_ + 0);
-        }
 
         template <typename Iterator, typename Context
           , typename RuleContext, typename Attribute>
@@ -80,15 +88,9 @@ namespace boost { namespace spirit { namespace x3
           , Context const& /* context */, RuleContext&, Attribute& attr_) const
         {
             // $$$ Change to copy_to once we have it $$$
-            traits::move_to(value_ + 0, value_ + N, attr_);
+            traits::move_to(this->value_ + 0, this->value_ + N, attr_);
             return true;
         }
-
-        Value value_[N];
-
-    private:
-        // silence MSVC warning C4512: assignment operator could not be generated
-        attr_parser& operator= (attr_parser const&);
     };
     
     template <typename Value>
@@ -104,28 +106,15 @@ namespace boost { namespace spirit { namespace x3
     struct attr_gen
     {
         template <typename Value>
-        attr_parser<typename remove_cv<
+        constexpr attr_parser<typename remove_cv<
             typename remove_reference<Value>::type>::type>
         operator()(Value&& value) const
         {
             return { std::forward<Value>(value) };
         }
-        
-        template <typename Value, std::size_t N>
-        attr_parser<typename remove_cv<Value>::type[N]>
-        operator()(Value (&value)[N]) const
-        {
-            return { value };
-        }
-        template <typename Value, std::size_t N>
-        attr_parser<typename remove_cv<Value>::type[N]>
-        operator()(Value (&&value)[N]) const
-        {
-            return { value };
-        }
     };
 
-    auto const attr = attr_gen{};
+    constexpr auto attr = attr_gen{};
 }}}
 
 #endif

linx64/include/boost/spirit/home/x3/auxiliary/eoi.hpp

@@ -35,7 +35,7 @@ namespace boost { namespace spirit { namespace x3
         result_type operator()(eoi_parser const &) const { return "eoi"; }
     };
 
-    auto const eoi = eoi_parser{};
+    constexpr auto eoi = eoi_parser{};
 }}}
 
 #endif

linx64/include/boost/spirit/home/x3/auxiliary/eol.hpp

@@ -49,7 +49,7 @@ namespace boost { namespace spirit { namespace x3
         result_type operator()(eol_parser const &) const { return "eol"; }
     };
 
-    auto const eol = eol_parser{};
+    constexpr auto eol = eol_parser{};
 }}}
 
 #endif

linx64/include/boost/spirit/home/x3/auxiliary/eps.hpp

@@ -20,7 +20,7 @@ namespace boost { namespace spirit { namespace x3
         typedef unused_type attribute_type;
         static bool const has_attribute = false;
 
-        semantic_predicate(bool predicate)
+        constexpr semantic_predicate(bool predicate)
           : predicate(predicate) {}
 
         template <typename Iterator, typename Context, typename Attribute>
@@ -40,7 +40,7 @@ namespace boost { namespace spirit { namespace x3
         typedef unused_type attribute_type;
         static bool const has_attribute = false;
 
-        lazy_semantic_predicate(F f)
+        constexpr lazy_semantic_predicate(F f)
           : f(f) {}
 
         template <typename Iterator, typename Context, typename Attribute>
@@ -68,19 +68,19 @@ namespace boost { namespace spirit { namespace x3
             return true;
         }
 
-        inline semantic_predicate operator()(bool predicate) const
+        constexpr semantic_predicate operator()(bool predicate) const
         {
             return { predicate };
         }
 
         template <typename F>
-        lazy_semantic_predicate<F> operator()(F f) const
+        constexpr lazy_semantic_predicate<F> operator()(F f) const
         {
             return { f };
         }
     };
 
-    auto const eps = eps_parser{};
+    constexpr auto eps = eps_parser{};
 }}}
 
 #endif

linx64/include/boost/spirit/home/x3/auxiliary/guard.hpp

@@ -26,7 +26,7 @@ namespace boost { namespace spirit { namespace x3
         typedef unary_parser<Subject, guard<Subject, Handler>> base_type;
         static bool const is_pass_through_unary = true;
 
-        guard(Subject const& subject, Handler handler)
+        constexpr guard(Subject const& subject, Handler handler)
           : base_type(subject), handler(handler) {}
 
         template <typename Iterator, typename Context