Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r58336 - in branches/release: . boost boost/algorithm/string boost/archive boost/config boost/filesystem boost/functional/hash boost/fusion boost/graph boost/interprocess boost/intrusive boost/iostreams boost/math boost/numeric/ublas boost/program_options boost/property_tree boost/proto boost/proto/context boost/proto/detail boost/proto/transform boost/python boost/regex boost/serialization boost/signals boost/signals2 boost/spirit boost/spirit/home boost/spirit/home/karma boost/spirit/home/support boost/spirit/repository/home/qi/nonterminal boost/system boost/thread boost/tr1 boost/type_traits boost/unordered boost/utility boost/variant boost/wave boost/xpressive boost/xpressive/detail boost/xpressive/detail/core boost/xpressive/detail/utility boost/xpressive/traits doc libs libs/config libs/filesystem libs/functional/hash libs/fusion libs/graph_parallel libs/interprocess libs/intrusive libs/iostreams libs/math libs/mpl/doc/refmanual libs/mpl/doc/src/refmanual libs/numeric/ublas libs/numeric/ublas/doc libs/program_options libs/property_tree libs/proto/test libs/python libs/regex libs/serialization libs/signals libs/signals2 libs/spirit libs/spirit/classic/example libs/spirit/doc libs/spirit/example libs/spirit/phoenix libs/spirit/test libs/spirit/test/qi libs/static_assert libs/system libs/thread libs/thread/doc libs/timer libs/tr1 libs/type_traits libs/unordered libs/utility libs/wave libs/xpressive/example libs/xpressive/test more people status tools tools/boostbook tools/build/v2 tools/inspect tools/quickbook tools/regression tools/release tools/wave wiki
From: eric_at_[hidden]
Date: 2009-12-13 02:29:14

Next message: gennadiy.rozental_at_[hidden]: "[Boost-commit] svn:boost r58337 - trunk/boost/test"
Previous message: gennadiy.rozental_at_[hidden]: "[Boost-commit] svn:boost r58335 - trunk/libs/test/example"

Author: eric_niebler
Date: 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
New Revision: 58336
URL: http://svn.boost.org/trac/boost/changeset/58336

Log:
assorted fixes to proto and xpressive merged to release from trunk
Added:
   branches/release/boost/xpressive/detail/core/list.hpp
      - copied, changed from r57174, /trunk/boost/xpressive/detail/core/list.hpp
   branches/release/boost/xpressive/detail/core/regex_domain.hpp
      - copied unchanged from r58323, /trunk/boost/xpressive/detail/core/regex_domain.hpp
Removed:
   branches/release/boost/proto/detail/prefix.hpp
   branches/release/boost/proto/detail/suffix.hpp
Properties modified:
   branches/release/ (props changed)
   branches/release/CMakeLists.txt (props changed)
   branches/release/INSTALL (props changed)
   branches/release/Jamroot (props changed)
   branches/release/LICENSE_1_0.txt (props changed)
   branches/release/boost/ (props changed)
   branches/release/boost-build.jam (props changed)
   branches/release/boost.css (props changed)
   branches/release/boost.png (props changed)
   branches/release/boost/algorithm/string/ (props changed)
   branches/release/boost/archive/ (props changed)
   branches/release/boost/config/ (props changed)
   branches/release/boost/filesystem/ (props changed)
   branches/release/boost/functional/hash/ (props changed)
   branches/release/boost/fusion/ (props changed)
   branches/release/boost/graph/ (props changed)
   branches/release/boost/interprocess/ (props changed)
   branches/release/boost/intrusive/ (props changed)
   branches/release/boost/iostreams/ (props changed)
   branches/release/boost/math/ (props changed)
   branches/release/boost/numeric/ublas/ (props changed)
   branches/release/boost/program_options/ (props changed)
   branches/release/boost/property_tree/ (props changed)
   branches/release/boost/python/ (props changed)
   branches/release/boost/regex/ (props changed)
   branches/release/boost/serialization/ (props changed)
   branches/release/boost/signals/ (props changed)
   branches/release/boost/signals2/ (props changed)
   branches/release/boost/spirit/ (props changed)
   branches/release/boost/spirit/home/ (props changed)
   branches/release/boost/spirit/home/karma/ (props changed)
   branches/release/boost/spirit/home/support/attributes.hpp (props changed)
   branches/release/boost/spirit/repository/home/qi/nonterminal/subrule.hpp (props changed)
   branches/release/boost/system/ (props changed)
   branches/release/boost/thread/ (props changed)
   branches/release/boost/thread.hpp (props changed)
   branches/release/boost/tr1/ (props changed)
   branches/release/boost/type_traits/ (props changed)
   branches/release/boost/unordered/ (props changed)
   branches/release/boost/utility/value_init.hpp (props changed)
   branches/release/boost/variant/ (props changed)
   branches/release/boost/version.hpp (props changed)
   branches/release/boost/wave/ (props changed)
   branches/release/bootstrap.bat (props changed)
   branches/release/bootstrap.sh (props changed)
   branches/release/doc/ (props changed)
   branches/release/index.htm (props changed)
   branches/release/index.html (props changed)
   branches/release/libs/ (props changed)
   branches/release/libs/config/ (props changed)
   branches/release/libs/filesystem/ (props changed)
   branches/release/libs/functional/hash/ (props changed)
   branches/release/libs/fusion/ (props changed)
   branches/release/libs/graph_parallel/ (props changed)
   branches/release/libs/interprocess/ (props changed)
   branches/release/libs/intrusive/ (props changed)
   branches/release/libs/iostreams/ (props changed)
   branches/release/libs/libraries.htm (props changed)
   branches/release/libs/maintainers.txt (props changed)
   branches/release/libs/math/ (props changed)
   branches/release/libs/mpl/doc/refmanual/broken-compiler-workarounds.html (props changed)
   branches/release/libs/mpl/doc/refmanual/categorized-index-concepts.html (props changed)
   branches/release/libs/mpl/doc/refmanual/cfg-no-preprocessed-headers.html (props changed)
   branches/release/libs/mpl/doc/refmanual/composition-and-argument-binding.html (props changed)
   branches/release/libs/mpl/doc/refmanual/data-types-concepts.html (props changed)
   branches/release/libs/mpl/doc/refmanual/data-types-miscellaneous.html (props changed)
   branches/release/libs/mpl/doc/refmanual/extensible-associative-sequence.html (props changed)
   branches/release/libs/mpl/doc/refmanual/inserter-class.html (props changed)
   branches/release/libs/mpl/doc/refmanual/tag-dispatched-metafunction.html (props changed)
   branches/release/libs/mpl/doc/refmanual/trivial-metafunctions-summary.html (props changed)
   branches/release/libs/mpl/doc/src/refmanual/Iterators-Iterator.rst (props changed)
   branches/release/libs/numeric/ublas/ (props changed)
   branches/release/libs/numeric/ublas/doc/ (props changed)
   branches/release/libs/program_options/ (props changed)
   branches/release/libs/property_tree/ (props changed)
   branches/release/libs/python/ (props changed)
   branches/release/libs/regex/ (props changed)
   branches/release/libs/serialization/ (props changed)
   branches/release/libs/signals/ (props changed)
   branches/release/libs/signals2/ (props changed)
   branches/release/libs/spirit/ (props changed)
   branches/release/libs/spirit/classic/example/ (props changed)
   branches/release/libs/spirit/doc/ (props changed)
   branches/release/libs/spirit/example/ (props changed)
   branches/release/libs/spirit/phoenix/ (props changed)
   branches/release/libs/spirit/test/ (props changed)
   branches/release/libs/spirit/test/qi/optional.cpp (props changed)
   branches/release/libs/static_assert/ (props changed)
   branches/release/libs/system/ (props changed)
   branches/release/libs/thread/ (props changed)
   branches/release/libs/thread/doc/ (props changed)
   branches/release/libs/timer/ (props changed)
   branches/release/libs/tr1/ (props changed)
   branches/release/libs/type_traits/ (props changed)
   branches/release/libs/unordered/ (props changed)
   branches/release/libs/utility/swap.html (props changed)
   branches/release/libs/utility/value_init.htm (props changed)
   branches/release/libs/utility/value_init_test.cpp (props changed)
   branches/release/libs/wave/ (props changed)
   branches/release/more/ (props changed)
   branches/release/people/ (props changed)
   branches/release/rst.css (props changed)
   branches/release/status/ (props changed)
   branches/release/tools/ (props changed)
   branches/release/tools/boostbook/ (props changed)
   branches/release/tools/build/v2/ (props changed)
   branches/release/tools/inspect/ (props changed)
   branches/release/tools/quickbook/ (props changed)
   branches/release/tools/regression/ (props changed)
   branches/release/tools/release/ (props changed)
   branches/release/tools/wave/ (props changed)
   branches/release/wiki/ (props changed)
Text files modified:
   branches/release/boost/proto/args.hpp | 240 +++++++++++------------
   branches/release/boost/proto/context.hpp | 2
   branches/release/boost/proto/context/callable.hpp | 6
   branches/release/boost/proto/context/default.hpp | 6
   branches/release/boost/proto/context/null.hpp | 4
   branches/release/boost/proto/core.hpp | 2
   branches/release/boost/proto/debug.hpp | 2
   branches/release/boost/proto/deep_copy.hpp | 2
   branches/release/boost/proto/detail/as_lvalue.hpp | 2
   branches/release/boost/proto/detail/decltype.hpp | 21 -
   branches/release/boost/proto/detail/deprecated.hpp | 2
   branches/release/boost/proto/domain.hpp | 153 +++++++-------
   branches/release/boost/proto/eval.hpp | 2
   branches/release/boost/proto/expr.hpp | 13
   branches/release/boost/proto/extends.hpp | 344 ++++++++++++++++-----------------
   branches/release/boost/proto/generate.hpp | 405 +++++++++++++++++++--------------------
   branches/release/boost/proto/literal.hpp | 4
   branches/release/boost/proto/make_expr.hpp | 62 ++---
   branches/release/boost/proto/matches.hpp | 12
   branches/release/boost/proto/operators.hpp | 142 ++++++++------
   branches/release/boost/proto/proto.hpp | 2
   branches/release/boost/proto/proto_fwd.hpp | 103 +++-------
   branches/release/boost/proto/proto_typeof.hpp | 2
   branches/release/boost/proto/repeat.hpp | 2
   branches/release/boost/proto/tags.hpp | 2
   branches/release/boost/proto/traits.hpp | 26 +-
   branches/release/boost/proto/transform.hpp | 2
   branches/release/boost/proto/transform/arg.hpp | 2
   branches/release/boost/proto/transform/call.hpp | 2
   branches/release/boost/proto/transform/default.hpp | 4
   branches/release/boost/proto/transform/fold.hpp | 72 ++----
   branches/release/boost/proto/transform/fold_tree.hpp | 2
   branches/release/boost/proto/transform/impl.hpp | 2
   branches/release/boost/proto/transform/lazy.hpp | 2
   branches/release/boost/proto/transform/make.hpp | 2
   branches/release/boost/proto/transform/pass_through.hpp | 2
   branches/release/boost/proto/transform/when.hpp | 4
   branches/release/boost/xpressive/basic_regex.hpp | 11
   branches/release/boost/xpressive/detail/core/access.hpp | 6
   branches/release/boost/xpressive/detail/core/list.hpp | 74 +++----
   branches/release/boost/xpressive/detail/core/results_cache.hpp | 180 ++++++++---------
   branches/release/boost/xpressive/detail/core/state.hpp | 4
   branches/release/boost/xpressive/detail/core/sub_match_impl.hpp | 21 -
   branches/release/boost/xpressive/detail/detail_fwd.hpp | 7
   branches/release/boost/xpressive/detail/utility/sequence_stack.hpp | 50 +++-
   branches/release/boost/xpressive/match_results.hpp | 52 ++--
   branches/release/boost/xpressive/regex_primitives.hpp | 19 +
   branches/release/boost/xpressive/traits/cpp_regex_traits.hpp | 2
   branches/release/boost/xpressive/xpressive_fwd.hpp | 5
   branches/release/libs/proto/test/examples.cpp | 11
   branches/release/libs/proto/test/lambda.cpp | 13 -
   branches/release/libs/proto/test/make_expr.cpp | 5
   branches/release/libs/proto/test/proto_fusion.cpp | 5
   branches/release/libs/proto/test/proto_fusion_s.cpp | 5
   branches/release/libs/proto/test/toy_spirit2.cpp | 31 +-
   branches/release/libs/xpressive/example/example.vcproj | 196 +-----------------
   branches/release/libs/xpressive/test/Jamfile.v2 | 1
   branches/release/libs/xpressive/test/test.hpp | 2
   58 files changed, 1012 insertions(+), 1347 deletions(-)

Modified: branches/release/boost/proto/args.hpp
==============================================================================
--- branches/release/boost/proto/args.hpp (original)
+++ branches/release/boost/proto/args.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -11,7 +11,6 @@
     #ifndef BOOST_PROTO_ARGS_HPP_EAN_04_01_2005
     #define BOOST_PROTO_ARGS_HPP_EAN_04_01_2005

- #include <boost/proto/detail/prefix.hpp>
     #include <boost/config.hpp>
     #include <boost/detail/workaround.hpp>
     #include <boost/preprocessor/cat.hpp>
@@ -24,145 +23,140 @@
     #include <boost/mpl/if.hpp>
     #include <boost/mpl/void.hpp>
     #include <boost/proto/proto_fwd.hpp>
- #include <boost/proto/detail/suffix.hpp>

     namespace boost { namespace proto
     {
         namespace detail
         {
- /// INTERNAL ONLY
- template<typename Expr>
- struct expr_traits
- {
- typedef Expr value_type;
- typedef Expr &reference;
- typedef Expr const &const_reference;
- };
-
- /// INTERNAL ONLY
- template<typename Expr>
- struct expr_traits<Expr &>
- {
- typedef Expr value_type;
- typedef Expr &reference;
- typedef Expr &const_reference;
- };
-
- /// INTERNAL ONLY
- template<typename Expr>
- struct expr_traits<Expr const &>
- {
- typedef Expr value_type;
- typedef Expr const &reference;
- typedef Expr const &const_reference;
- };
-
- /// INTERNAL ONLY
- template<typename T>
- struct term_traits
- {
- typedef T value_type;
- typedef T &reference;
- typedef T const &const_reference;
- };
-
- /// INTERNAL ONLY
- template<typename T>
- struct term_traits<T &>
- {
- typedef typename mpl::if_c<is_function<T>::value, T &, T>::type value_type;
- typedef T &reference;
- typedef T &const_reference;
- };
-
- /// INTERNAL ONLY
- template<typename T>
- struct term_traits<T const &>
- {
- typedef T value_type;
- typedef T const &reference;
- typedef T const &const_reference;
- };
-
- /// INTERNAL ONLY
- template<typename T, std::size_t N>
- struct term_traits<T (&)[N]>
- {
- typedef T value_type[N];
- typedef T (&reference)[N];
- typedef T (&const_reference)[N];
- };
-
- /// INTERNAL ONLY
- template<typename T, std::size_t N>
- struct term_traits<T const (&)[N]>
- {
- typedef T value_type[N];
- typedef T const (&reference)[N];
- typedef T const (&const_reference)[N];
- };
-
- /// INTERNAL ONLY
- template<typename T, std::size_t N>
- struct term_traits<T[N]>
- {
- typedef T value_type[N];
- typedef T (&reference)[N];
- typedef T const (&const_reference)[N];
- };
-
- /// INTERNAL ONLY
- template<typename T, std::size_t N>
- struct term_traits<T const[N]>
- {
- typedef T value_type[N];
- typedef T const (&reference)[N];
- typedef T const (&const_reference)[N];
- };
+ /// INTERNAL ONLY
+ template<typename Expr>
+ struct expr_traits
+ {
+ typedef Expr value_type;
+ typedef Expr &reference;
+ typedef Expr const &const_reference;
+ };

- }
+ /// INTERNAL ONLY
+ template<typename Expr>
+ struct expr_traits<Expr &>
+ {
+ typedef Expr value_type;
+ typedef Expr &reference;
+ typedef Expr &const_reference;
+ };

- ////////////////////////////////////////////////////////////////////////////////////////////
- BOOST_PROTO_BEGIN_ADL_NAMESPACE(argsns_)
+ /// INTERNAL ONLY
+ template<typename Expr>
+ struct expr_traits<Expr const &>
+ {
+ typedef Expr value_type;
+ typedef Expr const &reference;
+ typedef Expr const &const_reference;
+ };

- #define BOOST_PROTO_DEFINE_CHILD_N(Z, N, DATA) \
- typedef BOOST_PP_CAT(Arg, N) BOOST_PP_CAT(child, N); \
- /**< INTERNAL ONLY */
-
- #define BOOST_PROTO_DEFINE_VOID_N(z, n, data) \
- typedef mpl::void_ BOOST_PP_CAT(child, n); \
- /**< INTERNAL ONLY */
+ /// INTERNAL ONLY
+ template<typename T>
+ struct term_traits
+ {
+ typedef T value_type;
+ typedef T &reference;
+ typedef T const &const_reference;
+ };

- /// \brief A type sequence, for use as the 2nd parameter to the \c expr\<\> class template.
- ///
- /// A type sequence, for use as the 2nd parameter to the \c expr\<\> class template.
- /// The types in the sequence correspond to the children of a node in an expression tree.
- template< typename Arg0 >
- struct term
- {
- BOOST_STATIC_CONSTANT(long, arity = 0);
- typedef Arg0 child0;
+ /// INTERNAL ONLY
+ template<typename T>
+ struct term_traits<T &>
+ {
+ typedef typename mpl::if_c<is_function<T>::value, T &, T>::type value_type;
+ typedef T &reference;
+ typedef T &const_reference;
+ };

- #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
- BOOST_PP_REPEAT_FROM_TO(1, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_DEFINE_VOID_N, ~)
- #endif
+ /// INTERNAL ONLY
+ template<typename T>
+ struct term_traits<T const &>
+ {
+ typedef T value_type;
+ typedef T const &reference;
+ typedef T const &const_reference;
+ };

             /// INTERNAL ONLY
- ///
- typedef Arg0 back_;
- };
+ template<typename T, std::size_t N>
+ struct term_traits<T (&)[N]>
+ {
+ typedef T value_type[N];
+ typedef T (&reference)[N];
+ typedef T (&const_reference)[N];
+ };
+
+ /// INTERNAL ONLY
+ template<typename T, std::size_t N>
+ struct term_traits<T const (&)[N]>
+ {
+ typedef T value_type[N];
+ typedef T const (&reference)[N];
+ typedef T const (&const_reference)[N];
+ };

- #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/args.hpp>))
- #include BOOST_PP_ITERATE()
+ /// INTERNAL ONLY
+ template<typename T, std::size_t N>
+ struct term_traits<T[N]>
+ {
+ typedef T value_type[N];
+ typedef T (&reference)[N];
+ typedef T const (&const_reference)[N];
+ };

- #undef BOOST_PROTO_DEFINE_CHILD_N
+ /// INTERNAL ONLY
+ template<typename T, std::size_t N>
+ struct term_traits<T const[N]>
+ {
+ typedef T value_type[N];
+ typedef T const (&reference)[N];
+ typedef T const (&const_reference)[N];
+ };
+ }

- BOOST_PROTO_END_ADL_NAMESPACE(argsns_)
         ////////////////////////////////////////////////////////////////////////////////////////////
+ namespace argsns_
+ {

- #ifndef BOOST_PROTO_BUILDING_DOCS
- using namespace argsns_;
- #endif
+ #define BOOST_PROTO_DEFINE_CHILD_N(Z, N, DATA) \
+ typedef BOOST_PP_CAT(Arg, N) BOOST_PP_CAT(child, N); \
+ /**< INTERNAL ONLY */
+
+ #define BOOST_PROTO_DEFINE_VOID_N(z, n, data) \
+ typedef mpl::void_ BOOST_PP_CAT(child, n); \
+ /**< INTERNAL ONLY */
+
+ /// \brief A type sequence, for use as the 2nd parameter to the \c expr\<\> class template.
+ ///
+ /// A type sequence, for use as the 2nd parameter to the \c expr\<\> class template.
+ /// The types in the sequence correspond to the children of a node in an expression tree.
+ template< typename Arg0 >
+ struct term
+ {
+ BOOST_STATIC_CONSTANT(long, arity = 0);
+ typedef Arg0 child0;
+
+ #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+ BOOST_PP_REPEAT_FROM_TO(1, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_DEFINE_VOID_N, ~)
+ #endif
+
+ /// INTERNAL ONLY
+ ///
+ typedef Arg0 back_;
+ };
+
+ #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/args.hpp>))
+ #include BOOST_PP_ITERATE()
+
+ #undef BOOST_PROTO_DEFINE_CHILD_N
+
+ }
+ ////////////////////////////////////////////////////////////////////////////////////////////
     }}
     #endif

