1 /////////////////////////////////////////////////////////////////////////////// 2 /// \file proto_fwd.hpp 3 /// Forward declarations of all of proto's public types and functions. 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_PROTO_FWD_HPP_EAN_04_01_2005 10 #define BOOST_PROTO_FWD_HPP_EAN_04_01_2005 11 12 #include <cstddef> 13 #include <climits> 14 #include <boost/config.hpp> 15 #include <boost/detail/workaround.hpp> 16 #include <boost/preprocessor/cat.hpp> 17 #include <boost/preprocessor/arithmetic/inc.hpp> 18 #include <boost/preprocessor/punctuation/comma.hpp> 19 #include <boost/preprocessor/repetition/enum_params.hpp> 20 #include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> 21 #include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp> 22 #include <boost/preprocessor/repetition/repeat_from_to.hpp> 23 #include <boost/ref.hpp> 24 #include <boost/mpl/long.hpp> 25 #include <boost/type_traits/remove_const.hpp> 26 #include <boost/type_traits/remove_reference.hpp> 27 #include <boost/mpl/aux_/config/ttp.hpp> 28 #include <boost/utility/result_of.hpp> 29 30 #ifndef BOOST_PROTO_MAX_ARITY 31 # define BOOST_PROTO_MAX_ARITY 10 32 #endif 33 34 #ifndef BOOST_PROTO_MAX_LOGICAL_ARITY 35 # define BOOST_PROTO_MAX_LOGICAL_ARITY 10 36 #endif 37 38 #ifndef BOOST_PROTO_MAX_FUNCTION_CALL_ARITY 39 # define BOOST_PROTO_MAX_FUNCTION_CALL_ARITY BOOST_PROTO_MAX_ARITY 40 #endif 41 42 #if BOOST_PROTO_MAX_ARITY < 3 43 # error BOOST_PROTO_MAX_ARITY must be at least 3 44 #endif 45 46 #if BOOST_PROTO_MAX_FUNCTION_CALL_ARITY > BOOST_PROTO_MAX_ARITY 47 # error BOOST_PROTO_MAX_FUNCTION_CALL_ARITY cannot be larger than BOOST_PROTO_MAX_ARITY 48 #endif 49 50 #ifndef BOOST_PROTO_DONT_USE_PREPROCESSED_FILES 51 #if 10 < BOOST_PROTO_MAX_ARITY || \ 52 10 < BOOST_PROTO_MAX_LOGICAL_ARITY || \ 53 10 < BOOST_PROTO_MAX_FUNCTION_CALL_ARITY 54 #define BOOST_PROTO_DONT_USE_PREPROCESSED_FILES 55 #endif 56 #endif 57 58 #ifndef BOOST_PROTO_BROKEN_CONST_OVERLOADS 59 # if BOOST_WORKAROUND(__GNUC__, == 3) \ 60 || BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(310)) 61 # define BOOST_PROTO_BROKEN_CONST_OVERLOADS 62 # endif 63 #endif 64 65 #ifndef BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS 66 # if BOOST_WORKAROUND(__GNUC__, == 3) \ 67 || BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(310)) 68 # define BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS 69 # endif 70 #endif 71 72 #ifdef BOOST_PROTO_BROKEN_CONST_OVERLOADS 73 # include <boost/utility/enable_if.hpp> 74 # include <boost/type_traits/is_const.hpp> 75 # define BOOST_PROTO_DISABLE_IF_IS_CONST(T)\ 76 , typename boost::disable_if_c<boost::is_const<T>::value, boost::proto::detail::undefined>::type * = 0 77 #else 78 # define BOOST_PROTO_DISABLE_IF_IS_CONST(T) 79 #endif 80 81 #ifdef BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS 82 # include <boost/utility/enable_if.hpp> 83 # include <boost/type_traits/is_function.hpp> 84 # define BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T)\ 85 , typename boost::disable_if_c<boost::is_function<T>::value, boost::proto::detail::undefined>::type * = 0 86 #else 87 # define BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T) 88 #endif 89 90 #ifndef BOOST_PROTO_BROKEN_PTS 91 # if BOOST_WORKAROUND(BOOST_MSVC, <= 1400) 92 # define BOOST_PROTO_BROKEN_PTS 93 # endif 94 #endif 95 96 #ifdef BOOST_NO_CXX11_DECLTYPE_N3276 97 # // Proto can only use the decltype-based result_of if N3276 has been 98 # // implemented by the compiler. 99 # // See http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2011/n3276.pdf 100 # ifndef BOOST_PROTO_USE_NORMAL_RESULT_OF 101 # define BOOST_PROTO_USE_NORMAL_RESULT_OF 102 # endif 103 #endif 104 105 // Unless compiler support is there, use tr1_result_of instead of 106 // result_of to avoid the problems addressed by N3276. 107 #ifdef BOOST_PROTO_USE_NORMAL_RESULT_OF 108 # define BOOST_PROTO_RESULT_OF boost::result_of 109 #else 110 # define BOOST_PROTO_RESULT_OF boost::tr1_result_of 111 #endif 112 113 // If we're using the decltype-based result_of, we need to be a bit 114 // stricter about the return types of some functions. 115 #if defined(BOOST_RESULT_OF_USE_DECLTYPE) && defined(BOOST_PROTO_USE_NORMAL_RESULT_OF) 116 # define BOOST_PROTO_STRICT_RESULT_OF 117 # define BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(X, Y) X 118 #else 119 # define BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(X, Y) Y 120 #endif 121 122 #ifdef BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING 123 # define BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING 124 #endif 125 126 #if defined(_MSC_VER) 127 # define BOOST_PROTO_PUSH_WARNINGS __pragma(warning(push)) 128 # define BOOST_PROTO_POP_WARNINGS __pragma(warning(pop)) 129 # define BOOST_PROTO_DISABLE_MSVC_C4180 __pragma(warning(disable : 4180)) // qualifier applied to function type has no meaning; ignored 130 # define BOOST_PROTO_DISABLE_MSVC_C4522 __pragma(warning(disable : 4522)) // 'class' : multiple assignment operators specified 131 # define BOOST_PROTO_DISABLE_MSVC_C4714 __pragma(warning(disable : 4714)) // function 'xxx' marked as __forceinline not inlined 132 #else 133 # define BOOST_PROTO_PUSH_WARNINGS 134 # define BOOST_PROTO_POP_WARNINGS 135 # define BOOST_PROTO_DISABLE_MSVC_C4180 136 # define BOOST_PROTO_DISABLE_MSVC_C4522 137 # define BOOST_PROTO_DISABLE_MSVC_C4714 138 #endif 139 140 namespace boost { namespace proto 141 { 142 namespace detail 143 { 144 typedef char yes_type; 145 typedef char (&no_type)[2]; 146 147 template<int N> 148 struct sized_type 149 { 150 typedef char (&type)[N]; 151 }; 152 153 struct dont_care; 154 struct undefined; // leave this undefined 155 struct not_a_valid_type; 156 157 struct private_type_ 158 { 159 private_type_ operator ,(int) const; 160 }; 161 162 template<typename T> 163 struct uncvref 164 { 165 typedef T type; 166 }; 167 168 template<typename T> 169 struct uncvref<T const> 170 { 171 typedef T type; 172 }; 173 174 template<typename T> 175 struct uncvref<T &> 176 { 177 typedef T type; 178 }; 179 180 template<typename T> 181 struct uncvref<T const &> 182 { 183 typedef T type; 184 }; 185 186 template<typename T, std::size_t N> 187 struct uncvref<T const[N]> 188 { 189 typedef T type[N]; 190 }; 191 192 template<typename T, std::size_t N> 193 struct uncvref<T (&)[N]> 194 { 195 typedef T type[N]; 196 }; 197 198 template<typename T, std::size_t N> 199 struct uncvref<T const (&)[N]> 200 { 201 typedef T type[N]; 202 }; 203 204 struct ignore 205 { ignoreboost::proto::detail::ignore206 ignore() 207 {} 208 209 template<typename T> ignoreboost::proto::detail::ignore210 ignore(T const &) 211 {} 212 }; 213 214 /// INTERNAL ONLY 215 /// 216 #define BOOST_PROTO_UNCVREF(X) \ 217 typename boost::proto::detail::uncvref<X>::type \ 218 /**/ 219 220 struct _default; 221 222 struct not_a_domain; 223 struct not_a_grammar; 224 struct not_a_generator; 225 226 template<typename T, typename Void = void> 227 struct is_transform_; 228 229 template<typename T, typename Void = void> 230 struct is_aggregate_; 231 232 template<typename Expr> 233 struct flat_view; 234 } 235 236 typedef detail::ignore const ignore; 237 238 namespace argsns_ 239 { 240 template<typename Arg0> 241 struct term; 242 243 #define M0(Z, N, DATA) \ 244 template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename Arg)> struct BOOST_PP_CAT(list, N); \ 245 /**/ 246 BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M0, ~) 247 #undef M0 248 } 249 250 using namespace argsns_; 251 252 /////////////////////////////////////////////////////////////////////////////// 253 // Operator tags 254 namespace tagns_ 255 { 256 namespace tag 257 { 258 struct terminal; 259 struct unary_plus; 260 struct negate; 261 struct dereference; 262 struct complement; 263 struct address_of; 264 struct logical_not; 265 struct pre_inc; 266 struct pre_dec; 267 struct post_inc; 268 struct post_dec; 269 270 struct shift_left; 271 struct shift_right; 272 struct multiplies; 273 struct divides; 274 struct modulus; 275 struct plus; 276 struct minus; 277 struct less; 278 struct greater; 279 struct less_equal; 280 struct greater_equal; 281 struct equal_to; 282 struct not_equal_to; 283 struct logical_or; 284 struct logical_and; 285 struct bitwise_and; 286 struct bitwise_or; 287 struct bitwise_xor; 288 struct comma; 289 struct mem_ptr; 290 291 struct assign; 292 struct shift_left_assign; 293 struct shift_right_assign; 294 struct multiplies_assign; 295 struct divides_assign; 296 struct modulus_assign; 297 struct plus_assign; 298 struct minus_assign; 299 struct bitwise_and_assign; 300 struct bitwise_or_assign; 301 struct bitwise_xor_assign; 302 struct subscript; 303 struct member; 304 struct if_else_; 305 struct function; 306 307 // Fusion tags 308 template<typename Tag, typename Domain> struct proto_expr; 309 template<typename Tag, typename Domain> struct proto_expr_iterator; 310 template<typename Tag, typename Domain> struct proto_flat_view; 311 } 312 } 313 314 using namespace tagns_; 315 316 template<typename Expr> 317 struct tag_of; 318 319 //////////////////////////////////////////////////////////////////////////////////////////////// 320 struct _; 321 322 //////////////////////////////////////////////////////////////////////////////////////////////// 323 struct default_generator; 324 325 struct basic_default_generator; 326 327 template<template<typename> class Extends> 328 struct generator; 329 330 template<template<typename> class Extends> 331 struct pod_generator; 332 333 struct by_value_generator; 334 335 template<typename First, typename Second> 336 struct compose_generators; 337 338 template<typename Generator, typename Void = void> 339 struct wants_basic_expr; 340 341 template<typename Generator> 342 struct use_basic_expr; 343 344 //////////////////////////////////////////////////////////////////////////////////////////////// 345 namespace domainns_ 346 { 347 typedef detail::not_a_domain no_super_domain; 348 349 template< 350 typename Generator = default_generator 351 , typename Grammar = proto::_ 352 , typename Super = no_super_domain 353 > 354 struct domain; 355 356 struct default_domain; 357 358 struct basic_default_domain; 359 360 struct deduce_domain; 361 362 template<typename Domain, typename Tag, typename Args, bool WantsBasicExpr = wants_basic_expr<typename Domain::proto_generator>::value> 363 struct base_expr; 364 } 365 366 using namespace domainns_; 367 368 //////////////////////////////////////////////////////////////////////////////////////////////// 369 namespace exprns_ 370 { 371 template<typename Tag, typename Args, long Arity = Args::arity> 372 struct basic_expr; 373 374 template<typename Tag, typename Args, long Arity = Args::arity> 375 struct expr; 376 377 template< 378 typename Expr 379 , typename Derived 380 , typename Domain = default_domain 381 , long Arity = Expr::proto_arity_c 382 > 383 struct extends; 384 385 template<typename This, typename Fun, typename Domain> 386 struct virtual_member; 387 388 struct is_proto_expr; 389 } 390 //////////////////////////////////////////////////////////////////////////////////////////////// 391 392 using exprns_::expr; 393 using exprns_::basic_expr; 394 using exprns_::extends; 395 using exprns_::is_proto_expr; 396 397 template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G, void)> 398 struct or_; 399 400 template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G, void)> 401 struct and_; 402 403 template<typename Grammar> 404 struct not_; 405 406 template<typename Condition, typename Then = _, typename Else = not_<_> > 407 struct if_; 408 409 template<typename Cases, typename Transform = tag_of<_>()> 410 struct switch_; 411 412 template<typename T> 413 struct exact; 414 415 template<typename T> 416 struct convertible_to; 417 418 template<typename Grammar> 419 struct vararg; 420 421 struct pack; 422 423 // Boost bug https://svn.boost.org/trac/boost/ticket/4602 424 //int const N = INT_MAX; 425 int const N = (INT_MAX >> 10); 426 427 namespace context 428 { 429 struct null_context; 430 431 template<typename Expr, typename Context, long Arity = Expr::proto_arity_c> 432 struct null_eval; 433 434 struct default_context; 435 436 template<typename Expr, typename Context, typename Tag = typename Expr::proto_tag, long Arity = Expr::proto_arity_c> 437 struct default_eval; 438 439 template<typename Derived, typename DefaultCtx = default_context> 440 struct callable_context; 441 442 template<typename Expr, typename Context, long Arity = Expr::proto_arity_c> 443 struct callable_eval; 444 } 445 446 using context::null_context; 447 using context::null_eval; 448 using context::default_context; 449 using context::default_eval; 450 using context::callable_context; 451 using context::callable_eval; 452 453 namespace utility 454 { 455 template<typename T, typename Domain = default_domain> 456 struct literal; 457 } 458 459 using utility::literal; 460 461 namespace result_of 462 { 463 template<typename T, typename Domain = default_domain> 464 struct as_expr; 465 466 template<typename T, typename Domain = default_domain> 467 struct as_child; 468 469 template<typename Expr, typename N = mpl::long_<0> > 470 struct child; 471 472 template<typename Expr, long N> 473 struct child_c; 474 475 template<typename Expr> 476 struct left; 477 478 template<typename Expr> 479 struct right; 480 481 template<typename Expr> 482 struct deep_copy; 483 484 template<typename Expr, typename Context> 485 struct eval; 486 487 template< 488 typename Tag 489 , typename DomainOrA0 490 BOOST_PP_ENUM_TRAILING_BINARY_PARAMS( 491 BOOST_PROTO_MAX_ARITY 492 , typename A 493 , = void BOOST_PP_INTERCEPT 494 ) 495 , typename Void = void 496 > 497 struct make_expr; 498 499 template<typename Tag, typename DomainOrSequence, typename SequenceOrVoid = void, typename Void = void> 500 struct unpack_expr; 501 502 template<typename T> 503 struct as_env; 504 505 template<typename Env, typename Tag> 506 struct has_env_var; 507 508 template<typename Env, typename Tag> 509 struct env_var; 510 } 511 512 template<typename T, typename Void = void> 513 struct is_expr; 514 515 template<typename T, typename Void = void> 516 struct is_domain; 517 518 template<typename SubDomain, typename SuperDomain> 519 struct is_sub_domain_of; 520 521 template<typename T, typename Void = void> 522 struct is_env; 523 524 template<typename Expr> 525 struct arity_of; 526 527 template<typename T, typename Void = void> 528 struct domain_of; 529 530 template<typename Expr, typename Grammar> 531 struct matches; 532 533 // Generic expression metafunctions and 534 // grammar elements 535 template<typename Tag, typename Arg> 536 struct unary_expr; 537 538 template<typename Tag, typename Left, typename Right> 539 struct binary_expr; 540 541 template<typename Tag, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_ARITY, typename A, void)> 542 struct nary_expr; 543 544 // Specific expression metafunctions and 545 // grammar elements, for convenience 546 template<typename T> struct terminal; 547 template<typename T> struct unary_plus; 548 template<typename T> struct negate; 549 template<typename T> struct dereference; 550 template<typename T> struct complement; 551 template<typename T> struct address_of; 552 template<typename T> struct logical_not; 553 template<typename T> struct pre_inc; 554 template<typename T> struct pre_dec; 555 template<typename T> struct post_inc; 556 template<typename T> struct post_dec; 557 558 template<typename T, typename U> struct shift_left; 559 template<typename T, typename U> struct shift_right; 560 template<typename T, typename U> struct multiplies; 561 template<typename T, typename U> struct divides; 562 template<typename T, typename U> struct modulus; 563 template<typename T, typename U> struct plus; 564 template<typename T, typename U> struct minus; 565 template<typename T, typename U> struct less; 566 template<typename T, typename U> struct greater; 567 template<typename T, typename U> struct less_equal; 568 template<typename T, typename U> struct greater_equal; 569 template<typename T, typename U> struct equal_to; 570 template<typename T, typename U> struct not_equal_to; 571 template<typename T, typename U> struct logical_or; 572 template<typename T, typename U> struct logical_and; 573 template<typename T, typename U> struct bitwise_and; 574 template<typename T, typename U> struct bitwise_or; 575 template<typename T, typename U> struct bitwise_xor; 576 template<typename T, typename U> struct comma; 577 template<typename T, typename U> struct mem_ptr; 578 579 template<typename T, typename U> struct assign; 580 template<typename T, typename U> struct shift_left_assign; 581 template<typename T, typename U> struct shift_right_assign; 582 template<typename T, typename U> struct multiplies_assign; 583 template<typename T, typename U> struct divides_assign; 584 template<typename T, typename U> struct modulus_assign; 585 template<typename T, typename U> struct plus_assign; 586 template<typename T, typename U> struct minus_assign; 587 template<typename T, typename U> struct bitwise_and_assign; 588 template<typename T, typename U> struct bitwise_or_assign; 589 template<typename T, typename U> struct bitwise_xor_assign; 590 template<typename T, typename U> struct subscript; 591 template<typename T, typename U> struct member; 592 template<typename T, typename U, typename V> struct if_else_; 593 594 template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_ARITY, typename A, void)> 595 struct function; 596 597 namespace functional 598 { 599 struct left; 600 struct right; 601 struct eval; 602 struct deep_copy; 603 604 template<typename Domain = default_domain> 605 struct as_expr; 606 607 template<typename Domain = default_domain> 608 struct as_child; 609 610 template<typename N = mpl::long_<0> > 611 struct child; 612 613 template<long N> 614 struct child_c; 615 616 struct as_env; 617 618 template<typename Tag> 619 struct has_env_var; 620 621 template<typename Tag> 622 struct env_var; 623 624 template<typename Tag, typename Domain = deduce_domain> 625 struct make_expr; 626 627 template<typename Tag, typename Domain = deduce_domain> 628 struct unpack_expr; 629 630 typedef make_expr<tag::terminal> make_terminal; 631 typedef make_expr<tag::unary_plus> make_unary_plus; 632 typedef make_expr<tag::negate> make_negate; 633 typedef make_expr<tag::dereference> make_dereference; 634 typedef make_expr<tag::complement> make_complement; 635 typedef make_expr<tag::address_of> make_address_of; 636 typedef make_expr<tag::logical_not> make_logical_not; 637 typedef make_expr<tag::pre_inc> make_pre_inc; 638 typedef make_expr<tag::pre_dec> make_pre_dec; 639 typedef make_expr<tag::post_inc> make_post_inc; 640 typedef make_expr<tag::post_dec> make_post_dec; 641 typedef make_expr<tag::shift_left> make_shift_left; 642 typedef make_expr<tag::shift_right> make_shift_right; 643 typedef make_expr<tag::multiplies> make_multiplies; 644 typedef make_expr<tag::divides> make_divides; 645 typedef make_expr<tag::modulus> make_modulus; 646 typedef make_expr<tag::plus> make_plus; 647 typedef make_expr<tag::minus> make_minus; 648 typedef make_expr<tag::less> make_less; 649 typedef make_expr<tag::greater> make_greater; 650 typedef make_expr<tag::less_equal> make_less_equal; 651 typedef make_expr<tag::greater_equal> make_greater_equal; 652 typedef make_expr<tag::equal_to> make_equal_to; 653 typedef make_expr<tag::not_equal_to> make_not_equal_to; 654 typedef make_expr<tag::logical_or> make_logical_or; 655 typedef make_expr<tag::logical_and> make_logical_and; 656 typedef make_expr<tag::bitwise_and> make_bitwise_and; 657 typedef make_expr<tag::bitwise_or> make_bitwise_or; 658 typedef make_expr<tag::bitwise_xor> make_bitwise_xor; 659 typedef make_expr<tag::comma> make_comma; 660 typedef make_expr<tag::mem_ptr> make_mem_ptr; 661 typedef make_expr<tag::assign> make_assign; 662 typedef make_expr<tag::shift_left_assign> make_shift_left_assign; 663 typedef make_expr<tag::shift_right_assign> make_shift_right_assign; 664 typedef make_expr<tag::multiplies_assign> make_multiplies_assign; 665 typedef make_expr<tag::divides_assign> make_divides_assign; 666 typedef make_expr<tag::modulus_assign> make_modulus_assign; 667 typedef make_expr<tag::plus_assign> make_plus_assign; 668 typedef make_expr<tag::minus_assign> make_minus_assign; 669 typedef make_expr<tag::bitwise_and_assign> make_bitwise_and_assign; 670 typedef make_expr<tag::bitwise_or_assign> make_bitwise_or_assign; 671 typedef make_expr<tag::bitwise_xor_assign> make_bitwise_xor_assign; 672 typedef make_expr<tag::subscript> make_subscript; 673 typedef make_expr<tag::if_else_> make_if_else; 674 typedef make_expr<tag::function> make_function; 675 676 struct flatten; 677 struct make_pair; 678 struct first; 679 struct second; 680 struct at; 681 struct pop_front; 682 struct push_front; 683 struct pop_back; 684 struct push_back; 685 struct reverse; 686 } 687 688 typedef functional::flatten _flatten; 689 typedef functional::make_pair _make_pair; 690 typedef functional::first _first; 691 typedef functional::second _second; 692 typedef functional::at _at; 693 typedef functional::pop_front _pop_front; 694 typedef functional::push_front _push_front; 695 typedef functional::pop_back _pop_back; 696 typedef functional::push_back _push_back; 697 typedef functional::reverse _reverse; 698 typedef functional::eval _eval; 699 struct _deep_copy; 700 701 typedef functional::make_expr<tag::terminal> _make_terminal; 702 typedef functional::make_expr<tag::unary_plus> _make_unary_plus; 703 typedef functional::make_expr<tag::negate> _make_negate; 704 typedef functional::make_expr<tag::dereference> _make_dereference; 705 typedef functional::make_expr<tag::complement> _make_complement; 706 typedef functional::make_expr<tag::address_of> _make_address_of; 707 typedef functional::make_expr<tag::logical_not> _make_logical_not; 708 typedef functional::make_expr<tag::pre_inc> _make_pre_inc; 709 typedef functional::make_expr<tag::pre_dec> _make_pre_dec; 710 typedef functional::make_expr<tag::post_inc> _make_post_inc; 711 typedef functional::make_expr<tag::post_dec> _make_post_dec; 712 typedef functional::make_expr<tag::shift_left> _make_shift_left; 713 typedef functional::make_expr<tag::shift_right> _make_shift_right; 714 typedef functional::make_expr<tag::multiplies> _make_multiplies; 715 typedef functional::make_expr<tag::divides> _make_divides; 716 typedef functional::make_expr<tag::modulus> _make_modulus; 717 typedef functional::make_expr<tag::plus> _make_plus; 718 typedef functional::make_expr<tag::minus> _make_minus; 719 typedef functional::make_expr<tag::less> _make_less; 720 typedef functional::make_expr<tag::greater> _make_greater; 721 typedef functional::make_expr<tag::less_equal> _make_less_equal; 722 typedef functional::make_expr<tag::greater_equal> _make_greater_equal; 723 typedef functional::make_expr<tag::equal_to> _make_equal_to; 724 typedef functional::make_expr<tag::not_equal_to> _make_not_equal_to; 725 typedef functional::make_expr<tag::logical_or> _make_logical_or; 726 typedef functional::make_expr<tag::logical_and> _make_logical_and; 727 typedef functional::make_expr<tag::bitwise_and> _make_bitwise_and; 728 typedef functional::make_expr<tag::bitwise_or> _make_bitwise_or; 729 typedef functional::make_expr<tag::bitwise_xor> _make_bitwise_xor; 730 typedef functional::make_expr<tag::comma> _make_comma; 731 typedef functional::make_expr<tag::mem_ptr> _make_mem_ptr; 732 typedef functional::make_expr<tag::assign> _make_assign; 733 typedef functional::make_expr<tag::shift_left_assign> _make_shift_left_assign; 734 typedef functional::make_expr<tag::shift_right_assign> _make_shift_right_assign; 735 typedef functional::make_expr<tag::multiplies_assign> _make_multiplies_assign; 736 typedef functional::make_expr<tag::divides_assign> _make_divides_assign; 737 typedef functional::make_expr<tag::modulus_assign> _make_modulus_assign; 738 typedef functional::make_expr<tag::plus_assign> _make_plus_assign; 739 typedef functional::make_expr<tag::minus_assign> _make_minus_assign; 740 typedef functional::make_expr<tag::bitwise_and_assign> _make_bitwise_and_assign; 741 typedef functional::make_expr<tag::bitwise_or_assign> _make_bitwise_or_assign; 742 typedef functional::make_expr<tag::bitwise_xor_assign> _make_bitwise_xor_assign; 743 typedef functional::make_expr<tag::subscript> _make_subscript; 744 typedef functional::make_expr<tag::if_else_> _make_if_else; 745 typedef functional::make_expr<tag::function> _make_function; 746 747 template<typename T> 748 struct is_callable; 749 750 template<typename T> 751 struct is_transform; 752 753 template<typename T> 754 struct is_aggregate; 755 756 #define BOOST_PROTO_UNEXPR() typedef int proto_is_expr_; 757 #define BOOST_PROTO_CALLABLE() typedef void proto_is_callable_; 758 #define BOOST_PROTO_AGGREGATE() typedef void proto_is_aggregate_; 759 #define BOOST_PROTO_USE_BASIC_EXPR() typedef void proto_use_basic_expr_; 760 761 struct callable 762 { 763 BOOST_PROTO_CALLABLE() 764 }; 765 766 namespace envns_ 767 { 768 struct key_not_found; 769 770 struct empty_env; 771 772 typedef int empty_state; 773 774 template<typename Tag, typename Value, typename Base = empty_env> 775 struct env; 776 777 struct data_type; 778 779 struct transforms_type; 780 } 781 782 using envns_::key_not_found; 783 using envns_::empty_env; 784 using envns_::empty_state; 785 using envns_::env; 786 using envns_::data_type; 787 using envns_::transforms_type; 788 789 struct external_transform; 790 791 template<typename PrimitiveTransform = void, typename X = void> 792 struct transform; 793 794 template<typename Grammar, typename Fun = Grammar> 795 struct when; 796 797 template<typename Fun> 798 struct otherwise; 799 800 template<typename Fun> 801 struct call; 802 803 template<typename Fun> 804 struct make; 805 806 template<typename PrimitiveTransform> 807 struct protect; 808 809 template<typename T> 810 struct noinvoke; 811 812 template<typename Fun> 813 struct lazy; 814 815 template<typename Sequence, typename State, typename Fun> 816 struct fold; 817 818 template<typename Sequence, typename State, typename Fun> 819 struct reverse_fold; 820 821 // Q: can we replace fold_tree with fold<flatten(_), state, fun> ? 822 // A: once segmented Fusion works well. 823 template<typename Sequence, typename State, typename Fun> 824 struct fold_tree; 825 826 template<typename Sequence, typename State, typename Fun> 827 struct reverse_fold_tree; 828 829 template<typename Grammar, typename Domain = deduce_domain> 830 struct pass_through; 831 832 template<typename Grammar = detail::_default> 833 struct _default; 834 835 struct _expr; 836 struct _state; 837 struct _data; 838 839 struct _value; 840 841 struct _void; 842 843 template<typename T, T I> 844 struct integral_c; 845 846 template<char I> 847 struct char_; 848 849 template<int I> 850 struct int_; 851 852 template<long I> 853 struct long_; 854 855 template<std::size_t I> 856 struct size_t; 857 858 template<int I> 859 struct _child_c; 860 861 typedef _child_c<0> _child0; 862 typedef _child_c<1> _child1; 863 typedef _child0 _child; 864 typedef _child0 _left; 865 typedef _child1 _right; 866 867 // _child2, _child3, _child4, ... 868 #define M0(Z, N, DATA) typedef _child_c<N> BOOST_PP_CAT(_child, N); 869 BOOST_PP_REPEAT_FROM_TO( 870 2 871 , BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY) 872 , M0 873 , ~ 874 ) 875 #undef M0 876 877 struct _byref; 878 struct _byval; 879 880 template<typename Tag> 881 struct _env_var; 882 883 struct _env; 884 885 template<typename T> 886 struct is_extension; 887 888 namespace exops = exprns_; 889 890 }} // namespace boost::proto 891 892 #endif 893