Ticket #1500: spirit.patch

File spirit.patch, 12.2 KB (added by Richard Webb <richard.webb@…>, 15 years ago)

'assignment operator could not be generated' warnings

  • actor/ref_value_actor.hpp

     
    1111
    1212namespace boost { namespace spirit {
    1313
     14#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     15#pragma warning(push)
     16#pragma warning(disable:4512) //assignment operator could not be generated
     17#endif
     18
    1419    ///////////////////////////////////////////////////////////////////////////
    1520    //  Summary:
    1621    //  A semantic action policy holder. This holder stores a reference to ref.
    … …  
    6065        }
    6166    };
    6267
     68#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     69#pragma warning(pop)
     70#endif
     71
    6372}}
    6473
    6574#endif

  • core/composite/actions.hpp

     
    1414
    1515namespace boost { namespace spirit {
    1616
     17#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     18#pragma warning(push)
     19#pragma warning(disable:4512) //assignment operator could not be generated
     20#endif
     21
    1722    ///////////////////////////////////////////////////////////////////////////
    1823    //
    1924    //  action class
    … …  
    118123        ActionT actor;
    119124    };
    120125
     126#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     127#pragma warning(pop)
     128#endif
     129
    121130}} // namespace boost::spirit
    122131
    123132#endif

  • core/composite/alternative.hpp

     
    3737    ///////////////////////////////////////////////////////////////////////////
    3838    struct alternative_parser_gen;
    3939   
     40#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     41#pragma warning(push)
     42#pragma warning(disable:4512) //assignment operator could not be generated
     43#endif
     44
    4045    template <typename A, typename B>
    4146    struct alternative
    4247    :   public binary<A, B, parser<alternative<A, B> > >
    … …  
    6469            return this->right().parse(scan);
    6570        }
    6671    };
     72
     73#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     74#pragma warning(pop)
     75#endif
    6776   
    6877    struct alternative_parser_gen
    6978    {

  • core/composite/composite.hpp

     
    1515///////////////////////////////////////////////////////////////////////////////
    1616namespace boost { namespace spirit {
    1717
     18#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     19#pragma warning(push)
     20#pragma warning(disable:4512) //assignment operator could not be generated
     21#endif
     22
    1823    ///////////////////////////////////////////////////////////////////////////
    1924    //
    2025    //  unary class.
    … …  
    133138        boost::compressed_pair<left_embed_t, right_embed_t> subj;
    134139    };
    135140
     141#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     142#pragma warning(pop)
     143#endif
     144
    136145}} // namespace boost::spirit
    137146
    138147#endif

  • core/composite/difference.hpp

     
    3333    //
    3434    ///////////////////////////////////////////////////////////////////////////
    3535    struct difference_parser_gen;
    36    
     36
     37#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     38#pragma warning(push)
     39#pragma warning(disable:4512) //assignment operator could not be generated
     40#endif
     41
    3742    template <typename A, typename B>
    3843    struct difference
    3944    :   public binary<A, B, parser<difference<A, B> > >
    … …  
    6772            return scan.no_match();
    6873        }
    6974    };
     75
     76#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     77#pragma warning(pop)
     78#endif
    7079   
    7180    struct difference_parser_gen
    7281    {

  • core/composite/kleene_star.hpp

     
    3232    ///////////////////////////////////////////////////////////////////////////
    3333    struct kleene_star_parser_gen;
    3434   
     35#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     36#pragma warning(push)
     37#pragma warning(disable:4512) //assignment operator could not be generated
     38#endif
     39
    3540    template <typename S>
    3641    struct kleene_star
    3742    :   public unary<S, parser<kleene_star<S> > >
    … …  
    6873        }
    6974    };
    7075   
     76#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     77#pragma warning(pop)
     78#endif
     79
    7180    struct kleene_star_parser_gen
    7281    {
    7382        template <typename S>

  • core/composite/positive.hpp

     
    3232    ///////////////////////////////////////////////////////////////////////////
    3333    struct positive_parser_gen;
    3434   
     35#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     36#pragma warning(push)
     37#pragma warning(disable:4512) //assignment operator could not be generated
     38#endif
     39
    3540    template <typename S>
    3641    struct positive
    3742    :   public unary<S, parser<positive<S> > >
    … …  
    7176            return hit;
    7277        }
    7378    };
     79
     80#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     81#pragma warning(pop)
     82#endif
    7483   
    7584    struct positive_parser_gen
    7685    {

  • core/composite/sequence.hpp

     
    3434    //////////////////////////////////////////////////////////////////////////
    3535    struct sequence_parser_gen;
    3636   
     37#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     38#pragma warning(push)
     39#pragma warning(disable:4512) //assignment operator could not be generated
     40#endif
     41
    3742    template <typename A, typename B>
    3843    struct sequence : public binary<A, B, parser<sequence<A, B> > >
    3944    {
    … …  
    5964            return scan.no_match();
    6065        }
    6166    };
     67
     68#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     69#pragma warning(pop)
     70#endif
    6271   
    6372    struct sequence_parser_gen
    6473    {

  • core/non_terminal/impl/rule.ipp

     
    221221        //  concrete_parser class
    222222        //
    223223        ///////////////////////////////////////////////////////////////////////
     224#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     225#pragma warning(push)
     226#pragma warning(disable:4512) //assignment operator could not be generated
     227#endif
     228       
    224229        template <typename ParserT, typename ScannerT, typename AttrT>
    225230        struct concrete_parser : abstract_parser<ScannerT, AttrT>
    226231        {
    … …  
    241246
    242247            typename ParserT::embed_t p;
    243248        };
     249       
     250#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     251#pragma warning(pop)
     252#endif
    244253
    245254#if BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1
    246255

  • meta/refactoring.hpp

     
    1919///////////////////////////////////////////////////////////////////////////////
    2020namespace boost { namespace spirit {
    2121
     22#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     23#pragma warning(push)
     24#pragma warning(disable:4512) //assignment operator could not be generated
     25#endif
     26
    2227///////////////////////////////////////////////////////////////////////////////
    2328//
    2429//  refactor_unary_parser class
    … …  
    267272
    268273const attach_action_gen<> attach_action_d = attach_action_gen<>();
    269274
     275#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     276#pragma warning(pop)
     277#endif
     278
    270279///////////////////////////////////////////////////////////////////////////////
    271280}} // namespace boost::spirit
    272281

  • phoenix/actor.hpp

     
    125125};
    126126
    127127//////////////////////////////////
     128#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     129#pragma warning(push)
     130#pragma warning(disable:4512) //assignment operator could not be generated
     131#endif
     132
    128133template <typename BaseT>
    129134struct actor : public BaseT {
    130135
    … …  
    271276    operator[](B const& b) const;
    272277};
    273278
     279#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     280#pragma warning(pop)
     281#endif
     282
    274283///////////////////////////////////////////////////////////////////////////
    275284//
    276285//  as_actor

  • phoenix/closures.hpp

     
    2222///////////////////////////////////////////////////////////////////////////////
    2323namespace phoenix {
    2424
     25#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     26#pragma warning(push)
     27#pragma warning(disable:4512) //assignment operator could not be generated
     28#endif
     29
    2530///////////////////////////////////////////////////////////////////////////////
    2631//
    2732//  Adaptable closures
    … …  
    434439    mutable holder_t frame;
    435440};
    436441
     442#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     443#pragma warning(pop)
     444#endif
     445
    437446}
    438447   //  namespace phoenix
    439448

  • phoenix/composite.hpp

     
    1515///////////////////////////////////////////////////////////////////////////////
    1616namespace phoenix {
    1717
     18#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     19#pragma warning(push)
     20#pragma warning(disable:4512) //assignment operator could not be generated
     21#endif
     22
    1823///////////////////////////////////////////////////////////////////////////////
    1924//
    2025//  composite class
    … …  
    14181423
    14191424}   // namespace impl
    14201425
     1426#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     1427#pragma warning(pop)
     1428#endif
     1429
    14211430}   //  namespace phoenix
    14221431
    14231432#endif

  • phoenix/primitives.hpp

     
    197197//      a variable<T const&> object using a constant reference.
    198198//
    199199///////////////////////////////////////////////////////////////////////////////
     200#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     201#pragma warning(push)
     202#pragma warning(disable:4512) //assignment operator could not be generated
     203#endif
     204
    200205template <typename T>
    201206struct variable {
    202207
    … …  
    216221    T& var;
    217222};
    218223
     224#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     225#pragma warning(pop)
     226#endif
     227
    219228//////////////////////////////////
    220229template <typename T>
    221230inline actor<variable<T> > const

  • phoenix/tuples.hpp

     
    6161#include <boost/call_traits.hpp>
    6262#include <boost/type_traits/remove_reference.hpp>
    6363
     64#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     65#pragma warning(push)
     66#pragma warning(disable:4512) //assignment operator could not be generated
     67#endif
     68
    6469///////////////////////////////////////////////////////////////////////////////
    6570namespace phoenix {
    6671
    … …  
    13241329#endif
    13251330#endif
    13261331
     1332#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     1333#pragma warning(pop)
     1334#endif
     1335
    13271336///////////////////////////////////////////////////////////////////////////////
    13281337}   //  namespace phoenix
    13291338

  • utility/confix.hpp

     
    3434//
    3535///////////////////////////////////////////////////////////////////////////////
    3636
     37#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     38#pragma warning(push)
     39#pragma warning(disable:4512) //assignment operator could not be generated
     40#endif
     41
    3742template<typename NestedT = non_nested, typename LexemeT = non_lexeme>
    3843struct confix_parser_gen;
    3944
    … …  
    6974    typename as_parser<CloseT>::type::embed_t close;
    7075};
    7176
     77#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
     78#pragma warning(pop)
     79#endif
     80
    7281///////////////////////////////////////////////////////////////////////////////
    7382//
    7483//  Confix parser generator template