Modified: branches/release/boost/proto/context.hpp
==============================================================================
--- branches/release/boost/proto/context.hpp (original)
+++ branches/release/boost/proto/context.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -9,10 +9,8 @@
#ifndef BOOST_PROTO_CONTEXT_HPP_EAN_06_23_2007
#define BOOST_PROTO_CONTEXT_HPP_EAN_06_23_2007

-#include <boost/proto/detail/prefix.hpp> // must be first include
#include <boost/proto/context/null.hpp>
#include <boost/proto/context/default.hpp>
#include <boost/proto/context/callable.hpp>
-#include <boost/proto/detail/suffix.hpp> // must be last include

#endif

Modified: branches/release/boost/proto/context/callable.hpp
==============================================================================
--- branches/release/boost/proto/context/callable.hpp (original)
+++ branches/release/boost/proto/context/callable.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -14,7 +14,6 @@
     #ifndef BOOST_PROTO_CONTEXT_CALLABLE_HPP_EAN_06_23_2007
     #define BOOST_PROTO_CONTEXT_CALLABLE_HPP_EAN_06_23_2007

- #include <boost/proto/detail/prefix.hpp> // must be first include
     #include <boost/config.hpp>
     #include <boost/detail/workaround.hpp>
     #include <boost/preprocessor/cat.hpp>
@@ -32,7 +31,6 @@
     #include <boost/type_traits/remove_cv.hpp>
     #include <boost/proto/proto_fwd.hpp>
     #include <boost/proto/traits.hpp> // for child_c
