Ticket #2488: spirit.patch

File spirit.patch, 78.1 KB (added by Eric Niebler, 14 years ago)

  • home/lex/lexer/meta_grammar.hpp

     
    9494            // semantic actions for tokens
    9595            meta_grammar::binary_rule<
    9696                lex::domain, proto::tag::subscript, action,
    97                 token_def_meta_grammar, proto::when<proto::_, proto::_arg>
     97                token_def_meta_grammar, proto::when<proto::_, proto::_child>
    9898            >,
    9999            meta_grammar::binary_rule<
    100100                lex::domain, proto::tag::subscript, action,
    101                 action_lexer_meta_grammar, proto::when<proto::_, proto::_arg>
     101                action_lexer_meta_grammar, proto::when<proto::_, proto::_child>
    102102            >
    103103        >
    104104    {

  • home/lex/lexer/terminal_holder.hpp

     
    77#if !defined(BOOST_SPIRIT_LEX_TERMINAL_HOLDER_MAR_22_2007_0217PM)
    88#define BOOST_SPIRIT_LEX_TERMINAL_HOLDER_MAR_22_2007_0217PM
    99
    10 #include <boost/xpressive/proto/proto.hpp>
     10#include <boost/proto/core.hpp>
    1111
    1212namespace boost { namespace spirit { namespace lex
    1313{

  • home/lex/set_state.hpp

     
    1010#pragma once      // MS compatible compilers support #pragma once
    1111#endif
    1212
    13 #include <boost/xpressive/proto/proto.hpp>
     13#include <boost/proto/core.hpp>
    1414
    1515///////////////////////////////////////////////////////////////////////////////
    1616namespace boost { namespace spirit

  • home/lex/qi/state/in_state.hpp

     
    1010#pragma once      // MS compatible compilers support #pragma once
    1111#endif
    1212
    13 #include <boost/xpressive/proto/proto.hpp>
     13#include <boost/proto/core.hpp>
    1414
    1515///////////////////////////////////////////////////////////////////////////////
    1616namespace boost { namespace spirit { namespace qi

  • home/lex/qi/state/state_switcher.hpp

     
    142142
    143143            // the state has to be reset at exit in any case
    144144            detail::reset_state_on_exit<Iterator> guard(
    145                 first, proto::arg_c<0>(argument1(component)).name);
     145                first, proto::child_c<0>(argument1(component)).name);
    146146
    147147            return director::parse(spirit::subject(component), first,
    148148                last, context, skipper, attr);
    … …  
    153153        {
    154154            std::string result("in_state(\"");
    155155            result += spirit::detail::to_narrow_string(
    156                 proto::arg_c<0>(argument1(component)).name);
     156                proto::child_c<0>(argument1(component)).name);
    157157            result += "\")[";
    158158
    159159            typedef typename

  • home/lex/qi/utility/plain_token.hpp

     
    1111#endif
    1212
    1313#include <boost/lexical_cast.hpp>
    14 #include <boost/xpressive/proto/proto.hpp>
     14#include <boost/proto/core.hpp>
    1515#include <boost/range/iterator_range.hpp>
    1616
    1717namespace boost { namespace spirit { namespace qi

  • home/qi/binary/meta_grammar.hpp

     
    197197    struct int_binary_meta_grammar
    198198      : meta_grammar::compose_empty<
    199199            proto::if_<
    200                 is_int_lit_tag<proto::_arg, qi::domain>()
     200                is_int_lit_tag<proto::_child, qi::domain>()
    201201            >,
    202202            qi::domain,
    203203            mpl::identity<extract_literal_bin_director<mpl::_> >
    … …  
    209209      : proto::or_<
    210210            meta_grammar::compose_empty<
    211211                proto::if_<
    212                     is_binary_tag<proto::_arg, qi::domain>()
     212                    is_binary_tag<proto::_child, qi::domain>()
    213213                >,
    214214                qi::domain,
    215215                mpl::identity<extract_binary_director<mpl::_> >
    … …  
    217217            meta_grammar::compose_function1_eval<
    218218                proto::function<
    219219                    proto::if_<
    220                         is_binary_tag<proto::_arg, qi::domain>()
     220                        is_binary_tag<proto::_child, qi::domain>()
    221221                    >,
    222222                    int_binary_meta_grammar
    223223                >,

  • home/qi/nonterminal/nonterminal.hpp

     
    1111#include <boost/spirit/home/support/nonterminal/locals.hpp>
    1212#include <boost/spirit/home/support/argument.hpp>
    1313
    14 #include <boost/xpressive/proto/proto.hpp>
     14#include <boost/proto/core.hpp>
    1515#include <boost/function_types/result_type.hpp>
    1616#include <boost/function_types/parameter_types.hpp>
    1717#include <boost/function_types/is_function.hpp>

  • home/qi/stream/meta_grammar.hpp

     
    9595        // stream, wstream
    9696        meta_grammar::compose_empty<   
    9797            proto::if_<
    98                 is_stream_tag<proto::_arg, qi::domain>()
     98                is_stream_tag<proto::_child, qi::domain>()
    9999            >,
    100100            qi::domain,
    101101            mpl::identity<extract_stream_director<mpl::_> >

  • home/qi/operator/meta_grammar.hpp

     
    9999            >
    100100            // +a
    101101          , meta_grammar::unary_rule<
    102                 qi::domain, proto::tag::posit, plus
     102                qi::domain, proto::tag::unary_plus, plus
    103103              , main_meta_grammar
    104104            >
    105105            // &a

  • home/qi/numeric/meta_grammar.hpp

     
    271271    ///////////////////////////////////////////////////////////////////////////
    272272    struct int_meta_grammar
    273273      : meta_grammar::compose_empty<
    274             proto::if_<is_int_tag<proto::_arg, qi::domain>()>
     274            proto::if_<is_int_tag<proto::_child, qi::domain>()>
    275275          , qi::domain
    276276          , mpl::identity<extract_int_director<mpl::_> >
    277277        >
    … …  
    279279
    280280    struct real_meta_grammar
    281281      : meta_grammar::compose_single<
    282             proto::if_<is_real_tag<proto::_arg, qi::domain>()>
     282            proto::if_<is_real_tag<proto::_child, qi::domain>()>
    283283          , qi::domain
    284284          , mpl::identity<extract_real_director<mpl::_> >
    285285        >

  • home/qi/string/meta_grammar.hpp

     
    159159          , meta_grammar::compose_function1_eval<
    160160                proto::function<
    161161                    proto::if_<
    162                         is_lit_tag<proto::_arg, qi::domain>()>
     162                        is_lit_tag<proto::_child, qi::domain>()>
    163163                  , proto::or_<basic_string_literal_meta_grammar, basic_std_string_meta_grammar>
    164164                >
    165165              , qi::domain
    … …  
    170170              , tag::lit
    171171              , lazy_string
    172172              , proto::if_<
    173                     detail::is_not_convertible_to_int<proto::_arg >() >
     173                    detail::is_not_convertible_to_int<proto::_child >() >
    174174            >
    175175          , meta_grammar::terminal_rule<
    176176                qi::domain

  • home/qi/string/symbols.hpp

     
    1313#include <boost/spirit/home/support/modifier.hpp>
    1414#include <boost/spirit/home/qi/detail/assign_to.hpp>
    1515#include <boost/fusion/include/at.hpp>
    16 #include <boost/xpressive/proto/proto.hpp>
     16#include <boost/proto/core.hpp>
    1717#include <boost/shared_ptr.hpp>
    1818#include <boost/range.hpp>
    1919#include <boost/type_traits/add_reference.hpp>
    … …  
    9292          : add(*this)
    9393          , remove(*this)
    9494        {
    95             proto::arg(*this).lookup = ptr_type(new Lookup());
     95            proto::child(*this).lookup = ptr_type(new Lookup());
    9696        }
    9797
    9898        template <typename Symbols>
    … …  
    100100          : add(*this)
    101101          , remove(*this)
    102102        {
    103             proto::arg(*this).lookup = ptr_type(new Lookup());
     103            proto::child(*this).lookup = ptr_type(new Lookup());
    104104            typename range_const_iterator<Symbols>::type si = boost::begin(syms);
    105105            while (si != boost::end(syms))
    106106                add(*si++);
    … …  
    111111          : add(*this)
    112112          , remove(*this)
    113113        {
    114             proto::arg(*this).lookup = ptr_type(new Lookup());
     114            proto::child(*this).lookup = ptr_type(new Lookup());
    115115            typename range_const_iterator<Symbols>::type si = boost::begin(syms);
    116116            typename range_const_iterator<Data>::type di = boost::begin(data);
    117117            while (si != boost::end(syms))
    … …  
    121121        symbols&
    122122        operator=(symbols const& rhs)
    123123        {
    124             proto::arg(*this) = proto::arg(rhs);
     124            proto::child(*this) = proto::child(rhs);
    125125            return *this;
    126126        }
    127127
    … …  
    154154
    155155        ptr_type lookup() const
    156156        {
    157             return proto::arg(*this).lookup;
     157            return proto::child(*this).lookup;
    158158        }
    159159
    160160        template <typename F>

  • home/qi/auxiliary/confix.hpp

     
    8282            // parse the prefix
    8383            parse_helper(first, last, context, skipper,
    8484                spirit::detail::confix_extractor::prefix(
    85                     proto::arg_c<0>(spirit::argument1(component))));
     85                    proto::child_c<0>(spirit::argument1(component))));
    8686
    8787            // generate the embedded items
    8888            typedef typename
    … …  
    9494            // append the suffix
    9595            parse_helper(first, last, context, skipper,
    9696                spirit::detail::confix_extractor::suffix(
    97                     proto::arg_c<0>(spirit::argument1(component))));
     97                    proto::child_c<0>(spirit::argument1(component))));
    9898
    9999            return result;
    100100        }
    … …  
    105105            std::string result = "confix(";
    106106
    107107            result += what_helper(spirit::detail::confix_extractor::prefix(
    108                     proto::arg_c<0>(spirit::argument1(component))), ctx);
     108                    proto::child_c<0>(spirit::argument1(component))), ctx);
    109109            result += ", ";
    110110
    111111            result += what_helper(spirit::detail::confix_extractor::suffix(
    112                     proto::arg_c<0>(spirit::argument1(component))), ctx);
     112                    proto::child_c<0>(spirit::argument1(component))), ctx);
    113113            result += ")[";
    114114
    115115            typedef typename

  • home/qi/action/meta_grammar.hpp

     
    3131    struct action_meta_grammar :
    3232        meta_grammar::binary_rule<
    3333            qi::domain, proto::tag::subscript, action
    34           , main_meta_grammar, proto::when<proto::_, proto::_arg>
     34          , main_meta_grammar, proto::when<proto::_, proto::_child>
    3535        >
    3636    {
    3737    };

  • home/qi/char/meta_grammar.hpp

     
    263263            // char_, wchar --> any_char
    264264            meta_grammar::compose_empty<
    265265                proto::if_<
    266                     is_char_tag<proto::_arg, qi::domain>()
     266                    is_char_tag<proto::_child, qi::domain>()
    267267                >
    268268              , qi::domain
    269269              , mpl::identity<extract_any_char_director<mpl::_> >
    … …  
    272272          , meta_grammar::compose_function1_eval<
    273273                proto::function<
    274274                    proto::if_<
    275                         is_char_tag<proto::_arg, qi::domain>()
     275                        is_char_tag<proto::_child, qi::domain>()
    276276                    >
    277277                  , single_char_literal_meta_grammar
    278278                >
    … …  
    283283          , meta_grammar::compose_function1_eval<
    284284                proto::function<
    285285                    proto::if_<
    286                         is_lit_tag<proto::_arg, qi::domain>()
     286                        is_lit_tag<proto::_child, qi::domain>()
    287287                    >
    288288                  , basic_char_literal_meta_grammar
    289289                >
    … …  
    294294          , meta_grammar::compose_function1_eval<
    295295                proto::function<
    296296                    proto::if_<
    297                         is_char_tag<proto::_arg, qi::domain>()>
     297                        is_char_tag<proto::_child, qi::domain>()>
    298298                  , proto::or_<basic_string_literal_meta_grammar, basic_std_string_meta_grammar>
    299299                >
    300300              , qi::domain
    … …  
    310310          , meta_grammar::compose_function2_eval<
    311311                proto::function<
    312312                    proto::if_<
    313                         is_char_tag<proto::_arg, qi::domain>()
     313                        is_char_tag<proto::_child, qi::domain>()
    314314                    >
    315315                  , basic_char_literal_meta_grammar
    316316                  , basic_char_literal_meta_grammar

  • home/karma/binary/meta_grammar.hpp

     
    199199    struct int_binary_meta_grammar
    200200      : meta_grammar::compose_empty<
    201201            proto::if_<
    202                 is_int_lit_tag<proto::_arg, karma::domain>()
     202                is_int_lit_tag<proto::_child, karma::domain>()
    203203            >,
    204204            karma::domain,
    205205            mpl::identity<extract_literal_bin_director<mpl::_> >
    … …  
    211211      : proto::or_<
    212212            meta_grammar::compose_empty<
    213213                proto::if_<
    214                     is_binary_tag<proto::_arg, karma::domain>()
     214                    is_binary_tag<proto::_child, karma::domain>()
    215215                >,
    216216                karma::domain,
    217217                mpl::identity<extract_binary_director<mpl::_> >
    … …  
    219219            meta_grammar::compose_function1_eval<
    220220                proto::function<
    221221                    proto::if_<
    222                         is_binary_tag<proto::_arg, karma::domain>()
     222                        is_binary_tag<proto::_child, karma::domain>()
    223223                    >,
    224224                    int_binary_meta_grammar
    225225                >,

  • home/karma/nonterminal/nonterminal.hpp

     
    1515#include <boost/spirit/home/support/nonterminal/locals.hpp>
    1616#include <boost/spirit/home/support/argument.hpp>
    1717
    18 #include <boost/xpressive/proto/proto.hpp>
     18#include <boost/proto/core.hpp>
    1919#include <boost/function_types/result_type.hpp>
    2020#include <boost/function_types/parameter_types.hpp>
    2121#include <boost/function_types/is_function.hpp>

  • home/karma/stream/meta_grammar.hpp

     
    7575            // stream, wstream
    7676            meta_grammar::compose_empty<
    7777                proto::if_<
    78                     is_stream_tag<proto::_arg, karma::domain>()
     78                    is_stream_tag<proto::_child, karma::domain>()
    7979                >,
    8080                karma::domain,
    8181                mpl::identity<extract_any_stream_director<mpl::_> >
    … …  
    8484            meta_grammar::compose_function1_eval<
    8585                proto::function<
    8686                    proto::if_<
    87                         is_stream_tag<proto::_arg, karma::domain>()
     87                        is_stream_tag<proto::_child, karma::domain>()
    8888                    >,
    8989                    proto::_
    9090                >,

  • home/karma/operator/meta_grammar.hpp

     
    7070                main_meta_grammar
    7171            >,
    7272            meta_grammar::unary_rule<
    73                 karma::domain, proto::tag::posit, plus,
     73                karma::domain, proto::tag::unary_plus, plus,
    7474                main_meta_grammar
    7575            >,
    7676            meta_grammar::binary_rule<

  • home/karma/numeric/meta_grammar.hpp

     
    359359    struct int_literal_meta_grammar
    360360      : meta_grammar::compose_empty<
    361361            proto::if_<
    362                 is_int_lit_tag<proto::_arg, karma::domain>()
     362                is_int_lit_tag<proto::_child, karma::domain>()
    363363            >,
    364364            karma::domain,
    365365            mpl::identity<extract_literal_int_director<mpl::_> >
    … …  
    372372      : proto::or_<
    373373            meta_grammar::compose_empty<
    374374                proto::if_<
    375                     is_int_tag<proto::_arg, karma::domain>()
     375                    is_int_tag<proto::_child, karma::domain>()
    376376                >,
    377377                karma::domain,
    378378                mpl::identity<extract_int_director_plain<mpl::_> >
    … …  
    380380            meta_grammar::compose_function1_eval<
    381381                proto::function<
    382382                    proto::if_<
    383                         is_int_tag<proto::_arg, karma::domain>()
     383                        is_int_tag<proto::_child, karma::domain>()
    384384                    >,
    385385                    int_literal_meta_grammar
    386386                >,
    … …  
    394394    struct real_literal_meta_grammar
    395395      : meta_grammar::compose_empty<
    396396            proto::if_<
    397                 is_real_lit_tag<proto::_arg, karma::domain>()
     397                is_real_lit_tag<proto::_child, karma::domain>()
    398398            >,
    399399            karma::domain,
    400400            mpl::identity<extract_literal_real_director<mpl::_> >
    … …  
    405405      : proto::or_<
    406406            meta_grammar::compose_single<
    407407                proto::if_<
    408                     is_real_tag<proto::_arg, karma::domain>()
     408                    is_real_tag<proto::_child, karma::domain>()
    409409                >,
    410410                karma::domain,
    411411                mpl::identity<extract_real_director_plain<mpl::_> >
    … …  
    413413            meta_grammar::compose_function1_full<
    414414                proto::function<
    415415                    proto::if_<
    416                         is_real_tag<proto::_arg, karma::domain>()
     416                        is_real_tag<proto::_child, karma::domain>()
    417417                    >,
    418418                    real_literal_meta_grammar
    419419                >,

  • home/karma/string/meta_grammar.hpp

     
    185185            std_string_meta_grammar,
    186186            meta_grammar::compose_empty<
    187187                proto::if_<
    188                     is_lit_tag<proto::_arg, karma::domain>()
     188                    is_lit_tag<proto::_child, karma::domain>()
    189189                >,
    190190                karma::domain,
    191191                mpl::identity<extract_lit_director_plain<mpl::_> >
    … …  
    193193            meta_grammar::compose_function1_eval<
    194194                proto::function<
    195195                    proto::if_<
    196                         is_lit_tag<proto::_arg, karma::domain>()
     196                        is_lit_tag<proto::_child, karma::domain>()
    197197                    >,
    198198                    proto::or_<
    199199                        basic_string_literal_meta_grammar,
    … …  
    206206            meta_grammar::function1_rule<
    207207                karma::domain, tag::lit, lazy_string,
    208208                proto::if_<
    209                     detail::is_not_convertible_to_int<proto::_arg>()
     209                    detail::is_not_convertible_to_int<proto::_child>()
    210210                >
    211211            >
    212212        >

  • home/karma/auxiliary/confix.hpp

     
    7676            // generate the prefix
    7777            generate_helper(sink, ctx, d,
    7878                spirit::detail::confix_extractor::prefix(
    79                     proto::arg_c<0>(spirit::argument1(component))));
     79                    proto::child_c<0>(spirit::argument1(component))));
    8080
    8181            // generate the embedded items
    8282            typedef typename
    … …  
    8888            // append the suffix
    8989            generate_helper(sink, ctx, d,
    9090                spirit::detail::confix_extractor::suffix(
    91                     proto::arg_c<0>(spirit::argument1(component))));
     91                    proto::child_c<0>(spirit::argument1(component))));
    9292
    9393            return result;
    9494        }
    … …  
    9999            std::string result = "confix(";
    100100
    101101            result += what_helper(spirit::detail::confix_extractor::prefix(
    102                     proto::arg_c<0>(spirit::argument1(component))), ctx);
     102                    proto::child_c<0>(spirit::argument1(component))), ctx);
    103103            result += ", ";
    104104
    105105            result += what_helper(spirit::detail::confix_extractor::suffix(
    106                     proto::arg_c<0>(spirit::argument1(component))), ctx);
     106                    proto::child_c<0>(spirit::argument1(component))), ctx);
    107107            result += ")[";
    108108
    109109            typedef typename

  • home/karma/action/meta_grammar.hpp

     
    3535    struct action_meta_grammar :
    3636        meta_grammar::binary_rule<
    3737            karma::domain, proto::tag::subscript, action,
    38             main_meta_grammar, proto::when<proto::_, proto::_arg>
     38            main_meta_grammar, proto::when<proto::_, proto::_child>
    3939        >
    4040    {
    4141    };

  • home/karma/char/meta_grammar.hpp

     
    163163            // char_, wchar, space
    164164            meta_grammar::compose_empty<
    165165                proto::if_<
    166                     is_char_tag<proto::_arg, karma::domain>()
     166                    is_char_tag<proto::_child, karma::domain>()
    167167                >,
    168168                karma::domain,
    169169                mpl::identity<extract_any_char_director<mpl::_> >
    … …  
    172172            meta_grammar::compose_function1_eval<
    173173                proto::function<
    174174                    proto::if_<
    175                         is_char_tag<proto::_arg, karma::domain>()
     175                        is_char_tag<proto::_child, karma::domain>()
    176176                    >,
    177177                    basic_char_literal_meta_grammar
    178178                >,
    … …  
    183183            meta_grammar::compose_function1_eval<
    184184                proto::function<
    185185                    proto::if_<
    186                         is_lit_tag<proto::_arg, karma::domain>()
     186                        is_lit_tag<proto::_child, karma::domain>()
    187187                    >,
    188188                    basic_char_literal_meta_grammar
    189189                >,

  • home/karma/directive/right_alignment.hpp

     
    9696            Context& ctx, Delimiter const& d, Parameter const& param)
    9797        {
    9898            return detail::right_align_generate(sink, ctx, d, param,
    99                 subject(component), proto::arg_c<0>(argument1(component)), ' ');
     99                subject(component), proto::child_c<0>(argument1(component)), ' ');
    100100        }
    101101
    102102        template <typename Component, typename Context>
    … …  
    105105            std::string result = "right_align(";
    106106
    107107            result += boost::lexical_cast<std::string>(
    108                 proto::arg_c<0>(argument1(component)));
     108                proto::child_c<0>(argument1(component)));
    109109            result += ")[";
    110110
    111111            typedef typename
    … …  
    194194            Context& ctx, Delimiter const& d, Parameter const& param)
    195195        {
    196196            return detail::right_align_generate(sink, ctx, d, param,
    197                 subject(component), proto::arg_c<0>(argument1(component)),
     197                subject(component), proto::child_c<0>(argument1(component)),
    198198                argument2(component));
    199199        }
    200200
    … …  
    204204            std::string result = "right_align(";
    205205
    206206            result += boost::lexical_cast<std::string>(
    207                 proto::arg_c<0>(argument1(component)));
     207                proto::child_c<0>(argument1(component)));
    208208            result += ", ";
    209209
    210210            typedef typename

  • home/karma/directive/center_alignment.hpp

     
    9696            Context& ctx, Delimiter const& d, Parameter const& param)
    9797        {
    9898            return detail::center_generate(sink, ctx, d, param,
    99                 subject(component), proto::arg_c<0>(argument1(component)), ' ');
     99                subject(component), proto::child_c<0>(argument1(component)), ' ');
    100100        }
    101101
    102102        template <typename Component, typename Context>
    … …  
    105105            std::string result = "center(";
    106106
    107107            result += boost::lexical_cast<std::string>(
    108                 proto::arg_c<0>(argument1(component)));
     108                proto::child_c<0>(argument1(component)));
    109109            result += ")[";
    110110
    111111            typedef typename
    … …  
    194194            Context& ctx, Delimiter const& d, Parameter const& param)
    195195        {
    196196            return detail::center_generate(sink, ctx, d, param,
    197                 subject(component), proto::arg_c<0>(argument1(component)),
     197                subject(component), proto::child_c<0>(argument1(component)),
    198198                argument2(component));
    199199        }
    200200
    … …  
    204204            std::string result = "center(";
    205205
    206206            result += boost::lexical_cast<std::string>(
    207                 proto::arg_c<0>(argument1(component)));
     207                proto::child_c<0>(argument1(component)));
    208208            result += ", ";
    209209
    210210            typedef typename

  • home/karma/directive/left_alignment.hpp

     
    9595            Context& ctx, Delimiter const& d, Parameter const& param)
    9696        {
    9797            return detail::left_align_generate(sink, ctx, d, param,
    98                 subject(component), proto::arg_c<0>(argument1(component)), ' ');
     98                subject(component), proto::child_c<0>(argument1(component)), ' ');
    9999        }
    100100
    101101        template <typename Component, typename Context>
    … …  
    104104            std::string result = "left_align(";
    105105
    106106            result += boost::lexical_cast<std::string>(
    107                 proto::arg_c<0>(argument1(component)));
     107                proto::child_c<0>(argument1(component)));
    108108            result += ")[";
    109109
    110110            typedef typename
    … …  
    193193            Context& ctx, Delimiter const& d, Parameter const& param)
    194194        {
    195195            return detail::left_align_generate(sink, ctx, d, param,
    196                 subject(component), proto::arg_c<0>(argument1(component)),
     196                subject(component), proto::child_c<0>(argument1(component)),
    197197                argument2(component));
    198198        }
    199199
    … …  
    203203            std::string result = "left_align(";
    204204
    205205            result += boost::lexical_cast<std::string>(
    206                 proto::arg_c<0>(argument1(component)));
     206                proto::child_c<0>(argument1(component)));
    207207            result += ", ";
    208208
    209209            typedef typename

  • home/support/standard.hpp

     
    88#define SPIRIT_STANDARD_JAN_31_2006_0529PM
    99
    1010#include <boost/spirit/home/support/char_class.hpp>
    11 #include <boost/xpressive/proto/proto.hpp>
     11#include <boost/proto/core.hpp>
    1212
    1313namespace boost { namespace spirit { namespace standard
    1414{

  • home/support/nonterminal/nonterminal.hpp

     
    77#if !defined(BOOST_SPIRIT_NONTERMINAL_MAR_06_2007_0236PM)
    88#define BOOST_SPIRIT_NONTERMINAL_MAR_06_2007_0236PM
    99
    10 #include <boost/xpressive/proto/proto.hpp>
     10#include <boost/proto/core.hpp>
    1111#include <boost/function_types/result_type.hpp>
    1212#include <boost/function_types/parameter_types.hpp>
    1313#include <boost/fusion/include/as_vector.hpp>

  • home/support/component.hpp

     
    99
    1010#include <boost/spirit/home/support/unused.hpp>
    1111#include <boost/spirit/home/support/meta_grammar/grammar.hpp>
    12 #include <boost/xpressive/proto/proto.hpp>
     12#include <boost/proto/core.hpp>
    1313#include <boost/fusion/include/at.hpp>
    1414#include <boost/fusion/include/value_at.hpp>
    1515#include <boost/mpl/void.hpp>
    … …  
    198198        {
    199199            typedef typename meta_grammar::grammar<Domain>::type grammar;
    200200            typedef typename proto::result_of::as_expr<Expr>::type proto_xpr;
    201 
    202             typedef typename
    203                 grammar::template result<
    204                     void(proto_xpr, State, Visitor)
    205                 >::type
    206             type;
     201            typedef typename grammar::template impl<proto_xpr, State, Visitor> callable;
     202            typedef typename callable::result_type type;
    207203        };
    208204
    209205        // special case for arrays
    … …  
    214210        {
    215211            typedef typename meta_grammar::grammar<Domain>::type grammar;
    216212            typedef typename proto::result_of::as_expr<T const*>::type proto_xpr;
    217 
    218             typedef typename
    219                 grammar::template result<
    220                     void(proto_xpr, State, Visitor)
    221                 >::type
    222             type;
     213            typedef typename grammar::template impl<proto_xpr, State, Visitor> callable;
     214            typedef typename callable::result_type type;
    223215        };
    224216
    225217        // special case for components
    … …  
    229221        {
    230222        };
    231223    }
     224   
     225    namespace detail
     226    {
     227        template<typename T>
     228        T &decay(T &t)
     229        {
     230            return t;
     231        }
    232232
     233        template<typename T, int N>
     234        T *decay(T (&t)[N])
     235        {
     236            return t;
     237        }
     238    }
     239
    233240    template <typename Domain, typename Expr>
    234241    inline typename result_of::as_component<Domain, Expr>::type
    235242    as_component(Domain, Expr const& xpr)
    236243    {
    237         unused_type unused;
    238         typedef typename result_of::as_component<Domain, Expr>::grammar grammar;
    239         return grammar()(proto::as_expr(xpr), unused, unused);
     244        typedef typename result_of::as_component<Domain, Expr>::callable callable;
     245        return callable()(proto::as_expr(detail::decay(xpr)), unused_type(), unused_type());
    240246    }
    241247
    242248    template <typename Domain, typename Expr, typename State, typename Visitor>
    243249    inline typename result_of::as_component<Domain, Expr>::type
    244250    as_component(Domain, Expr const& xpr, State const& state, Visitor& visitor)
    245251    {
    246         typedef typename
    247             result_of::as_component<Domain, Expr, State, Visitor>::grammar
    248         grammar;
    249         return grammar()(proto::as_expr(xpr), state, visitor);
     252        typedef typename result_of::as_component<Domain, Expr, State, Visitor>::callable callable;
     253        return callable()(proto::as_expr(detail::decay(xpr)), state, visitor);
    250254    }
    251255
    252256    template <typename Domain, typename Director, typename Elements>

  • home/support/placeholders.hpp

     
    88#if !defined(BOOST_SPIRIT_PLACEHOLDERS_NOV_18_2006_0326PM)
    99#define BOOST_SPIRIT_PLACEHOLDERS_NOV_18_2006_0326PM
    1010
    11 #include <boost/xpressive/proto/proto.hpp>
     11#include <boost/proto/core.hpp>
    1212#include <boost/mpl/bool.hpp>
    1313#include <boost/type_traits/is_enum.hpp>
    1414

  • home/support/meta_grammar/basic_rules.hpp

     
    1111#include <boost/spirit/home/support/meta_grammar/basic_transforms.hpp>
    1212#include <boost/spirit/home/support/component.hpp>
    1313#include <boost/fusion/include/cons.hpp>
    14 #include <boost/xpressive/proto/proto.hpp>
    15 #include <boost/xpressive/proto/transform.hpp>
     14#include <boost/proto/core.hpp>
     15#include <boost/proto/transform.hpp>
    1616#include <boost/mpl/identity.hpp>
    1717
    1818namespace boost { namespace spirit { namespace meta_grammar

  • home/support/meta_grammar/basic_transforms.hpp

     
    1212#include <boost/spirit/home/support/component.hpp>
    1313#include <boost/spirit/home/support/modifier.hpp>
    1414
    15 #include <boost/xpressive/proto/proto.hpp>
    16 #include <boost/xpressive/proto/transform.hpp>
     15#include <boost/proto/core.hpp>
     16#include <boost/proto/transform.hpp>
    1717
    1818#include <boost/fusion/include/cons.hpp>
    1919#include <boost/fusion/include/list.hpp>
    … …  
    2525namespace boost { namespace spirit { namespace meta_grammar
    2626{
    2727    ///////////////////////////////////////////////////////////////////////////
     28    // Invoke the specified grammar in the "Proto v2" way, dropping top
     29    // level const and reference on the three parameters
     30    //template<typename Grammar, typename Expr, typename State, typename Data>
     31    //typename Grammar::template impl<Expr, State, Data>::result_type
     32    //invoke_grammar(Expr const &expr, State const &state, Data &data)
     33    //{
     34    //    return typename Grammar::template impl<Expr, State, Data>()(expr, state, data);
     35    //}
     36   
     37    template<typename Grammar, typename Expr, typename State, typename Data>
     38    struct invoke_grammar
     39      : Grammar::template impl<Expr, State, Data>
     40    {};
     41
     42    ///////////////////////////////////////////////////////////////////////////
    2843    //  A proto transform for creating empty component meta descriptions
    2944    //  (proto expressions) usable for defining meta grammars. Additionally,
    3045    //  this is used to make the corresponding spirit component.
    … …  
    3752    //               domain (i.e.: any_char)
    3853    ///////////////////////////////////////////////////////////////////////////
    3954    template <typename Grammar, typename Domain, typename DirectorF>
    40     struct compose_empty : Grammar
     55    struct compose_empty : proto::transform<compose_empty<Grammar, Domain, DirectorF> >, Grammar
    4156    {
    42         template<typename Sig>
    43         struct result;
    44 
    45         template <typename This, typename Expr, typename State, typename Visitor>
    46         struct result<This(Expr, State, Visitor)>
     57        template<typename Expr, typename State, typename Data>
     58        struct impl : proto::transform_impl<Expr, State, Data>
    4759        {
    48             typedef typename proto::result_of::arg<Expr>::type arg_type;
     60            typedef typename proto::result_of::child<Expr>::type arg_type;
    4961
    5062            typedef
    5163                traits::make_component<
    5264                    Domain
    5365                  , typename mpl::apply1<DirectorF, arg_type>::type
    5466                  , fusion::nil
    55                   , Visitor
     67                  , Data
    5668                >
    5769            make_component;
    5870
    59             typedef typename make_component::type type;
    60         };
     71            typedef typename make_component::type result_type;
    6172
    62         template<typename Expr, typename State, typename Visitor>
    63         typename result<void(Expr, State, Visitor)>::type
    64         operator ()(Expr const&, State const&, Visitor&) const
    65         {
    66             typedef typename result<void(Expr, State, Visitor)>::make_component result;
    67             return result::call(fusion::nil());
    68         }
     73            result_type operator ()(
     74                typename impl::expr_param
     75              , typename impl::state_param
     76              , typename impl::data_param
     77            ) const
     78            {
     79                return make_component::call(fusion::nil());
     80            }
     81        };
    6982    };
    7083
    7184    ///////////////////////////////////////////////////////////////////////////
    … …  
    8093    //               domain (i.e.: negated_char_parser<...>)
    8194    ///////////////////////////////////////////////////////////////////////////
    8295    template <typename Grammar, typename Domain, typename DirectorF>
    83     struct compose_single : Grammar
     96    struct compose_single : proto::transform<compose_single<Grammar, Domain, DirectorF> >, Grammar
    8497    {
    85         template<typename Sig>
    86         struct result;
    87 
    88         template <typename This, typename Expr, typename State, typename Visitor>
    89         struct result<This(Expr, State, Visitor)>
     98        template<typename Expr, typename State, typename Data>
     99        struct impl : proto::transform_impl<Expr, State, Data>
    90100        {
    91101            typedef typename
    92                 proto::result_of::arg<
    93                     typename Grammar::template result<void(Expr, State, Visitor)>::type
     102                proto::result_of::child<
     103                    typename Grammar::template impl<Expr, State, Data>::result_type
    94104                >::type
    95105            arg_type;
    96 
     106           
    97107            typedef
    98108                traits::make_component<
    99109                    Domain
    100110                  , typename mpl::apply1<DirectorF, arg_type>::type
    101111                  , typename fusion::result_of::make_cons<arg_type>::type
    102                   , Visitor
     112                  , Data
    103113                >
    104114            make_component;
    105115
    106             typedef typename make_component::type type;
    107         };
     116            typedef typename make_component::type result_type;
    108117
    109         template<typename Expr, typename State, typename Visitor>
    110         typename result<void(Expr, State, Visitor)>::type
    111         operator ()(Expr const& expr, State const& state, Visitor& visitor) const
    112         {
    113             typedef typename result<void(Expr, State, Visitor)>::make_component result;
    114             return result::call(
    115                 fusion::make_cons(
    116                    proto::arg(Grammar()(expr, state, visitor))
    117                 )
    118             );
    119         }
     118            result_type operator ()(
     119                typename impl::expr_param   expr
     120              , typename impl::state_param  state
     121              , typename impl::data_param   data
     122            ) const
     123            {
     124                return make_component::call(
     125                    fusion::make_cons(
     126                       proto::child(invoke_grammar<Grammar, Expr, State, Data>()(expr, state, data))
     127                    )
     128                );
     129            }
     130        };
    120131    };
    121132
    122133    ///////////////////////////////////////////////////////////////////////////
    … …  
    131142    //               domain (i.e.: difference)
    132143    ///////////////////////////////////////////////////////////////////////////
    133144    template <typename Grammar, typename Domain, typename DirectorF>
    134     struct compose_double : Grammar
     145    struct compose_double : proto::transform<compose_double<Grammar, Domain, DirectorF> >, Grammar
    135146    {
    136         template<typename Sig>
    137         struct result;
    138 
    139         template <typename This, typename Expr, typename State, typename Visitor>
    140         struct result<This(Expr, State, Visitor)>
     147        template<typename Expr, typename State, typename Data>
     148        struct impl : proto::transform_impl<Expr, State, Data>
    141149        {
    142150            typedef typename
    143                 Grammar::template result<void(Expr, State, Visitor)>::type
     151                Grammar::template impl<Expr, State, Data>::result_type
    144152            trans;
    145153
    146154            typedef typename proto::result_of::left<trans>::type left_type;
    … …  
    154162                    Domain
    155163                  , typename mpl::apply1<DirectorF, list_type>::type
    156164                  , list_type
    157                   , Visitor
     165                  , Data
    158166                >
    159167            make_component;
    160168
    161             typedef typename make_component::type type;
    162         };
     169            typedef typename make_component::type result_type;
    163170
    164         template<typename Expr, typename State, typename Visitor>
    165         typename result<void(Expr, State, Visitor)>::type
    166         operator ()(Expr const& expr, State const& state, Visitor& visitor) const
    167         {
    168             typedef result<void(Expr, State, Visitor)> apply;
    169             typedef typename apply::make_component result;
    170             typedef typename apply::list_type list_type;
    171 
    172             typename apply::trans trans = Grammar()(expr, state, visitor);
    173             return result::call(
    174                 fusion::make_list(proto::left(trans), proto::right(trans))
    175             );
    176         }
     171            result_type operator ()(
     172                typename impl::expr_param   expr
     173              , typename impl::state_param  state
     174              , typename impl::data_param   data
     175            ) const
     176            {
     177                trans t = invoke_grammar<Grammar, Expr, State, Data>()(expr, state, data);
     178                return make_component::call(
     179                    fusion::make_list(proto::left(t), proto::right(t))
     180                );
     181            }
     182        };
    177183    };
    178184
    179185    ///////////////////////////////////////////////////////////////////////////
    … …  
    189195    ///////////////////////////////////////////////////////////////////////////
    190196
    191197    template <typename Grammar, typename Domain, typename DirectorF>
    192     struct compose_triple : Grammar
     198    struct compose_triple : proto::transform<compose_triple<Grammar, Domain, DirectorF> >, Grammar
    193199    {
    194         template<typename Sig>
    195         struct result;
    196 
    197         template <typename This, typename Expr, typename State, typename Visitor>
    198         struct result<This(Expr, State, Visitor)>
     200        template<typename Expr, typename State, typename Data>
     201        struct impl : proto::transform_impl<Expr, State, Data>
    199202        {
    200203            typedef typename
    201                 Grammar::template result<void(Expr, State, Visitor)>::type
     204                Grammar::template impl<Expr, State, Data>::result_type
    202205            trans;
    203206
    204             typedef typename proto::result_of::arg_c<trans, 0>::type arg0_type;
    205             typedef typename proto::result_of::arg_c<trans, 1>::type arg1_type;
    206             typedef typename proto::result_of::arg_c<trans, 2>::type arg2_type;
     207            typedef typename proto::result_of::child_c<trans, 0>::type arg0_type;
     208            typedef typename proto::result_of::child_c<trans, 1>::type arg1_type;
     209            typedef typename proto::result_of::child_c<trans, 2>::type arg2_type;
    207210
    208211            typedef typename
    209212                fusion::result_of::make_list<arg0_type, arg1_type, arg2_type>::type
    … …  
    214217                    Domain
    215218                  , typename mpl::apply1<DirectorF, list_type>::type
    216219                  , list_type
    217                   , Visitor
     220                  , Data
    218221                >
    219222            make_component;
    220223
    221             typedef typename make_component::type type;
    222         };
     224            typedef typename make_component::type result_type;
    223225
    224         template<typename Expr, typename State, typename Visitor>
    225         typename result<void(Expr, State, Visitor)>::type
    226         operator ()(Expr const& expr, State const& state, Visitor& visitor) const
    227         {
    228             typedef result<void(Expr, State, Visitor)> apply;
    229             typedef typename apply::make_component result;
    230             typedef typename apply::list_type list_type;
    231 
    232             typename apply::trans trans = Grammar()(expr, state, visitor);
    233             return result::call(
    234                 fusion::make_list(proto::arg_c<0>(trans), proto::arg_c<1>(trans), proto::arg_c<2>(trans))
    235             );
    236         }
     226            result_type operator ()(
     227                typename impl::expr_param   expr
     228              , typename impl::state_param  state
     229              , typename impl::data_param   data
     230            ) const
     231            {
     232                trans t = invoke_grammar<Grammar, Expr, State, Data>()(expr, state, data);
     233                return make_component::call(
     234                    fusion::make_list(proto::child_c<0>(t), proto::child_c<1>(t), proto::child_c<2>(t))
     235                );
     236            }
     237        };
    237238    };
    238239
    239240    ///////////////////////////////////////////////////////////////////////////
    … …  
    249250    //               domain (i.e.: difference)
    250251    ///////////////////////////////////////////////////////////////////////////
    251252    template <typename Grammar, typename Domain, typename DirectorF>
    252     struct compose_right : Grammar
     253    struct compose_right : proto::transform<compose_right<Grammar, Domain, DirectorF> >, Grammar
    253254    {
    254         template<typename Sig>
    255         struct result;
    256 
    257         template <typename This, typename Expr, typename State, typename Visitor>
    258         struct result<This(Expr, State, Visitor)>
     255        template<typename Expr, typename State, typename Data>
     256        struct impl : proto::transform_impl<Expr, State, Data>
    259257        {
    260258            typedef typename
    261                 Grammar::template result<void(Expr, State, Visitor)>::type
     259                Grammar::template impl<Expr, State, Data>::result_type
    262260            trans;
    263261
    264262            typedef typename proto::result_of::right<trans>::type right_type;
    … …  
    271269                    Domain
    272270                  , typename mpl::apply1<DirectorF, list_type>::type
    273271                  , list_type
    274                   , Visitor
     272                  , Data
    275273                >
    276274            make_component;
    277275
    278             typedef typename make_component::type type;
    279         };
     276            typedef typename make_component::type result_type;
    280277
    281         template<typename Expr, typename State, typename Visitor>
    282         typename result<void(Expr, State, Visitor)>::type
    283         operator ()(Expr const& expr, State const& state, Visitor& visitor) const
    284         {
    285             typedef result<void(Expr, State, Visitor)> apply;
    286             typedef typename apply::make_component result;
    287             typedef typename apply::list_type list_type;
    288 
    289             typename apply::trans trans = Grammar()(expr, state, visitor);
    290             return result::call(
    291                 fusion::make_list(proto::right(trans))
    292             );
    293         }
     278            result_type operator ()(
     279                typename impl::expr_param   expr
     280              , typename impl::state_param  state
     281              , typename impl::data_param   data
     282            ) const
     283            {
     284                trans t = invoke_grammar<Grammar, Expr, State, Data>()(expr, state, data);
     285                return make_component::call(
     286                    fusion::make_list(proto::right(t))
     287                );
     288            }
     289        };
    294290    };
    295291
    296292    ///////////////////////////////////////////////////////////////////////////
    … …  
    299295    ///////////////////////////////////////////////////////////////////////////
    300296    template <typename Pred, typename TransformF>
    301297    struct if_transform
    302       : proto::when<proto::if_<Pred>, proto::bind<TransformF> >
     298      : proto::when<proto::if_<Pred>, proto::lazy<TransformF> >
    303299    {
    304300    };
    305301
    … …  
    307303    //  A proto transform that composes components from a fusion::list
    308304    ///////////////////////////////////////////////////////////////////////////
    309305    template <typename Grammar, typename Domain, typename Director>
    310     struct compose_list : Grammar
     306    struct compose_list : proto::transform<compose_list<Grammar, Domain, Director> >, Grammar
    311307    {
    312         template<typename Sig>
    313         struct result;
    314 
    315         template <typename This, typename Expr, typename State, typename Visitor>
    316         struct result<This(Expr, State, Visitor)>
     308        template<typename Expr, typename State, typename Data>
     309        struct impl : proto::transform_impl<Expr, State, Data>
    317310        {
    318311            typedef
    319312                traits::make_component<
    320313                    Domain, Director
    321                   , typename Grammar::template
    322                         result<void(Expr, State, Visitor)>::type
    323                   , Visitor
     314                  , typename Grammar::template impl<Expr, State, Data>::result_type
     315                  , Data
    324316                >
    325317            make_component;
    326318
    327             typedef typename make_component::type type;
    328         };
     319            typedef typename make_component::type result_type;
    329320
    330         template<typename Expr, typename State, typename Visitor>
    331         typename result<void(Expr, State, Visitor)>::type
    332         operator ()(Expr const& expr, State const& state, Visitor& visitor) const
    333         {
    334             typedef typename result<void(Expr, State, Visitor)>::make_component result;
    335             return result::call(Grammar()(expr, state, visitor));
    336         }
     321            result_type operator ()(
     322                typename impl::expr_param   expr
     323              , typename impl::state_param  state
     324              , typename impl::data_param   data
     325            ) const
     326            {
     327                return make_component::call(invoke_grammar<Grammar, Expr, State, Data>()(expr, state, data));
     328            }
     329        };
    337330    };
    338331
    339332    ///////////////////////////////////////////////////////////////////////////
    … …  
    341334    //  from a 1-arity proto function expression (e.g. f(x))
    342335    ///////////////////////////////////////////////////////////////////////////
    343336    template <typename Grammar, typename Domain, typename Director>
    344     struct compose_function1 : Grammar
     337    struct compose_function1 : proto::transform<compose_function1<Grammar, Domain, Director> >, Grammar
    345338    {
    346         template<typename Sig>
    347         struct result;
    348 
    349         template <typename This, typename Expr, typename State, typename Visitor>
    350         struct result<This(Expr, State, Visitor)>
     339        template<typename Expr, typename State, typename Data>
     340        struct impl : proto::transform_impl<Expr, State, Data>
    351341        {
    352342            typedef typename
    353                 proto::result_of::arg<
    354                     typename proto::result_of::arg_c<Expr, 1>::type
     343                proto::result_of::child<
     344                    typename proto::result_of::child_c<Expr, 1>::type
    355345                >::type
    356346            arg1;
    357347
    … …  
    359349                traits::make_component<
    360350                    Domain, Director
    361351                  , typename fusion::result_of::make_cons<arg1>::type
    362                   , Visitor
     352                  , Data
    363353                >
    364354            make_component;
    365355
    366             typedef typename make_component::type type;
    367         };
     356            typedef typename make_component::type result_type;
    368357
    369         template<typename Expr, typename State, typename Visitor>
    370         typename result<void(Expr, State, Visitor)>::type
    371         operator ()(Expr const& expr, State const&, Visitor&) const
    372         {
    373             typedef typename result<void(Expr, State, Visitor)>::make_component result;
    374             return result::call(fusion::make_cons(proto::arg(proto::arg_c<1>(expr))));
    375         }
     358            result_type operator ()(
     359                typename impl::expr_param   expr
     360              , typename impl::state_param  state
     361              , typename impl::data_param   data
     362            ) const
     363            {
     364                return make_component::call(fusion::make_cons(proto::child(proto::child_c<1>(expr))));
     365            }
     366        };
    376367    };
    377368
    378369    //  Same as compose_function1, except that DirectorF is a meta-function to
    379370    //  be evaluated to get the director
    380371    template <typename Grammar, typename Domain, typename DirectorF>
    381     struct compose_function1_eval : Grammar
     372    struct compose_function1_eval : proto::transform<compose_function1_eval<Grammar, Domain, DirectorF> >, Grammar
    382373    {
    383         template<typename Sig>
    384         struct result;
    385 
    386         template <typename This, typename Expr, typename State, typename Visitor>
    387         struct result<This(Expr, State, Visitor)>
     374        template<typename Expr, typename State, typename Data>
     375        struct impl : proto::transform_impl<Expr, State, Data>
    388376        {
    389377            typedef typename
    390                 proto::result_of::arg<
    391                     typename proto::result_of::arg_c<Expr, 0>::type
     378                proto::result_of::child<
     379                    typename proto::result_of::child_c<Expr, 0>::type
    392380                >::type
    393381            function;
    394382            typedef typename
    395                 proto::result_of::arg<
    396                     typename proto::result_of::arg_c<Expr, 1>::type
     383                proto::result_of::child<
     384                    typename proto::result_of::child_c<Expr, 1>::type
    397385                >::type
    398386            arg1;
    399387
    … …  
    402390                    Domain
    403391                  , typename mpl::apply2<DirectorF, function, arg1>::type
    404392                  , typename fusion::result_of::make_cons<arg1>::type
    405                   , Visitor
     393                  , Data
    406394                >
    407395            make_component;
    408396
    409             typedef typename make_component::type type;
    410         };
     397            typedef typename make_component::type result_type;
    411398
    412         template<typename Expr, typename State, typename Visitor>
    413         typename result<void(Expr, State, Visitor)>::type
    414         operator ()(Expr const& expr, State const&, Visitor&) const
    415         {
    416             typedef typename result<void(Expr, State, Visitor)>::make_component result;
    417             return result::call(
    418                 fusion::make_cons(proto::arg(proto::arg_c<1>(expr))));
    419         }
     399            result_type operator ()(
     400                typename impl::expr_param   expr
     401              , typename impl::state_param  state
     402              , typename impl::data_param   data
     403            ) const
     404            {
     405                return make_component::call(
     406                    fusion::make_cons(proto::child(proto::child_c<1>(expr))));
     407            }
     408        };
    420409    };
    421410
    422411    //  Same as compose_function1, except that the generated component holds
    423412    //  not only the function argument, but the function tag as well
    424413    template <typename Grammar, typename Domain, typename DirectorF>
    425     struct compose_function1_full : Grammar
     414    struct compose_function1_full : proto::transform<compose_function1_full<Grammar, Domain, DirectorF> >, Grammar
    426415    {
    427         template<typename Sig>
    428         struct result;
    429 
    430         template <typename This, typename Expr, typename State, typename Visitor>
    431         struct result<This(Expr, State, Visitor)>
     416        template<typename Expr, typename State, typename Data>
     417        struct impl : proto::transform_impl<Expr, State, Data>
    432418        {
    433419            typedef typename
    434                 proto::result_of::arg<
    435                     typename proto::result_of::arg_c<Expr, 0>::type
     420                proto::result_of::child<
     421                    typename proto::result_of::child_c<Expr, 0>::type
    436422                >::type
    437423            function;
     424
    438425            typedef typename
    439                 proto::result_of::arg<
    440                     typename proto::result_of::arg_c<Expr, 1>::type
     426                proto::result_of::child<
     427                    typename proto::result_of::child_c<Expr, 1>::type
    441428                >::type
    442429            arg1;
    443430
    … …  
    446433                    Domain
    447434                  , typename mpl::apply2<DirectorF, function, arg1>::type
    448435                  , typename fusion::result_of::make_list<function, arg1>::type
    449                   , Visitor
     436                  , Data
    450437                >
    451438            make_component;
    452439
    453             typedef typename make_component::type type;
    454         };
     440            typedef typename make_component::type result_type;
    455441
    456         template<typename Expr, typename State, typename Visitor>
    457         typename result<void(Expr, State, Visitor)>::type
    458         operator ()(Expr const& expr, State const& /*state*/, Visitor& /*visitor*/) const
    459         {
    460             typedef typename result<void(Expr, State, Visitor)>::make_component result;
    461             return result::call(fusion::make_list(
    462                     proto::arg(proto::arg_c<0>(expr)),
    463                     proto::arg(proto::arg_c<1>(expr))
    464                 ));
    465         }
     442            result_type operator ()(
     443                typename impl::expr_param   expr
     444              , typename impl::state_param
     445              , typename impl::data_param
     446            ) const
     447            {
     448                return make_component::call(fusion::make_list(
     449                        proto::child(proto::child_c<0>(expr)),
     450                        proto::child(proto::child_c<1>(expr))
     451                    ));
     452            }
     453        };
    466454    };
    467455
    468456    ///////////////////////////////////////////////////////////////////////////
    … …  
    470458    //  from a 2-arity proto function expression (e.g. f(x, y))
    471459    ///////////////////////////////////////////////////////////////////////////
    472460    template <typename Grammar, typename Domain, typename Director>
    473     struct compose_function2 : Grammar
     461    struct compose_function2 : proto::transform<compose_function2<Grammar, Domain, Director> >, Grammar
    474462    {
    475         template<typename Sig>
    476         struct result;
    477 
    478         template <typename This, typename Expr, typename State, typename Visitor>
    479         struct result<This(Expr, State, Visitor)>
     463        template<typename Expr, typename State, typename Data>
     464        struct impl : proto::transform_impl<Expr, State, Data>
    480465        {
    481466            typedef typename
    482                 proto::result_of::arg<
    483                     typename proto::result_of::arg_c<Expr, 1>::type
     467                proto::result_of::child<
     468                    typename proto::result_of::child_c<Expr, 1>::type
    484469                >::type
    485470            arg1;
    486471
    487472            typedef typename
    488                 proto::result_of::arg<
    489                     typename proto::result_of::arg_c<Expr, 2>::type
     473                proto::result_of::child<
     474                    typename proto::result_of::child_c<Expr, 2>::type
    490475                >::type
    491476            arg2;
    492477
    … …  
    494479                traits::make_component<
    495480                    Domain, Director
    496481                  , typename fusion::result_of::make_list<arg1, arg2>::type
    497                   , Visitor
     482                  , Data
    498483                >
    499484            make_component;
    500485
    501             typedef typename make_component::type type;
    502         };
     486            typedef typename make_component::type result_type;
    503487
    504         template<typename Expr, typename State, typename Visitor>
    505         typename result<void(Expr, State, Visitor)>::type
    506         operator ()(Expr const& expr, State const& /*state*/, Visitor& /*visitor*/) const
    507         {
    508             typedef typename result<void(Expr, State, Visitor)>::make_component result;
    509             return result::call(fusion::make_list(
    510                 proto::arg(proto::arg_c<1>(expr))
    511               , proto::arg(proto::arg_c<2>(expr))
    512             ));
    513         }
     488            result_type operator ()(
     489                typename impl::expr_param   expr
     490              , typename impl::state_param
     491              , typename impl::data_param
     492            ) const
     493            {
     494                return make_component::call(fusion::make_list(
     495                    proto::child(proto::child_c<1>(expr))
     496                  , proto::child(proto::child_c<2>(expr))
     497                ));
     498            }
     499        };
    514500    };
    515501
    516502    //  Same as compose_function2, except that DirectorF is a meta-function to
    517503    //  be evaluated to get the director
    518504    template <typename Grammar, typename Domain, typename DirectorF>
    519     struct compose_function2_eval : Grammar
     505    struct compose_function2_eval : proto::transform<compose_function2_eval<Grammar, Domain, DirectorF> >, Grammar
    520506    {
    521         template<typename Sig>
    522         struct result;
    523 
    524         template <typename This, typename Expr, typename State, typename Visitor>
    525         struct result<This(Expr, State, Visitor)>
     507        template<typename Expr, typename State, typename Data>
     508        struct impl : proto::transform_impl<Expr, State, Data>
    526509        {
    527510            typedef typename
    528                 proto::result_of::arg<
    529                     typename proto::result_of::arg_c<Expr, 0>::type
     511                proto::result_of::child<
     512                    typename proto::result_of::child_c<Expr, 0>::type
    530513                >::type
    531514            function;
     515
    532516            typedef typename
    533                 proto::result_of::arg<
    534                     typename proto::result_of::arg_c<Expr, 1>::type
     517                proto::result_of::child<
     518                    typename proto::result_of::child_c<Expr, 1>::type
    535519                >::type
    536520            arg1;
     521
    537522            typedef typename
    538                 proto::result_of::arg<
    539                     typename proto::result_of::arg_c<Expr, 2>::type
     523                proto::result_of::child<
     524                    typename proto::result_of::child_c<Expr, 2>::type
    540525                >::type
    541526            arg2;
    542527
    … …  
    545530                    Domain
    546531                  , typename mpl::apply2<DirectorF, function, arg1>::type
    547532                  , typename fusion::result_of::make_list<arg1, arg2>::type
    548                   , Visitor
     533                  , Data
    549534                >
    550535            make_component;
    551536
    552             typedef typename make_component::type type;
    553         };
     537            typedef typename make_component::type result_type;
    554538
    555         template<typename Expr, typename State, typename Visitor>
    556         typename result<void(Expr, State, Visitor)>::type
    557         operator ()(Expr const& expr, State const& /*state*/, Visitor& /*visitor*/) const
    558         {
    559             typedef typename result<void(Expr, State, Visitor)>::make_component result;
    560             return result::call(fusion::make_list(
    561                 proto::arg(proto::arg_c<1>(expr))
    562               , proto::arg(proto::arg_c<2>(expr))
    563             ));
    564         }
     539            result_type operator ()(
     540                typename impl::expr_param   expr
     541              , typename impl::state_param
     542              , typename impl::data_param
     543            ) const
     544            {
     545                return make_component::call(fusion::make_list(
     546                    proto::child(proto::child_c<1>(expr))
     547                  , proto::child(proto::child_c<2>(expr))
     548                ));
     549            }
     550        };
    565551    };
    566552
    567553    ///////////////////////////////////////////////////////////////////////////
    568554    //  A proto transform for directives. The directive (terminal) tag
    569     //  is pushed into the modifier state (the Visitor).
     555    //  is pushed into the modifier state (the Data).
    570556    ///////////////////////////////////////////////////////////////////////////
    571557    template <typename Grammar>
    572     struct compose_deep_directive : Grammar
     558    struct compose_deep_directive : proto::transform<compose_deep_directive<Grammar> >, Grammar
    573559    {
    574         template<typename Sig>
    575         struct result;
    576 
    577         template <typename This, typename Expr, typename State, typename Visitor>
    578         struct result<This(Expr, State, Visitor)>
     560        template<typename Expr, typename State, typename Data>
     561        struct impl : proto::transform_impl<Expr, State, Data>
    579562        {
    580563            typedef typename
    581564                add_modifier<
    582                     Visitor
    583                   , typename proto::result_of::arg<
    584                         typename proto::result_of::arg_c<Expr, 0>::type
     565                    Data
     566                  , typename proto::result_of::child<
     567                        typename proto::result_of::child_c<Expr, 0>::type
    585568                    >::type
    586569                >::type
    587570            modifier_type;
    588571
    589572            typedef typename
    590                 Grammar::template result<void(Expr, State, modifier_type)>::type
    591             type;
    592         };
     573                Grammar::template impl<Expr, State, modifier_type>::result_type
     574            result_type;
    593575
    594         template<typename Expr, typename State, typename Visitor>
    595         typename result<void(Expr, State, Visitor)>::type
    596         operator ()(Expr const& expr, State const& state, Visitor&) const
    597         {
    598             typename add_modifier<
    599                 Visitor
    600               , typename proto::result_of::arg<
    601                     typename proto::result_of::arg_c<Expr, 0>::type
    602                 >::type
    603             >::type
    604             modifier;
    605             return Grammar()(expr, state, modifier);
    606         }
     576            result_type operator ()(
     577                typename impl::expr_param   expr
     578              , typename impl::state_param  state
     579              , typename impl::data_param
     580            ) const
     581            {
     582                modifier_type modifier;
     583                return invoke_grammar<Grammar, Expr, State, modifier_type>()(expr, state, modifier);
     584            }
     585        };
    607586    };
    608587
    609588    ///////////////////////////////////////////////////////////////////////////
    … …  
    615594    //
    616595    ///////////////////////////////////////////////////////////////////////////
    617596    template <typename Grammar, typename Domain, typename Director>
    618     struct compose_subscript : Grammar
     597    struct compose_subscript : proto::transform<compose_subscript<Grammar, Domain, Director> >, Grammar
    619598    {
    620         template<typename Sig>
    621         struct result;
    622 
    623         template <typename This, typename Expr, typename State, typename Visitor>
    624         struct result<This(Expr, State, Visitor)>
     599        template<typename Expr, typename State, typename Data>
     600        struct impl : proto::transform_impl<Expr, State, Data>
    625601        {
    626602            // apply all grammar transformations mandated for the whole
    627603            // expression
    628604            typedef typename
    629                 Grammar::template result<void(Expr, State, Visitor)>::type
     605                Grammar::template impl<Expr, State, Data>::result_type
    630606            trans;
    631607
    632608            // this calculates the type of the directive
    633             typedef typename proto::result_of::arg_c<trans, 0>::type directive;
     609            typedef typename proto::result_of::child_c<trans, 0>::type directive;
    634610           
    635611            // this calculates the type of the embedded expression
    636             typedef typename proto::result_of::arg_c<trans, 1>::type embedded;
     612            typedef typename proto::result_of::child_c<trans, 1>::type embedded;
    637613           
    638614            // this is the type of the contained data
    639615            typedef fusion::list<embedded, directive> list_type;
    640616
    641617            typedef
    642                 traits::make_component<Domain, Director, list_type, Visitor>
     618                traits::make_component<Domain, Director, list_type, Data>
    643619            make_component;
    644620
    645             typedef typename make_component::type type;
    646         };
     621            typedef typename make_component::type result_type;
    647622
    648         template<typename Expr, typename State, typename Visitor>
    649         typename result<void(Expr, State, Visitor)>::type
    650         operator ()(Expr const& expr, State const& state, Visitor& visitor) const
    651         {
    652             typedef result<void(Expr, State, Visitor)> apply;
    653             typedef typename apply::make_component result;
    654             typedef typename apply::list_type list_type;
    655             typename apply::trans trans = Grammar()(expr, state, visitor);
    656 
    657             return result::call(
    658                 list_type(proto::arg_c<1>(trans), proto::arg_c<0>(trans)));
    659         }
     623            result_type operator ()(
     624                typename impl::expr_param   expr
     625              , typename impl::state_param  state
     626              , typename impl::data_param   data
     627            ) const
     628            {
     629                trans t = invoke_grammar<Grammar, Expr, State, Data>()(expr, state, data);
     630                return make_component::call(
     631                    list_type(proto::child_c<1>(t), proto::child_c<0>(t)));
     632            }
     633        };
    660634    };
    661635
    662636    ///////////////////////////////////////////////////////////////////////////
    … …  
    668642    //
    669643    ///////////////////////////////////////////////////////////////////////////
    670644    template <typename Grammar, typename Domain, typename Director>
    671     struct compose_subscript_function1 : Grammar
     645    struct compose_subscript_function1 : proto::transform<compose_subscript_function1<Grammar, Domain, Director> >, Grammar
    672646    {
    673         template<typename Sig>
    674         struct result;
    675 
    676         template <typename This, typename Expr, typename State, typename Visitor>
    677         struct result<This(Expr, State, Visitor)>
     647        template<typename Expr, typename State, typename Data>
     648        struct impl : proto::transform_impl<Expr, State, Data>
    678649        {
    679650            // apply all grammar transformations mandated for the whole
    680651            // expression
    681652            typedef typename
    682                 Grammar::template result<void(Expr, State, Visitor)>::type
     653                Grammar::template impl<Expr, State, Data>::result_type
    683654            trans;
    684655
    685656            // this calculates the type of the embedded expression
    686             typedef typename proto::result_of::arg_c<trans, 1>::type embedded;
     657            typedef typename proto::result_of::child_c<trans, 1>::type embedded;
    687658           
    688659            // this calculates the type of the argument of the function
    689660            typedef typename
    690                 proto::result_of::arg_c<
    691                     typename proto::result_of::arg_c<trans, 0>::type, 1
     661                proto::result_of::child_c<
     662                    typename proto::result_of::child_c<trans, 0>::type, 1
    692663                >::type
    693664            arg1;
    694665
    … …  
    699670                traits::make_component<
    700671                    Domain, Director,
    701672                    list_type,
    702                     Visitor
     673                    Data
    703674                >
    704675            make_component;
    705676
    706             typedef typename make_component::type type;
    707         };
     677            typedef typename make_component::type result_type;
    708678
    709         template<typename Expr, typename State, typename Visitor>
    710         typename result<void(Expr, State, Visitor)>::type
    711         operator ()(Expr const& expr, State const& state, Visitor& visitor) const
    712         {
    713             typedef result<void(Expr, State, Visitor)> apply;
    714             typedef typename apply::make_component result;
    715             typedef typename apply::list_type list_type;
    716             typename apply::trans trans = Grammar()(expr, state, visitor);
     679            result_type operator ()(
     680                typename impl::expr_param   expr
     681              , typename impl::state_param  state
     682              , typename impl::data_param   data
     683            ) const
     684            {
     685                trans t = invoke_grammar<Grammar, Expr, State, Data>()(expr, state, data);
    717686
    718             return result::call(list_type(
    719                 proto::arg_c<1>(trans),
    720                 proto::arg_c<1>(proto::arg_c<0>(trans))));
    721         }
     687                return make_component::call(list_type(
     688                    proto::child_c<1>(t),
     689                    proto::child_c<1>(proto::child_c<0>(t))));
     690            }
     691        };
    722692    };
    723693
    724694    ///////////////////////////////////////////////////////////////////////////
    … …  
    730700    //
    731701    ///////////////////////////////////////////////////////////////////////////
    732702    template <typename Grammar, typename Domain, typename Director>
    733     struct compose_subscript_function2 : Grammar
     703    struct compose_subscript_function2 : proto::transform<compose_subscript_function2<Grammar, Domain, Director> >, Grammar
    734704    {
    735         template<typename Sig>
    736         struct result;
    737 
    738         template <typename This, typename Expr, typename State, typename Visitor>
    739         struct result<This(Expr, State, Visitor)>
     705        template<typename Expr, typename State, typename Data>
     706        struct impl : proto::transform_impl<Expr, State, Data>
    740707        {
    741708            // apply all grammar transformations mandated for the whole
    742709            // expression
    743710            typedef typename
    744                 Grammar::template result<void(Expr, State, Visitor)>::type
     711                Grammar::template impl<Expr, State, Data>::result_type
    745712            trans;
    746713
    747714            // this calculates the types of the arguments of the function
    748             typedef typename proto::result_of::arg_c<trans, 0>::type arg0;
    749             typedef typename proto::result_of::arg_c<arg0, 1>::type arg1;
    750             typedef typename proto::result_of::arg_c<arg0, 2>::type arg2;
     715            typedef typename proto::result_of::child_c<trans, 0>::type arg0;
     716            typedef typename proto::result_of::child_c<arg0, 1>::type arg1;
     717            typedef typename proto::result_of::child_c<arg0, 2>::type arg2;
    751718
    752719            // this calculates the type of the embedded expression
    753             typedef typename proto::result_of::arg_c<trans, 1>::type embedded;
     720            typedef typename proto::result_of::child_c<trans, 1>::type embedded;
    754721            typedef fusion::list<embedded, arg1, arg2> list_type;
    755722
    756723            typedef
    757724                traits::make_component<
    758725                    Domain, Director,
    759726                    list_type,
    760                     Visitor
     727                    Data
    761728                >
    762729            make_component;
    763730
    764             typedef typename make_component::type type;
    765         };
     731            typedef typename make_component::type result_type;
    766732
    767         template<typename Expr, typename State, typename Visitor>
    768         typename result<void(Expr, State, Visitor)>::type
    769         operator ()(Expr const& expr, State const& state, Visitor& visitor) const
    770         {
    771             typedef result<void(Expr, State, Visitor)> apply;
    772             typedef typename apply::make_component result;
    773             typedef typename apply::list_type list_type;
    774             typename apply::trans trans = Grammar()(expr, state, visitor);
    775             typename apply::arg0 arg0 = proto::arg_c<0>(trans);
     733            result_type operator ()(
     734                typename impl::expr_param   expr
     735              , typename impl::state_param  state
     736              , typename impl::data_param   data
     737            ) const
     738            {
     739                trans t = invoke_grammar<Grammar, Expr, State, Data>()(expr, state, data);
     740                arg0 a0 = proto::child_c<0>(t);
    776741
    777             return result::call(list_type(
    778                 proto::arg_c<1>(trans), proto::arg_c<1>(arg0),
    779                 proto::arg_c<2>(arg0)));
    780         }
     742                return make_component::call(list_type(
     743                    proto::child_c<1>(t), proto::child_c<1>(a0),
     744                    proto::child_c<2>(a0)));
     745            }
     746        };
    781747    };
    782748
    783749}}}

  • home/support/iso8859_1.hpp

     
    88#define SPIRIT_ISO8859_1_JAN_31_2006_0529PM
    99
    1010#include <boost/spirit/home/support/char_class.hpp>
    11 #include <boost/xpressive/proto/proto.hpp>
     11#include <boost/proto/core.hpp>
    1212
    1313namespace boost { namespace spirit { namespace iso8859_1
    1414{

  • home/support/standard_wide.hpp

     
    88#define SPIRIT_STANDARD_WIDE_JAN_31_2006_0529PM
    99
    1010#include <boost/spirit/home/support/char_class.hpp>
    11 #include <boost/xpressive/proto/proto.hpp>
     11#include <boost/proto/core.hpp>
    1212
    1313namespace boost { namespace spirit { namespace standard_wide
    1414{

  • home/support/auxiliary/functor_holder.hpp

     
    1010#pragma once      // MS compatible compilers support #pragma once
    1111#endif
    1212
    13 #include <boost/xpressive/proto/proto.hpp>
     13#include <boost/proto/core.hpp>
    1414
    1515namespace boost { namespace spirit
    1616{

  • home/support/ascii.hpp

     
    88#define SPIRIT_ASCII_JAN_31_2006_0529PM
    99
    1010#include <boost/spirit/home/support/char_class.hpp>
    11 #include <boost/xpressive/proto/proto.hpp>
     11#include <boost/proto/core.hpp>
    1212
    1313namespace boost { namespace spirit { namespace ascii
    1414{