Index: actor/ref_value_actor.hpp
===================================================================
--- actor/ref_value_actor.hpp	(revision 41836)
+++ actor/ref_value_actor.hpp	(working copy)
@@ -11,6 +11,11 @@
 
 namespace boost { namespace spirit {
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+
     ///////////////////////////////////////////////////////////////////////////
     //  Summary:
     //  A semantic action policy holder. This holder stores a reference to ref.
@@ -60,6 +65,10 @@
         }
     };
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
+
 }}
 
 #endif
Index: core/composite/actions.hpp
===================================================================
--- core/composite/actions.hpp	(revision 41836)
+++ core/composite/actions.hpp	(working copy)
@@ -14,6 +14,11 @@
 
 namespace boost { namespace spirit {
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+
     ///////////////////////////////////////////////////////////////////////////
     //
     //  action class
@@ -118,6 +123,10 @@
         ActionT actor;
     };
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
+
 }} // namespace boost::spirit
 
 #endif
Index: core/composite/alternative.hpp
===================================================================
--- core/composite/alternative.hpp	(revision 41836)
+++ core/composite/alternative.hpp	(working copy)
@@ -37,6 +37,11 @@
     ///////////////////////////////////////////////////////////////////////////
     struct alternative_parser_gen;
     
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+
     template <typename A, typename B>
     struct alternative
     :   public binary<A, B, parser<alternative<A, B> > >
@@ -64,6 +69,10 @@
             return this->right().parse(scan);
         }
     };
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
     
     struct alternative_parser_gen
     {
Index: core/composite/composite.hpp
===================================================================
--- core/composite/composite.hpp	(revision 41836)
+++ core/composite/composite.hpp	(working copy)
@@ -15,6 +15,11 @@
 ///////////////////////////////////////////////////////////////////////////////
 namespace boost { namespace spirit {
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+
     ///////////////////////////////////////////////////////////////////////////
     //
     //  unary class.
@@ -133,6 +138,10 @@
         boost::compressed_pair<left_embed_t, right_embed_t> subj;
     };
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
+
 }} // namespace boost::spirit
 
 #endif
Index: core/composite/difference.hpp
===================================================================
--- core/composite/difference.hpp	(revision 41836)
+++ core/composite/difference.hpp	(working copy)
@@ -33,7 +33,12 @@
     //
     ///////////////////////////////////////////////////////////////////////////
     struct difference_parser_gen;
-    
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+
     template <typename A, typename B>
     struct difference
     :   public binary<A, B, parser<difference<A, B> > >