- #include <boost/proto/detail/suffix.hpp> // must be last include

     namespace boost { namespace proto
     {
@@ -86,7 +84,7 @@
             template<
                 typename Expr
               , typename Context
- , long Arity BOOST_PROTO_WHEN_BUILDING_DOCS(= Expr::proto_arity_c)
+ , long Arity // = Expr::proto_arity_c
>
             struct callable_eval
             {};
@@ -191,7 +189,7 @@
             /// \endcode
             template<
                 typename Context
- , typename DefaultCtx BOOST_PROTO_WHEN_BUILDING_DOCS(= default_context)
+ , typename DefaultCtx // = default_context
>
             struct callable_context
             {

Modified: branches/release/boost/proto/context/default.hpp
==============================================================================
--- branches/release/boost/proto/context/default.hpp (original)
+++ branches/release/boost/proto/context/default.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -12,7 +12,6 @@
     #ifndef BOOST_PROTO_CONTEXT_DEFAULT_HPP_EAN_01_08_2007
     #define BOOST_PROTO_CONTEXT_DEFAULT_HPP_EAN_01_08_2007

- #include <boost/proto/detail/prefix.hpp> // must be first include
     #include <boost/config.hpp>
     #include <boost/preprocessor/iteration/iterate.hpp>
     #include <boost/preprocessor/repetition/enum_shifted.hpp>
@@ -28,7 +27,6 @@
     #include <boost/proto/eval.hpp>
     #include <boost/proto/traits.hpp> // for proto::child_c()
     #include <boost/proto/detail/decltype.hpp>
- #include <boost/proto/detail/suffix.hpp> // must be last include

     namespace boost { namespace proto
     {
@@ -41,8 +39,8 @@
             template<
                 typename Expr
               , typename Context
- , typename Tag BOOST_PROTO_WHEN_BUILDING_DOCS(= typename Expr::proto_tag)
- , long Arity BOOST_PROTO_WHEN_BUILDING_DOCS(= Expr::proto_arity_c)
+ , typename Tag // = typename Expr::proto_tag
+ , long Arity // = Expr::proto_arity_c
>
             struct default_eval
             {};

Modified: branches/release/boost/proto/context/null.hpp
==============================================================================
--- branches/release/boost/proto/context/null.hpp (original)
+++ branches/release/boost/proto/context/null.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -12,13 +12,11 @@
     #ifndef BOOST_PROTO_CONTEXT_NULL_HPP_EAN_06_24_2007
     #define BOOST_PROTO_CONTEXT_NULL_HPP_EAN_06_24_2007

- #include <boost/proto/detail/prefix.hpp> // must be first include
     #include <boost/preprocessor/iteration/iterate.hpp>
     #include <boost/preprocessor/repetition/repeat.hpp>
     #include <boost/proto/proto_fwd.hpp>
     #include <boost/proto/eval.hpp>
     #include <boost/proto/traits.hpp>
- #include <boost/proto/detail/suffix.hpp> // must be last include

     namespace boost { namespace proto { namespace context
     {
@@ -26,7 +24,7 @@
         template<
             typename Expr
           , typename Context
- , long Arity BOOST_PROTO_WHEN_BUILDING_DOCS(= Expr::proto_arity_c)
+ , long Arity // = Expr::proto_arity_c
>
         struct null_eval
         {};

Modified: branches/release/boost/proto/core.hpp
==============================================================================
--- branches/release/boost/proto/core.hpp (original)
+++ branches/release/boost/proto/core.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -10,7 +10,6 @@
#ifndef BOOST_PROTO_CORE_HPP_EAN_04_01_2005
#define BOOST_PROTO_CORE_HPP_EAN_04_01_2005

-#include <boost/proto/detail/prefix.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/args.hpp>
#include <boost/proto/tags.hpp>
@@ -27,6 +26,5 @@
#include <boost/proto/operators.hpp>
#include <boost/proto/deep_copy.hpp>
#include <boost/proto/make_expr.hpp>
-#include <boost/proto/detail/suffix.hpp>

#endif

Modified: branches/release/boost/proto/debug.hpp
==============================================================================
--- branches/release/boost/proto/debug.hpp (original)
+++ branches/release/boost/proto/debug.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -9,7 +9,6 @@
#ifndef BOOST_PROTO_DEBUG_HPP_EAN_12_31_2006
#define BOOST_PROTO_DEBUG_HPP_EAN_12_31_2006

-#include <boost/proto/detail/prefix.hpp>
#include <boost/preprocessor/iteration/local.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <iomanip>
@@ -19,7 +18,6 @@
#include <boost/proto/expr.hpp>
#include <boost/proto/traits.hpp>
#include <boost/proto/detail/dont_care.hpp>
-#include <boost/proto/detail/suffix.hpp>

namespace boost { namespace proto
{

Modified: branches/release/boost/proto/deep_copy.hpp
==============================================================================
--- branches/release/boost/proto/deep_copy.hpp (original)
+++ branches/release/boost/proto/deep_copy.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -10,7 +10,6 @@
     #ifndef BOOST_PROTO_DEEP_COPY_HPP_EAN_11_21_2006
     #define BOOST_PROTO_DEEP_COPY_HPP_EAN_11_21_2006

- #include <boost/proto/detail/prefix.hpp>
     #include <boost/preprocessor/cat.hpp>
     #include <boost/preprocessor/repetition/enum.hpp>
     #include <boost/preprocessor/iteration/iterate.hpp>
@@ -19,7 +18,6 @@
     #include <boost/type_traits/remove_reference.hpp>
     #include <boost/proto/proto_fwd.hpp>
     #include <boost/proto/expr.hpp>
- #include <boost/proto/detail/suffix.hpp>

     namespace boost { namespace proto
     {

Modified: branches/release/boost/proto/detail/as_lvalue.hpp
==============================================================================
--- branches/release/boost/proto/detail/as_lvalue.hpp (original)
+++ branches/release/boost/proto/detail/as_lvalue.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -9,9 +9,7 @@
#ifndef BOOST_PROTO_TRANSFORM_AS_LVALUE_HPP_EAN_12_27_2007
#define BOOST_PROTO_TRANSFORM_AS_LVALUE_HPP_EAN_12_27_2007

-#include <boost/proto/detail/prefix.hpp>
#include <boost/proto/proto_fwd.hpp>
-#include <boost/proto/detail/suffix.hpp>

namespace boost { namespace proto
{

Modified: branches/release/boost/proto/detail/decltype.hpp
==============================================================================
--- branches/release/boost/proto/detail/decltype.hpp (original)
+++ branches/release/boost/proto/detail/decltype.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -9,7 +9,6 @@
#ifndef BOOST_PROTO_DETAIL_DECLTYPE_HPP_EAN_04_04_2008
#define BOOST_PROTO_DETAIL_DECLTYPE_HPP_EAN_04_04_2008

-#include <boost/proto/detail/prefix.hpp> // must be first include
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/get_pointer.hpp>
@@ -35,15 +34,11 @@
#include <boost/utility/result_of.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/proto/repeat.hpp>
-#include <boost/proto/detail/suffix.hpp> // must be last include

-// If we're generating doxygen documentation, hide all the nasty
-// Boost.Typeof gunk.
-#ifndef BOOST_PROTO_BUILDING_DOCS
-# ifdef BOOST_HAS_DECLTYPE
-# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) typedef decltype(EXPR) TYPE;
-# else
-# define BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(NESTED, EXPR) \
+#ifdef BOOST_HAS_DECLTYPE
+# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) typedef decltype(EXPR) TYPE;
+#else
+# define BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(NESTED, EXPR) \
     BOOST_TYPEOF_NESTED_TYPEDEF_TPL(BOOST_PP_CAT(nested_and_hidden_, NESTED), EXPR) \
     static int const sz = sizeof(boost::proto::detail::check_reference(EXPR)); \
     struct NESTED \
@@ -53,15 +48,9 @@
           , typename BOOST_PP_CAT(nested_and_hidden_, NESTED)::type \
> \
     {};
-# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) \
+# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) \
     BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(BOOST_PP_CAT(nested_, TYPE), (EXPR)) \
     typedef typename BOOST_PP_CAT(nested_, TYPE)::type TYPE;
-# endif
-#else
-/// INTERNAL ONLY
-///
-# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) \
- typedef detail::unspecified TYPE;
#endif

namespace boost { namespace proto

Modified: branches/release/boost/proto/detail/deprecated.hpp
==============================================================================
--- branches/release/boost/proto/detail/deprecated.hpp (original)
+++ branches/release/boost/proto/detail/deprecated.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -10,7 +10,6 @@
#ifndef BOOST_PROTO_DETAIL_DEPRECATED_HPP_EAN_11_25_2008
#define BOOST_PROTO_DETAIL_DEPRECATED_HPP_EAN_11_25_2008

-#include <boost/proto/detail/prefix.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/facilities/intercept.hpp>
#include <boost/preprocessor/arithmetic/inc.hpp>
@@ -37,7 +36,6 @@
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
#include <boost/proto/proto_fwd.hpp>
-#include <boost/proto/detail/suffix.hpp>

/// INTERNAL ONLY
///

Deleted: branches/release/boost/proto/detail/prefix.hpp
==============================================================================
--- branches/release/boost/proto/detail/prefix.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
+++ (empty file)
@@ -1,10 +0,0 @@
-#if defined(__WAVE__) && defined(BOOST_PROTO_BUILDING_DOCS)
-#pragma wave option(output:push)
-#pragma wave option(output:null)
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// Copyright 2008 Eric Niebler. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-///////////////////////////////////////////////////////////////////////////////

Deleted: branches/release/boost/proto/detail/suffix.hpp
==============================================================================
--- branches/release/boost/proto/detail/suffix.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
+++ (empty file)
@@ -1,16 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright 2008 Eric Niebler. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-///////////////////////////////////////////////////////////////////////////////
-
-#if defined(__WAVE__) && defined(BOOST_PROTO_BUILDING_DOCS)
-#pragma wave option(output:pop)
-#endif
-
-#ifndef BOOST_PROTO_SUFFIX_DUMMY_STRUCT_DEFINED
-#define BOOST_PROTO_SUFFIX_DUMMY_STRUCT_DEFINED
-/// INTERNAL ONLY
-///
-struct a_dummy_struct;
-#endif

Modified: branches/release/boost/proto/domain.hpp
==============================================================================
--- branches/release/boost/proto/domain.hpp (original)
+++ branches/release/boost/proto/domain.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -11,12 +11,10 @@
#ifndef BOOST_PROTO_DOMAIN_HPP_EAN_02_13_2007
#define BOOST_PROTO_DOMAIN_HPP_EAN_02_13_2007

-#include <boost/proto/detail/prefix.hpp>
#include <boost/ref.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/generate.hpp>
-#include <boost/proto/detail/suffix.hpp>

namespace boost { namespace proto
{
@@ -30,84 +28,83 @@
         {};
     }

- BOOST_PROTO_BEGIN_ADL_NAMESPACE(domainns_)
-
- /// \brief For use in defining domain tags to be used
- /// with \c proto::extends\<\>. A \e Domain associates
- /// an expression type with a \e Generator, and optionally
- /// a \e Grammar.
- ///
- /// The Generator determines how new expressions in the
- /// domain are constructed. Typically, a generator wraps
- /// all new expressions in a wrapper that imparts
- /// domain-specific behaviors to expressions within its
- /// domain. (See \c proto::extends\<\>.)
- ///
- /// The Grammar determines whether a given expression is
- /// valid within the domain, and automatically disables
- /// any operator overloads which would cause an invalid
- /// expression to be created. By default, the Grammar
- /// parameter defaults to the wildcard, \c proto::_, which
- /// makes all expressions valid within the domain.
- ///
- /// Example:
- /// \code
- /// template<typename Expr>
- /// struct MyExpr;
- ///
- /// struct MyGrammar
- /// : or_< terminal<_>, plus<MyGrammar, MyGrammar> >
- /// {};
- ///
- /// // Define MyDomain, in which all expressions are
- /// // wrapped in MyExpr<> and only expressions that
- /// // conform to MyGrammar are allowed.
- /// struct MyDomain
- /// : domain<generator<MyExpr>, MyGrammar>
- /// {};
- ///
- /// // Use MyDomain to define MyExpr
- /// template<typename Expr>
- /// struct MyExpr
- /// : extends<Expr, MyExpr<Expr>, MyDomain>
- /// {
- /// // ...
- /// };
- /// \endcode
- ///
- template<
- typename Generator BOOST_PROTO_WHEN_BUILDING_DOCS(= default_generator)
- , typename Grammar BOOST_PROTO_WHEN_BUILDING_DOCS(= proto::_)
- >
- struct domain
- : Generator
+ namespace domainns_
     {
- typedef Grammar proto_grammar;
+ /// \brief For use in defining domain tags to be used
+ /// with \c proto::extends\<\>. A \e Domain associates
+ /// an expression type with a \e Generator, and optionally
+ /// a \e Grammar.
+ ///
+ /// The Generator determines how new expressions in the
+ /// domain are constructed. Typically, a generator wraps
+ /// all new expressions in a wrapper that imparts
+ /// domain-specific behaviors to expressions within its
+ /// domain. (See \c proto::extends\<\>.)
+ ///
+ /// The Grammar determines whether a given expression is
+ /// valid within the domain, and automatically disables
+ /// any operator overloads which would cause an invalid
+ /// expression to be created. By default, the Grammar
+ /// parameter defaults to the wildcard, \c proto::_, which
+ /// makes all expressions valid within the domain.
+ ///
+ /// Example:
+ /// \code
+ /// template<typename Expr>
+ /// struct MyExpr;
+ ///
+ /// struct MyGrammar
+ /// : or_< terminal<_>, plus<MyGrammar, MyGrammar> >
+ /// {};
+ ///
+ /// // Define MyDomain, in which all expressions are
+ /// // wrapped in MyExpr<> and only expressions that
+ /// // conform to MyGrammar are allowed.
+ /// struct MyDomain
+ /// : domain<generator<MyExpr>, MyGrammar>
+ /// {};
+ ///
+ /// // Use MyDomain to define MyExpr
+ /// template<typename Expr>
+ /// struct MyExpr
+ /// : extends<Expr, MyExpr<Expr>, MyDomain>
+ /// {
+ /// // ...
+ /// };
+ /// \endcode
+ ///
+ template<
+ typename Generator // = default_generator
+ , typename Grammar // = proto::_
+ >
+ struct domain
+ : Generator
+ {
+ typedef Grammar proto_grammar;

- /// INTERNAL ONLY
- typedef void proto_is_domain_;
- };
+ /// INTERNAL ONLY
+ typedef void proto_is_domain_;
+ };

- /// \brief The domain expressions have by default, if
- /// \c proto::extends\<\> has not been used to associate
- /// a domain with an expression.
- ///
- struct default_domain
- : domain<>
- {};
-
- /// \brief A pseudo-domain for use in functions and
- /// metafunctions that require a domain parameter. It
- /// indicates that the domain of the parent node should
- /// be inferred from the domains of the child nodes.
- ///
- /// \attention \c deduce_domain is not itself a valid domain.
- ///
- struct deduce_domain
- : domain<detail::not_a_generator, detail::not_a_grammar>
- {};
+ /// \brief The domain expressions have by default, if
+ /// \c proto::extends\<\> has not been used to associate
+ /// a domain with an expression.
+ ///
+ struct default_domain
+ : domain<>
+ {};

- BOOST_PROTO_END_ADL_NAMESPACE(domainns_)
+ /// \brief A pseudo-domain for use in functions and
+ /// metafunctions that require a domain parameter. It
+ /// indicates that the domain of the parent node should
+ /// be inferred from the domains of the child nodes.
+ ///
+ /// \attention \c deduce_domain is not itself a valid domain.
+ ///
+ struct deduce_domain
+ : domain<detail::not_a_generator, detail::not_a_grammar>
+ {};
+ }

     namespace result_of
     {
@@ -116,7 +113,7 @@
         /// \c mpl::false_ otherwise. If \c T inherits from
         /// \c proto::domain\<\>, \c is_domain\<T\> is
         /// \c mpl::true_.
- template<typename T, typename Void BOOST_PROTO_WHEN_BUILDING_DOCS(= void)>
+ template<typename T, typename Void /* = void*/>
         struct is_domain
           : mpl::false_
         {};
@@ -133,7 +130,7 @@
         /// type, it returns that expression's associated
         /// domain. If not, it returns
         /// \c proto::default_domain.
- template<typename T, typename Void BOOST_PROTO_WHEN_BUILDING_DOCS(= void)>
+ template<typename T, typename Void /* = void*/>
         struct domain_of
         {
             typedef default_domain type;

Modified: branches/release/boost/proto/eval.hpp
==============================================================================
--- branches/release/boost/proto/eval.hpp (original)
+++ branches/release/boost/proto/eval.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -9,10 +9,8 @@
#ifndef BOOST_PROTO_EVAL_HPP_EAN_03_29_2007
#define BOOST_PROTO_EVAL_HPP_EAN_03_29_2007

-#include <boost/proto/detail/prefix.hpp> // must be first include
#include <boost/proto/proto_fwd.hpp> // BOOST_PROTO_CALLABLE
#include <boost/type_traits/remove_reference.hpp>
-#include <boost/proto/detail/suffix.hpp> // must be last include

namespace boost { namespace proto
{

Modified: branches/release/boost/proto/expr.hpp
==============================================================================
--- branches/release/boost/proto/expr.hpp (original)
+++ branches/release/boost/proto/expr.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -10,7 +10,6 @@
     #ifndef BOOST_PROTO_EXPR_HPP_EAN_04_01_2005
     #define BOOST_PROTO_EXPR_HPP_EAN_04_01_2005

- #include <boost/proto/detail/prefix.hpp>
     #include <boost/preprocessor/cat.hpp>
     #include <boost/preprocessor/arithmetic/dec.hpp>
     #include <boost/preprocessor/selection/max.hpp>
@@ -26,7 +25,6 @@
     #include <boost/proto/proto_fwd.hpp>
     #include <boost/proto/args.hpp>
     #include <boost/proto/traits.hpp>
- #include <boost/proto/detail/suffix.hpp>

     #if defined(_MSC_VER) && (_MSC_VER >= 1020)
     # pragma warning(push)
@@ -136,10 +134,11 @@
         // a basic_expr because they should be layout compatible. Or not, because
         // that would incur an extra template instantiation. :-(

- BOOST_PROTO_BEGIN_ADL_NAMESPACE(exprns_)
- #define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/expr.hpp>))
- #include BOOST_PP_ITERATE()
- BOOST_PROTO_END_ADL_NAMESPACE(exprns_)
+ namespace exprns_
+ {
+ #define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/expr.hpp>))
+ #include BOOST_PP_ITERATE()
+ }

         #undef BOOST_PROTO_CHILD
         #undef BOOST_PROTO_VOID
@@ -221,7 +220,7 @@
             typedef BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)> proto_args;
             #endif
             typedef default_domain proto_domain;
- BOOST_PROTO_FUSION_DEFINE_TAG(proto::tag::proto_expr)
+ typedef proto::tag::proto_expr fusion_tag;
             typedef expr proto_derived_expr;
             typedef void proto_is_expr_; /**< INTERNAL ONLY */

Modified: branches/release/boost/proto/extends.hpp
==============================================================================
--- branches/release/boost/proto/extends.hpp (original)
+++ branches/release/boost/proto/extends.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -9,7 +9,6 @@
#ifndef BOOST_PROTO_EXTENDS_HPP_EAN_11_1_2006
#define BOOST_PROTO_EXTENDS_HPP_EAN_11_1_2006

-#include <boost/proto/detail/prefix.hpp>
#include <cstddef> // for offsetof
#include <boost/preprocessor/tuple/elem.hpp>
#include <boost/preprocessor/control/if.hpp>
@@ -30,7 +29,6 @@
#include <boost/proto/args.hpp>
#include <boost/proto/traits.hpp>
#include <boost/proto/generate.hpp>
-#include <boost/proto/detail/suffix.hpp>

namespace boost { namespace proto
{
@@ -158,7 +156,7 @@
         typedef typename proto_base_expr::address_of_hack_type_ proto_address_of_hack_type_; \
         typedef void proto_is_expr_; /**< INTERNAL ONLY */ \
         BOOST_STATIC_CONSTANT(long, proto_arity_c = proto_base_expr::proto_arity_c); \
- BOOST_PROTO_FUSION_DEFINE_TAG(boost::proto::tag::proto_expr) \
+ typedef boost::proto::tag::proto_expr fusion_tag; \
         BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_EXTENDS_CHILD, ~) \
                                                                                                     \
         static proto_derived_expr const make(Expr const &e) \
@@ -413,192 +411,192 @@
         BOOST_PROTO_EXTENDS_FUNCTION() \
         /**/

- BOOST_PROTO_BEGIN_ADL_NAMESPACE(exprns_)
-
- /// \brief Empty type to be used as a dummy template parameter of
- /// POD expression wrappers. It allows argument-dependent lookup
- /// to find Proto's operator overloads.
- ///
- /// \c proto::is_proto_expr allows argument-dependent lookup
- /// to find Proto's operator overloads. For example:
- ///
- /// \code
- /// template<typename T, typename Dummy = proto::is_proto_expr>
- /// struct my_terminal
- /// {
- /// BOOST_PROTO_BASIC_EXTENDS(
- /// typename proto::terminal<T>::type
- /// , my_terminal<T>
- /// , default_domain
- /// )
- /// };
- ///
- /// // ...
- /// my_terminal<int> _1, _2;
- /// _1 + _2; // OK, uses proto::operator+
- /// \endcode
- ///
- /// Without the second \c Dummy template parameter, Proto's operator
- /// overloads would not be considered by name lookup.
- struct is_proto_expr
- {};
-
- /// \brief extends\<\> class template for adding behaviors to a Proto expression template
- ///
- template<
- typename Expr
- , typename Derived
- , typename Domain BOOST_PROTO_WHEN_BUILDING_DOCS(= proto::default_domain)
- , long Arity BOOST_PROTO_WHEN_BUILDING_DOCS(= Expr::proto_arity_c)
- >
- struct extends
+ namespace exprns_
     {
- extends()
- : proto_expr_()
- {}
-
- extends(extends const &that)
- : proto_expr_(that.proto_expr_)
- {}
-
- extends(Expr const &expr_)
- : proto_expr_(expr_)
- {}
-
- BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain)
- BOOST_PROTO_EXTENDS_ASSIGN_CONST()
- BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST()
-
- // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
- // nested preprocessor loops, use file iteration here to generate
- // the operator() overloads, which is more efficient.
- BOOST_PROTO_EXTENDS_FUNCTION_()
-
- #ifdef BOOST_HAS_VARIADIC_TMPL
- BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(1)
- #else
- /// INTERNAL ONLY
+ /// \brief Empty type to be used as a dummy template parameter of
+ /// POD expression wrappers. It allows argument-dependent lookup
+ /// to find Proto's operator overloads.
         ///
- #define BOOST_PP_LOCAL_MACRO(N) \
- BOOST_PROTO_DEFINE_FUN_OP_CONST(1, N, ~) \
- /**/
-
- /// INTERNAL ONLY
+ /// \c proto::is_proto_expr allows argument-dependent lookup
+ /// to find Proto's operator overloads. For example:
         ///
- #define BOOST_PP_LOCAL_LIMITS (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY))
- #include BOOST_PP_LOCAL_ITERATE()
-
- #endif
- };
-
- /// \brief extends\<\> class template for adding behaviors to a Proto expression template
- ///
- template<typename Expr, typename Derived, typename Domain>
- struct extends<Expr, Derived, Domain, 0>
- {
- extends()
- : proto_expr_()
- {}
-
- extends(extends const &that)
- : proto_expr_(that.proto_expr_)
- {}
-
- extends(Expr const &expr_)
- : proto_expr_(expr_)
- {}
-
- BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain)
- BOOST_PROTO_EXTENDS_ASSIGN()
- BOOST_PROTO_EXTENDS_SUBSCRIPT()
-
- // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
- // nested preprocessor loops, use file iteration here to generate
- // the operator() overloads, which is more efficient.
- BOOST_PROTO_EXTENDS_FUNCTION_()
-
- #ifdef BOOST_HAS_VARIADIC_TMPL
- BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(0)
- BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(1)
- #else
-
- /// INTERNAL ONLY
+ /// \code
+ /// template<typename T, typename Dummy = proto::is_proto_expr>
+ /// struct my_terminal
+ /// {
+ /// BOOST_PROTO_BASIC_EXTENDS(
+ /// typename proto::terminal<T>::type
+ /// , my_terminal<T>
+ /// , default_domain
+ /// )
+ /// };
         ///
- #define BOOST_PP_LOCAL_MACRO(N) \
- BOOST_PROTO_DEFINE_FUN_OP(1, N, ~) \
- /**/
+ /// // ...
+ /// my_terminal<int> _1, _2;
+ /// _1 + _2; // OK, uses proto::operator+
+ /// \endcode
+ ///
+ /// Without the second \c Dummy template parameter, Proto's operator
+ /// overloads would not be considered by name lookup.
+ struct is_proto_expr
+ {};

- /// INTERNAL ONLY
+ /// \brief extends\<\> class template for adding behaviors to a Proto expression template
         ///
- #define BOOST_PP_LOCAL_LIMITS (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY))
- #include BOOST_PP_LOCAL_ITERATE()
+ template<
+ typename Expr
+ , typename Derived
+ , typename Domain // = proto::default_domain
+ , long Arity // = Expr::proto_arity_c
+ >
+ struct extends
+ {
+ extends()
+ : proto_expr_()
+ {}
+
+ extends(extends const &that)
+ : proto_expr_(that.proto_expr_)
+ {}
+
+ extends(Expr const &expr_)
+ : proto_expr_(expr_)
+ {}
+
+ BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain)
+ BOOST_PROTO_EXTENDS_ASSIGN_CONST()
+ BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST()
+
+ // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
+ // nested preprocessor loops, use file iteration here to generate
+ // the operator() overloads, which is more efficient.
+ BOOST_PROTO_EXTENDS_FUNCTION_()
+
+ #ifdef BOOST_HAS_VARIADIC_TMPL
+ BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(1)
+ #else
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PP_LOCAL_MACRO(N) \
+ BOOST_PROTO_DEFINE_FUN_OP_CONST(1, N, ~) \
+ /**/

- #endif
- };
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PP_LOCAL_LIMITS (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY))
+ #include BOOST_PP_LOCAL_ITERATE()

- /// INTERNAL ONLY
- ///
- template<typename This, typename Fun, typename Domain>
- struct virtual_member
- {
- typedef
- expr<tag::member, list2<This &, expr<tag::terminal, term<Fun> > const &>, 2>
- proto_base_expr;
- typedef Domain proto_domain;
- typedef virtual_member<This, Fun, Domain> proto_derived_expr;
- typedef typename proto_base_expr::proto_tag proto_tag;
- typedef typename proto_base_expr::proto_args proto_args;
- typedef typename proto_base_expr::proto_arity proto_arity;
- typedef typename proto_base_expr::address_of_hack_type_ proto_address_of_hack_type_;
- typedef void proto_is_expr_; /**< INTERNAL ONLY */
- BOOST_STATIC_CONSTANT(long, proto_arity_c = proto_base_expr::proto_arity_c);
- BOOST_PROTO_FUSION_DEFINE_TAG(boost::proto::tag::proto_expr)
- BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_EXTENDS_CHILD, ~)
- typedef void proto_is_aggregate_; /**< INTERNAL ONLY */
-
- BOOST_PROTO_EXTENDS_ASSIGN()
- BOOST_PROTO_EXTENDS_SUBSCRIPT()
- BOOST_PROTO_EXTENDS_FUNCTION()
+ #endif
+ };

- proto_base_expr const proto_base() const
+ /// \brief extends\<\> class template for adding behaviors to a Proto expression template
+ ///
+ template<typename Expr, typename Derived, typename Domain>
+ struct extends<Expr, Derived, Domain, 0>
         {
- proto_base_expr that = {this->child0(), this->child1()};
- return that;
- }
+ extends()
+ : proto_expr_()
+ {}
+
+ extends(extends const &that)
+ : proto_expr_(that.proto_expr_)
+ {}
+
+ extends(Expr const &expr_)
+ : proto_expr_(expr_)
+ {}
+
+ BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain)
+ BOOST_PROTO_EXTENDS_ASSIGN()
+ BOOST_PROTO_EXTENDS_SUBSCRIPT()
+
+ // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
+ // nested preprocessor loops, use file iteration here to generate
+ // the operator() overloads, which is more efficient.
+ BOOST_PROTO_EXTENDS_FUNCTION_()
+
+ #ifdef BOOST_HAS_VARIADIC_TMPL
+ BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(0)
+ BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(1)
+ #else
+
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PP_LOCAL_MACRO(N) \
+ BOOST_PROTO_DEFINE_FUN_OP(1, N, ~) \
+ /**/

- proto_child0 child0() const
- {
- return *(This *)((char *)this - BOOST_PROTO_OFFSETOF(This, proto_member_union_start_));
- }
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PP_LOCAL_LIMITS (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY))
+ #include BOOST_PP_LOCAL_ITERATE()
+
+ #endif
+ };

- proto_child1 child1() const
+ /// INTERNAL ONLY
+ ///
+ template<typename This, typename Fun, typename Domain>
+ struct virtual_member
         {
- static expr<tag::terminal, term<Fun>, 0> const that = {Fun()};
- return that;
- }
- };
+ typedef
+ expr<tag::member, list2<This &, expr<tag::terminal, term<Fun> > const &>, 2>
+ proto_base_expr;
+ typedef Domain proto_domain;
+ typedef virtual_member<This, Fun, Domain> proto_derived_expr;
+ typedef typename proto_base_expr::proto_tag proto_tag;
+ typedef typename proto_base_expr::proto_args proto_args;
+ typedef typename proto_base_expr::proto_arity proto_arity;
+ typedef typename proto_base_expr::address_of_hack_type_ proto_address_of_hack_type_;
+ typedef void proto_is_expr_; /**< INTERNAL ONLY */
+ BOOST_STATIC_CONSTANT(long, proto_arity_c = proto_base_expr::proto_arity_c);
+ typedef boost::proto::tag::proto_expr fusion_tag;
+ BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_EXTENDS_CHILD, ~)
+ typedef void proto_is_aggregate_; /**< INTERNAL ONLY */
+
+ BOOST_PROTO_EXTENDS_ASSIGN()
+ BOOST_PROTO_EXTENDS_SUBSCRIPT()
+ BOOST_PROTO_EXTENDS_FUNCTION()
+
+ proto_base_expr const proto_base() const
+ {
+ proto_base_expr that = {this->child0(), this->child1()};
+ return that;
+ }
+
+ proto_child0 child0() const
+ {
+ return *(This *)((char *)this - BOOST_PROTO_OFFSETOF(This, proto_member_union_start_));
+ }
+
+ proto_child1 child1() const
+ {
+ static expr<tag::terminal, term<Fun>, 0> const that = {Fun()};
+ return that;
+ }
+ };

- /// INTERNAL ONLY
- ///
- #define BOOST_PROTO_EXTENDS_MEMBER_(R, DATA, ELEM) \
- boost::proto::exprns_::virtual_member< \
- proto_derived_expr \
- , BOOST_PP_TUPLE_ELEM(2, 0, ELEM) \
- , proto_domain \
- > BOOST_PP_TUPLE_ELEM(2, 1, ELEM); \
- /**/
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PROTO_EXTENDS_MEMBER_(R, DATA, ELEM) \
+ boost::proto::exprns_::virtual_member< \
+ proto_derived_expr \
+ , BOOST_PP_TUPLE_ELEM(2, 0, ELEM) \
+ , proto_domain \
+ > BOOST_PP_TUPLE_ELEM(2, 1, ELEM); \
+ /**/

- /// \brief For declaring virtual data members in an extension class.
- ///
- #define BOOST_PROTO_EXTENDS_MEMBERS(SEQ) \
- union \
- { \
- char proto_member_union_start_; \
- BOOST_PP_SEQ_FOR_EACH(BOOST_PROTO_EXTENDS_MEMBER_, ~, SEQ) \
- }; \
- /**/
+ /// \brief For declaring virtual data members in an extension class.
+ ///
+ #define BOOST_PROTO_EXTENDS_MEMBERS(SEQ) \
+ union \
+ { \
+ char proto_member_union_start_; \
+ BOOST_PP_SEQ_FOR_EACH(BOOST_PROTO_EXTENDS_MEMBER_, ~, SEQ) \
+ }; \
+ /**/

- BOOST_PROTO_END_ADL_NAMESPACE(exprns_)
+ }

}}

Modified: branches/release/boost/proto/generate.hpp
==============================================================================
--- branches/release/boost/proto/generate.hpp (original)
+++ branches/release/boost/proto/generate.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -11,7 +11,6 @@
     #ifndef BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007
     #define BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007

- #include <boost/proto/detail/prefix.hpp>
     #include <boost/config.hpp>
     #include <boost/utility/result_of.hpp>
     #include <boost/preprocessor/cat.hpp>
@@ -20,7 +19,6 @@
     #include <boost/utility/enable_if.hpp>
     #include <boost/proto/proto_fwd.hpp>
     #include <boost/proto/args.hpp>
- #include <boost/proto/detail/suffix.hpp>

     namespace boost { namespace proto
     {
@@ -75,242 +73,241 @@

         }

- BOOST_PROTO_BEGIN_ADL_NAMESPACE(generatorns_)
-
- /// \brief A simple generator that passes an expression
- /// through unchanged.
- ///
- /// Generators are intended for use as the first template parameter
- /// to the \c domain\<\> class template and control if and how
- /// expressions within that domain are to be customized.
- /// The \c default_generator makes no modifications to the expressions
- /// passed to it.
- struct default_generator
+ namespace generatorns_
         {
- BOOST_PROTO_CALLABLE()
-
- template<typename Sig>
- struct result;
-
- template<typename This, typename Expr>
- struct result<This(Expr)>
+ /// \brief A simple generator that passes an expression
+ /// through unchanged.
+ ///
+ /// Generators are intended for use as the first template parameter
+ /// to the \c domain\<\> class template and control if and how
+ /// expressions within that domain are to be customized.
+ /// The \c default_generator makes no modifications to the expressions
+ /// passed to it.
+ struct default_generator
             {
- typedef Expr type;
- };
-
- /// \param expr A Proto expression
- /// \return expr
- template<typename Expr>
- #ifdef BOOST_HAS_DECLTYPE
- Expr
- #else
- Expr const &
- #endif
- operator ()(Expr const &e) const
- {
- return e;
- }
- };
-
- /// \brief A generator that wraps expressions passed
- /// to it in the specified extension wrapper.
- ///
- /// Generators are intended for use as the first template parameter
- /// to the \c domain\<\> class template and control if and how
- /// expressions within that domain are to be customized.
- /// \c generator\<\> wraps each expression passed to it in
- /// the \c Extends\<\> wrapper.
- template<template<typename> class Extends>
- struct generator
- {
- BOOST_PROTO_CALLABLE()
+ BOOST_PROTO_CALLABLE()

- template<typename Sig>
- struct result;
+ template<typename Sig>
+ struct result;

- template<typename This, typename Expr>
- struct result<This(Expr)>
- {
- typedef Extends<Expr> type;
- };
+ template<typename This, typename Expr>
+ struct result<This(Expr)>
+ {
+ typedef Expr type;
+ };

- template<typename This, typename Expr>
- struct result<This(Expr &)>
- {
- typedef Extends<Expr> type;
+ /// \param expr A Proto expression
+ /// \return expr
+ template<typename Expr>
+ #ifdef BOOST_HAS_DECLTYPE
+ Expr
+ #else
+ Expr const &
+ #endif
+ operator ()(Expr const &e) const
+ {
+ return e;
+ }
             };

- template<typename This, typename Expr>
- struct result<This(Expr const &)>
+ /// \brief A generator that wraps expressions passed
+ /// to it in the specified extension wrapper.
+ ///
+ /// Generators are intended for use as the first template parameter
+ /// to the \c domain\<\> class template and control if and how
+ /// expressions within that domain are to be customized.
+ /// \c generator\<\> wraps each expression passed to it in
+ /// the \c Extends\<\> wrapper.
+ template<template<typename> class Extends>
+ struct generator
             {
- typedef Extends<Expr> type;
- };
+ BOOST_PROTO_CALLABLE()

- /// \param expr A Proto expression
- /// \return Extends<Expr>(expr)
- template<typename Expr>
- Extends<Expr> operator ()(Expr const &e) const
- {
- return Extends<Expr>(e);
- }
- };
+ template<typename Sig>
+ struct result;

- /// \brief A generator that wraps expressions passed
- /// to it in the specified extension wrapper and uses
- /// aggregate initialization for the wrapper.
- ///
- /// Generators are intended for use as the first template parameter
- /// to the \c domain\<\> class template and control if and how
- /// expressions within that domain are to be customized.
- /// \c pod_generator\<\> wraps each expression passed to it in
- /// the \c Extends\<\> wrapper, and uses aggregate initialzation
- /// for the wrapped object.
- template<template<typename> class Extends>
- struct pod_generator
- {
- BOOST_PROTO_CALLABLE()
+ template<typename This, typename Expr>
+ struct result<This(Expr)>
+ {
+ typedef Extends<Expr> type;
+ };

- template<typename Sig>
- struct result;
+ template<typename This, typename Expr>
+ struct result<This(Expr &)>
+ {
+ typedef Extends<Expr> type;
+ };

- template<typename This, typename Expr>
- struct result<This(Expr)>
- {
- typedef Extends<Expr> type;
- };
+ template<typename This, typename Expr>
+ struct result<This(Expr const &)>
+ {
+ typedef Extends<Expr> type;
+ };

- template<typename This, typename Expr>
- struct result<This(Expr &)>
- {
- typedef Extends<Expr> type;
+ /// \param expr A Proto expression
+ /// \return Extends<Expr>(expr)
+ template<typename Expr>
+ Extends<Expr> operator ()(Expr const &e) const
+ {
+ return Extends<Expr>(e);
+ }
             };

- template<typename This, typename Expr>
- struct result<This(Expr const &)>
+ /// \brief A generator that wraps expressions passed
+ /// to it in the specified extension wrapper and uses
+ /// aggregate initialization for the wrapper.
+ ///
+ /// Generators are intended for use as the first template parameter
+ /// to the \c domain\<\> class template and control if and how
+ /// expressions within that domain are to be customized.
+ /// \c pod_generator\<\> wraps each expression passed to it in
+ /// the \c Extends\<\> wrapper, and uses aggregate initialzation
+ /// for the wrapped object.
+ template<template<typename> class Extends>
+ struct pod_generator
             {
- typedef Extends<Expr> type;
- };
+ BOOST_PROTO_CALLABLE()

- /// \param expr The expression to wrap
- /// \return <tt>Extends\<Expr\> that = {expr}; return that;</tt>
- template<typename Expr>
- Extends<Expr> operator ()(Expr const &e) const
- {
- Extends<Expr> that = {e};
- return that;
- }
- };
+ template<typename Sig>
+ struct result;

- /// \brief A generator that replaces child nodes held by
- /// reference with ones held by value. Use with
- /// \c compose_generators to forward that result to another
- /// generator.
- ///
- /// Generators are intended for use as the first template parameter
- /// to the \c domain\<\> class template and control if and how
- /// expressions within that domain are to be customized.
- /// \c by_value_generator ensures all child nodes are
- /// held by value. This generator is typically composed with a
- /// second generator for further processing, as
- /// <tt>compose_generators\<by_value_generator, MyGenerator\></tt>.
- struct by_value_generator
- {
- BOOST_PROTO_CALLABLE()
+ template<typename This, typename Expr>
+ struct result<This(Expr)>
+ {
+ typedef Extends<Expr> type;
+ };

- template<typename Sig>
- struct result;
+ template<typename This, typename Expr>
+ struct result<This(Expr &)>
+ {
+ typedef Extends<Expr> type;
+ };

- template<typename This, typename Expr>
- struct result<This(Expr)>
- {
- typedef
- typename detail::by_value_generator_<Expr>::type
- type;
- };
+ template<typename This, typename Expr>
+ struct result<This(Expr const &)>
+ {
+ typedef Extends<Expr> type;
+ };

- template<typename This, typename Expr>
- struct result<This(Expr &)>
- {
- typedef
- typename detail::by_value_generator_<Expr>::type
- type;
+ /// \param expr The expression to wrap
+ /// \return <tt>Extends\<Expr\> that = {expr}; return that;</tt>
+ template<typename Expr>
+ Extends<Expr> operator ()(Expr const &e) const
+ {
+ Extends<Expr> that = {e};
+ return that;
+ }
             };

- template<typename This, typename Expr>
- struct result<This(Expr const &)>
+ /// \brief A generator that replaces child nodes held by
+ /// reference with ones held by value. Use with
+ /// \c compose_generators to forward that result to another
+ /// generator.
+ ///
+ /// Generators are intended for use as the first template parameter
+ /// to the \c domain\<\> class template and control if and how
+ /// expressions within that domain are to be customized.
+ /// \c by_value_generator ensures all child nodes are
+ /// held by value. This generator is typically composed with a
+ /// second generator for further processing, as
+ /// <tt>compose_generators\<by_value_generator, MyGenerator\></tt>.
+ struct by_value_generator
             {
- typedef
- typename detail::by_value_generator_<Expr>::type
- type;
- };
+ BOOST_PROTO_CALLABLE()

- /// \param expr The expression to modify.
- /// \return <tt>deep_copy(expr)</tt>
- template<typename Expr>
- typename result<by_value_generator(Expr)>::type operator ()(Expr const &e) const
- {
- return detail::by_value_generator_<Expr>::make(e);
- }
- };
+ template<typename Sig>
+ struct result;

- /// \brief A composite generator that first applies one
- /// transform to an expression and then forwards the result
- /// on to another generator for further transformation.
- ///
- /// Generators are intended for use as the first template parameter
- /// to the \c domain\<\> class template and control if and how
- /// expressions within that domain are to be customized.
- /// \c compose_generators\<\> is a composite generator that first
- /// applies one transform to an expression and then forwards the
- /// result on to another generator for further transformation.
- template<typename First, typename Second>
- struct compose_generators
- {
- BOOST_PROTO_CALLABLE()
+ template<typename This, typename Expr>
+ struct result<This(Expr)>
+ {
+ typedef
+ typename detail::by_value_generator_<Expr>::type
+ type;
+ };

- template<typename Sig>
- struct result;
+ template<typename This, typename Expr>
+ struct result<This(Expr &)>
+ {
+ typedef
+ typename detail::by_value_generator_<Expr>::type
+ type;
+ };

- template<typename This, typename Expr>
- struct result<This(Expr)>
- {
- typedef
- typename Second::template result<
- Second(typename First::template result<First(Expr)>::type)
- >::type
- type;
+ template<typename This, typename Expr>
+ struct result<This(Expr const &)>
+ {
+ typedef
+ typename detail::by_value_generator_<Expr>::type
+ type;
+ };
+
+ /// \param expr The expression to modify.
+ /// \return <tt>deep_copy(expr)</tt>
+ template<typename Expr>
+ typename result<by_value_generator(Expr)>::type operator ()(Expr const &e) const
+ {
+ return detail::by_value_generator_<Expr>::make(e);
+ }
             };

- template<typename This, typename Expr>
- struct result<This(Expr &)>
+ /// \brief A composite generator that first applies one
+ /// transform to an expression and then forwards the result
+ /// on to another generator for further transformation.
+ ///
+ /// Generators are intended for use as the first template parameter
+ /// to the \c domain\<\> class template and control if and how
+ /// expressions within that domain are to be customized.
+ /// \c compose_generators\<\> is a composite generator that first
+ /// applies one transform to an expression and then forwards the
+ /// result on to another generator for further transformation.
+ template<typename First, typename Second>
+ struct compose_generators
             {
- typedef
- typename Second::template result<
- Second(typename First::template result<First(Expr)>::type)
- >::type
- type;
- };
+ BOOST_PROTO_CALLABLE()

- template<typename This, typename Expr>
- struct result<This(Expr const &)>
- {
- typedef
- typename Second::template result<
- Second(typename First::template result<First(Expr)>::type)
- >::type
- type;
- };
+ template<typename Sig>
+ struct result;

- /// \param expr The expression to modify.
- /// \return Second()(First()(expr))
- template<typename Expr>
- typename result<compose_generators(Expr)>::type operator ()(Expr const &e) const
- {
- return Second()(First()(e));
- }
- };
+ template<typename This, typename Expr>
+ struct result<This(Expr)>
+ {
+ typedef
+ typename Second::template result<
+ Second(typename First::template result<First(Expr)>::type)
+ >::type
+ type;
+ };
+
+ template<typename This, typename Expr>
+ struct result<This(Expr &)>
+ {
+ typedef
+ typename Second::template result<
+ Second(typename First::template result<First(Expr)>::type)
+ >::type
+ type;
+ };

- BOOST_PROTO_END_ADL_NAMESPACE(generatorns_)
+ template<typename This, typename Expr>
+ struct result<This(Expr const &)>
+ {
+ typedef
+ typename Second::template result<
+ Second(typename First::template result<First(Expr)>::type)
+ >::type
+ type;
+ };
+
+ /// \param expr The expression to modify.
+ /// \return Second()(First()(expr))
+ template<typename Expr>
+ typename result<compose_generators(Expr)>::type operator ()(Expr const &e) const
+ {
+ return Second()(First()(e));
+ }
+ };
+ }

         /// INTERNAL ONLY
         template<>

Modified: branches/release/boost/proto/literal.hpp
==============================================================================
--- branches/release/boost/proto/literal.hpp (original)
+++ branches/release/boost/proto/literal.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -10,13 +10,11 @@
#ifndef BOOST_PROTO_LITERAL_HPP_EAN_01_03_2007
#define BOOST_PROTO_LITERAL_HPP_EAN_01_03_2007

-#include <boost/proto/detail/prefix.hpp>
#include <boost/config.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/expr.hpp>
#include <boost/proto/traits.hpp>
#include <boost/proto/extends.hpp>
-#include <boost/proto/detail/suffix.hpp>

namespace boost { namespace proto
{
@@ -33,7 +31,7 @@
         /// \c proto::default_domain.
         template<
             typename T
- , typename Domain BOOST_PROTO_WHEN_BUILDING_DOCS(= default_domain)
+ , typename Domain // = default_domain
>
         struct literal
           : extends<expr<tag::terminal, term<T>, 0>, literal<T, Domain>, Domain>

Modified: branches/release/boost/proto/make_expr.hpp
==============================================================================
--- branches/release/boost/proto/make_expr.hpp (original)
+++ branches/release/boost/proto/make_expr.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -12,8 +12,6 @@
     #ifndef BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005
     #define BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005

- #include <boost/proto/detail/prefix.hpp>
- #include <boost/version.hpp>
     #include <boost/config.hpp>
     #include <boost/detail/workaround.hpp>
     #include <boost/preprocessor/cat.hpp>
@@ -28,7 +26,6 @@
     #include <boost/preprocessor/repetition/enum_binary_params.hpp>
     #include <boost/preprocessor/repetition/enum_shifted_params.hpp>
     #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
- #include <boost/preprocessor/repetition/enum_shifted_binary_params.hpp>
     #include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
     #include <boost/preprocessor/repetition/repeat.hpp>
     #include <boost/ref.hpp>
@@ -46,20 +43,12 @@
     #include <boost/proto/traits.hpp>
     #include <boost/proto/domain.hpp>
     #include <boost/proto/generate.hpp>
- #if BOOST_VERSION >= 103500
- # include <boost/fusion/include/begin.hpp>
- # include <boost/fusion/include/next.hpp>
- # include <boost/fusion/include/value_of.hpp>
- # include <boost/fusion/include/size.hpp>
- #else
- # include <boost/spirit/fusion/sequence/begin.hpp>
- # include <boost/spirit/fusion/iterator/next.hpp>
- # include <boost/spirit/fusion/iterator/value_of.hpp>
- # include <boost/spirit/fusion/sequence/size.hpp>
- #endif
+ #include <boost/fusion/include/begin.hpp>
+ #include <boost/fusion/include/next.hpp>
+ #include <boost/fusion/include/value_of.hpp>
+ #include <boost/fusion/include/size.hpp>
     #include <boost/proto/detail/poly_function.hpp>
     #include <boost/proto/detail/deprecated.hpp>
- #include <boost/proto/detail/suffix.hpp>

     #ifdef _MSC_VER
     # pragma warning(push)
@@ -102,7 +91,7 @@
     /// INTERNAL ONLY
     ///
     #define BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE(Z, N, DATA) \
- typedef typename fusion::BOOST_PROTO_FUSION_RESULT_OF::next< \
+ typedef typename fusion::result_of::next< \
             BOOST_PP_CAT(fusion_iterator, N)>::type \
                 BOOST_PP_CAT(fusion_iterator, BOOST_PP_INC(N)); \
         /**/
@@ -111,7 +100,7 @@
     ///
     #define BOOST_PROTO_FUSION_ITERATORS_TYPE(N) \
         typedef \
- typename fusion::BOOST_PROTO_FUSION_RESULT_OF::begin<Sequence const>::type \
+ typename fusion::result_of::begin<Sequence const>::type \
         fusion_iterator0; \
         BOOST_PP_REPEAT(BOOST_PP_DEC(N), BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE, fusion_iterator) \
         /**/
@@ -120,7 +109,7 @@
     ///
     #define BOOST_PROTO_FUSION_AT_TYPE(Z, N, DATA) \
         typename add_const< \
- typename fusion::BOOST_PROTO_FUSION_RESULT_OF::value_of< \
+ typename fusion::result_of::value_of< \
                 BOOST_PP_CAT(fusion_iterator, N) \
>::type \
>::type \
@@ -254,8 +243,8 @@
             {
                 typedef
                     typename add_const<
- typename fusion::BOOST_PROTO_FUSION_RESULT_OF::value_of<
- typename fusion::BOOST_PROTO_FUSION_RESULT_OF::begin<Sequence>::type
+ typename fusion::result_of::value_of<
+ typename fusion::result_of::begin<Sequence>::type
>::type
>::type
                 terminal_type;
@@ -269,7 +258,7 @@

                 static type const call(Sequence const &sequence)
                 {
- return proto::detail::protoify_<terminal_type, Domain>::call(fusion::BOOST_PROTO_FUSION_AT_C(0, sequence));
+ return proto::detail::protoify_<terminal_type, Domain>::call(fusion::at_c<0>(sequence));
                 }
             };

@@ -398,14 +387,9 @@
             /// specialization is selected.)
             template<
                 typename Tag
- , typename A0
- , BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS(
- BOOST_PROTO_MAX_ARITY
- , typename A
- , BOOST_PROTO_WHEN_BUILDING_DOCS(= void) BOOST_PP_INTERCEPT
- )
- , typename Void1 BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
- , typename Void2 BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
+ , BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_ARITY, typename A)
+ , typename Void1 // = void
+ , typename Void2 // = void
>
             struct make_expr
             {
@@ -489,8 +473,8 @@
             template<
                 typename Tag
               , typename Sequence
- , typename Void1 BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
- , typename Void2 BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
+ , typename Void1 // = void
+ , typename Void2 // = void
>
             struct unpack_expr
             {
@@ -505,7 +489,7 @@
                         Tag
                       , deduce_domain
                       , Sequence
- , fusion::BOOST_PROTO_FUSION_RESULT_OF::size<Sequence>::type::value
+ , fusion::result_of::size<Sequence>::type::value
>::type
                 type;
             };
@@ -529,7 +513,7 @@
                         Tag
                       , Domain
                       , Sequence
- , fusion::BOOST_PROTO_FUSION_RESULT_OF::size<Sequence>::type::value
+ , fusion::result_of::size<Sequence>::type::value
>::type
                 type;
             };
@@ -545,7 +529,7 @@
             ///
             /// <tt>functional::make_expr\<Tag\>()(a0, ... aN)</tt>
             /// is equivalent to <tt>proto::make_expr\<Tag\>(a0, ... aN)</tt>.
- template<typename Tag, typename Domain BOOST_PROTO_WHEN_BUILDING_DOCS(= deduce_domain)>
+ template<typename Tag, typename Domain /* = deduce_domain*/>
             struct make_expr
             {
                 BOOST_PROTO_CALLABLE()
@@ -619,7 +603,7 @@
             ///
             /// <tt>functional::unpack_expr\<Tag\>()(seq)</tt>
             /// is equivalent to <tt>proto::unpack_expr\<Tag\>(seq)</tt>.
- template<typename Tag, typename Domain BOOST_PROTO_WHEN_BUILDING_DOCS(= deduce_domain)>
+ template<typename Tag, typename Domain /* = deduce_domain*/>
             struct unpack_expr
             {
                 BOOST_PROTO_CALLABLE()
@@ -653,7 +637,7 @@
                         Tag
                       , Domain
                       , Sequence const
- , fusion::BOOST_PROTO_FUSION_RESULT_OF::size<Sequence>::type::value
+ , fusion::result_of::size<Sequence>::type::value
>::call(sequence);
                 }
             };
@@ -688,7 +672,7 @@
                         Tag
                       , Domain
                       , Sequence const
- , fusion::BOOST_PROTO_FUSION_RESULT_OF::size<Sequence>::type::value
+ , fusion::result_of::size<Sequence>::type::value
>::call(sequence);
                 }
             };
@@ -805,7 +789,7 @@
                 Tag
               , deduce_domain
               , Sequence const
- , fusion::BOOST_PROTO_FUSION_RESULT_OF::size<Sequence>::type::value
+ , fusion::result_of::size<Sequence>::type::value
>::call(sequence);
         }

@@ -819,7 +803,7 @@
                 Tag
               , Domain
               , Sequence2 const
- , fusion::BOOST_PROTO_FUSION_RESULT_OF::size<Sequence2>::type::value
+ , fusion::result_of::size<Sequence2>::type::value
>::call(sequence2);
         }

Modified: branches/release/boost/proto/matches.hpp
==============================================================================
--- branches/release/boost/proto/matches.hpp (original)
+++ branches/release/boost/proto/matches.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -11,7 +11,6 @@
     #ifndef BOOST_PROTO_MATCHES_HPP_EAN_11_03_2006
     #define BOOST_PROTO_MATCHES_HPP_EAN_11_03_2006

- #include <boost/proto/detail/prefix.hpp> // must be first include
     #include <boost/config.hpp>
     #include <boost/detail/workaround.hpp>
     #include <boost/preprocessor/cat.hpp>
@@ -43,7 +42,6 @@
     #include <boost/proto/traits.hpp>
     #include <boost/proto/transform/when.hpp>
     #include <boost/proto/transform/impl.hpp>
- #include <boost/proto/detail/suffix.hpp> // must be last include

     // Some compilers (like GCC) need extra help figuring out a template's arity.
     // I use MPL's BOOST_MPL_AUX_LAMBDA_ARITY_PARAM() macro to disambiguate, which
@@ -517,7 +515,8 @@
             {};
         }

- BOOST_PROTO_BEGIN_ADL_NAMESPACE(wildcardns_)
+ namespace wildcardns_
+ {

             /// \brief A wildcard grammar element that matches any expression,
             /// and a transform that returns the current expression unchanged.
@@ -586,8 +585,7 @@
                     }
                 };
             };
