1 files changed, 3 insertions, 3 deletions
diff --git a/3rdParty/Boost/src/boost/proto/traits.hpp b/3rdParty/Boost/src/boost/proto/traits.hpp
index cf9f091..f1a83fc 100644
--- a/3rdParty/Boost/src/boost/proto/traits.hpp
+++ b/3rdParty/Boost/src/boost/proto/traits.hpp
@@ -1,70 +1,70 @@
 ///////////////////////////////////////////////////////////////////////////////
 /// \file traits.hpp
 /// Contains definitions for child\<\>, child_c\<\>, left\<\>,
 /// right\<\>, tag_of\<\>, and the helper functions child(), child_c(),
 /// value(), left() and right().
 //
 //  Copyright 2008 Eric Niebler. 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)
 
 #ifndef BOOST_PROTO_ARG_TRAITS_HPP_EAN_04_01_2005
 #define BOOST_PROTO_ARG_TRAITS_HPP_EAN_04_01_2005
 
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/preprocessor/iteration/iterate.hpp>
 #include <boost/preprocessor/repetition/enum.hpp>
 #include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
 #include <boost/preprocessor/repetition/repeat.hpp>
 #include <boost/preprocessor/repetition/repeat_from_to.hpp>
 #include <boost/preprocessor/facilities/intercept.hpp>
 #include <boost/preprocessor/arithmetic/sub.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/mpl/bool.hpp>
 #include <boost/proto/detail/template_arity.hpp>
 #include <boost/type_traits/is_pod.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/add_const.hpp>
 #include <boost/proto/proto_fwd.hpp>
 #include <boost/proto/args.hpp>
 #include <boost/proto/domain.hpp>
 #include <boost/proto/transform/pass_through.hpp>
 
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
 # pragma warning(push)
 # if BOOST_WORKAROUND( BOOST_MSVC, >= 1400 )
 #  pragma warning(disable: 4180) // warning C4180: qualifier applied to function type has no meaning; ignored
 # endif
 # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
 #endif
 
 namespace boost { namespace proto
 {
     namespace detail
     {
         template<typename T, typename Void = void>
         struct if_vararg
         {};
 
         template<typename T>
         struct if_vararg<T, typename T::proto_is_vararg_>
           : T
         {};
 
         template<typename T, typename Void = void>
         struct is_callable2_
           : mpl::false_
         {};
 
         template<typename T>
         struct is_callable2_<T, typename T::proto_is_callable_>
           : mpl::true_
         {};
 
         template<typename T BOOST_PROTO_TEMPLATE_ARITY_PARAM(long Arity = boost::proto::detail::template_arity<T>::value)>
         struct is_callable_
           : is_callable2_<T>
         {};
 
@@ -1105,71 +1105,71 @@ namespace boost { namespace proto
     {
         return expr2.proto_base().child0;
     }
 
     /// \brief Return the Nth child of the specified Proto expression.
     ///
     /// Return the Nth child of the specified Proto expression. The child
     /// is returned by reference.
     ///
     /// \param expr The Proto expression.
     /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true.
     /// \pre <tt>N \< Expr::proto_arity::value</tt>
     /// \throw nothrow
     /// \return A reference to the Nth child
     template<long N, typename Expr>
     BOOST_FORCEINLINE
     typename result_of::child_c<Expr &, N>::type
     child_c(Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr))
     {
         return result_of::child_c<Expr &, N>::call(e);
     }
 
     /// \overload
     ///
     template<long N, typename Expr>
     BOOST_FORCEINLINE
     typename result_of::child_c<Expr const &, N>::type
     child_c(Expr const &e)
     {
         return result_of::child_c<Expr const &, N>::call(e);
     }
 
     /// \brief Return the value stored within the specified Proto
     /// terminal expression.
     ///
-    /// Return the the value stored within the specified Proto
+    /// Return the value stored within the specified Proto
     /// terminal expression. The value is returned by
     /// reference.
     ///
     /// \param expr The Proto terminal expression.
     /// \pre <tt>N::value == 0</tt>
     /// \throw nothrow
     /// \return A reference to the terminal's value
     template<typename Expr>
     BOOST_FORCEINLINE
     typename result_of::value<Expr &>::type
     value(Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr))
     {
         return e.proto_base().child0;
     }
 
     /// \overload
     ///
     template<typename Expr>
     BOOST_FORCEINLINE
     typename result_of::value<Expr const &>::type
     value(Expr const &e)
     {
         return e.proto_base().child0;
     }
 
     /// \brief Return the left child of the specified binary Proto
     /// expression.
     ///
     /// Return the left child of the specified binary Proto expression. The
     /// child is returned by reference.
     ///
     /// \param expr The Proto expression.
     /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true.
     /// \pre <tt>2 == Expr::proto_arity::value</tt>
     /// \throw nothrow
@@ -1219,40 +1219,40 @@ namespace boost { namespace proto
     right(Expr const &e)
     {
         return e.proto_base().child1;
     }
 
     /// INTERNAL ONLY
     ///
     template<typename Domain>
     struct is_callable<functional::as_expr<Domain> >
       : mpl::true_
     {};
 
     /// INTERNAL ONLY
     ///
     template<typename Domain>
     struct is_callable<functional::as_child<Domain> >
       : mpl::true_
     {};
 
     /// INTERNAL ONLY
     ///
     template<long N>
     struct is_callable<functional::child_c<N> >
       : mpl::true_
     {};
 
     /// INTERNAL ONLY
     ///
     template<typename N>
     struct is_callable<functional::child<N> >
       : mpl::true_
     {};
 
 }}
 
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
 # pragma warning(pop)
 #endif
 
 #endif