update boost

linx64/include/boost/spirit/home/classic/utility/grammar_def.hpp

@@ -97,7 +97,11 @@ namespace impl {
     struct assign_zero_to_tuple_member {
 
         template <typename TupleT>
-        static void do_(TupleT &t) { t[::phoenix::tuple_index<N>()] = 0; }
+        static void do_(TupleT &t)
+        {
+            ::phoenix::tuple_index<N> const idx;
+            t[idx] = 0;
+        }
     };
 
     template <int N>
@@ -282,6 +286,8 @@ public:
     //  grammar.
         BOOST_STATIC_ASSERT(N > 0 && N < tuple_t::length);
 
+        ::phoenix::tuple_index<N> const idx;
+
     //  If the following assertion is fired, you have probably forgot to call
     //  the start_parser() function from inside the constructor of your
     //  embedded definition class to initialize the start parsers to be exposed
@@ -289,9 +295,9 @@ public:
     //  Another reason may be, that there is a count mismatch between
     //  the number of template parameters to the grammar_def<> class and the
     //  number of parameters used while calling start_parsers().
-        BOOST_SPIRIT_ASSERT(0 != t[::phoenix::tuple_index<N>()]);
+        BOOST_SPIRIT_ASSERT(0 != t[idx]);
 
-        return t[::phoenix::tuple_index<N>()];
+        return t[idx];
     }
 
 private:

linx64/include/boost/spirit/home/classic/utility/impl/escape_char.ipp

@@ -166,7 +166,7 @@ namespace impl {
             return scan.no_match(); // overflow detected
         }
     };
-#if (defined(BOOST_MSVC) && (BOOST_MSVC <= 1310))
+#if defined(BOOST_MSVC)
 #pragma warning(pop)
 #endif
 

linx64/include/boost/spirit/home/classic/utility/rule_parser.hpp

@@ -267,7 +267,7 @@
 //
 // 3. Utilities for by-reference embedding
 //
-// When using parsers mutiple times or recursively it can be helpful to embed
+// When using parsers multiple times or recursively it can be helpful to embed
 // them by-reference into the final parser expression.
 // For this purpose the library provides a wrapper template 'parser_reference'.
 // There is also a function template to create a wrapped parser which can deduce
@@ -1001,7 +1001,7 @@ namespace type_of {
         ( concatenate_actions(chain.action(), a) );
   }
 
-  // Expression template for mutiple action chain assignments
+  // Expression template for multiple action chain assignments
   template<class ChainOrChains, class LastChain>
   class action_chains
   {

linx64/include/boost/spirit/home/classic/utility/scoped_lock.hpp

@@ -10,10 +10,8 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 #include <boost/spirit/home/classic/namespace.hpp>
+#include <boost/spirit/home/classic/core/composite/composite.hpp>
 #include <boost/thread/lock_types.hpp>
-#if !defined(BOOST_SPIRIT_COMPOSITE_HPP)
-#include <boost/spirit/home/classic/core/composite.hpp>
-#endif
 
 ///////////////////////////////////////////////////////////////////////////////
 namespace boost { namespace spirit {