-
- BOOST_PROTO_END_ADL_NAMESPACE(wildcardns_)
+ }

         namespace control
         {
@@ -679,8 +677,8 @@
             /// \endcode
             template<
                 typename If
- , typename Then BOOST_PROTO_WHEN_BUILDING_DOCS(= _)
- , typename Else BOOST_PROTO_WHEN_BUILDING_DOCS(= not_<_>)
+ , typename Then // = _
+ , typename Else // = not_<_>
>
             struct if_ : transform<if_<If, Then, Else> >
             {

Modified: branches/release/boost/proto/operators.hpp
==============================================================================
--- branches/release/boost/proto/operators.hpp (original)
+++ branches/release/boost/proto/operators.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -10,7 +10,6 @@
#ifndef BOOST_PROTO_OPERATORS_HPP_EAN_04_01_2005
#define BOOST_PROTO_OPERATORS_HPP_EAN_04_01_2005

-#include <boost/proto/detail/prefix.hpp>
#include <boost/preprocessor/punctuation/comma.hpp>
#include <boost/preprocessor/seq/seq.hpp>
#include <boost/mpl/or.hpp>
@@ -22,12 +21,36 @@
#include <boost/proto/matches.hpp>
#include <boost/proto/generate.hpp>
#include <boost/proto/make_expr.hpp>
-#include <boost/proto/detail/suffix.hpp>

namespace boost { namespace proto
{
     namespace detail
     {
+ template<typename Domain1, typename Domain2>
+ struct choose_domain2
+ {
+ BOOST_MPL_ASSERT((boost::is_same<Domain1, Domain2>));
+ typedef Domain1 type;
+ };
+
+ template<typename Domain1>
+ struct choose_domain2<Domain1, proto::default_domain>
+ {
+ typedef Domain1 type;
+ };
+
+ template<typename Domain2>
+ struct choose_domain2<proto::default_domain, Domain2>
+ {
+ typedef Domain2 type;
+ };
+
+ template<>
+ struct choose_domain2<proto::default_domain, proto::default_domain>
+ {
+ typedef proto::default_domain type;
+ };
+
         template<typename Domain, typename Expr, typename EnableIf = void>
         struct generate_if
           : lazy_enable_if_c<
@@ -133,13 +156,12 @@
         template<typename Tag, typename Left, typename Right>
         struct as_expr_if<Tag, Left, Right, typename Left::proto_is_expr_, typename Right::proto_is_expr_>
           : generate_if<
- typename Left::proto_domain
+ typename choose_domain2<typename Left::proto_domain, typename Right::proto_domain>::type
               , proto::expr<Tag, list2<Left &, Right &>, 2>
>
         {
             typedef proto::expr<Tag, list2<Left &, Right &>, 2> expr_type;
- typedef typename Left::proto_domain proto_domain;
- BOOST_MPL_ASSERT((is_same<proto_domain, typename Right::proto_domain>));
+ typedef typename choose_domain2<typename Left::proto_domain, typename Right::proto_domain>::type proto_domain;

             static typename proto_domain::template result<proto_domain(expr_type)>::type
             make(Left &left, Right &right)
@@ -274,63 +296,63 @@
     } \
     /**/

- BOOST_PROTO_BEGIN_ADL_NAMESPACE(exprns_)
-
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(+, tag::unary_plus, 0)
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(-, tag::negate, 0)
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(*, tag::dereference, 0)
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(~, tag::complement, 0)
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(&, tag::address_of, 0)
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(!, tag::logical_not, 0)
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(++, tag::pre_inc, 0)
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(--, tag::pre_dec, 0)
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(++, tag::post_inc, 1)
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(--, tag::post_dec, 1)
-
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(<<, tag::shift_left)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(>>, tag::shift_right)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(*, tag::multiplies)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(/, tag::divides)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(%, tag::modulus)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(+, tag::plus)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(-, tag::minus)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(<, tag::less)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(>, tag::greater)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(<=, tag::less_equal)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(>=, tag::greater_equal)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(==, tag::equal_to)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(!=, tag::not_equal_to)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(||, tag::logical_or)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(&&, tag::logical_and)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(&, tag::bitwise_and)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(|, tag::bitwise_or)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(^, tag::bitwise_xor)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(BOOST_PP_COMMA(), tag::comma)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(->*, tag::mem_ptr)
-
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(<<=, tag::shift_left_assign)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(>>=, tag::shift_right_assign)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(*=, tag::multiplies_assign)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(/=, tag::divides_assign)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(%=, tag::modulus_assign)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(+=, tag::plus_assign)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(-=, tag::minus_assign)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(&=, tag::bitwise_and_assign)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(|=, tag::bitwise_or_assign)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(^=, tag::bitwise_xor_assign)
-
- /// if_else
- ///
- template<typename A0, typename A1, typename A2>
- typename functional::make_expr<tag::if_else_>::impl<A0 const &, A1 const &, A2 const &>::result_type const
- if_else(A0 const &a0, A1 const &a1, A2 const &a2)
+ namespace exprns_
     {
- return functional::make_expr<tag::if_else_>::impl<A0 const &, A1 const &, A2 const &>()(a0, a1, a2);
- }

- BOOST_PROTO_END_ADL_NAMESPACE(exprns_)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(+, tag::unary_plus, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(-, tag::negate, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(*, tag::dereference, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(~, tag::complement, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(&, tag::address_of, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(!, tag::logical_not, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(++, tag::pre_inc, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(--, tag::pre_dec, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(++, tag::post_inc, 1)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(--, tag::post_dec, 1)
+
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<<, tag::shift_left)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>>, tag::shift_right)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(*, tag::multiplies)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(/, tag::divides)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(%, tag::modulus)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(+, tag::plus)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(-, tag::minus)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<, tag::less)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>, tag::greater)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<=, tag::less_equal)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>=, tag::greater_equal)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(==, tag::equal_to)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(!=, tag::not_equal_to)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(||, tag::logical_or)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(&&, tag::logical_and)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(&, tag::bitwise_and)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(|, tag::bitwise_or)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(^, tag::bitwise_xor)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(BOOST_PP_COMMA(), tag::comma)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(->*, tag::mem_ptr)
+
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<<=, tag::shift_left_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>>=, tag::shift_right_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(*=, tag::multiplies_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(/=, tag::divides_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(%=, tag::modulus_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(+=, tag::plus_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(-=, tag::minus_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(&=, tag::bitwise_and_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(|=, tag::bitwise_or_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(^=, tag::bitwise_xor_assign)
+
+ /// if_else
+ ///
+ template<typename A0, typename A1, typename A2>
+ typename functional::make_expr<tag::if_else_>::impl<A0 const &, A1 const &, A2 const &>::result_type const
+ if_else(A0 const &a0, A1 const &a1, A2 const &a2)
+ {
+ return functional::make_expr<tag::if_else_>::impl<A0 const &, A1 const &, A2 const &>()(a0, a1, a2);
+ }
+ }

- BOOST_PROTO_WHEN_NOT_BUILDING_DOCS(using exprns_::if_else;)
+ using exprns_::if_else;

#undef BOOST_PROTO_DEFINE_UNARY_OPERATOR
#undef BOOST_PROTO_DEFINE_BINARY_OPERATOR
@@ -437,13 +459,11 @@
       : mpl::false_
     {};

- #ifndef BOOST_PROTO_BUILDING_DOCS
     namespace exops
     {
         BOOST_PROTO_DEFINE_OPERATORS(is_extension, default_domain)
         using proto::if_else;
     }
- #endif

}}

Modified: branches/release/boost/proto/proto.hpp
==============================================================================
--- branches/release/boost/proto/proto.hpp (original)
+++ branches/release/boost/proto/proto.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -9,11 +9,9 @@
#ifndef BOOST_PROTO_HPP_EAN_04_01_2005
#define BOOST_PROTO_HPP_EAN_04_01_2005

-#include <boost/proto/detail/prefix.hpp>
#include <boost/proto/core.hpp>
#include <boost/proto/debug.hpp>
#include <boost/proto/context.hpp>
#include <boost/proto/transform.hpp>
-#include <boost/proto/detail/suffix.hpp>

#endif

Modified: branches/release/boost/proto/proto_fwd.hpp
==============================================================================
--- branches/release/boost/proto/proto_fwd.hpp (original)
+++ branches/release/boost/proto/proto_fwd.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -9,14 +9,14 @@
#ifndef BOOST_PROTO_FWD_HPP_EAN_04_01_2005
#define BOOST_PROTO_FWD_HPP_EAN_04_01_2005

-#include <boost/proto/detail/prefix.hpp> // must be first include
#include <cstddef>
#include <climits>
#include <boost/config.hpp>
-#include <boost/version.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
#include <boost/preprocessor/punctuation/comma.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
@@ -83,59 +83,6 @@
# endif
#endif

-#if BOOST_VERSION < 103500
-#define BOOST_PROTO_FUSION_DEFINE_TAG(X) typedef X tag;
-#define BOOST_PROTO_FUSION_DEFINE_CATEGORY(X)
-#define BOOST_PROTO_FUSION_RESULT_OF meta
-#define BOOST_PROTO_FUSION_EXTENSION meta
-#define BOOST_PROTO_FUSION_AT_C(N, X) at<N>(X)
-#else
-#define BOOST_PROTO_FUSION_DEFINE_TAG(X) typedef X fusion_tag;
-#define BOOST_PROTO_FUSION_DEFINE_CATEGORY(X) typedef X category;
-#define BOOST_PROTO_FUSION_RESULT_OF result_of
-#define BOOST_PROTO_FUSION_EXTENSION extension
-#define BOOST_PROTO_FUSION_AT_C(N, X) at_c<N>(X)
-#endif
-
-#include <boost/proto/detail/suffix.hpp> // must be last include
-
-#ifdef BOOST_PROTO_BUILDING_DOCS
-// HACKHACK so Doxygen shows inheritance from mpl::true_ and mpl::false_
-namespace boost
-{
- /// INTERNAL ONLY
- ///
- namespace mpl
- {
- /// INTERNAL ONLY
- ///
- struct true_ {};
- /// INTERNAL ONLY
- ///
- struct false_ {};
- }
-
- /// INTERNAL ONLY
- ///
- namespace fusion
- {
- /// INTERNAL ONLY
- ///
- template<typename Function>
- class unfused_generic {};
- }
-}
-#define BOOST_PROTO_WHEN_BUILDING_DOCS(x) x
-#define BOOST_PROTO_WHEN_NOT_BUILDING_DOCS(x)
-#define BOOST_PROTO_BEGIN_ADL_NAMESPACE(x)
-#define BOOST_PROTO_END_ADL_NAMESPACE(x)
-#else
-#define BOOST_PROTO_WHEN_BUILDING_DOCS(x)
-#define BOOST_PROTO_WHEN_NOT_BUILDING_DOCS(x) x
-#define BOOST_PROTO_BEGIN_ADL_NAMESPACE(x) namespace x {
-#define BOOST_PROTO_END_ADL_NAMESPACE(x) }
-#endif
-
namespace boost { namespace proto
{
     namespace detail
@@ -195,6 +142,24 @@

     typedef detail::ignore const ignore;

+ namespace argsns_
+ {
+ template<typename Arg0>
+ struct term;
+
+ #define M0(Z, N, DATA) \
+ template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename Arg)> struct BOOST_PP_CAT(list, N); \
+ /**/
+ BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M0, ~)
+ #undef M0
+ }
+
+ using argsns_::term;
+
+ #define M0(Z, N, DATA) using argsns_::BOOST_PP_CAT(list, N);
+ BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M0, ~)
+ #undef M0
+
     ///////////////////////////////////////////////////////////////////////////////
     // Operator tags
     namespace tag
@@ -255,17 +220,17 @@
     }

     ////////////////////////////////////////////////////////////////////////////////////////////////
- BOOST_PROTO_BEGIN_ADL_NAMESPACE(wildcardns_)
+ namespace wildcardns_
+ {
         struct _;
- BOOST_PROTO_END_ADL_NAMESPACE(wildcardns_)
+ }
     ////////////////////////////////////////////////////////////////////////////////////////////////

- #ifndef BOOST_PROTO_BUILDING_DOCS
     using wildcardns_::_;
- #endif

     ////////////////////////////////////////////////////////////////////////////////////////////////
- BOOST_PROTO_BEGIN_ADL_NAMESPACE(generatorns_)
+ namespace generatorns_
+ {
         struct default_generator;

         template<template<typename> class Extends>
@@ -278,36 +243,34 @@

         template<typename First, typename Second>
         struct compose_generators;
- BOOST_PROTO_END_ADL_NAMESPACE(generatorns_)
+ }
     ////////////////////////////////////////////////////////////////////////////////////////////////

- #ifndef BOOST_PROTO_BUILDING_DOCS
     using generatorns_::default_generator;
     using generatorns_::generator;
     using generatorns_::pod_generator;
     using generatorns_::by_value_generator;
     using generatorns_::compose_generators;
- #endif

     ////////////////////////////////////////////////////////////////////////////////////////////////
- BOOST_PROTO_BEGIN_ADL_NAMESPACE(domainns_)
+ namespace domainns_
+ {
         template<typename Generator = default_generator, typename Grammar = proto::_>
         struct domain;

         struct default_domain;

         struct deduce_domain;
- BOOST_PROTO_END_ADL_NAMESPACE(domainns_)
+ }
     ////////////////////////////////////////////////////////////////////////////////////////////////

- #ifndef BOOST_PROTO_BUILDING_DOCS
     using domainns_::domain;
     using domainns_::default_domain;
     using domainns_::deduce_domain;
- #endif

     ////////////////////////////////////////////////////////////////////////////////////////////////
- BOOST_PROTO_BEGIN_ADL_NAMESPACE(exprns_)
+ namespace exprns_
+ {
         template<typename Tag, typename Args, long Arity = Args::arity>
         struct expr;

@@ -323,14 +286,12 @@
         struct virtual_member;

         struct is_proto_expr;
- BOOST_PROTO_END_ADL_NAMESPACE(exprns_)
+ }
     ////////////////////////////////////////////////////////////////////////////////////////////////

- #ifndef BOOST_PROTO_BUILDING_DOCS
     using exprns_::expr;
     using exprns_::extends;
     using exprns_::is_proto_expr;
- #endif

     namespace control
     {

Modified: branches/release/boost/proto/proto_typeof.hpp
==============================================================================
--- branches/release/boost/proto/proto_typeof.hpp (original)
+++ branches/release/boost/proto/proto_typeof.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -10,13 +10,11 @@
#ifndef BOOST_XPRESSIVE_PROTO_PROTO_TYPEOF_H
#define BOOST_XPRESSIVE_PROTO_PROTO_TYPEOF_H

-#include <boost/proto/detail/prefix.hpp>
#include <boost/config.hpp>
#include <boost/typeof/typeof.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/deep_copy.hpp>
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-#include <boost/proto/detail/suffix.hpp>

BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::terminal)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::unary_plus)

Modified: branches/release/boost/proto/repeat.hpp
==============================================================================
--- branches/release/boost/proto/repeat.hpp (original)
+++ branches/release/boost/proto/repeat.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -9,7 +9,6 @@
#ifndef BOOST_PROTO_REPEAT_HPP_EAN_11_24_2008
#define BOOST_PROTO_REPEAT_HPP_EAN_11_24_2008

-#include <boost/proto/detail/prefix.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/facilities/intercept.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
@@ -18,7 +17,6 @@
#include <boost/preprocessor/iteration/local.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
#include <boost/proto/proto_fwd.hpp> // for BOOST_PROTO_MAX_ARITY
-#include <boost/proto/detail/suffix.hpp>

////////////////////////////////////////////
/// INTERNAL ONLY

Modified: branches/release/boost/proto/tags.hpp
==============================================================================
--- branches/release/boost/proto/tags.hpp (original)
+++ branches/release/boost/proto/tags.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -9,9 +9,7 @@
#ifndef BOOST_PROTO_TAGS_HPP_EAN_04_01_2005
#define BOOST_PROTO_TAGS_HPP_EAN_04_01_2005

-#include <boost/proto/detail/prefix.hpp>
#include <boost/proto/proto_fwd.hpp>
-#include <boost/proto/detail/suffix.hpp>

namespace boost { namespace proto { namespace tag
{

Modified: branches/release/boost/proto/traits.hpp
==============================================================================
--- branches/release/boost/proto/traits.hpp (original)
+++ branches/release/boost/proto/traits.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -12,7 +12,6 @@
     #ifndef BOOST_PROTO_ARG_TRAITS_HPP_EAN_04_01_2005
     #define BOOST_PROTO_ARG_TRAITS_HPP_EAN_04_01_2005

- #include <boost/proto/detail/prefix.hpp>
     #include <boost/config.hpp>
     #include <boost/detail/workaround.hpp>
     #include <boost/preprocessor/iteration/iterate.hpp>
@@ -44,7 +43,6 @@
     #include <boost/proto/args.hpp>
     #include <boost/proto/tags.hpp>
     #include <boost/proto/transform/pass_through.hpp>
- #include <boost/proto/detail/suffix.hpp>

     #if BOOST_WORKAROUND( BOOST_MSVC, >= 1400 )
         #pragma warning(push)
@@ -155,7 +153,7 @@
         {};

         /// TODO document me!
- template<typename T, typename Void BOOST_PROTO_WHEN_BUILDING_DOCS(= void)>
+ template<typename T, typename Void /* = void*/>
         struct is_transform
           : mpl::false_
         {};
@@ -176,7 +174,7 @@
             /// from <tt>proto::extends\<\></tt> or that uses the
             /// <tt>BOOST_PROTO_BASIC_EXTENDS()</tt> macro.) Otherwise,
             /// <tt>is_expr\<T\>::::value</tt> is \c false.
- template<typename T, typename Void BOOST_PROTO_WHEN_BUILDING_DOCS(= void)>
+ template<typename T, typename Void /* = void*/>
             struct is_expr
               : mpl::false_
             {};
@@ -242,10 +240,10 @@
             /// <tt>boost::result_of\<Domain(expr\< tag::terminal, term\<A\> \>)\>::::type</tt>.
             template<
                 typename T
- , typename Domain BOOST_PROTO_WHEN_BUILDING_DOCS(= default_domain)
- , typename Void BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
+ , typename Domain // = default_domain
+ , typename Void // = void
               #ifdef BOOST_PROTO_BROKEN_PTS
- , typename Void2 BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
+ , typename Void2 // = void
               #endif
>
             struct as_expr
@@ -337,10 +335,10 @@
             /// <tt>boost::result_of\<Domain(expr\< tag::terminal, term\<T &\> \>)\>::::type</tt>.
             template<
                 typename T
- , typename Domain BOOST_PROTO_WHEN_BUILDING_DOCS(= default_domain)
- , typename Void BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
+ , typename Domain // = default_domain
+ , typename Void // = void
               #ifdef BOOST_PROTO_BROKEN_PTS
- , typename Void2 BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
+ , typename Void2 // = void
               #endif
>
             struct as_child
@@ -432,7 +430,7 @@
             ///
             /// <tt>result_of::child\<Expr, N\></tt> is equivalent to
             /// <tt>result_of::child_c\<Expr, N::value\></tt>.
- template<typename Expr, typename N BOOST_PROTO_WHEN_BUILDING_DOCS(= mpl::long_<0>) >
+ template<typename Expr, typename N /* = mpl::long_<0>*/>
             struct child
               : child_c<Expr, N::value>
             {};
@@ -791,7 +789,7 @@
         {
             /// \brief A callable PolymorphicFunctionObject that is
             /// equivalent to the \c as_expr() function.
- template<typename Domain BOOST_PROTO_WHEN_BUILDING_DOCS(= default_domain)>
+ template<typename Domain /* = default_domain*/>
             struct as_expr
             {
                 BOOST_PROTO_CALLABLE()
@@ -845,7 +843,7 @@

             /// \brief A callable PolymorphicFunctionObject that is
             /// equivalent to the \c as_child() function.
- template<typename Domain BOOST_PROTO_WHEN_BUILDING_DOCS(= default_domain)>
+ template<typename Domain /* = default_domain*/>
             struct as_child
             {
                 BOOST_PROTO_CALLABLE()
@@ -926,7 +924,7 @@
             /// A callable PolymorphicFunctionObject that is
             /// equivalent to the \c child() function. \c N is required
             /// to be an MPL Integral Constant.
- template<typename N BOOST_PROTO_WHEN_BUILDING_DOCS(= mpl::long_<0>) >
+ template<typename N /* = mpl::long_<0>*/>
             struct child
             {
                 BOOST_PROTO_CALLABLE()

Modified: branches/release/boost/proto/transform.hpp
==============================================================================
--- branches/release/boost/proto/transform.hpp (original)
+++ branches/release/boost/proto/transform.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -9,7 +9,6 @@
#ifndef BOOST_PROTO_TRANSFORM_HPP_EAN_06_23_2007
#define BOOST_PROTO_TRANSFORM_HPP_EAN_06_23_2007

-#include <boost/proto/detail/prefix.hpp> // must be first include
#include <boost/proto/transform/arg.hpp>
#include <boost/proto/transform/call.hpp>
#include <boost/proto/transform/default.hpp>
@@ -19,6 +18,5 @@
#include <boost/proto/transform/make.hpp>
#include <boost/proto/transform/pass_through.hpp>
#include <boost/proto/transform/when.hpp>
-#include <boost/proto/detail/suffix.hpp> // must be last include

#endif

Modified: branches/release/boost/proto/transform/arg.hpp
==============================================================================
--- branches/release/boost/proto/transform/arg.hpp (original)
+++ branches/release/boost/proto/transform/arg.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -9,12 +9,10 @@
#ifndef BOOST_PROTO_TRANSFORM_ARG_HPP_EAN_11_01_2007
#define BOOST_PROTO_TRANSFORM_ARG_HPP_EAN_11_01_2007

-#include <boost/proto/detail/prefix.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/traits.hpp>
#include <boost/proto/transform/impl.hpp>
#include <boost/type_traits/is_array.hpp>
-#include <boost/proto/detail/suffix.hpp>

namespace boost { namespace proto
{

Modified: branches/release/boost/proto/transform/call.hpp
==============================================================================
--- branches/release/boost/proto/transform/call.hpp (original)
+++ branches/release/boost/proto/transform/call.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -10,7 +10,6 @@
     #ifndef BOOST_PROTO_TRANSFORM_CALL_HPP_EAN_11_02_2007
     #define BOOST_PROTO_TRANSFORM_CALL_HPP_EAN_11_02_2007

- #include <boost/proto/detail/prefix.hpp>
     #include <boost/preprocessor/cat.hpp>
     #include <boost/preprocessor/facilities/intercept.hpp>
     #include <boost/preprocessor/iteration/iterate.hpp>
@@ -27,7 +26,6 @@
     #include <boost/proto/detail/dont_care.hpp>
     #include <boost/proto/detail/as_lvalue.hpp>
     #include <boost/proto/detail/poly_function.hpp>
- #include <boost/proto/detail/suffix.hpp>

     namespace boost { namespace proto
     {

Modified: branches/release/boost/proto/transform/default.hpp
==============================================================================
--- branches/release/boost/proto/transform/default.hpp (original)
+++ branches/release/boost/proto/transform/default.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -11,7 +11,6 @@
     #ifndef BOOST_PROTO_TRANSFORM_DEFAULT_HPP_EAN_04_04_2008
     #define BOOST_PROTO_TRANSFORM_DEFAULT_HPP_EAN_04_04_2008

- #include <boost/proto/detail/prefix.hpp>
     #include <boost/preprocessor/iteration/iterate.hpp>
     #include <boost/preprocessor/repetition/repeat.hpp>
     #include <boost/preprocessor/repetition/enum_shifted.hpp>
@@ -27,11 +26,10 @@
     #include <boost/proto/transform/impl.hpp>
     #include <boost/proto/transform/arg.hpp>
     #include <boost/proto/detail/decltype.hpp>
- #include <boost/proto/detail/suffix.hpp>

     namespace boost { namespace proto
     {
- template<typename Grammar BOOST_PROTO_WHEN_BUILDING_DOCS(= detail::_default)>
+ template<typename Grammar /*= detail::_default*/>
         struct _default
           : transform<_default<Grammar> >
         {

Modified: branches/release/boost/proto/transform/fold.hpp
==============================================================================
--- branches/release/boost/proto/transform/fold.hpp (original)
+++ branches/release/boost/proto/transform/fold.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -10,24 +10,18 @@
     #ifndef BOOST_PROTO_TRANSFORM_FOLD_HPP_EAN_11_04_2007
     #define BOOST_PROTO_TRANSFORM_FOLD_HPP_EAN_11_04_2007

- #include <boost/proto/detail/prefix.hpp>
     #include <boost/version.hpp>
     #include <boost/preprocessor/cat.hpp>
     #include <boost/preprocessor/iteration/iterate.hpp>
     #include <boost/preprocessor/arithmetic/inc.hpp>
     #include <boost/preprocessor/arithmetic/sub.hpp>
     #include <boost/preprocessor/repetition/repeat.hpp>
- #if BOOST_VERSION >= 103500
     #include <boost/fusion/include/fold.hpp>
- #else
- #include <boost/spirit/fusion/algorithm/fold.hpp>
- #endif
     #include <boost/proto/proto_fwd.hpp>
     #include <boost/proto/fusion.hpp>
     #include <boost/proto/traits.hpp>
     #include <boost/proto/transform/call.hpp>
     #include <boost/proto/transform/impl.hpp>
- #include <boost/proto/detail/suffix.hpp>

     namespace boost { namespace proto
     {
@@ -43,6 +37,25 @@
                 template<typename Sig>
                 struct result;

+ #if 0 //BOOST_VERSION >= 104200
+
+ template<typename This, typename State, typename Expr>
+ struct result<This(State, Expr)>
+ {
+ typedef
+ typename when<_, Transform>::template impl<Expr, State, Data>::result_type
+ type;
+ };
+
+ template<typename State, typename Expr>
+ typename when<_, Transform>::template impl<Expr &, State const &, Data>::result_type
+ operator ()(State const &s, Expr &e) const
+ {
+ return typename when<_, Transform>::template impl<Expr &, State const &, Data>()(e, s, this->v_);
+ }
+
+ #else
+
                 template<typename This, typename Expr, typename State>
                 struct result<This(Expr, State)>
                 {
@@ -51,13 +64,6 @@
                     type;
                 };

- #if BOOST_VERSION < 103500
- template<typename Expr, typename State>
- struct apply
- : result<as_callable(Expr, State)>
- {};
- #endif
-
                 template<typename Expr, typename State>
                 typename when<_, Transform>::template impl<Expr &, State const &, Data>::result_type
                 operator ()(Expr &e, State const &s) const
@@ -65,42 +71,12 @@
                     return typename when<_, Transform>::template impl<Expr &, State const &, Data>()(e, s, this->v_);
                 }

+ #endif
+
             private:
                 Data v_;
             };

- #if BOOST_VERSION < 103500
- template<typename Sequence, typename Void = void>
- struct as_fusion_sequence_type
- {
- typedef Sequence const type;
- };
-
- template<typename Sequence>
- Sequence const &as_fusion_sequence(Sequence const &sequence, ...)
- {
- return sequence;
- }
-
- template<typename Sequence>
- struct as_fusion_sequence_type<Sequence, typename Sequence::proto_is_expr_>
- {
- typedef typename Sequence::proto_base_expr const type;
- };
-
- template<typename Sequence>
- typename Sequence::proto_base_expr const &as_fusion_sequence(Sequence const &sequence, int)
- {
- return sequence.proto_base();
- }
-
- #define BOOST_PROTO_AS_FUSION_SEQUENCE_TYPE(X) typename detail::as_fusion_sequence_type<X>::type
- #define BOOST_PROTO_AS_FUSION_SEQUENCE(X) detail::as_fusion_sequence(X, 0)
- #else
- #define BOOST_PROTO_AS_FUSION_SEQUENCE_TYPE(X) X
- #define BOOST_PROTO_AS_FUSION_SEQUENCE(X) X
- #endif
-
             template<
                 typename State0
               , typename Fun
@@ -220,8 +196,8 @@
                 fun;

                 typedef
- typename fusion::BOOST_PROTO_FUSION_RESULT_OF::fold<
- BOOST_PROTO_AS_FUSION_SEQUENCE_TYPE(sequence)
+ typename fusion::result_of::fold<
+ sequence
                       , state0
                       , fun
>::type
@@ -245,7 +221,7 @@
                     typename when<_, Sequence>::template impl<Expr, State, Data> seq;
                     detail::as_callable<Fun, Data> f(d);
                     return fusion::fold(
- BOOST_PROTO_AS_FUSION_SEQUENCE(seq(e, s, d))
+ seq(e, s, d)
                       , typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d)
                       , f
                     );

Modified: branches/release/boost/proto/transform/fold_tree.hpp
==============================================================================
--- branches/release/boost/proto/transform/fold_tree.hpp (original)
+++ branches/release/boost/proto/transform/fold_tree.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -9,14 +9,12 @@
#ifndef BOOST_PROTO_TRANSFORM_FOLD_TREE_HPP_EAN_11_05_2007
#define BOOST_PROTO_TRANSFORM_FOLD_TREE_HPP_EAN_11_05_2007

-#include <boost/proto/detail/prefix.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/traits.hpp>
#include <boost/proto/matches.hpp>
#include <boost/proto/transform/fold.hpp>
#include <boost/proto/transform/impl.hpp>
-#include <boost/proto/detail/suffix.hpp>

namespace boost { namespace proto
{

Modified: branches/release/boost/proto/transform/impl.hpp
==============================================================================
--- branches/release/boost/proto/transform/impl.hpp (original)
+++ branches/release/boost/proto/transform/impl.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -9,9 +9,7 @@
#ifndef BOOST_PROTO_TRANSFORM_IMPL_HPP_EAN_04_03_2008
#define BOOST_PROTO_TRANSFORM_IMPL_HPP_EAN_04_03_2008

-#include <boost/proto/detail/prefix.hpp>
#include <boost/proto/proto_fwd.hpp>
-#include <boost/proto/detail/suffix.hpp>

namespace boost { namespace proto
{

Modified: branches/release/boost/proto/transform/lazy.hpp
==============================================================================
--- branches/release/boost/proto/transform/lazy.hpp (original)
+++ branches/release/boost/proto/transform/lazy.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -10,7 +10,6 @@
     #ifndef BOOST_PROTO_TRANSFORM_LAZY_HPP_EAN_12_02_2007
     #define BOOST_PROTO_TRANSFORM_LAZY_HPP_EAN_12_02_2007

- #include <boost/proto/detail/prefix.hpp>
     #include <boost/preprocessor/iteration/iterate.hpp>
     #include <boost/preprocessor/repetition/enum_params.hpp>
     #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
@@ -18,7 +17,6 @@
     #include <boost/proto/transform/make.hpp>
     #include <boost/proto/transform/call.hpp>
     #include <boost/proto/transform/impl.hpp>
- #include <boost/proto/detail/suffix.hpp>

     namespace boost { namespace proto
     {

Modified: branches/release/boost/proto/transform/make.hpp
==============================================================================
--- branches/release/boost/proto/transform/make.hpp (original)
+++ branches/release/boost/proto/transform/make.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -10,7 +10,6 @@
     #ifndef BOOST_PROTO_TRANSFORM_MAKE_HPP_EAN_12_02_2007
     #define BOOST_PROTO_TRANSFORM_MAKE_HPP_EAN_12_02_2007

- #include <boost/proto/detail/prefix.hpp>
     #include <boost/detail/workaround.hpp>
     #include <boost/preprocessor/repetition/enum.hpp>
     #include <boost/preprocessor/repetition/enum_params.hpp>
@@ -35,7 +34,6 @@
     #include <boost/proto/transform/impl.hpp>
     #include <boost/proto/detail/as_lvalue.hpp>
     #include <boost/proto/detail/ignore_unused.hpp>
- #include <boost/proto/detail/suffix.hpp>

     namespace boost { namespace proto
     {

Modified: branches/release/boost/proto/transform/pass_through.hpp
==============================================================================
--- branches/release/boost/proto/transform/pass_through.hpp (original)
+++ branches/release/boost/proto/transform/pass_through.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -13,7 +13,6 @@
     #ifndef BOOST_PROTO_TRANSFORM_PASS_THROUGH_HPP_EAN_12_26_2006
     #define BOOST_PROTO_TRANSFORM_PASS_THROUGH_HPP_EAN_12_26_2006

- #include <boost/proto/detail/prefix.hpp>
     #include <boost/preprocessor/cat.hpp>
     #include <boost/preprocessor/repetition/enum.hpp>
     #include <boost/preprocessor/iteration/iterate.hpp>
@@ -22,7 +21,6 @@
     #include <boost/proto/proto_fwd.hpp>
     #include <boost/proto/args.hpp>
     #include <boost/proto/transform/impl.hpp>
- #include <boost/proto/detail/suffix.hpp>

     namespace boost { namespace proto
     {

Modified: branches/release/boost/proto/transform/when.hpp
==============================================================================
--- branches/release/boost/proto/transform/when.hpp (original)
+++ branches/release/boost/proto/transform/when.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -10,7 +10,6 @@
     #ifndef BOOST_PROTO_TRANSFORM_WHEN_HPP_EAN_10_29_2007
     #define BOOST_PROTO_TRANSFORM_WHEN_HPP_EAN_10_29_2007

- #include <boost/proto/detail/prefix.hpp>
     #include <boost/preprocessor/cat.hpp>
     #include <boost/preprocessor/repetition/enum_params.hpp>
     #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
@@ -21,7 +20,6 @@
     #include <boost/proto/transform/call.hpp>
     #include <boost/proto/transform/make.hpp>
     #include <boost/proto/transform/impl.hpp>
- #include <boost/proto/detail/suffix.hpp>

     namespace boost { namespace proto
     {
@@ -53,7 +51,7 @@
         ///
         /// <tt>when\<G,T\>()(e,s,v)</tt> is the same as
         /// <tt>T()(e,s,v)</tt>.
- template<typename Grammar, typename PrimitiveTransform BOOST_PROTO_WHEN_BUILDING_DOCS(= Grammar)>
+ template<typename Grammar, typename PrimitiveTransform /*= Grammar*/>
         struct when
           : PrimitiveTransform
         {

Modified: branches/release/boost/xpressive/basic_regex.hpp
==============================================================================
--- branches/release/boost/xpressive/basic_regex.hpp (original)
+++ branches/release/boost/xpressive/basic_regex.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -21,6 +21,7 @@
#include <boost/xpressive/regex_constants.hpp>
#include <boost/xpressive/detail/detail_fwd.hpp>
#include <boost/xpressive/detail/core/regex_impl.hpp>
+#include <boost/xpressive/detail/core/regex_domain.hpp>

// Doxygen can't handle proto :-(
#ifndef BOOST_XPRESSIVE_DOXYGEN_INVOKED
@@ -51,13 +52,14 @@
template<typename BidiIter>
struct basic_regex
   : proto::extends<
- typename proto::terminal<detail::tracking_ptr<detail::regex_impl<BidiIter> > >::type
+ proto::expr<proto::tag::terminal, proto::term<detail::tracking_ptr<detail::regex_impl<BidiIter> > >, 0>
       , basic_regex<BidiIter>
+ , detail::regex_domain
>
{
private:
- typedef typename proto::terminal<detail::tracking_ptr<detail::regex_impl<BidiIter> > >::type pimpl_type;
- typedef proto::extends<pimpl_type, basic_regex<BidiIter> > base_type;
+ typedef proto::expr<proto::tag::terminal, proto::term<detail::tracking_ptr<detail::regex_impl<BidiIter> > >, 0> pimpl_type;
+ typedef proto::extends<pimpl_type, basic_regex<BidiIter>, detail::regex_domain> base_type;

public:
     typedef BidiIter iterator_type;
@@ -256,9 +258,6 @@
     void compile_(Expr const &, mpl::false_)
     {
     }
-
- /// INTERNAL ONLY
- void dump_(std::ostream &sout) const;
};

#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

Modified: branches/release/boost/xpressive/detail/core/access.hpp
==============================================================================
--- branches/release/boost/xpressive/detail/core/access.hpp (original)
+++ branches/release/boost/xpressive/detail/core/access.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -15,6 +15,7 @@

#include <vector>
#include <boost/shared_ptr.hpp>
+#include <boost/proto/traits.hpp>
#include <boost/xpressive/detail/detail_fwd.hpp>
#include <boost/xpressive/detail/dynamic/matchable.hpp>
#include <boost/xpressive/match_results.hpp> // for type_info_less
@@ -119,6 +120,11 @@
     {
         what.set_base_(base);
     }
+
+ static BidiIter get_base(match_results<BidiIter> &what)
+ {
+ return *what.base_;
+ }
};

}}} // namespace boost::xpressive::detail

Copied: branches/release/boost/xpressive/detail/core/list.hpp (from r57174, /trunk/boost/xpressive/detail/core/list.hpp)
==============================================================================
--- /trunk/boost/xpressive/detail/core/list.hpp (original)
+++ branches/release/boost/xpressive/detail/core/list.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -40,7 +40,7 @@

         struct node : node_base
         {
- explicit node(T const &value = T())
+ explicit node(T const &value)
               : _value(value)
             {}

@@ -49,40 +49,29 @@

         node_base _sentry;

- public:
- struct iterator
- : boost::iterator_facade<iterator, T, std::bidirectional_iterator_tag>
+ template<typename Ref = T &>
+ struct list_iterator
+ : boost::iterator_facade<list_iterator<Ref>, T, std::bidirectional_iterator_tag, Ref>
         {
- explicit iterator(node_base *n = 0) : _node(n) {}
+ list_iterator(list_iterator<> const &it) : _node(it._node) {}
+ explicit list_iterator(node_base *n = 0) : _node(n) {}
         private:
             friend struct list<T>;
             friend class boost::iterator_core_access;
- T &dereference() const { return static_cast<node *>(_node)->_value; }
+ Ref dereference() const { return static_cast<node *>(_node)->_value; }
             void increment() { _node = _node->_next; }
             void decrement() { _node = _node->_prev; }
- bool equal(iterator it) const { return _node == it._node; }
+ bool equal(list_iterator const &it) const { return _node == it._node; }
             node_base *_node;
         };

- struct const_iterator
- : boost::iterator_facade<const_iterator, T, std::bidirectional_iterator_tag, T const &>
- {
- const_iterator(iterator it) : _node(it._node) {}
- explicit const_iterator(node_base const *n = 0) : _node(n) {}
- private:
- friend struct list<T>;
- friend class boost::iterator_core_access;
- T const &dereference() const { return static_cast<node const *>(_node)->_value; }
- void increment() { _node = _node->_next; }
- void decrement() { _node = _node->_prev; }
- bool equal(const_iterator it) const { return _node == it._node; }
- node_base const *_node;
- };
-
+ public:
         typedef T *pointer;
         typedef T const *const_pointer;
         typedef T &reference;
         typedef T const &const_reference;
+ typedef list_iterator<> iterator;
+ typedef list_iterator<T const &> const_iterator;
         typedef std::size_t size_type;

         list()
@@ -90,7 +79,7 @@
             _sentry._next = _sentry._prev = &_sentry;
         }

- list(list<T> const &that)
+ list(list const &that)
         {
             _sentry._next = _sentry._prev = &_sentry;
             const_iterator it = that.begin(), e = that.end();
@@ -98,9 +87,9 @@
                 push_back(*it);
         }

- list &operator =(list<T> const &that)
+ list &operator =(list const &that)
         {
- list<T>(that).swap(*this);
+ list(that).swap(*this);
             return *this;
         }

@@ -115,12 +104,12 @@
                 pop_front();
         }

- void swap(list<T> &that) // throw()
+ void swap(list &that) // throw()
         {
- list<T> tmp;
- tmp.splice(tmp.begin(), *this); // move this to tmp
- splice(begin(), that); // move that to this
- that.splice(that.begin(), tmp); // move tmp to that
+ list temp;
+ temp.splice(temp.begin(), that); // move that to temp
+ that.splice(that.begin(), *this); // move this to that
+ splice(begin(), temp); // move temp to this
         }

         void push_front(T const &t)
@@ -168,21 +157,21 @@
             return _sentry._next == &_sentry;
         }

- void splice(iterator it, list<T> &x)
+ void splice(iterator it, list &x)
         {
- if(!x.empty())
- {
- x._sentry._prev->_next = it._node;
- x._sentry._next->_prev = it._node->_prev;
+ if(x.empty())
+ return;
+
+ x._sentry._prev->_next = it._node;
+ x._sentry._next->_prev = it._node->_prev;

- it._node->_prev->_next = x._sentry._next;
- it._node->_prev = x._sentry._prev;
+ it._node->_prev->_next = x._sentry._next;
+ it._node->_prev = x._sentry._prev;

- x._sentry._prev = x._sentry._next = &x._sentry;
- }
+ x._sentry._prev = x._sentry._next = &x._sentry;
         }

- void splice(iterator it, list<T> &, iterator xit)
+ void splice(iterator it, list &, iterator xit)
         {
             xit._node->_prev->_next = xit._node->_next;
             xit._node->_next->_prev = xit._node->_prev;
@@ -190,8 +179,7 @@
             xit._node->_next = it._node;
             xit._node->_prev = it._node->_prev;

- it._node->_prev->_next = xit._node;
- it._node->_prev = xit._node;
+ it._node->_prev = it._node->_prev->_next = xit._node;
         }

         reference front()
@@ -235,7 +223,7 @@

         const_iterator end() const
         {
- return const_iterator(&_sentry);
+ return const_iterator(const_cast<node_base *>(&_sentry));
         }

         size_type size() const

Modified: branches/release/boost/xpressive/detail/core/results_cache.hpp
==============================================================================
--- branches/release/boost/xpressive/detail/core/results_cache.hpp (original)
+++ branches/release/boost/xpressive/detail/core/results_cache.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -13,129 +13,121 @@
# pragma once
#endif

-#include <list>
+#include <cstddef>
#include <boost/detail/workaround.hpp>
#include <boost/assert.hpp>
#include <boost/xpressive/detail/detail_fwd.hpp>
+#include <boost/xpressive/detail/core/list.hpp>
#include <boost/xpressive/detail/core/access.hpp>
#include <boost/xpressive/match_results.hpp>

namespace boost { namespace xpressive { namespace detail
{

-///////////////////////////////////////////////////////////////////////////////
-// nested_results
-// BUGBUG by using std::list, it makes construction of of an empty nested_results
-// incur a dynamic allocation. As a result, construction an empty match_results is
-// likewise not free. FIXME.
-#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
-template<typename BidiIter>
-struct nested_results
- : std::list<match_results<BidiIter> >
-{
- friend struct results_cache<BidiIter>;
- friend struct match_results<BidiIter>;
-};
-#else
-template<typename BidiIter>
-struct nested_results
- : private std::list<match_results<BidiIter> >
-{
- friend struct results_cache<BidiIter>;
- friend struct xpressive::match_results<BidiIter>;
- typedef std::list<xpressive::match_results<BidiIter> > base_type;
-
- using base_type::iterator;
- using base_type::const_iterator;
- #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB , == 1)
- // old Dinkumware doesn't expose pointer typedefs
- typedef base_type::value_type *pointer;
- typedef base_type::value_type const *const_pointer;
+ ///////////////////////////////////////////////////////////////////////////////
+ // nested_results
+ #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
+ template<typename BidiIter>
+ struct nested_results
+ : detail::list<match_results<BidiIter> >
+ {
+ friend struct results_cache<BidiIter>;
+ friend struct match_results<BidiIter>;
+ };
     #else
- using base_type::pointer;
- using base_type::const_pointer;
+ template<typename BidiIter>
+ struct nested_results
+ : private detail::list<match_results<BidiIter> >
+ {
+ friend struct results_cache<BidiIter>;
+ friend struct xpressive::match_results<BidiIter>;
+ typedef list<xpressive::match_results<BidiIter> > base_type;
+
+ using base_type::iterator;
+ using base_type::const_iterator;
+ using base_type::pointer;
+ using base_type::const_pointer;
+ using base_type::reference;
+ using base_type::const_reference;
+ using base_type::size_type;
+ using base_type::begin;
+ using base_type::end;
+ using base_type::size;
+ using base_type::empty;
+ using base_type::front;
+ using base_type::back;
+ };
     #endif
- using base_type::reference;
- using base_type::const_reference;
- using base_type::size_type;
- using base_type::begin;
- using base_type::end;
- using base_type::size;
- using base_type::empty;
- using base_type::front;
- using base_type::back;
-};
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// results_cache
-//
-// cache storage for reclaimed match_results structs
-template<typename BidiIter>
-struct results_cache
-{
- typedef core_access<BidiIter> access;

- match_results<BidiIter> &append_new(nested_results<BidiIter> &out)
+ ///////////////////////////////////////////////////////////////////////////////
+ // results_cache
+ //
+ // cache storage for reclaimed match_results structs
+ template<typename BidiIter>
+ struct results_cache
     {
- if(this->cache_.empty())
- {
- out.push_back(match_results<BidiIter>());
- }
- else
+ typedef core_access<BidiIter> access;
+
+ match_results<BidiIter> &append_new(nested_results<BidiIter> &out)
         {
- BOOST_ASSERT(access::get_nested_results(this->cache_.back()).empty());
- out.splice(out.end(), this->cache_, --this->cache_.end());
+ if(this->cache_.empty())
+ {
+ out.push_back(match_results<BidiIter>());
+ }
+ else
+ {
+ BOOST_ASSERT(access::get_nested_results(this->cache_.back()).empty());
+ out.splice(out.end(), this->cache_, --this->cache_.end());
+ }
+ return out.back();
         }
- return out.back();
- }

- // move the last match_results struct into the cache
- void reclaim_last(nested_results<BidiIter> &out)
- {
- BOOST_ASSERT(!out.empty());
- // first, reclaim any nested results
- nested_results<BidiIter> &nested = access::get_nested_results(out.back());
- if(!nested.empty())
+ // move the last match_results struct into the cache
+ void reclaim_last(nested_results<BidiIter> &out)
         {
- this->reclaim_all(nested);
+ BOOST_ASSERT(!out.empty());
+ // first, reclaim any nested results
+ nested_results<BidiIter> &nested = access::get_nested_results(out.back());
+ if(!nested.empty())
+ {
+ this->reclaim_all(nested);
+ }
+ // then, reclaim the last match_results
+ this->cache_.splice(this->cache_.end(), out, --out.end());
         }
- // then, reclaim the last match_results
- this->cache_.splice(this->cache_.end(), out, --out.end());
- }

- // move the last n match_results structs into the cache
- void reclaim_last_n(nested_results<BidiIter> &out, std::size_t count)
- {
- for(; 0 != count; --count)
+ // move the last n match_results structs into the cache
+ void reclaim_last_n(nested_results<BidiIter> &out, std::size_t count)
         {
- this->reclaim_last(out);
+ for(; 0 != count; --count)
+ {
+ this->reclaim_last(out);
+ }
         }
- }

- void reclaim_all(nested_results<BidiIter> &out)
- {
- typedef typename nested_results<BidiIter>::iterator iter_type;
-
- // first, recursively reclaim all the nested results
- for(iter_type begin = out.begin(); begin != out.end(); ++begin)
+ void reclaim_all(nested_results<BidiIter> &out)
         {
- nested_results<BidiIter> &nested = access::get_nested_results(*begin);
+ typedef typename nested_results<BidiIter>::iterator iter_type;

- if(!nested.empty())
+ // first, recursively reclaim all the nested results
+ for(iter_type begin = out.begin(); begin != out.end(); ++begin)
             {
- this->reclaim_all(nested);
+ nested_results<BidiIter> &nested = access::get_nested_results(*begin);
+
+ if(!nested.empty())
+ {
+ this->reclaim_all(nested);
+ }
             }
- }

- // next, reclaim the results themselves
- this->cache_.splice(this->cache_.end(), out);
- }
+ // next, reclaim the results themselves
+ this->cache_.splice(this->cache_.end(), out);
+ }

-private:
+ private:

- nested_results<BidiIter> cache_;
-};
+ nested_results<BidiIter> cache_;
+ };

}}} // namespace boost::xpressive::detail

Modified: branches/release/boost/xpressive/detail/core/state.hpp
==============================================================================
--- branches/release/boost/xpressive/detail/core/state.hpp (original)
+++ branches/release/boost/xpressive/detail/core/state.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -289,7 +289,7 @@
         this->context_.results_ptr_ = &what;
         this->context_.traits_ = impl.traits_.get();
         this->mark_count_ = impl.mark_count_ + 1;
- this->sub_matches_ = this->extras_->sub_match_stack_.push_sequence(total_mark_count, detail::sub_match_impl_default());
+ this->sub_matches_ = this->extras_->sub_match_stack_.push_sequence(total_mark_count, sub_match_impl(begin_), detail::fill);
         this->sub_matches_ += impl.hidden_mark_count_;

         // initialize the match_results struct
@@ -329,7 +329,7 @@
{
     memento<BidiIter> mem =
     {
- state.extras_->sub_match_stack_.push_sequence(state.mark_count_)
+ state.extras_->sub_match_stack_.push_sequence(state.mark_count_, sub_match_impl<BidiIter>(state.begin_))
       , state.context_.results_ptr_->nested_results().size()
       , state.action_list_.next
       , state.action_list_tail_

Modified: branches/release/boost/xpressive/detail/core/sub_match_impl.hpp
==============================================================================
--- branches/release/boost/xpressive/detail/core/sub_match_impl.hpp (original)
+++ branches/release/boost/xpressive/detail/core/sub_match_impl.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -23,13 +23,6 @@
// need is trivial constructor/destructor. (???)

///////////////////////////////////////////////////////////////////////////////
-// sub_match_impl_default
-//
-struct sub_match_impl_default
-{
-};
-
-///////////////////////////////////////////////////////////////////////////////
// sub_match_impl
//
template<typename BidiIter>
@@ -40,21 +33,13 @@
     BidiIter begin_;
     bool zero_width_;

- sub_match_impl()
- : sub_match<BidiIter>()
+ sub_match_impl(BidiIter const &begin)
+ : sub_match<BidiIter>(begin, begin)
       , repeat_count_(0)
- , begin_()
+ , begin_(begin)
       , zero_width_(false)
     {
     }
-
- sub_match_impl &operator =(sub_match_impl_default const &)
- {
- this->matched = false;
- this->repeat_count_ = 0;
- this->zero_width_ = false;
- return *this;
- }
};

}}} // namespace boost::xpressive::detail

Modified: branches/release/boost/xpressive/detail/detail_fwd.hpp
==============================================================================
--- branches/release/boost/xpressive/detail/detail_fwd.hpp (original)
+++ branches/release/boost/xpressive/detail/detail_fwd.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -212,11 +212,11 @@
     template<typename Traits>
     struct logical_newline_matcher;

- typedef proto::terminal<logical_newline_placeholder>::type logical_newline_xpression;
+ typedef proto::expr<proto::tag::terminal, proto::term<logical_newline_placeholder>, 0> logical_newline_xpression;

     struct set_initializer;

- typedef proto::terminal<set_initializer>::type set_initializer_type;
+ typedef proto::expr<proto::tag::terminal, proto::term<set_initializer>, 0> set_initializer_type;

     struct lookahead_tag;

@@ -287,6 +287,9 @@
     template<typename BidiIter>
     struct sub_match_impl;

+ template<typename T>
+ struct list;
+
     template<typename BidiIter>
     struct results_cache;

Modified: branches/release/boost/xpressive/detail/utility/sequence_stack.hpp
==============================================================================
--- branches/release/boost/xpressive/detail/utility/sequence_stack.hpp (original)
+++ branches/release/boost/xpressive/detail/utility/sequence_stack.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -21,6 +21,8 @@
namespace boost { namespace xpressive { namespace detail
{

+struct fill_t {} const fill = {};
+
//////////////////////////////////////////////////////////////////////////
// sequence_stack
//
@@ -30,11 +32,34 @@
struct sequence_stack
{
private:
+ static T *allocate(std::size_t size, T const &t)
+ {
+ std::size_t i = 0;
+ T *p = (T *)::operator new(size * sizeof(T));
+ try
+ {
+ for(; i < size; ++i)
+ ::new((void *)(p+i)) T(t);
+ }
+ catch(...)
+ {
+ deallocate(p, i);
+ throw;
+ }
+ return p;
+ }
+
+ static void deallocate(T *p, std::size_t i)
+ {
+ while(i-- > 0)
+ (p+i)->~T();
+ ::operator delete(p);
+ }

     struct chunk
     {
- chunk(std::size_t size, std::size_t count, chunk *back, chunk *next)
- : begin_(new T[ size ])
+ chunk(std::size_t size, T const &t, std::size_t count, chunk *back, chunk *next)
+ : begin_(allocate(size, t))
           , curr_(begin_ + count)
           , end_(begin_ + size)
           , back_(back)
@@ -48,7 +73,7 @@

         ~chunk()
         {
- delete[] this->begin_;
+ deallocate(this->begin_, this->size());
         }

         std::size_t size() const
@@ -70,7 +95,7 @@
     T *curr_;
     T *end_;

- T *grow_(std::size_t count)
+ T *grow_(std::size_t count, T const &t)
     {
         if(this->current_chunk_)
         {
@@ -85,7 +110,7 @@
                 this->curr_ = this->current_chunk_->curr_ = this->current_chunk_->begin_ + count;
                 this->end_ = this->current_chunk_->end_;
                 this->begin_ = this->current_chunk_->begin_;
- std::fill_n(this->begin_, count, T());
+ std::fill_n(this->begin_, count, t);
                 return this->begin_;
             }

@@ -93,7 +118,7 @@
             std::size_t new_size = (std::max)(count, static_cast<std::size_t>(this->current_chunk_->size() * 1.5));

             // Create a new expr and insert it into the list
- this->current_chunk_ = new chunk(new_size, count, this->current_chunk_, this->current_chunk_->next_);
+ this->current_chunk_ = new chunk(new_size, t, count, this->current_chunk_, this->current_chunk_->next_);
         }
         else
         {
@@ -101,7 +126,7 @@
             std::size_t new_size = (std::max)(count, static_cast<std::size_t>(256U));

             // Create a new expr and insert it into the list
- this->current_chunk_ = new chunk(new_size, count, 0, 0);
+ this->current_chunk_ = new chunk(new_size, t, count, 0, 0);
         }

         this->begin_ = this->current_chunk_->begin_;
@@ -173,7 +198,7 @@
         this->begin_ = this->curr_ = this->end_ = 0;
     }

- T *push_sequence(std::size_t count)
+ T *push_sequence(std::size_t count, T const &t)
     {
         // This is the ptr to return
         T *ptr = this->curr_;
@@ -188,17 +213,16 @@
             this->curr_ = ptr;

             // allocate a new block and return a ptr to the new memory
- return this->grow_(count);
+ return this->grow_(count, t);
         }

         return ptr;
     }

- template<typename U>
- T *push_sequence(std::size_t count, U const &u)
+ T *push_sequence(std::size_t count, T const &t, fill_t)
     {
- T *ptr = this->push_sequence(count);
- std::fill_n(ptr, count, u);
+ T *ptr = this->push_sequence(count, t);
+ std::fill_n(ptr, count, t);
         return ptr;
     }

Modified: branches/release/boost/xpressive/match_results.hpp
==============================================================================
--- branches/release/boost/xpressive/match_results.hpp (original)
+++ branches/release/boost/xpressive/match_results.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -40,6 +40,7 @@
#include <boost/utility/enable_if.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/numeric/conversion/converter.hpp>
+#include <boost/optional.hpp>
#include <boost/range/end.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/as_literal.hpp>
@@ -57,8 +58,12 @@
#include <boost/xpressive/detail/utility/literals.hpp>
#include <boost/xpressive/detail/utility/algorithm.hpp>
#include <boost/xpressive/detail/utility/counted_base.hpp>
-#include <boost/proto/proto_fwd.hpp>
-#include <boost/proto/eval.hpp>
+// Doxygen can't handle proto :-(
+#ifndef BOOST_XPRESSIVE_DOXYGEN_INVOKED
+# include <boost/proto/proto_fwd.hpp>
+# include <boost/proto/traits.hpp>
+# include <boost/proto/eval.hpp>
+#endif

namespace boost { namespace xpressive { namespace detail
{
@@ -410,14 +415,14 @@
         {
             extras_type &extras = this->get_extras_();
             std::size_t size = that.sub_matches_.size();
- detail::sub_match_impl<BidiIter> *sub_matches = extras.sub_match_stack_.push_sequence(size, detail::sub_match_impl_default());
+ detail::sub_match_impl<BidiIter> *sub_matches = extras.sub_match_stack_.push_sequence(size, detail::sub_match_impl<BidiIter>(*that.base_), detail::fill);
             detail::core_access<BidiIter>::init_sub_match_vector(this->sub_matches_, sub_matches, size, that.sub_matches_);

- // BUGBUG this doesn't share the extras::sequence_stack
- this->nested_results_ = that.nested_results_;
+ this->base_ = that.base_;
             this->prefix_ = that.prefix_;
             this->suffix_ = that.suffix_;
- this->base_ = that.base_;
+ // BUGBUG this doesn't share the extras::sequence_stack
+ this->nested_results_ = that.nested_results_;
             this->traits_ = that.traits_;
         }
     }
@@ -469,7 +474,7 @@
     /// of a repeated search with a regex_iterator then base is the same as prefix().first - end note]
     difference_type position(size_type sub = 0) const
     {
- return this->sub_matches_[ sub ].matched ? std::distance(this->base_, this->sub_matches_[ sub ].first) : -1;
+ return this->sub_matches_[ sub ].matched ? std::distance(*this->base_, this->sub_matches_[ sub ].first) : -1;
     }

     /// Returns (*this)[sub].str().
@@ -493,17 +498,19 @@
     /// Returns a reference to the sub_match object representing the character sequence from
     /// the start of the string being matched/searched, to the start of the match found.
     ///
+ /// \pre (*this)[0].matched is true
     const_reference prefix() const
     {
- return this->prefix_;
+ return this->prefix_ ? *this->prefix_ : this->sub_matches_[this->sub_matches_.size()];
     }

     /// Returns a reference to the sub_match object representing the character sequence from
     /// the end of the match found to the end of the string being matched/searched.
     ///
+ /// \pre (*this)[0].matched is true
     const_reference suffix() const
     {
- return this->suffix_;
+ return this->suffix_ ? *this->suffix_ : this->sub_matches_[this->sub_matches_.size()];
     }

     /// Returns a starting iterator that enumerates over all the marked sub-expression matches
@@ -526,7 +533,7 @@
     ///
     operator bool_type() const
     {
- return this->sub_matches_[ 0 ].matched ? &dummy::i_ : 0;
+ return (!this->empty() && this->sub_matches_[ 0 ].matched) ? &dummy::i_ : 0;
     }

     /// Returns true if empty() || !(*this)[0].matched, else returns false.
@@ -650,11 +657,12 @@
     /// \throw nothrow
     void swap(match_results<BidiIter> &that) // throw()
     {
- std::swap(this->regex_id_, that.regex_id_);
+ using std::swap;
+ swap(this->regex_id_, that.regex_id_);
         this->sub_matches_.swap(that.sub_matches_);
- std::swap(this->base_, that.base_);
- std::swap(this->prefix_, that.prefix_);
- std::swap(this->suffix_, that.suffix_);
+ swap(this->base_, that.base_);
+ swap(this->prefix_, that.prefix_);
+ swap(this->suffix_, that.suffix_);
         this->nested_results_.swap(that.nested_results_);
         this->extras_ptr_.swap(that.extras_ptr_);
         this->traits_.swap(that.traits_);
@@ -738,14 +746,8 @@
     void set_prefix_suffix_(BidiIter begin, BidiIter end)
     {
         this->base_ = begin;
-
- this->prefix_.first = begin;
- this->prefix_.second = this->sub_matches_[ 0 ].first;
- this->prefix_.matched = this->prefix_.first != this->prefix_.second;
-
- this->suffix_.first = this->sub_matches_[ 0 ].second;
- this->suffix_.second = end;
- this->suffix_.matched = this->suffix_.first != this->suffix_.second;
+ this->prefix_ = sub_match<BidiIter>(begin, this->sub_matches_[ 0 ].first, begin != this->sub_matches_[ 0 ].first);
+ this->suffix_ = sub_match<BidiIter>(this->sub_matches_[ 0 ].second, end, this->sub_matches_[ 0 ].second != end);

         typename nested_results_type::iterator ibegin = this->nested_results_.begin();
         typename nested_results_type::iterator iend = this->nested_results_.end();
@@ -1335,9 +1337,9 @@

     regex_id_type regex_id_;
     detail::sub_match_vector<BidiIter> sub_matches_;
- BidiIter base_;
- sub_match<BidiIter> prefix_;
- sub_match<BidiIter> suffix_;
+ boost::optional<BidiIter> base_;
+ boost::optional<sub_match<BidiIter> > prefix_;
+ boost::optional<sub_match<BidiIter> > suffix_;
     nested_results_type nested_results_;
     intrusive_ptr<extras_type> extras_ptr_;
     intrusive_ptr<detail::traits<char_type> const> traits_;

Modified: branches/release/boost/xpressive/regex_primitives.hpp
==============================================================================
--- branches/release/boost/xpressive/regex_primitives.hpp (original)
+++ branches/release/boost/xpressive/regex_primitives.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -20,6 +20,7 @@
#include <boost/preprocessor/cat.hpp>
#include <boost/xpressive/detail/detail_fwd.hpp>
#include <boost/xpressive/detail/core/matchers.hpp>
+#include <boost/xpressive/detail/core/regex_domain.hpp>
#include <boost/xpressive/detail/utility/ignore_unused.hpp>

// Doxygen can't handle proto :-(
@@ -536,16 +537,24 @@
/// can be used to index into the <tt>match_results\<\></tt> object to retrieve the
/// corresponding sub-match.
struct mark_tag
- : proto::extends<detail::basic_mark_tag, mark_tag>
+ : proto::extends<detail::basic_mark_tag, mark_tag, detail::regex_domain>
{
+private:
+ typedef proto::extends<detail::basic_mark_tag, mark_tag, detail::regex_domain> base_type;
+
+ static detail::basic_mark_tag make_tag(int mark_nbr)
+ {
+ detail::basic_mark_tag mark = {{mark_nbr}};
+ return mark;
+ }
+
+public:
     /// \brief Initialize a mark_tag placeholder
     /// \param mark_nbr An integer that uniquely identifies this \c mark_tag
     /// within the static regexes in which this \c mark_tag will be used.
     /// \pre <tt>mark_nbr \> 0</tt>
     mark_tag(int mark_nbr)
- : proto::extends<detail::basic_mark_tag, mark_tag>(
- detail::basic_mark_tag::make(mark_nbr)
- )
+ : base_type(mark_tag::make_tag(mark_nbr))
     {
         // Marks numbers must be integers greater than 0.
         BOOST_ASSERT(mark_nbr > 0);
@@ -557,7 +566,7 @@
         return this->proto_base();
     }

- using proto::extends<detail::basic_mark_tag, mark_tag>::operator =;
+ using base_type::operator =;
};

// This macro is used when declaring mark_tags that are global because

Modified: branches/release/boost/xpressive/traits/cpp_regex_traits.hpp
==============================================================================
--- branches/release/boost/xpressive/traits/cpp_regex_traits.hpp (original)
+++ branches/release/boost/xpressive/traits/cpp_regex_traits.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -81,7 +81,7 @@

     #ifndef BOOST_XPRESSIVE_BUGGY_CTYPE_FACET
     // an unsigned integer with the highest bit set
- umaskex_t const highest_bit = 1 << (sizeof(umaskex_t) * CHAR_BIT - 1);
+ umaskex_t const highest_bit = static_cast<umaskex_t>(1) << (sizeof(umaskex_t) * CHAR_BIT - 1);

     ///////////////////////////////////////////////////////////////////////////////
     // unused_mask

Modified: branches/release/boost/xpressive/xpressive_fwd.hpp
==============================================================================
--- branches/release/boost/xpressive/xpressive_fwd.hpp (original)
+++ branches/release/boost/xpressive/xpressive_fwd.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -51,7 +51,6 @@
#endif

#include <boost/proto/proto_fwd.hpp>
-#include <boost/proto/traits.hpp>

namespace boost { namespace xpressive
{
@@ -78,7 +77,9 @@
         };

         struct mark_placeholder;
- typedef proto::terminal<mark_placeholder>::type basic_mark_tag;
+ typedef proto::expr<proto::tag::terminal, proto::term<mark_placeholder>, 0> basic_mark_tag;
+
+ struct regex_domain;

     } // namespace detail

Modified: branches/release/libs/proto/test/examples.cpp
==============================================================================
--- branches/release/libs/proto/test/examples.cpp (original)
+++ branches/release/libs/proto/test/examples.cpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -11,14 +11,9 @@
#include <boost/proto/core.hpp>
#include <boost/proto/transform.hpp>
#include <boost/utility/result_of.hpp>
-#if BOOST_VERSION < 103500
-# include <boost/spirit/fusion/sequence/cons.hpp>
-# include <boost/spirit/fusion/sequence/tuple.hpp>
-#else
-# include <boost/fusion/include/cons.hpp>
-# include <boost/fusion/include/tuple.hpp>
-# include <boost/fusion/include/pop_front.hpp>
-#endif
+#include <boost/fusion/include/cons.hpp>
+#include <boost/fusion/include/tuple.hpp>
+#include <boost/fusion/include/pop_front.hpp>
#include <boost/test/unit_test.hpp>

namespace mpl = boost::mpl;

Modified: branches/release/libs/proto/test/lambda.cpp
==============================================================================
--- branches/release/libs/proto/test/lambda.cpp (original)
+++ branches/release/libs/proto/test/lambda.cpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -6,19 +6,12 @@
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <sstream>
-#include <boost/version.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/min_max.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/next_prior.hpp>
-#if BOOST_VERSION < 103500
-# include <boost/spirit/fusion/sequence/at.hpp>
-# include <boost/spirit/fusion/sequence/tuple.hpp>
-namespace boost { namespace fusion { namespace result_of { using namespace meta; }}}
-#else
-# include <boost/fusion/tuple.hpp>
-#endif
+#include <boost/fusion/tuple.hpp>
#include <boost/typeof/typeof.hpp>
#include <boost/typeof/std/sstream.hpp>
#include <boost/typeof/std/ostream.hpp>
@@ -95,11 +88,7 @@
     typename fusion::result_of::at<Tuple, I>::type
     operator ()(proto::tag::terminal, placeholder<I> const &) const
     {
- #if BOOST_VERSION < 103500
- return fusion::at<I::value>(this->args_);
- #else
         return fusion::at<I>(this->args_);
- #endif
     }

     Tuple args_;

Modified: branches/release/libs/proto/test/make_expr.cpp
==============================================================================
--- branches/release/libs/proto/test/make_expr.cpp (original)
+++ branches/release/libs/proto/test/make_expr.cpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -6,15 +6,10 @@
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <sstream>
-#include <boost/version.hpp>
#include <boost/proto/core.hpp>
#include <boost/proto/transform.hpp>
#include <boost/utility/addressof.hpp>
-#if BOOST_VERSION >= 103500
#include <boost/fusion/tuple.hpp>
-#else
-#include <boost/spirit/fusion/sequence/make_tuple.hpp>
-#endif
#include <boost/test/unit_test.hpp>

using namespace boost;

Modified: branches/release/libs/proto/test/proto_fusion.cpp
==============================================================================
--- branches/release/libs/proto/test/proto_fusion.cpp (original)
+++ branches/release/libs/proto/test/proto_fusion.cpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -5,11 +5,6 @@
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-#include <boost/version.hpp>
-#if BOOST_VERSION < 103500
-# error This test only works on Boost v1.35
-#endif
-
#include <boost/proto/core.hpp>
#include <boost/proto/fusion.hpp>
#include <boost/fusion/include/for_each.hpp>

Modified: branches/release/libs/proto/test/proto_fusion_s.cpp
==============================================================================
--- branches/release/libs/proto/test/proto_fusion_s.cpp (original)
+++ branches/release/libs/proto/test/proto_fusion_s.cpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -5,11 +5,6 @@
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-#include <boost/version.hpp>
-#if BOOST_VERSION < 103500
-# error This test only works on Boost v1.35
-#endif
-
#include <boost/proto/core.hpp>
#include <boost/proto/fusion.hpp>
#include <boost/fusion/algorithm/iteration/ext_/for_each_s.hpp>

Modified: branches/release/libs/proto/test/toy_spirit2.cpp
==============================================================================
--- branches/release/libs/proto/test/toy_spirit2.cpp (original)
+++ branches/release/libs/proto/test/toy_spirit2.cpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -17,17 +17,10 @@
#include <boost/type_traits/is_same.hpp>
#include <boost/proto/core.hpp>
#include <boost/proto/transform.hpp>
-#if BOOST_VERSION < 103500
-# include <boost/spirit/fusion/algorithm/for_each.hpp>
-# include <boost/spirit/fusion/algorithm/fold.hpp>
-# include <boost/spirit/fusion/algorithm/any.hpp>
-# include <boost/spirit/fusion/sequence/cons.hpp>
-#else
-# include <boost/fusion/include/for_each.hpp>
-# include <boost/fusion/include/fold.hpp>
-# include <boost/fusion/include/cons.hpp>
-# include <boost/fusion/include/any.hpp>
-#endif
+#include <boost/fusion/include/for_each.hpp>
+#include <boost/fusion/include/fold.hpp>
+#include <boost/fusion/include/cons.hpp>
+#include <boost/fusion/include/any.hpp>
#include <boost/test/unit_test.hpp>

namespace boost
@@ -291,21 +284,21 @@
           : parse(p)
         {}

- #if BOOST_VERSION < 103500
- template<typename, typename>
- struct apply
- {
- typedef bool type;
- };
- #else
         typedef bool result_type;
- #endif

+ #if 0 //BOOST_VERSION >= 104200
+ template<typename T>
+ bool operator ()(bool success, T const &t) const
+ {
+ return success && this->parse(t);
+ }
+ #else
         template<typename T>
         bool operator ()(T const &t, bool success) const
         {
             return success && this->parse(t);
         }
+ #endif
     };

     template<typename Iterator>

Modified: branches/release/libs/xpressive/example/example.vcproj
==============================================================================
--- branches/release/libs/xpressive/example/example.vcproj (original)
+++ branches/release/libs/xpressive/example/example.vcproj 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -1,10 +1,11 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
         ProjectType="Visual C++"
- Version="8.00"
- Name="example"
+ Version="9.00"
+ Name="example-vc9"
         ProjectGUID="{5B83CA94-A2A6-43A6-8363-E5F4731443F7}"
         Keyword="Win32Proj"
+ TargetFrameworkVersion="131072"
>
         <Platforms>
                 <Platform
@@ -47,12 +48,13 @@
                                 ExceptionHandling="0"
                                 BasicRuntimeChecks="3"
                                 RuntimeLibrary="3"
+ DisableLanguageExtensions="false"
                                 TreatWChar_tAsBuiltInType="true"
                                 ForceConformanceInForLoopScope="true"
                                 RuntimeTypeInfo="true"
                                 UsePrecompiledHeader="0"
                                 WarningLevel="3"
- Detect64BitPortabilityProblems="true"
+ Detect64BitPortabilityProblems="false"
                                 DebugInformationFormat="3"
                         />
                         <Tool
@@ -71,6 +73,8 @@
                                 GenerateDebugInformation="true"
                                 ProgramDatabaseFile="$(OutDir)/example.pdb"
                                 SubSystem="1"
+ RandomizedBaseAddress="1"
+ DataExecutionPrevention="0"
                                 TargetMachine="1"
                         />
                         <Tool
@@ -92,9 +96,6 @@
                                 Name="VCAppVerifierTool"
                         />
                         <Tool
- Name="VCWebDeploymentTool"
- />
- <Tool
                                 Name="VCPostBuildEventTool"
                         />
                 </Configuration>
@@ -128,7 +129,7 @@
                                 RuntimeLibrary="0"
                                 UsePrecompiledHeader="0"
                                 WarningLevel="3"
- Detect64BitPortabilityProblems="true"
+ Detect64BitPortabilityProblems="false"
                                 DebugInformationFormat="3"
                         />
                         <Tool
@@ -148,6 +149,8 @@
                                 SubSystem="1"
                                 OptimizeReferences="2"
                                 EnableCOMDATFolding="2"
+ RandomizedBaseAddress="1"
+ DataExecutionPrevention="0"
                                 TargetMachine="1"
                         />
                         <Tool
@@ -169,9 +172,6 @@
                                 Name="VCAppVerifierTool"
                         />
                         <Tool
- Name="VCWebDeploymentTool"
- />
- <Tool
                                 Name="VCPostBuildEventTool"
                         />
                 </Configuration>
@@ -306,6 +306,10 @@
>
                                         </File>
                                         <File
+ RelativePath="..\..\..\boost\xpressive\detail\core\list.hpp"
+ >
+ </File>
+ <File
                                                 RelativePath="..\..\..\boost\xpressive\detail\core\matchers.hpp"
>
                                         </File>
@@ -727,178 +731,6 @@
                                         </File>
                                 </Filter>
                         </Filter>
- <Filter
- Name="proto"
- >
- <File
- RelativePath="..\..\..\boost\xpressive\proto\args.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\context.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\debug.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\deep_copy.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\domain.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\eval.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\expr.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\extends.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\fusion.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\generate.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\literal.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\make_expr.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\matches.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\operators.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\proto.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\proto_fwd.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\proto_typeof.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\ref.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\tags.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\traits.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\transform.hpp"
- >
- </File>
- <Filter
- Name="context"
- >
- <File
- RelativePath="..\..\..\boost\xpressive\proto\context\callable.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\context\default.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\context\null.hpp"
- >
- </File>
- </Filter>
- <Filter
- Name="transform"
- >
- <File
- RelativePath="..\..\..\boost\xpressive\proto\transform\arg.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\transform\bind.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\transform\call.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\transform\fold.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\transform\fold_tree.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\transform\make.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\transform\pass_through.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\transform\when.hpp"
- >
- </File>
- </Filter>
- <Filter
- Name="detail"
- >
- <File
- RelativePath="..\..\..\boost\xpressive\proto\detail\as_lvalue.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\detail\dont_care.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\detail\funop.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\detail\pop_front.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\detail\prefix.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\detail\reverse.hpp"
- >
- </File>
- <File
- RelativePath="..\..\..\boost\xpressive\proto\detail\suffix.hpp"
- >
- </File>
- </Filter>
- </Filter>
                 </Filter>
         </Files>
         <Globals>

Modified: branches/release/libs/xpressive/test/Jamfile.v2
==============================================================================
--- branches/release/libs/xpressive/test/Jamfile.v2 (original)
+++ branches/release/libs/xpressive/test/Jamfile.v2 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -12,6 +12,7 @@
         <toolset>msvc-8.0:<define>_SCL_SECURE_NO_DEPRECATE
         <toolset>msvc-8.0:<define>_CRT_SECURE_NO_DEPRECATE
         <toolset>msvc-9.0:<define>_SCL_SECURE_NO_DEPRECATE
+ <toolset>msvc-10.0:<define>_SCL_SECURE_NO_WARNINGS
         <toolset>gcc:<cxxflags>-ftemplate-depth-1024
         <toolset>darwin:<cxxflags>-ftemplate-depth-1024
# <toolset>gcc:<cxxflags>-W

Modified: branches/release/libs/xpressive/test/test.hpp
==============================================================================
--- branches/release/libs/xpressive/test/test.hpp (original)
+++ branches/release/libs/xpressive/test/test.hpp 2009-12-13 02:29:08 EST (Sun, 13 Dec 2009)
@@ -105,7 +105,7 @@

             for(std::size_t i = 0; i < what.size() && i < this->brs_.size(); ++i)
             {
- BOOST_XPR_CHECK(!what[i].matched && this->brs_[i] == empty || this->brs_[i] == what[i].str());
+ BOOST_XPR_CHECK((!what[i].matched && this->brs_[i] == empty) || this->brs_[i] == what[i].str());
             }
         }
         else

Next message: gennadiy.rozental_at_[hidden]: "[Boost-commit] svn:boost r58337 - trunk/boost/test"
Previous message: gennadiy.rozental_at_[hidden]: "[Boost-commit] svn:boost r58335 - trunk/libs/test/example"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk