boost/xpressive/regex_actions.hpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 /// \file regex_actions.hpp
   3 /// Defines the syntax elements of xpressive's action expressions.
   4 //
   5 //  Copyright 2008 Eric Niebler. Distributed under the Boost
   6 //  Software License, Version 1.0. (See accompanying file
   7 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   8
   9 #ifndef BOOST_XPRESSIVE_ACTIONS_HPP_EAN_03_22_2007
  10 #define BOOST_XPRESSIVE_ACTIONS_HPP_EAN_03_22_2007
  11
  12 // MS compatible compilers support #pragma once
  13 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
  14 # pragma once
  15 #endif
  16
  17 #include <boost/config.hpp>
  18 #include <boost/ref.hpp>
  19 #include <boost/mpl/if.hpp>
  20 #include <boost/mpl/or.hpp>
  21 #include <boost/mpl/int.hpp>
  22 #include <boost/lexical_cast.hpp>
  23 #include <boost/throw_exception.hpp>
  24 #include <boost/utility/enable_if.hpp>
  25 #include <boost/type_traits/is_const.hpp>
  26 #include <boost/type_traits/is_integral.hpp>
  27 #include <boost/type_traits/remove_cv.hpp>
  28 #include <boost/type_traits/remove_reference.hpp>
  29 #include <boost/xpressive/detail/detail_fwd.hpp>
  30 #include <boost/xpressive/detail/core/state.hpp>
  31 #include <boost/xpressive/detail/core/matcher/attr_matcher.hpp>
  32 #include <boost/xpressive/detail/core/matcher/attr_end_matcher.hpp>
  33 #include <boost/xpressive/detail/core/matcher/attr_begin_matcher.hpp>
  34 #include <boost/xpressive/detail/core/matcher/predicate_matcher.hpp>
  35 #include <boost/xpressive/detail/utility/ignore_unused.hpp>
  36
  37 // These are very often needed by client code.
  38 #include <boost/typeof/std/map.hpp>
  39 #include <boost/typeof/std/string.hpp>
  40
  41 // Doxygen can't handle proto :-(
  42 #ifndef BOOST_XPRESSIVE_DOXYGEN_INVOKED
  43 # include <boost/proto/transform/arg.hpp>
  44 # include <boost/proto/transform/when.hpp>
  45 # include <boost/xpressive/detail/core/matcher/action_matcher.hpp>
  46 #endif
  47
  48 /// INTERNAL ONLY
  49 ///
  50 #define UNREF(x)    typename remove_reference<x>::type
  51
  52 /// INTERNAL ONLY
  53 ///
  54 #define UNCVREF(x)  typename remove_cv<typename remove_reference<x>::type>::type
  55
  56 #if BOOST_MSVC
  57 #pragma warning(push)
  58 #pragma warning(disable : 4510) // default constructor could not be generated
  59 #pragma warning(disable : 4512) // assignment operator could not be generated
  60 #pragma warning(disable : 4610) // can never be instantiated - user defined constructor required
  61 #endif
  62
  63 namespace boost { namespace xpressive
  64 {
  65
  66     namespace detail
  67     {
  68         template<typename T, typename U>
  69         struct action_arg
  70         {
  71             typedef T type;
  72             typedef typename add_reference<T>::type reference;
  73
  74             reference cast(void *pv) const
  75             {
  76                 return *static_cast<UNREF(T) *>(pv);
  77             }
  78         };
  79
  80         template<typename T>
  81         struct value_wrapper
  82         {
  83             value_wrapper()
  84               : value()
  85             {}
  86
  87             value_wrapper(T const &t)
  88               : value(t)
  89             {}
  90
  91             T value;
  92         };
  93
  94         struct check_tag
  95         {};
  96
  97         struct BindArg : proto::callable
  98         {
  99             typedef int result_type;
 100
 101             template<typename Data, typename Expr>
 102             int operator ()(Data &data, Expr const &expr) const
 103             {
 104                 data.let(expr);
 105                 return 0;
 106             }
 107         };
 108
 109         struct let_tag
 110         {};
 111
 112         struct BindArgs
 113           : proto::when<
 114                 // let(_a = b, _c = d)
 115                 proto::function<
 116                     proto::terminal<let_tag>
 117                   , proto::vararg<proto::assign<proto::_, proto::_> >
 118                 >
 119               , proto::function<
 120                     proto::_state   // no-op
 121                   , proto::vararg<proto::call<BindArg(proto::_data, proto::_)> >
 122                 >
 123             >
 124         {};
 125
 126         struct let_domain
 127           : boost::proto::domain<boost::proto::pod_generator<let_> >
 128         {};
 129
 130         template<typename Expr>
 131         struct let_
 132         {
 133             BOOST_PROTO_BASIC_EXTENDS(Expr, let_<Expr>, let_domain)
 134             BOOST_PROTO_EXTENDS_FUNCTION()
 135         };
 136
 137         template<typename Args, typename BidiIter>
 138         void bind_args(let_<Args> const &args, match_results<BidiIter> &what)
 139         {
 140             BindArgs::impl<let_<Args> const &, int, match_results<BidiIter> &>()(
 141                 args
 142               , 0
 143               , what
 144             );
 145         }
 146
 147         template<typename BidiIter>
 148         struct replacement_context
 149           : proto::callable_context<replacement_context<BidiIter> const>
 150         {
 151             replacement_context(match_results<BidiIter> const &what)
 152               : what_(what)
 153             {}
 154
 155             template<typename Sig>
 156             struct result;
 157
 158             template<typename This>
 159             struct result<This(proto::tag::terminal, mark_placeholder const &)>
 160             {
 161                 typedef sub_match<BidiIter> const &type;
 162             };
 163
 164             template<typename This>
 165             struct result<This(proto::tag::terminal, any_matcher const &)>
 166             {
 167                 typedef sub_match<BidiIter> const &type;
 168             };
 169
 170             template<typename This, typename T>
 171             struct result<This(proto::tag::terminal, reference_wrapper<T> const &)>
 172             {
 173                 typedef T &type;
 174             };
 175
 176             sub_match<BidiIter> const &operator ()(proto::tag::terminal, mark_placeholder m) const
 177             {
 178                 return this->what_[m.mark_number_];
 179             }
 180
 181             sub_match<BidiIter> const &operator ()(proto::tag::terminal, any_matcher) const
 182             {
 183                 return this->what_[0];
 184             }
 185
 186             template<typename T>
 187             T &operator ()(proto::tag::terminal, reference_wrapper<T> r) const
 188             {
 189                 return r;
 190             }
 191         private:
 192             match_results<BidiIter> const &what_;
 193         };
 194     }
 195
 196     namespace op
 197     {
 198         struct push
 199         {
 200             typedef void result_type;
 201
 202             template<typename Sequence, typename Value>
 203             void operator()(Sequence &seq, Value const &val) const
 204             {
 205                 seq.push(val);
 206             }
 207         };
 208
 209         struct push_back
 210         {
 211             typedef void result_type;
 212
 213             template<typename Sequence, typename Value>
 214             void operator()(Sequence &seq, Value const &val) const
 215             {
 216                 seq.push_back(val);
 217             }
 218         };
 219
 220         struct push_front
 221         {
 222             typedef void result_type;
 223
 224             template<typename Sequence, typename Value>
 225             void operator()(Sequence &seq, Value const &val) const
 226             {
 227                 seq.push_front(val);
 228             }
 229         };
 230
 231         struct pop
 232         {
 233             typedef void result_type;
 234
 235             template<typename Sequence>
 236             void operator()(Sequence &seq) const
 237             {
 238                 seq.pop();
 239             }
 240         };
 241
 242         struct pop_back
 243         {
 244             typedef void result_type;
 245
 246             template<typename Sequence>
 247             void operator()(Sequence &seq) const
 248             {
 249                 seq.pop_back();
 250             }
 251         };
 252
 253         struct pop_front
 254         {
 255             typedef void result_type;
 256
 257             template<typename Sequence>
 258             void operator()(Sequence &seq) const
 259             {
 260                 seq.pop_front();
 261             }
 262         };
 263
 264         struct front
 265         {
 266             template<typename Sig>
 267             struct result {};
 268
 269             template<typename This, typename Sequence>
 270             struct result<This(Sequence)>
 271             {
 272                 typedef UNREF(Sequence) sequence_type;
 273                 typedef
 274                     typename mpl::if_<
 275                         is_const<sequence_type>
 276                       , typename sequence_type::const_reference
 277                       , typename sequence_type::reference
 278                     >::type
 279                 type;
 280             };
 281
 282             template<typename Sequence>
 283             typename result<front(Sequence &)>::type operator()(Sequence &seq) const
 284             {
 285                 return seq.front();
 286             }
 287         };
 288
 289         struct back
 290         {
 291             template<typename Sig>
 292             struct result {};
 293
 294             template<typename This, typename Sequence>
 295             struct result<This(Sequence)>
 296             {
 297                 typedef UNREF(Sequence) sequence_type;
 298                 typedef
 299                     typename mpl::if_<
 300                         is_const<sequence_type>
 301                       , typename sequence_type::const_reference
 302                       , typename sequence_type::reference
 303                     >::type
 304                 type;
 305             };
 306
 307             template<typename Sequence>
 308             typename result<back(Sequence &)>::type operator()(Sequence &seq) const
 309             {
 310                 return seq.back();
 311             }
 312         };
 313
 314         struct top
 315         {
 316             template<typename Sig>
 317             struct result {};
 318
 319             template<typename This, typename Sequence>
 320             struct result<This(Sequence)>
 321             {
 322                 typedef UNREF(Sequence) sequence_type;
 323                 typedef
 324                     typename mpl::if_<
 325                         is_const<sequence_type>
 326                       , typename sequence_type::value_type const &
 327                       , typename sequence_type::value_type &
 328                     >::type
 329                 type;
 330             };
 331
 332             template<typename Sequence>
 333             typename result<top(Sequence &)>::type operator()(Sequence &seq) const
 334             {
 335                 return seq.top();
 336             }
 337         };
 338
 339         struct first
 340         {
 341             template<typename Sig>
 342             struct result {};
 343
 344             template<typename This, typename Pair>
 345             struct result<This(Pair)>
 346             {
 347                 typedef UNREF(Pair)::first_type type;
 348             };
 349
 350             template<typename Pair>
 351             typename Pair::first_type operator()(Pair const &p) const
 352             {
 353                 return p.first;
 354             }
 355         };
 356
 357         struct second
 358         {
 359             template<typename Sig>
 360             struct result {};
 361
 362             template<typename This, typename Pair>
 363             struct result<This(Pair)>
 364             {
 365                 typedef UNREF(Pair)::second_type type;
 366             };
 367
 368             template<typename Pair>
 369             typename Pair::second_type operator()(Pair const &p) const
 370             {
 371                 return p.second;
 372             }
 373         };
 374
 375         struct matched
 376         {
 377             typedef bool result_type;
 378
 379             template<typename Sub>
 380             bool operator()(Sub const &sub) const
 381             {
 382                 return sub.matched;
 383             }
 384         };
 385
 386         struct length
 387         {
 388             template<typename Sig>
 389             struct result {};
 390
 391             template<typename This, typename Sub>
 392             struct result<This(Sub)>
 393             {
 394                 typedef UNREF(Sub)::difference_type type;
 395             };
 396
 397             template<typename Sub>
 398             typename Sub::difference_type operator()(Sub const &sub) const
 399             {
 400                 return sub.length();
 401             }
 402         };
 403
 404         struct str
 405         {
 406             template<typename Sig>
 407             struct result {};
 408
 409             template<typename This, typename Sub>
 410             struct result<This(Sub)>
 411             {
 412                 typedef UNREF(Sub)::string_type type;
 413             };
 414
 415             template<typename Sub>
 416             typename Sub::string_type operator()(Sub const &sub) const
 417             {
 418                 return sub.str();
 419             }
 420         };
 421
 422         // This codifies the return types of the various insert member
 423         // functions found in sequence containers, the 2 flavors of
 424         // associative containers, and strings.
 425         struct insert
 426         {
 427             template<typename Sig, typename EnableIf = void>
 428             struct result
 429             {};
 430
 431             // assoc containers
 432             template<typename This, typename Cont, typename Value>
 433             struct result<This(Cont, Value), void>
 434             {
 435                 typedef UNREF(Cont) cont_type;
 436                 typedef UNREF(Value) value_type;
 437                 static cont_type &scont_;
 438                 static value_type &svalue_;
 439                 typedef char yes_type;
 440                 typedef char (&no_type)[2];
 441                 static yes_type check_insert_return(typename cont_type::iterator);
 442                 static no_type check_insert_return(std::pair<typename cont_type::iterator, bool>);
 443                 BOOST_STATIC_CONSTANT(bool, is_iterator = (sizeof(yes_type) == sizeof(check_insert_return(scont_.insert(svalue_)))));
 444                 typedef
 445                     typename mpl::if_c<
 446                         is_iterator
 447                       , typename cont_type::iterator
 448                       , std::pair<typename cont_type::iterator, bool>
 449                     >::type
 450                 type;
 451             };
 452
 453             // sequence containers, assoc containers, strings
 454             template<typename This, typename Cont, typename It, typename Value>
 455             struct result<This(Cont, It, Value),
 456                 typename disable_if<mpl::or_<is_integral<UNCVREF(It)>, is_same<UNCVREF(It), UNCVREF(Value)> > >::type>
 457             {
 458                 typedef UNREF(Cont)::iterator type;
 459             };
 460
 461             // strings
 462             template<typename This, typename Cont, typename Size, typename T>
 463             struct result<This(Cont, Size, T),
 464                 typename enable_if<is_integral<UNCVREF(Size)> >::type>
 465             {
 466                 typedef UNREF(Cont) &type;
 467             };
 468
 469             // assoc containers
 470             template<typename This, typename Cont, typename It>
 471             struct result<This(Cont, It, It), void>
 472             {
 473                 typedef void type;
 474             };
 475
 476             // sequence containers, strings
 477             template<typename This, typename Cont, typename It, typename Size, typename Value>
 478             struct result<This(Cont, It, Size, Value),
 479                 typename disable_if<is_integral<UNCVREF(It)> >::type>
 480             {
 481                 typedef void type;
 482             };
 483
 484             // strings
 485             template<typename This, typename Cont, typename Size, typename A0, typename A1>
 486             struct result<This(Cont, Size, A0, A1),
 487                 typename enable_if<is_integral<UNCVREF(Size)> >::type>
 488             {
 489                 typedef UNREF(Cont) &type;
 490             };
 491
 492             /// operator()
 493             ///
 494             template<typename Cont, typename A0>
 495             typename result<insert(Cont &, A0 const &)>::type
 496             operator()(Cont &cont, A0 const &a0) const
 497             {
 498                 return cont.insert(a0);
 499             }
 500
 501             /// \overload
 502             ///
 503             template<typename Cont, typename A0, typename A1>
 504             typename result<insert(Cont &, A0 const &, A1 const &)>::type
 505             operator()(Cont &cont, A0 const &a0, A1 const &a1) const
 506             {
 507                 return cont.insert(a0, a1);
 508             }
 509
 510             /// \overload
 511             ///
 512             template<typename Cont, typename A0, typename A1, typename A2>
 513             typename result<insert(Cont &, A0 const &, A1 const &, A2 const &)>::type
 514             operator()(Cont &cont, A0 const &a0, A1 const &a1, A2 const &a2) const
 515             {
 516                 return cont.insert(a0, a1, a2);
 517             }
 518         };
 519
 520         struct make_pair
 521         {
 522             template<typename Sig>
 523             struct result {};
 524
 525             template<typename This, typename First, typename Second>
 526             struct result<This(First, Second)>
 527             {
 528                 typedef std::pair<UNCVREF(First), UNCVREF(Second)> type;
 529             };
 530
 531             template<typename First, typename Second>
 532             std::pair<First, Second> operator()(First const &first, Second const &second) const
 533             {
 534                 return std::make_pair(first, second);
 535             }
 536         };
 537
 538         template<typename T>
 539         struct as
 540         {
 541             typedef T result_type;
 542
 543             template<typename Value>
 544             T operator()(Value const &val) const
 545             {
 546                 return lexical_cast<T>(val);
 547             }
 548         };
 549
 550         template<typename T>
 551         struct static_cast_
 552         {
 553             typedef T result_type;
 554
 555             template<typename Value>
 556             T operator()(Value const &val) const
 557             {
 558                 return static_cast<T>(val);
 559             }
 560         };
 561
 562         template<typename T>
 563         struct dynamic_cast_
 564         {
 565             typedef T result_type;
 566
 567             template<typename Value>
 568             T operator()(Value const &val) const
 569             {
 570                 return dynamic_cast<T>(val);
 571             }
 572         };
 573
 574         template<typename T>
 575         struct const_cast_
 576         {
 577             typedef T result_type;
 578
 579             template<typename Value>
 580             T operator()(Value const &val) const
 581             {
 582                 return const_cast<T>(val);
 583             }
 584         };
 585
 586         template<typename T>
 587         struct construct
 588         {
 589             typedef T result_type;
 590
 591             T operator()() const
 592             {
 593                 return T();
 594             }
 595
 596             template<typename A0>
 597             T operator()(A0 const &a0) const
 598             {
 599                 return T(a0);
 600             }
 601
 602             template<typename A0, typename A1>
 603             T operator()(A0 const &a0, A1 const &a1) const
 604             {
 605                 return T(a0, a1);
 606             }
 607
 608             template<typename A0, typename A1, typename A2>
 609             T operator()(A0 const &a0, A1 const &a1, A2 const &a2) const
 610             {
 611                 return T(a0, a1, a2);
 612             }
 613         };
 614
 615         template<typename Except>
 616         struct throw_
 617         {
 618             typedef void result_type;
 619
 620             void operator()() const
 621             {
 622                 BOOST_THROW_EXCEPTION(Except());
 623             }
 624
 625             template<typename A0>
 626             void operator()(A0 const &a0) const
 627             {
 628                 BOOST_THROW_EXCEPTION(Except(a0));
 629             }
 630
 631             template<typename A0, typename A1>
 632             void operator()(A0 const &a0, A1 const &a1) const
 633             {
 634                 BOOST_THROW_EXCEPTION(Except(a0, a1));
 635             }
 636
 637             template<typename A0, typename A1, typename A2>
 638             void operator()(A0 const &a0, A1 const &a1, A2 const &a2) const
 639             {
 640                 BOOST_THROW_EXCEPTION(Except(a0, a1, a2));
 641             }
 642         };
 643     }
 644
 645     template<typename Fun>
 646     struct function
 647     {
 648         typedef typename proto::terminal<Fun>::type type;
 649     };
 650
 651     function<op::push>::type const push = {{}};
 652     function<op::push_back>::type const push_back = {{}};
 653     function<op::push_front>::type const push_front = {{}};
 654     function<op::pop>::type const pop = {{}};
 655     function<op::pop_back>::type const pop_back = {{}};
 656     function<op::pop_front>::type const pop_front = {{}};
 657     function<op::top>::type const top = {{}};
 658     function<op::back>::type const back = {{}};
 659     function<op::front>::type const front = {{}};
 660     function<op::first>::type const first = {{}};
 661     function<op::second>::type const second = {{}};
 662     function<op::matched>::type const matched = {{}};
 663     function<op::length>::type const length = {{}};
 664     function<op::str>::type const str = {{}};
 665     function<op::insert>::type const insert = {{}};
 666     function<op::make_pair>::type const make_pair = {{}};
 667
 668     template<typename T>
 669     struct value
 670       : proto::extends<typename proto::terminal<T>::type, value<T> >
 671     {
 672         typedef proto::extends<typename proto::terminal<T>::type, value<T> > base_type;
 673
 674         value()
 675           : base_type()
 676         {}
 677
 678         explicit value(T const &t)
 679           : base_type(base_type::proto_base_expr::make(t))
 680         {}
 681
 682         using base_type::operator =;
 683
 684         T &get()
 685         {
 686             return proto::value(*this);
 687         }
 688
 689         T const &get() const
 690         {
 691             return proto::value(*this);
 692         }
 693     };
 694
 695     template<typename T>
 696     struct reference
 697       : proto::extends<typename proto::terminal<reference_wrapper<T> >::type, reference<T> >
 698     {
 699         typedef proto::extends<typename proto::terminal<reference_wrapper<T> >::type, reference<T> > base_type;
 700
 701         explicit reference(T &t)
 702           : base_type(base_type::proto_base_expr::make(boost::ref(t)))
 703         {}
 704
 705         using base_type::operator =;
 706
 707         T &get() const
 708         {
 709             return proto::value(*this).get();
 710         }
 711     };
 712
 713     template<typename T>
 714     struct local
 715       : detail::value_wrapper<T>
 716       , proto::terminal<reference_wrapper<T> >::type
 717     {
 718         typedef typename proto::terminal<reference_wrapper<T> >::type base_type;
 719
 720         local()
 721           : detail::value_wrapper<T>()
 722           , base_type(base_type::make(boost::ref(detail::value_wrapper<T>::value)))
 723         {}
 724
 725         explicit local(T const &t)
 726           : detail::value_wrapper<T>(t)
 727           , base_type(base_type::make(boost::ref(detail::value_wrapper<T>::value)))
 728         {}
 729
 730         using base_type::operator =;
 731
 732         T &get()
 733         {
 734             return proto::value(*this);
 735         }
 736
 737         T const &get() const
 738         {
 739             return proto::value(*this);
 740         }
 741
 742     private:
 743         local(local const &);
 744     };
 745
 746     /// as (a.k.a., lexical_cast)
 747     ///
 748     BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE(
 749         1
 750       , as
 751       , boost::proto::default_domain
 752       , (boost::proto::tag::function)
 753       , ((op::as)(typename))
 754     )
 755
 756     /// static_cast_
 757     ///
 758     BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE(
 759         1
 760       , static_cast_
 761       , boost::proto::default_domain
 762       , (boost::proto::tag::function)
 763       , ((op::static_cast_)(typename))
 764     )
 765
 766     /// dynamic_cast_
 767     ///
 768     BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE(
 769         1
 770       , dynamic_cast_
 771       , boost::proto::default_domain
 772       , (boost::proto::tag::function)
 773       , ((op::dynamic_cast_)(typename))
 774     )
 775
 776     /// const_cast_
 777     ///
 778     BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE(
 779         1
 780       , const_cast_
 781       , boost::proto::default_domain
 782       , (boost::proto::tag::function)
 783       , ((op::const_cast_)(typename))
 784     )
 785
 786     /// val()
 787     ///
 788     template<typename T>
 789     value<T> const val(T const &t)
 790     {
 791         return value<T>(t);
 792     }
 793
 794     /// ref()
 795     ///
 796     template<typename T>
 797     reference<T> const ref(T &t)
 798     {
 799         return reference<T>(t);
 800     }
 801
 802     /// cref()
 803     ///
 804     template<typename T>
 805     reference<T const> const cref(T const &t)
 806     {
 807         return reference<T const>(t);
 808     }
 809
 810     /// check(), for testing custom assertions
 811     ///
 812     proto::terminal<detail::check_tag>::type const check = {{}};
 813
 814     /// let(), for binding references to non-local variables
 815     ///
 816     detail::let_<proto::terminal<detail::let_tag>::type> const let = {{{}}};
 817
 818     /// placeholder<T>, for defining a placeholder to stand in fo
 819     /// a variable of type T in a semantic action.
 820     ///
 821     template<typename T, int I, typename Dummy>
 822     struct placeholder
 823     {
 824         typedef placeholder<T, I, Dummy> this_type;
 825         typedef typename proto::terminal<detail::action_arg<T, mpl::int_<I> > >::type action_arg_type;
 826
 827         BOOST_PROTO_EXTENDS(action_arg_type, this_type, proto::default_domain)
 828     };
 829
 830     /// Usage: construct\<Type\>(arg1, arg2)
 831     ///
 832     BOOST_PROTO_DEFINE_VARARG_FUNCTION_TEMPLATE(
 833         construct
 834       , boost::proto::default_domain
 835       , (boost::proto::tag::function)
 836       , ((op::construct)(typename))
 837     )
 838
 839     /// Usage: throw_\<Exception\>(arg1, arg2)
 840     ///
 841     BOOST_PROTO_DEFINE_VARARG_FUNCTION_TEMPLATE(
 842         throw_
 843       , boost::proto::default_domain
 844       , (boost::proto::tag::function)
 845       , ((op::throw_)(typename))
 846     )
 847
 848     namespace detail
 849     {
 850         inline void ignore_unused_regex_actions()
 851         {
 852             ignore_unused(xpressive::push);
 853             ignore_unused(xpressive::push_back);
 854             ignore_unused(xpressive::push_front);
 855             ignore_unused(xpressive::pop);
 856             ignore_unused(xpressive::pop_back);
 857             ignore_unused(xpressive::pop_front);
 858             ignore_unused(xpressive::top);
 859             ignore_unused(xpressive::back);
 860             ignore_unused(xpressive::front);
 861             ignore_unused(xpressive::first);
 862             ignore_unused(xpressive::second);
 863             ignore_unused(xpressive::matched);
 864             ignore_unused(xpressive::length);
 865             ignore_unused(xpressive::str);
 866             ignore_unused(xpressive::insert);
 867             ignore_unused(xpressive::make_pair);
 868             ignore_unused(xpressive::check);
 869             ignore_unused(xpressive::let);
 870         }
 871     }
 872
 873 }}
 874
 875 #undef UNREF
 876 #undef UNCVREF
 877
 878 #if BOOST_MSVC
 879 #pragma warning(pop)
 880 #endif
 881
 882 #endif // BOOST_XPRESSIVE_ACTIONS_HPP_EAN_03_22_2007