update boost

linx64/include/boost/spirit/home/classic/dynamic/if.hpp

@@ -133,7 +133,7 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
 
     //////////////////////////////////
     // if-parser, conditionally runs a parser is a functor condition is true.
-    // If the condition is fales, it fails the parse.
+    // If the condition is false, it fails the parse.
     // It can optionally become an if-else-parser through the member else_p.
     template <typename ParsableT, typename CondT>
     struct if_parser

linx64/include/boost/spirit/home/classic/dynamic/impl/select.ipp

@@ -72,8 +72,9 @@ struct parse_tuple_element {
         typedef typename ScannerT::iterator_t                       iterator_t;
         typedef typename parser_result<parser_t, ScannerT>::type    result_t;
     
-    iterator_t save(scan.first);
-    result_t result(t[::phoenix::tuple_index<index>()].parse(scan));
+        iterator_t save(scan.first);
+        ::phoenix::tuple_index<index> const idx;
+        result_t result(t[idx].parse(scan));
 
         if (result) {
             return scan.create_match(result.length(), TupleT::length - N, 
@@ -98,8 +99,9 @@ struct parse_tuple_element<1, ResultT, TupleT, BehaviourT> {
         typedef typename ScannerT::iterator_t                       iterator_t;
         typedef typename parser_result<parser_t, ScannerT>::type    result_t;
         
-    iterator_t save(scan.first);
-    result_t result(t[::phoenix::tuple_index<index>()].parse(scan));
+        iterator_t save(scan.first);
+        ::phoenix::tuple_index<index> const idx;
+        result_t result(t[idx].parse(scan));
 
         if (result) {
             return scan.create_match(result.length(), TupleT::length - 1, 

linx64/include/boost/spirit/home/classic/dynamic/impl/switch.ipp

@@ -222,7 +222,7 @@ struct default_case<CaseT, true> {
 };
 
 ///////////////////////////////////////////////////////////////////////////////
-//  The case_chain template calculates recursivly the depth of the left
+//  The case_chain template calculates recursively the depth of the left
 //  subchain of the given case branch node.
 template <typename CaseT, bool IsSimple = CaseT::is_simple>
 struct case_chain {
@@ -240,7 +240,7 @@ struct case_chain<CaseT, true> {
 
 ///////////////////////////////////////////////////////////////////////////////
 //  The chain_parser template is used to extract the type and the instance of
-//  a left or a right parser, burried arbitrary deep inside the case parser
+//  a left or a right parser, buried arbitrary deep inside the case parser
 //  chain.
 template <int Depth, typename CaseT>
 struct chain_parser {

linx64/include/boost/spirit/home/classic/dynamic/switch.hpp

@@ -55,7 +55,7 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
 ///////////////////////////////////////////////////////////////////////////////
 //
 //  The switch_parser allows to build switch like parsing constructs, which
-//  will have much better perfomance as comparable straight solutions.
+//  will have much better performance as comparable straight solutions.
 //
 //  Input stream driven syntax:
 //