@@ -67,6 +72,10 @@
             return scan.no_match();
         }
     };
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
     
     struct difference_parser_gen
     {
Index: core/composite/kleene_star.hpp
===================================================================
--- core/composite/kleene_star.hpp	(revision 41836)
+++ core/composite/kleene_star.hpp	(working copy)
@@ -32,6 +32,11 @@
     ///////////////////////////////////////////////////////////////////////////
     struct kleene_star_parser_gen;
     
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+
     template <typename S>
     struct kleene_star
     :   public unary<S, parser<kleene_star<S> > >
@@ -68,6 +73,10 @@
         }
     };
     
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
+
     struct kleene_star_parser_gen
     {
         template <typename S>
Index: core/composite/positive.hpp
===================================================================
--- core/composite/positive.hpp	(revision 41836)
+++ core/composite/positive.hpp	(working copy)
@@ -32,6 +32,11 @@
     ///////////////////////////////////////////////////////////////////////////
     struct positive_parser_gen;
     
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+
     template <typename S>
     struct positive
     :   public unary<S, parser<positive<S> > >
@@ -71,6 +76,10 @@
             return hit;
         }
     };
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
     
     struct positive_parser_gen
     {
Index: core/composite/sequence.hpp
===================================================================
--- core/composite/sequence.hpp	(revision 41836)
+++ core/composite/sequence.hpp	(working copy)
@@ -34,6 +34,11 @@
     //////////////////////////////////////////////////////////////////////////
     struct sequence_parser_gen;
     
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+
     template <typename A, typename B>
     struct sequence : public binary<A, B, parser<sequence<A, B> > >
     {
@@ -59,6 +64,10 @@
             return scan.no_match();
         }
     };
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
     
     struct sequence_parser_gen
     {
Index: core/non_terminal/impl/rule.ipp
===================================================================
--- core/non_terminal/impl/rule.ipp	(revision 41836)
+++ core/non_terminal/impl/rule.ipp	(working copy)
@@ -221,6 +221,11 @@
         //  concrete_parser class
         //
         ///////////////////////////////////////////////////////////////////////
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+        
         template <typename ParserT, typename ScannerT, typename AttrT>
         struct concrete_parser : abstract_parser<ScannerT, AttrT>
         {
@@ -241,6 +246,10 @@
 
             typename ParserT::embed_t p;
         };
+        
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
 
 #if BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1
 
Index: meta/refactoring.hpp
===================================================================
--- meta/refactoring.hpp	(revision 41836)
+++ meta/refactoring.hpp	(working copy)
@@ -19,6 +19,11 @@
 ///////////////////////////////////////////////////////////////////////////////
 namespace boost { namespace spirit {
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 //
 //  refactor_unary_parser class
@@ -267,6 +272,10 @@
 
 const attach_action_gen<> attach_action_d = attach_action_gen<>();
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 }} // namespace boost::spirit
 
Index: phoenix/actor.hpp
===================================================================
--- phoenix/actor.hpp	(revision 41836)
+++ phoenix/actor.hpp	(working copy)
@@ -125,6 +125,11 @@
 };
 
 //////////////////////////////////
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+
 template <typename BaseT>
 struct actor : public BaseT {
 
@@ -271,6 +276,10 @@
     operator[](B const& b) const;
 };
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
+
 ///////////////////////////////////////////////////////////////////////////
 //
 //  as_actor
Index: phoenix/closures.hpp
===================================================================
--- phoenix/closures.hpp	(revision 41836)
+++ phoenix/closures.hpp	(working copy)
@@ -22,6 +22,11 @@
 ///////////////////////////////////////////////////////////////////////////////
 namespace phoenix {
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 //
 //  Adaptable closures
@@ -434,6 +439,10 @@
     mutable holder_t frame;
 };
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
+
 }
    //  namespace phoenix
 
Index: phoenix/composite.hpp
===================================================================
--- phoenix/composite.hpp	(revision 41836)
+++ phoenix/composite.hpp	(working copy)
@@ -15,6 +15,11 @@
 ///////////////////////////////////////////////////////////////////////////////
 namespace phoenix {
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 //
 //  composite class
@@ -1418,6 +1423,10 @@
 
 }   // namespace impl
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
+
 }   //  namespace phoenix
 
 #endif
Index: phoenix/primitives.hpp
===================================================================
--- phoenix/primitives.hpp	(revision 41836)
+++ phoenix/primitives.hpp	(working copy)
@@ -197,6 +197,11 @@
 //      a variable<T const&> object using a constant reference.
 //
 ///////////////////////////////////////////////////////////////////////////////
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+
 template <typename T>
 struct variable {
 
@@ -216,6 +221,10 @@
     T& var;
 };
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
+
 //////////////////////////////////
 template <typename T>
 inline actor<variable<T> > const
Index: phoenix/tuples.hpp
===================================================================
--- phoenix/tuples.hpp	(revision 41836)
+++ phoenix/tuples.hpp	(working copy)
@@ -61,6 +61,11 @@
 #include <boost/call_traits.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 namespace phoenix {
 
@@ -1324,6 +1329,10 @@
 #endif
 #endif
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 }   //  namespace phoenix
 
Index: utility/confix.hpp
===================================================================
--- utility/confix.hpp	(revision 41836)
+++ utility/confix.hpp	(working copy)
@@ -34,6 +34,11 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+
 template<typename NestedT = non_nested, typename LexemeT = non_lexeme>
 struct confix_parser_gen;
 
@@ -69,6 +74,10 @@
     typename as_parser<CloseT>::type::embed_t close;
 };
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 //
 //  Confix parser generator template