detail/preprocessed/expr_variadic.hpp

0001     ///////////////////////////////////////////////////////////////////////////////
0002     /// \file expr_variadic.hpp
0003     /// Contains definition of expr\<\> class template.
0004     //
0005     //  Copyright 2008 Eric Niebler. Distributed under the Boost
0006     //  Software License, Version 1.0. (See accompanying file
0007     //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023
0024
0025
0026
0027
0028
0029
0030
0031
0032
0033
0034
0035
0036     template<typename Tag, typename Arg0>
0037     struct expr<Tag, term<Arg0>, 0>
0038     {
0039         typedef Tag proto_tag;
0040         static const long proto_arity_c = 0;
0041         typedef mpl::long_<0 > proto_arity;
0042         typedef expr proto_base_expr;
0043         typedef term<Arg0> proto_args;
0044         typedef basic_expr<Tag, proto_args, 0 > proto_grammar;
0045         typedef default_domain proto_domain;
0046         typedef default_generator proto_generator;
0047         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
0048         typedef expr proto_derived_expr;
0049         typedef void proto_is_expr_;
0050         typedef Arg0 proto_child0; proto_child0 child0;
0051         typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
0052
0053
0054         BOOST_FORCEINLINE
0055         expr const &proto_base() const
0056         {
0057             return *this;
0058         }
0059
0060
0061         BOOST_FORCEINLINE
0062         expr &proto_base()
0063         {
0064             return *this;
0065         }
0066
0067
0068
0069         template<typename A0>
0070         BOOST_FORCEINLINE
0071         static expr const make(A0 &a0)
0072         {
0073             return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0));
0074         }
0075
0076
0077         template<typename A0>
0078         BOOST_FORCEINLINE
0079         static expr const make(A0 const &a0)
0080         {
0081             return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0));
0082         }
0083
0084
0085         typedef detail::not_a_valid_type address_of_hack_type_;
0086
0087
0088
0089
0090         BOOST_FORCEINLINE
0091         proto::expr<
0092             proto::tag::assign
0093           , list2<expr &, expr const &>
0094           , 2
0095         > const
0096         operator =(expr const &a)
0097         {
0098             proto::expr<
0099                 proto::tag::assign
0100               , list2<expr &, expr const &>
0101               , 2
0102             > that = {*this, a};
0103             return that;
0104         }
0105
0106
0107
0108
0109         template<typename A>
0110         BOOST_FORCEINLINE
0111         proto::expr<
0112             proto::tag::assign
0113           , list2<expr const &, typename result_of::as_child<A>::type>
0114           , 2
0115         > const
0116         operator =(A &a) const
0117         {
0118             proto::expr<
0119                 proto::tag::assign
0120               , list2<expr const &, typename result_of::as_child<A>::type>
0121               , 2
0122             > that = {*this, proto::as_child(a)};
0123             return that;
0124         }
0125
0126
0127         template<typename A>
0128         BOOST_FORCEINLINE
0129         proto::expr<
0130             proto::tag::assign
0131           , list2<expr const &, typename result_of::as_child<A const>::type>
0132           , 2
0133         > const
0134         operator =(A const &a) const
0135         {
0136             proto::expr<
0137                 proto::tag::assign
0138               , list2<expr const &, typename result_of::as_child<A const>::type>
0139               , 2
0140             > that = {*this, proto::as_child(a)};
0141             return that;
0142         }
0143
0144
0145         template<typename A>
0146         BOOST_FORCEINLINE
0147         proto::expr<
0148             proto::tag::assign
0149           , list2<expr &, typename result_of::as_child<A>::type>
0150           , 2
0151         > const
0152         operator =(A &a)
0153         {
0154             proto::expr<
0155                 proto::tag::assign
0156               , list2<expr &, typename result_of::as_child<A>::type>
0157               , 2
0158             > that = {*this, proto::as_child(a)};
0159             return that;
0160         }
0161
0162
0163         template<typename A>
0164         BOOST_FORCEINLINE
0165         proto::expr<
0166             proto::tag::assign
0167           , list2<expr &, typename result_of::as_child<A const>::type>
0168           , 2
0169         > const
0170         operator =(A const &a)
0171         {
0172             proto::expr<
0173                 proto::tag::assign
0174               , list2<expr &, typename result_of::as_child<A const>::type>
0175               , 2
0176             > that = {*this, proto::as_child(a)};
0177             return that;
0178         }
0179
0180
0181
0182
0183         template<typename A>
0184         BOOST_FORCEINLINE
0185         proto::expr<
0186             proto::tag::subscript
0187           , list2<expr const &, typename result_of::as_child<A>::type>
0188           , 2
0189         > const
0190         operator [](A &a) const
0191         {
0192             proto::expr<
0193                 proto::tag::subscript
0194               , list2<expr const &, typename result_of::as_child<A>::type>
0195               , 2
0196             > that = {*this, proto::as_child(a)};
0197             return that;
0198         }
0199
0200
0201         template<typename A>
0202         BOOST_FORCEINLINE
0203         proto::expr<
0204             proto::tag::subscript
0205           , list2<expr const &, typename result_of::as_child<A const>::type>
0206           , 2
0207         > const
0208         operator [](A const &a) const
0209         {
0210             proto::expr<
0211                 proto::tag::subscript
0212               , list2<expr const &, typename result_of::as_child<A const>::type>
0213               , 2
0214             > that = {*this, proto::as_child(a)};
0215             return that;
0216         }
0217
0218
0219         template<typename A>
0220         BOOST_FORCEINLINE
0221         proto::expr<
0222             proto::tag::subscript
0223           , list2<expr &, typename result_of::as_child<A>::type>
0224           , 2
0225         > const
0226         operator [](A &a)
0227         {
0228             proto::expr<
0229                 proto::tag::subscript
0230               , list2<expr &, typename result_of::as_child<A>::type>
0231               , 2
0232             > that = {*this, proto::as_child(a)};
0233             return that;
0234         }
0235
0236
0237         template<typename A>
0238         BOOST_FORCEINLINE
0239         proto::expr<
0240             proto::tag::subscript
0241           , list2<expr &, typename result_of::as_child<A const>::type>
0242           , 2
0243         > const
0244         operator [](A const &a)
0245         {
0246             proto::expr<
0247                 proto::tag::subscript
0248               , list2<expr &, typename result_of::as_child<A const>::type>
0249               , 2
0250             > that = {*this, proto::as_child(a)};
0251             return that;
0252         }
0253
0254
0255         template<typename Sig>
0256         struct result
0257         {
0258             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
0259         };
0260
0261
0262         template<typename ...A>
0263         BOOST_FORCEINLINE
0264         typename result_of::funop<
0265             expr const(A const &...)
0266           , expr
0267           , default_domain
0268         >::type const
0269         operator ()(A const &... a) const
0270         {
0271             return result_of::funop<
0272                 expr const(A const &...)
0273               , expr
0274               , default_domain
0275             >::call(*this, a...);
0276         }
0277
0278
0279         template<typename ...A>
0280         BOOST_FORCEINLINE
0281         typename result_of::funop<
0282             expr(A const &...)
0283           , expr
0284           , default_domain
0285         >::type const
0286         operator ()(A const &... a)
0287         {
0288             return result_of::funop<
0289                 expr(A const &...)
0290               , expr
0291               , default_domain
0292             >::call(*this, a...);
0293         }
0294     };
0295
0296
0297
0298
0299
0300
0301
0302
0303
0304
0305
0306
0307
0308
0309
0310
0311
0312
0313
0314
0315
0316
0317
0318
0319
0320
0321
0322     template<typename Tag , typename Arg0>
0323     struct expr<Tag, list1<Arg0>, 1 >
0324     {
0325         typedef Tag proto_tag;
0326         static const long proto_arity_c = 1;
0327         typedef mpl::long_<1 > proto_arity;
0328         typedef expr proto_base_expr;
0329         typedef list1<Arg0> proto_args;
0330         typedef basic_expr<Tag, proto_args, 1 > proto_grammar;
0331         typedef default_domain proto_domain;
0332         typedef default_generator proto_generator;
0333         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
0334         typedef expr proto_derived_expr;
0335         typedef void proto_is_expr_;
0336         typedef Arg0 proto_child0; proto_child0 child0;
0337         typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
0338
0339
0340         BOOST_FORCEINLINE
0341         expr const &proto_base() const
0342         {
0343             return *this;
0344         }
0345
0346
0347         BOOST_FORCEINLINE
0348         expr &proto_base()
0349         {
0350             return *this;
0351         }
0352
0353
0354
0355         template<typename A0>
0356         BOOST_FORCEINLINE
0357         static expr const make(A0 const &a0)
0358         {
0359             expr that = {a0};
0360             return that;
0361         }
0362
0363
0364
0365         typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_;
0366
0367
0368
0369
0370
0371
0372
0373         BOOST_FORCEINLINE
0374         operator address_of_hack_type_() const
0375         {
0376             return boost::addressof(this->child0);
0377         }
0378
0379
0380
0381
0382         BOOST_FORCEINLINE
0383         proto::expr<
0384             proto::tag::assign
0385           , list2<expr &, expr const &>
0386           , 2
0387         > const
0388         operator =(expr const &a)
0389         {
0390             proto::expr<
0391                 proto::tag::assign
0392               , list2<expr &, expr const &>
0393               , 2
0394             > that = {*this, a};
0395             return that;
0396         }
0397
0398
0399
0400
0401         template<typename A>
0402         BOOST_FORCEINLINE
0403         proto::expr<
0404             proto::tag::assign
0405           , list2<expr const &, typename result_of::as_child<A>::type>
0406           , 2
0407         > const
0408         operator =(A &a) const
0409         {
0410             proto::expr<
0411                 proto::tag::assign
0412               , list2<expr const &, typename result_of::as_child<A>::type>
0413               , 2
0414             > that = {*this, proto::as_child(a)};
0415             return that;
0416         }
0417
0418
0419         template<typename A>
0420         BOOST_FORCEINLINE
0421         proto::expr<
0422             proto::tag::assign
0423           , list2<expr const &, typename result_of::as_child<A const>::type>
0424           , 2
0425         > const
0426         operator =(A const &a) const
0427         {
0428             proto::expr<
0429                 proto::tag::assign
0430               , list2<expr const &, typename result_of::as_child<A const>::type>
0431               , 2
0432             > that = {*this, proto::as_child(a)};
0433             return that;
0434         }
0435
0436
0437
0438
0439         template<typename A>
0440         BOOST_FORCEINLINE
0441         proto::expr<
0442             proto::tag::subscript
0443           , list2<expr const &, typename result_of::as_child<A>::type>
0444           , 2
0445         > const
0446         operator [](A &a) const
0447         {
0448             proto::expr<
0449                 proto::tag::subscript
0450               , list2<expr const &, typename result_of::as_child<A>::type>
0451               , 2
0452             > that = {*this, proto::as_child(a)};
0453             return that;
0454         }
0455
0456
0457         template<typename A>
0458         BOOST_FORCEINLINE
0459         proto::expr<
0460             proto::tag::subscript
0461           , list2<expr const &, typename result_of::as_child<A const>::type>
0462           , 2
0463         > const
0464         operator [](A const &a) const
0465         {
0466             proto::expr<
0467                 proto::tag::subscript
0468               , list2<expr const &, typename result_of::as_child<A const>::type>
0469               , 2
0470             > that = {*this, proto::as_child(a)};
0471             return that;
0472         }
0473
0474
0475         template<typename Sig>
0476         struct result
0477         {
0478             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
0479         };
0480
0481
0482         template<typename ...A>
0483         BOOST_FORCEINLINE
0484         typename result_of::funop<
0485             expr const(A const &...)
0486           , expr
0487           , default_domain
0488         >::type const
0489         operator ()(A const &... a) const
0490         {
0491             return result_of::funop<
0492                 expr const(A const &...)
0493               , expr
0494               , default_domain
0495             >::call(*this, a...);
0496         }
0497     };
0498
0499
0500
0501
0502
0503
0504
0505
0506
0507
0508
0509
0510
0511
0512
0513
0514
0515
0516
0517
0518
0519
0520
0521
0522
0523
0524
0525     template<typename Tag , typename Arg0 , typename Arg1>
0526     struct expr<Tag, list2<Arg0 , Arg1>, 2 >
0527     {
0528         typedef Tag proto_tag;
0529         static const long proto_arity_c = 2;
0530         typedef mpl::long_<2 > proto_arity;
0531         typedef expr proto_base_expr;
0532         typedef list2<Arg0 , Arg1> proto_args;
0533         typedef basic_expr<Tag, proto_args, 2 > proto_grammar;
0534         typedef default_domain proto_domain;
0535         typedef default_generator proto_generator;
0536         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
0537         typedef expr proto_derived_expr;
0538         typedef void proto_is_expr_;
0539         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1;
0540         typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
0541
0542
0543         BOOST_FORCEINLINE
0544         expr const &proto_base() const
0545         {
0546             return *this;
0547         }
0548
0549
0550         BOOST_FORCEINLINE
0551         expr &proto_base()
0552         {
0553             return *this;
0554         }
0555
0556
0557
0558         template<typename A0 , typename A1>
0559         BOOST_FORCEINLINE
0560         static expr const make(A0 const &a0 , A1 const &a1)
0561         {
0562             expr that = {a0 , a1};
0563             return that;
0564         }
0565
0566
0567         typedef detail::not_a_valid_type address_of_hack_type_;
0568
0569
0570
0571
0572         BOOST_FORCEINLINE
0573         proto::expr<
0574             proto::tag::assign
0575           , list2<expr &, expr const &>
0576           , 2
0577         > const
0578         operator =(expr const &a)
0579         {
0580             proto::expr<
0581                 proto::tag::assign
0582               , list2<expr &, expr const &>
0583               , 2
0584             > that = {*this, a};
0585             return that;
0586         }
0587
0588
0589
0590
0591         template<typename A>
0592         BOOST_FORCEINLINE
0593         proto::expr<
0594             proto::tag::assign
0595           , list2<expr const &, typename result_of::as_child<A>::type>
0596           , 2
0597         > const
0598         operator =(A &a) const
0599         {
0600             proto::expr<
0601                 proto::tag::assign
0602               , list2<expr const &, typename result_of::as_child<A>::type>
0603               , 2
0604             > that = {*this, proto::as_child(a)};
0605             return that;
0606         }
0607
0608
0609         template<typename A>
0610         BOOST_FORCEINLINE
0611         proto::expr<
0612             proto::tag::assign
0613           , list2<expr const &, typename result_of::as_child<A const>::type>
0614           , 2
0615         > const
0616         operator =(A const &a) const
0617         {
0618             proto::expr<
0619                 proto::tag::assign
0620               , list2<expr const &, typename result_of::as_child<A const>::type>
0621               , 2
0622             > that = {*this, proto::as_child(a)};
0623             return that;
0624         }
0625
0626
0627
0628
0629         template<typename A>
0630         BOOST_FORCEINLINE
0631         proto::expr<
0632             proto::tag::subscript
0633           , list2<expr const &, typename result_of::as_child<A>::type>
0634           , 2
0635         > const
0636         operator [](A &a) const
0637         {
0638             proto::expr<
0639                 proto::tag::subscript
0640               , list2<expr const &, typename result_of::as_child<A>::type>
0641               , 2
0642             > that = {*this, proto::as_child(a)};
0643             return that;
0644         }
0645
0646
0647         template<typename A>
0648         BOOST_FORCEINLINE
0649         proto::expr<
0650             proto::tag::subscript
0651           , list2<expr const &, typename result_of::as_child<A const>::type>
0652           , 2
0653         > const
0654         operator [](A const &a) const
0655         {
0656             proto::expr<
0657                 proto::tag::subscript
0658               , list2<expr const &, typename result_of::as_child<A const>::type>
0659               , 2
0660             > that = {*this, proto::as_child(a)};
0661             return that;
0662         }
0663
0664
0665         template<typename Sig>
0666         struct result
0667         {
0668             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
0669         };
0670
0671
0672         template<typename ...A>
0673         BOOST_FORCEINLINE
0674         typename result_of::funop<
0675             expr const(A const &...)
0676           , expr
0677           , default_domain
0678         >::type const
0679         operator ()(A const &... a) const
0680         {
0681             return result_of::funop<
0682                 expr const(A const &...)
0683               , expr
0684               , default_domain
0685             >::call(*this, a...);
0686         }
0687     };
0688
0689
0690
0691
0692
0693
0694
0695
0696
0697
0698
0699
0700
0701
0702
0703
0704
0705
0706
0707
0708
0709
0710
0711
0712
0713
0714
0715     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2>
0716     struct expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3 >
0717     {
0718         typedef Tag proto_tag;
0719         static const long proto_arity_c = 3;
0720         typedef mpl::long_<3 > proto_arity;
0721         typedef expr proto_base_expr;
0722         typedef list3<Arg0 , Arg1 , Arg2> proto_args;
0723         typedef basic_expr<Tag, proto_args, 3 > proto_grammar;
0724         typedef default_domain proto_domain;
0725         typedef default_generator proto_generator;
0726         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
0727         typedef expr proto_derived_expr;
0728         typedef void proto_is_expr_;
0729         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2;
0730         typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
0731
0732
0733         BOOST_FORCEINLINE
0734         expr const &proto_base() const
0735         {
0736             return *this;
0737         }
0738
0739
0740         BOOST_FORCEINLINE
0741         expr &proto_base()
0742         {
0743             return *this;
0744         }
0745
0746
0747
0748         template<typename A0 , typename A1 , typename A2>
0749         BOOST_FORCEINLINE
0750         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2)
0751         {
0752             expr that = {a0 , a1 , a2};
0753             return that;
0754         }
0755
0756
0757         typedef detail::not_a_valid_type address_of_hack_type_;
0758
0759
0760
0761
0762         BOOST_FORCEINLINE
0763         proto::expr<
0764             proto::tag::assign
0765           , list2<expr &, expr const &>
0766           , 2
0767         > const
0768         operator =(expr const &a)
0769         {
0770             proto::expr<
0771                 proto::tag::assign
0772               , list2<expr &, expr const &>
0773               , 2
0774             > that = {*this, a};
0775             return that;
0776         }
0777
0778
0779
0780
0781         template<typename A>
0782         BOOST_FORCEINLINE
0783         proto::expr<
0784             proto::tag::assign
0785           , list2<expr const &, typename result_of::as_child<A>::type>
0786           , 2
0787         > const
0788         operator =(A &a) const
0789         {
0790             proto::expr<
0791                 proto::tag::assign
0792               , list2<expr const &, typename result_of::as_child<A>::type>
0793               , 2
0794             > that = {*this, proto::as_child(a)};
0795             return that;
0796         }
0797
0798
0799         template<typename A>
0800         BOOST_FORCEINLINE
0801         proto::expr<
0802             proto::tag::assign
0803           , list2<expr const &, typename result_of::as_child<A const>::type>
0804           , 2
0805         > const
0806         operator =(A const &a) const
0807         {
0808             proto::expr<
0809                 proto::tag::assign
0810               , list2<expr const &, typename result_of::as_child<A const>::type>
0811               , 2
0812             > that = {*this, proto::as_child(a)};
0813             return that;
0814         }
0815
0816
0817
0818
0819         template<typename A>
0820         BOOST_FORCEINLINE
0821         proto::expr<
0822             proto::tag::subscript
0823           , list2<expr const &, typename result_of::as_child<A>::type>
0824           , 2
0825         > const
0826         operator [](A &a) const
0827         {
0828             proto::expr<
0829                 proto::tag::subscript
0830               , list2<expr const &, typename result_of::as_child<A>::type>
0831               , 2
0832             > that = {*this, proto::as_child(a)};
0833             return that;
0834         }
0835
0836
0837         template<typename A>
0838         BOOST_FORCEINLINE
0839         proto::expr<
0840             proto::tag::subscript
0841           , list2<expr const &, typename result_of::as_child<A const>::type>
0842           , 2
0843         > const
0844         operator [](A const &a) const
0845         {
0846             proto::expr<
0847                 proto::tag::subscript
0848               , list2<expr const &, typename result_of::as_child<A const>::type>
0849               , 2
0850             > that = {*this, proto::as_child(a)};
0851             return that;
0852         }
0853
0854
0855         template<typename Sig>
0856         struct result
0857         {
0858             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
0859         };
0860
0861
0862         template<typename ...A>
0863         BOOST_FORCEINLINE
0864         typename result_of::funop<
0865             expr const(A const &...)
0866           , expr
0867           , default_domain
0868         >::type const
0869         operator ()(A const &... a) const
0870         {
0871             return result_of::funop<
0872                 expr const(A const &...)
0873               , expr
0874               , default_domain
0875             >::call(*this, a...);
0876         }
0877     };
0878
0879
0880
0881
0882
0883
0884
0885
0886
0887
0888
0889
0890
0891
0892
0893
0894
0895
0896
0897
0898
0899
0900
0901
0902
0903
0904
0905     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3>
0906     struct expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4 >
0907     {
0908         typedef Tag proto_tag;
0909         static const long proto_arity_c = 4;
0910         typedef mpl::long_<4 > proto_arity;
0911         typedef expr proto_base_expr;
0912         typedef list4<Arg0 , Arg1 , Arg2 , Arg3> proto_args;
0913         typedef basic_expr<Tag, proto_args, 4 > proto_grammar;
0914         typedef default_domain proto_domain;
0915         typedef default_generator proto_generator;
0916         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
0917         typedef expr proto_derived_expr;
0918         typedef void proto_is_expr_;
0919         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3;
0920         typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
0921
0922
0923         BOOST_FORCEINLINE
0924         expr const &proto_base() const
0925         {
0926             return *this;
0927         }
0928
0929
0930         BOOST_FORCEINLINE
0931         expr &proto_base()
0932         {
0933             return *this;
0934         }
0935
0936
0937
0938         template<typename A0 , typename A1 , typename A2 , typename A3>
0939         BOOST_FORCEINLINE
0940         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3)
0941         {
0942             expr that = {a0 , a1 , a2 , a3};
0943             return that;
0944         }
0945
0946
0947         typedef detail::not_a_valid_type address_of_hack_type_;
0948
0949
0950
0951
0952         BOOST_FORCEINLINE
0953         proto::expr<
0954             proto::tag::assign
0955           , list2<expr &, expr const &>
0956           , 2
0957         > const
0958         operator =(expr const &a)
0959         {
0960             proto::expr<
0961                 proto::tag::assign
0962               , list2<expr &, expr const &>
0963               , 2
0964             > that = {*this, a};
0965             return that;
0966         }
0967
0968
0969
0970
0971         template<typename A>
0972         BOOST_FORCEINLINE
0973         proto::expr<
0974             proto::tag::assign
0975           , list2<expr const &, typename result_of::as_child<A>::type>
0976           , 2
0977         > const
0978         operator =(A &a) const
0979         {
0980             proto::expr<
0981                 proto::tag::assign
0982               , list2<expr const &, typename result_of::as_child<A>::type>
0983               , 2
0984             > that = {*this, proto::as_child(a)};
0985             return that;
0986         }
0987
0988
0989         template<typename A>
0990         BOOST_FORCEINLINE
0991         proto::expr<
0992             proto::tag::assign
0993           , list2<expr const &, typename result_of::as_child<A const>::type>
0994           , 2
0995         > const
0996         operator =(A const &a) const
0997         {
0998             proto::expr<
0999                 proto::tag::assign
1000               , list2<expr const &, typename result_of::as_child<A const>::type>
1001               , 2
1002             > that = {*this, proto::as_child(a)};
1003             return that;
1004         }
1005
1006
1007
1008
1009         template<typename A>
1010         BOOST_FORCEINLINE
1011         proto::expr<
1012             proto::tag::subscript
1013           , list2<expr const &, typename result_of::as_child<A>::type>
1014           , 2
1015         > const
1016         operator [](A &a) const
1017         {
1018             proto::expr<
1019                 proto::tag::subscript
1020               , list2<expr const &, typename result_of::as_child<A>::type>
1021               , 2
1022             > that = {*this, proto::as_child(a)};
1023             return that;
1024         }
1025
1026
1027         template<typename A>
1028         BOOST_FORCEINLINE
1029         proto::expr<
1030             proto::tag::subscript
1031           , list2<expr const &, typename result_of::as_child<A const>::type>
1032           , 2
1033         > const
1034         operator [](A const &a) const
1035         {
1036             proto::expr<
1037                 proto::tag::subscript
1038               , list2<expr const &, typename result_of::as_child<A const>::type>
1039               , 2
1040             > that = {*this, proto::as_child(a)};
1041             return that;
1042         }
1043
1044
1045         template<typename Sig>
1046         struct result
1047         {
1048             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
1049         };
1050
1051
1052         template<typename ...A>
1053         BOOST_FORCEINLINE
1054         typename result_of::funop<
1055             expr const(A const &...)
1056           , expr
1057           , default_domain
1058         >::type const
1059         operator ()(A const &... a) const
1060         {
1061             return result_of::funop<
1062                 expr const(A const &...)
1063               , expr
1064               , default_domain
1065             >::call(*this, a...);
1066         }
1067     };
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4>
1096     struct expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5 >
1097     {
1098         typedef Tag proto_tag;
1099         static const long proto_arity_c = 5;
1100         typedef mpl::long_<5 > proto_arity;
1101         typedef expr proto_base_expr;
1102         typedef list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4> proto_args;
1103         typedef basic_expr<Tag, proto_args, 5 > proto_grammar;
1104         typedef default_domain proto_domain;
1105         typedef default_generator proto_generator;
1106         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
1107         typedef expr proto_derived_expr;
1108         typedef void proto_is_expr_;
1109         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4;
1110         typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
1111
1112
1113         BOOST_FORCEINLINE
1114         expr const &proto_base() const
1115         {
1116             return *this;
1117         }
1118
1119
1120         BOOST_FORCEINLINE
1121         expr &proto_base()
1122         {
1123             return *this;
1124         }
1125
1126
1127
1128         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
1129         BOOST_FORCEINLINE
1130         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4)
1131         {
1132             expr that = {a0 , a1 , a2 , a3 , a4};
1133             return that;
1134         }
1135
1136
1137         typedef detail::not_a_valid_type address_of_hack_type_;
1138
1139
1140
1141
1142         BOOST_FORCEINLINE
1143         proto::expr<
1144             proto::tag::assign
1145           , list2<expr &, expr const &>
1146           , 2
1147         > const
1148         operator =(expr const &a)
1149         {
1150             proto::expr<
1151                 proto::tag::assign
1152               , list2<expr &, expr const &>
1153               , 2
1154             > that = {*this, a};
1155             return that;
1156         }
1157
1158
1159
1160
1161         template<typename A>
1162         BOOST_FORCEINLINE
1163         proto::expr<
1164             proto::tag::assign
1165           , list2<expr const &, typename result_of::as_child<A>::type>
1166           , 2
1167         > const
1168         operator =(A &a) const
1169         {
1170             proto::expr<
1171                 proto::tag::assign
1172               , list2<expr const &, typename result_of::as_child<A>::type>
1173               , 2
1174             > that = {*this, proto::as_child(a)};
1175             return that;
1176         }
1177
1178
1179         template<typename A>
1180         BOOST_FORCEINLINE
1181         proto::expr<
1182             proto::tag::assign
1183           , list2<expr const &, typename result_of::as_child<A const>::type>
1184           , 2
1185         > const
1186         operator =(A const &a) const
1187         {
1188             proto::expr<
1189                 proto::tag::assign
1190               , list2<expr const &, typename result_of::as_child<A const>::type>
1191               , 2
1192             > that = {*this, proto::as_child(a)};
1193             return that;
1194         }
1195
1196
1197
1198
1199         template<typename A>
1200         BOOST_FORCEINLINE
1201         proto::expr<
1202             proto::tag::subscript
1203           , list2<expr const &, typename result_of::as_child<A>::type>
1204           , 2
1205         > const
1206         operator [](A &a) const
1207         {
1208             proto::expr<
1209                 proto::tag::subscript
1210               , list2<expr const &, typename result_of::as_child<A>::type>
1211               , 2
1212             > that = {*this, proto::as_child(a)};
1213             return that;
1214         }
1215
1216
1217         template<typename A>
1218         BOOST_FORCEINLINE
1219         proto::expr<
1220             proto::tag::subscript
1221           , list2<expr const &, typename result_of::as_child<A const>::type>
1222           , 2
1223         > const
1224         operator [](A const &a) const
1225         {
1226             proto::expr<
1227                 proto::tag::subscript
1228               , list2<expr const &, typename result_of::as_child<A const>::type>
1229               , 2
1230             > that = {*this, proto::as_child(a)};
1231             return that;
1232         }
1233
1234
1235         template<typename Sig>
1236         struct result
1237         {
1238             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
1239         };
1240
1241
1242         template<typename ...A>
1243         BOOST_FORCEINLINE
1244         typename result_of::funop<
1245             expr const(A const &...)
1246           , expr
1247           , default_domain
1248         >::type const
1249         operator ()(A const &... a) const
1250         {
1251             return result_of::funop<
1252                 expr const(A const &...)
1253               , expr
1254               , default_domain
1255             >::call(*this, a...);
1256         }
1257     };
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5>
1286     struct expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6 >
1287     {
1288         typedef Tag proto_tag;
1289         static const long proto_arity_c = 6;
1290         typedef mpl::long_<6 > proto_arity;
1291         typedef expr proto_base_expr;
1292         typedef list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> proto_args;
1293         typedef basic_expr<Tag, proto_args, 6 > proto_grammar;
1294         typedef default_domain proto_domain;
1295         typedef default_generator proto_generator;
1296         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
1297         typedef expr proto_derived_expr;
1298         typedef void proto_is_expr_;
1299         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5;
1300         typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
1301
1302
1303         BOOST_FORCEINLINE
1304         expr const &proto_base() const
1305         {
1306             return *this;
1307         }
1308
1309
1310         BOOST_FORCEINLINE
1311         expr &proto_base()
1312         {
1313             return *this;
1314         }
1315
1316
1317
1318         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
1319         BOOST_FORCEINLINE
1320         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5)
1321         {
1322             expr that = {a0 , a1 , a2 , a3 , a4 , a5};
1323             return that;
1324         }
1325
1326
1327         typedef detail::not_a_valid_type address_of_hack_type_;
1328
1329
1330
1331
1332         BOOST_FORCEINLINE
1333         proto::expr<
1334             proto::tag::assign
1335           , list2<expr &, expr const &>
1336           , 2
1337         > const
1338         operator =(expr const &a)
1339         {
1340             proto::expr<
1341                 proto::tag::assign
1342               , list2<expr &, expr const &>
1343               , 2
1344             > that = {*this, a};
1345             return that;
1346         }
1347
1348
1349
1350
1351         template<typename A>
1352         BOOST_FORCEINLINE
1353         proto::expr<
1354             proto::tag::assign
1355           , list2<expr const &, typename result_of::as_child<A>::type>
1356           , 2
1357         > const
1358         operator =(A &a) const
1359         {
1360             proto::expr<
1361                 proto::tag::assign
1362               , list2<expr const &, typename result_of::as_child<A>::type>
1363               , 2
1364             > that = {*this, proto::as_child(a)};
1365             return that;
1366         }
1367
1368
1369         template<typename A>
1370         BOOST_FORCEINLINE
1371         proto::expr<
1372             proto::tag::assign
1373           , list2<expr const &, typename result_of::as_child<A const>::type>
1374           , 2
1375         > const
1376         operator =(A const &a) const
1377         {
1378             proto::expr<
1379                 proto::tag::assign
1380               , list2<expr const &, typename result_of::as_child<A const>::type>
1381               , 2
1382             > that = {*this, proto::as_child(a)};
1383             return that;
1384         }
1385
1386
1387
1388
1389         template<typename A>
1390         BOOST_FORCEINLINE
1391         proto::expr<
1392             proto::tag::subscript
1393           , list2<expr const &, typename result_of::as_child<A>::type>
1394           , 2
1395         > const
1396         operator [](A &a) const
1397         {
1398             proto::expr<
1399                 proto::tag::subscript
1400               , list2<expr const &, typename result_of::as_child<A>::type>
1401               , 2
1402             > that = {*this, proto::as_child(a)};
1403             return that;
1404         }
1405
1406
1407         template<typename A>
1408         BOOST_FORCEINLINE
1409         proto::expr<
1410             proto::tag::subscript
1411           , list2<expr const &, typename result_of::as_child<A const>::type>
1412           , 2
1413         > const
1414         operator [](A const &a) const
1415         {
1416             proto::expr<
1417                 proto::tag::subscript
1418               , list2<expr const &, typename result_of::as_child<A const>::type>
1419               , 2
1420             > that = {*this, proto::as_child(a)};
1421             return that;
1422         }
1423
1424
1425         template<typename Sig>
1426         struct result
1427         {
1428             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
1429         };
1430
1431
1432         template<typename ...A>
1433         BOOST_FORCEINLINE
1434         typename result_of::funop<
1435             expr const(A const &...)
1436           , expr
1437           , default_domain
1438         >::type const
1439         operator ()(A const &... a) const
1440         {
1441             return result_of::funop<
1442                 expr const(A const &...)
1443               , expr
1444               , default_domain
1445             >::call(*this, a...);
1446         }
1447     };
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6>
1476     struct expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7 >
1477     {
1478         typedef Tag proto_tag;
1479         static const long proto_arity_c = 7;
1480         typedef mpl::long_<7 > proto_arity;
1481         typedef expr proto_base_expr;
1482         typedef list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> proto_args;
1483         typedef basic_expr<Tag, proto_args, 7 > proto_grammar;
1484         typedef default_domain proto_domain;
1485         typedef default_generator proto_generator;
1486         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
1487         typedef expr proto_derived_expr;
1488         typedef void proto_is_expr_;
1489         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6;
1490         typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
1491
1492
1493         BOOST_FORCEINLINE
1494         expr const &proto_base() const
1495         {
1496             return *this;
1497         }
1498
1499
1500         BOOST_FORCEINLINE
1501         expr &proto_base()
1502         {
1503             return *this;
1504         }
1505
1506
1507
1508         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
1509         BOOST_FORCEINLINE
1510         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6)
1511         {
1512             expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6};
1513             return that;
1514         }
1515
1516
1517         typedef detail::not_a_valid_type address_of_hack_type_;
1518
1519
1520
1521
1522         BOOST_FORCEINLINE
1523         proto::expr<
1524             proto::tag::assign
1525           , list2<expr &, expr const &>
1526           , 2
1527         > const
1528         operator =(expr const &a)
1529         {
1530             proto::expr<
1531                 proto::tag::assign
1532               , list2<expr &, expr const &>
1533               , 2
1534             > that = {*this, a};
1535             return that;
1536         }
1537
1538
1539
1540
1541         template<typename A>
1542         BOOST_FORCEINLINE
1543         proto::expr<
1544             proto::tag::assign
1545           , list2<expr const &, typename result_of::as_child<A>::type>
1546           , 2
1547         > const
1548         operator =(A &a) const
1549         {
1550             proto::expr<
1551                 proto::tag::assign
1552               , list2<expr const &, typename result_of::as_child<A>::type>
1553               , 2
1554             > that = {*this, proto::as_child(a)};
1555             return that;
1556         }
1557
1558
1559         template<typename A>
1560         BOOST_FORCEINLINE
1561         proto::expr<
1562             proto::tag::assign
1563           , list2<expr const &, typename result_of::as_child<A const>::type>
1564           , 2
1565         > const
1566         operator =(A const &a) const
1567         {
1568             proto::expr<
1569                 proto::tag::assign
1570               , list2<expr const &, typename result_of::as_child<A const>::type>
1571               , 2
1572             > that = {*this, proto::as_child(a)};
1573             return that;
1574         }
1575
1576
1577
1578
1579         template<typename A>
1580         BOOST_FORCEINLINE
1581         proto::expr<
1582             proto::tag::subscript
1583           , list2<expr const &, typename result_of::as_child<A>::type>
1584           , 2
1585         > const
1586         operator [](A &a) const
1587         {
1588             proto::expr<
1589                 proto::tag::subscript
1590               , list2<expr const &, typename result_of::as_child<A>::type>
1591               , 2
1592             > that = {*this, proto::as_child(a)};
1593             return that;
1594         }
1595
1596
1597         template<typename A>
1598         BOOST_FORCEINLINE
1599         proto::expr<
1600             proto::tag::subscript
1601           , list2<expr const &, typename result_of::as_child<A const>::type>
1602           , 2
1603         > const
1604         operator [](A const &a) const
1605         {
1606             proto::expr<
1607                 proto::tag::subscript
1608               , list2<expr const &, typename result_of::as_child<A const>::type>
1609               , 2
1610             > that = {*this, proto::as_child(a)};
1611             return that;
1612         }
1613
1614
1615         template<typename Sig>
1616         struct result
1617         {
1618             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
1619         };
1620
1621
1622         template<typename ...A>
1623         BOOST_FORCEINLINE
1624         typename result_of::funop<
1625             expr const(A const &...)
1626           , expr
1627           , default_domain
1628         >::type const
1629         operator ()(A const &... a) const
1630         {
1631             return result_of::funop<
1632                 expr const(A const &...)
1633               , expr
1634               , default_domain
1635             >::call(*this, a...);
1636         }
1637     };
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7>
1666     struct expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8 >
1667     {
1668         typedef Tag proto_tag;
1669         static const long proto_arity_c = 8;
1670         typedef mpl::long_<8 > proto_arity;
1671         typedef expr proto_base_expr;
1672         typedef list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> proto_args;
1673         typedef basic_expr<Tag, proto_args, 8 > proto_grammar;
1674         typedef default_domain proto_domain;
1675         typedef default_generator proto_generator;
1676         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
1677         typedef expr proto_derived_expr;
1678         typedef void proto_is_expr_;
1679         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7;
1680         typedef void proto_child8; typedef void proto_child9;
1681
1682
1683         BOOST_FORCEINLINE
1684         expr const &proto_base() const
1685         {
1686             return *this;
1687         }
1688
1689
1690         BOOST_FORCEINLINE
1691         expr &proto_base()
1692         {
1693             return *this;
1694         }
1695
1696
1697
1698         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
1699         BOOST_FORCEINLINE
1700         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7)
1701         {
1702             expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7};
1703             return that;
1704         }
1705
1706
1707         typedef detail::not_a_valid_type address_of_hack_type_;
1708
1709
1710
1711
1712         BOOST_FORCEINLINE
1713         proto::expr<
1714             proto::tag::assign
1715           , list2<expr &, expr const &>
1716           , 2
1717         > const
1718         operator =(expr const &a)
1719         {
1720             proto::expr<
1721                 proto::tag::assign
1722               , list2<expr &, expr const &>
1723               , 2
1724             > that = {*this, a};
1725             return that;
1726         }
1727
1728
1729
1730
1731         template<typename A>
1732         BOOST_FORCEINLINE
1733         proto::expr<
1734             proto::tag::assign
1735           , list2<expr const &, typename result_of::as_child<A>::type>
1736           , 2
1737         > const
1738         operator =(A &a) const
1739         {
1740             proto::expr<
1741                 proto::tag::assign
1742               , list2<expr const &, typename result_of::as_child<A>::type>
1743               , 2
1744             > that = {*this, proto::as_child(a)};
1745             return that;
1746         }
1747
1748
1749         template<typename A>
1750         BOOST_FORCEINLINE
1751         proto::expr<
1752             proto::tag::assign
1753           , list2<expr const &, typename result_of::as_child<A const>::type>
1754           , 2
1755         > const
1756         operator =(A const &a) const
1757         {
1758             proto::expr<
1759                 proto::tag::assign
1760               , list2<expr const &, typename result_of::as_child<A const>::type>
1761               , 2
1762             > that = {*this, proto::as_child(a)};
1763             return that;
1764         }
1765
1766
1767
1768
1769         template<typename A>
1770         BOOST_FORCEINLINE
1771         proto::expr<
1772             proto::tag::subscript
1773           , list2<expr const &, typename result_of::as_child<A>::type>
1774           , 2
1775         > const
1776         operator [](A &a) const
1777         {
1778             proto::expr<
1779                 proto::tag::subscript
1780               , list2<expr const &, typename result_of::as_child<A>::type>
1781               , 2
1782             > that = {*this, proto::as_child(a)};
1783             return that;
1784         }
1785
1786
1787         template<typename A>
1788         BOOST_FORCEINLINE
1789         proto::expr<
1790             proto::tag::subscript
1791           , list2<expr const &, typename result_of::as_child<A const>::type>
1792           , 2
1793         > const
1794         operator [](A const &a) const
1795         {
1796             proto::expr<
1797                 proto::tag::subscript
1798               , list2<expr const &, typename result_of::as_child<A const>::type>
1799               , 2
1800             > that = {*this, proto::as_child(a)};
1801             return that;
1802         }
1803
1804
1805         template<typename Sig>
1806         struct result
1807         {
1808             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
1809         };
1810
1811
1812         template<typename ...A>
1813         BOOST_FORCEINLINE
1814         typename result_of::funop<
1815             expr const(A const &...)
1816           , expr
1817           , default_domain
1818         >::type const
1819         operator ()(A const &... a) const
1820         {
1821             return result_of::funop<
1822                 expr const(A const &...)
1823               , expr
1824               , default_domain
1825             >::call(*this, a...);
1826         }
1827     };
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8>
1856     struct expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9 >
1857     {
1858         typedef Tag proto_tag;
1859         static const long proto_arity_c = 9;
1860         typedef mpl::long_<9 > proto_arity;
1861         typedef expr proto_base_expr;
1862         typedef list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> proto_args;
1863         typedef basic_expr<Tag, proto_args, 9 > proto_grammar;
1864         typedef default_domain proto_domain;
1865         typedef default_generator proto_generator;
1866         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
1867         typedef expr proto_derived_expr;
1868         typedef void proto_is_expr_;
1869         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8;
1870         typedef void proto_child9;
1871
1872
1873         BOOST_FORCEINLINE
1874         expr const &proto_base() const
1875         {
1876             return *this;
1877         }
1878
1879
1880         BOOST_FORCEINLINE
1881         expr &proto_base()
1882         {
1883             return *this;
1884         }
1885
1886
1887
1888         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1889         BOOST_FORCEINLINE
1890         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8)
1891         {
1892             expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8};
1893             return that;
1894         }
1895
1896
1897         typedef detail::not_a_valid_type address_of_hack_type_;
1898
1899
1900
1901
1902         BOOST_FORCEINLINE
1903         proto::expr<
1904             proto::tag::assign
1905           , list2<expr &, expr const &>
1906           , 2
1907         > const
1908         operator =(expr const &a)
1909         {
1910             proto::expr<
1911                 proto::tag::assign
1912               , list2<expr &, expr const &>
1913               , 2
1914             > that = {*this, a};
1915             return that;
1916         }
1917
1918
1919
1920
1921         template<typename A>
1922         BOOST_FORCEINLINE
1923         proto::expr<
1924             proto::tag::assign
1925           , list2<expr const &, typename result_of::as_child<A>::type>
1926           , 2
1927         > const
1928         operator =(A &a) const
1929         {
1930             proto::expr<
1931                 proto::tag::assign
1932               , list2<expr const &, typename result_of::as_child<A>::type>
1933               , 2
1934             > that = {*this, proto::as_child(a)};
1935             return that;
1936         }
1937
1938
1939         template<typename A>
1940         BOOST_FORCEINLINE
1941         proto::expr<
1942             proto::tag::assign
1943           , list2<expr const &, typename result_of::as_child<A const>::type>
1944           , 2
1945         > const
1946         operator =(A const &a) const
1947         {
1948             proto::expr<
1949                 proto::tag::assign
1950               , list2<expr const &, typename result_of::as_child<A const>::type>
1951               , 2
1952             > that = {*this, proto::as_child(a)};
1953             return that;
1954         }
1955
1956
1957
1958
1959         template<typename A>
1960         BOOST_FORCEINLINE
1961         proto::expr<
1962             proto::tag::subscript
1963           , list2<expr const &, typename result_of::as_child<A>::type>
1964           , 2
1965         > const
1966         operator [](A &a) const
1967         {
1968             proto::expr<
1969                 proto::tag::subscript
1970               , list2<expr const &, typename result_of::as_child<A>::type>
1971               , 2
1972             > that = {*this, proto::as_child(a)};
1973             return that;
1974         }
1975
1976
1977         template<typename A>
1978         BOOST_FORCEINLINE
1979         proto::expr<
1980             proto::tag::subscript
1981           , list2<expr const &, typename result_of::as_child<A const>::type>
1982           , 2
1983         > const
1984         operator [](A const &a) const
1985         {
1986             proto::expr<
1987                 proto::tag::subscript
1988               , list2<expr const &, typename result_of::as_child<A const>::type>
1989               , 2
1990             > that = {*this, proto::as_child(a)};
1991             return that;
1992         }
1993
1994
1995         template<typename Sig>
1996         struct result
1997         {
1998             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
1999         };
2000
2001
2002         template<typename ...A>
2003         BOOST_FORCEINLINE
2004         typename result_of::funop<
2005             expr const(A const &...)
2006           , expr
2007           , default_domain
2008         >::type const
2009         operator ()(A const &... a) const
2010         {
2011             return result_of::funop<
2012                 expr const(A const &...)
2013               , expr
2014               , default_domain
2015             >::call(*this, a...);
2016         }
2017     };
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9>
2046     struct expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10 >
2047     {
2048         typedef Tag proto_tag;
2049         static const long proto_arity_c = 10;
2050         typedef mpl::long_<10 > proto_arity;
2051         typedef expr proto_base_expr;
2052         typedef list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> proto_args;
2053         typedef basic_expr<Tag, proto_args, 10 > proto_grammar;
2054         typedef default_domain proto_domain;
2055         typedef default_generator proto_generator;
2056         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
2057         typedef expr proto_derived_expr;
2058         typedef void proto_is_expr_;
2059         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef Arg9 proto_child9; proto_child9 child9;
2060
2061
2062
2063         BOOST_FORCEINLINE
2064         expr const &proto_base() const
2065         {
2066             return *this;
2067         }
2068
2069
2070         BOOST_FORCEINLINE
2071         expr &proto_base()
2072         {
2073             return *this;
2074         }
2075
2076
2077
2078         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
2079         BOOST_FORCEINLINE
2080         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9)
2081         {
2082             expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9};
2083             return that;
2084         }
2085
2086
2087         typedef detail::not_a_valid_type address_of_hack_type_;
2088
2089
2090
2091
2092         BOOST_FORCEINLINE
2093         proto::expr<
2094             proto::tag::assign
2095           , list2<expr &, expr const &>
2096           , 2
2097         > const
2098         operator =(expr const &a)
2099         {
2100             proto::expr<
2101                 proto::tag::assign
2102               , list2<expr &, expr const &>
2103               , 2
2104             > that = {*this, a};
2105             return that;
2106         }
2107
2108
2109
2110
2111         template<typename A>
2112         BOOST_FORCEINLINE
2113         proto::expr<
2114             proto::tag::assign
2115           , list2<expr const &, typename result_of::as_child<A>::type>
2116           , 2
2117         > const
2118         operator =(A &a) const
2119         {
2120             proto::expr<
2121                 proto::tag::assign
2122               , list2<expr const &, typename result_of::as_child<A>::type>
2123               , 2
2124             > that = {*this, proto::as_child(a)};
2125             return that;
2126         }
2127
2128
2129         template<typename A>
2130         BOOST_FORCEINLINE
2131         proto::expr<
2132             proto::tag::assign
2133           , list2<expr const &, typename result_of::as_child<A const>::type>
2134           , 2
2135         > const
2136         operator =(A const &a) const
2137         {
2138             proto::expr<
2139                 proto::tag::assign
2140               , list2<expr const &, typename result_of::as_child<A const>::type>
2141               , 2
2142             > that = {*this, proto::as_child(a)};
2143             return that;
2144         }
2145
2146
2147
2148
2149         template<typename A>
2150         BOOST_FORCEINLINE
2151         proto::expr<
2152             proto::tag::subscript
2153           , list2<expr const &, typename result_of::as_child<A>::type>
2154           , 2
2155         > const
2156         operator [](A &a) const
2157         {
2158             proto::expr<
2159                 proto::tag::subscript
2160               , list2<expr const &, typename result_of::as_child<A>::type>
2161               , 2
2162             > that = {*this, proto::as_child(a)};
2163             return that;
2164         }
2165
2166
2167         template<typename A>
2168         BOOST_FORCEINLINE
2169         proto::expr<
2170             proto::tag::subscript
2171           , list2<expr const &, typename result_of::as_child<A const>::type>
2172           , 2
2173         > const
2174         operator [](A const &a) const
2175         {
2176             proto::expr<
2177                 proto::tag::subscript
2178               , list2<expr const &, typename result_of::as_child<A const>::type>
2179               , 2
2180             > that = {*this, proto::as_child(a)};
2181             return that;
2182         }
2183
2184
2185         template<typename Sig>
2186         struct result
2187         {
2188             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
2189         };
2190
2191
2192         template<typename ...A>
2193         BOOST_FORCEINLINE
2194         typename result_of::funop<
2195             expr const(A const &...)
2196           , expr
2197           , default_domain
2198         >::type const
2199         operator ()(A const &... a) const
2200         {
2201             return result_of::funop<
2202                 expr const(A const &...)
2203               , expr
2204               , default_domain
2205             >::call(*this, a...);
2206         }
2207     };
2208