+2002-06-16 Lars Gullik Bjønnes <larsbj@birdstep.com>
+
+ * update boost. (prev commit lost).
+
2002-06-12 Angus Leeming <leeming@lyx.org>
* boost/signals/connection.hpp:
class placeholder
{
public: // structors
-
+
virtual ~placeholder()
{
}
virtual const std::type_info & type() const = 0;
virtual placeholder * clone() const = 0;
-
+
};
template<typename ValueType>
// Author: Dietmar Kuehl dietmar.kuehl@claas-solutions.de
// Title: STL container support, including support for built-in arrays
-// Version: $Id: array_traits.hpp,v 1.2 2002/05/24 12:19:51 larsbj Exp $
+// Version: $Id: array_traits.hpp,v 1.3 2002/06/18 15:39:24 larsbj Exp $
// Dec 4, 2000 Added some more typedefs to array_traits including
// an iterator type to supersede iter_type. -J.Siek
typedef typename F::result_type type;
};
+template<class F> struct result_traits< unspecified, reference_wrapper<F> >
+{
+ typedef typename F::result_type type;
+};
+
#endif
// bind_t forward declaration for listN
template<class T> class type {};
+// unwrap
+
+template<class F> inline F & unwrap(F & f, long)
+{
+ return f;
+}
+
+template<class F> inline F & unwrap(reference_wrapper<F> & f, int)
+{
+ return f;
+}
+
+template<class F> inline F & unwrap(reference_wrapper<F> const & f, int)
+{
+ return f;
+}
+
// listN
#ifdef BOOST_NO_VOID_RETURNS
template<class R, class F, class A> R operator()(type<R>, F f, A &) const
{
- return f();
+ return unwrap(f, 0)();
}
template<class V> void accept(V &) const
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
{
- return f(a[a1_]);
+ return unwrap(f, 0)(a[a1_]);
}
template<class V> void accept(V & v) const
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
{
- return f(a[a1_], a[a2_]);
+ return unwrap(f, 0)(a[a1_], a[a2_]);
}
template<class V> void accept(V & v) const
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
{
- return f(a[a1_], a[a2_], a[a3_]);
+ return unwrap(f, 0)(a[a1_], a[a2_], a[a3_]);
}
template<class V> void accept(V & v) const
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
{
- return f(a[a1_], a[a2_], a[a3_], a[a4_]);
+ return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
}
template<class V> void accept(V & v) const
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
{
- return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
+ return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
}
template<class V> void accept(V & v) const
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
{
- return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
+ return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
}
template<class V> void accept(V & v) const
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
{
- return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
+ return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
}
template<class V> void accept(V & v) const
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
{
- return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
+ return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
}
template<class V> void accept(V & v) const
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
{
- return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
+ return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
}
template<class V> void accept(V & v) const
template<class L, class F, class A>
static R eval(L const&, F f, A &)
{
- return f();
+ return unwrap(f, 0)();
}
};
template<class L, class F, class A>
static void eval(L const&, F f, A &)
{
- f();
+ unwrap(f, 0)();
}
};
template<class L, class F, class A>
static R eval(L const& l, F f, A & a)
{
- return f(a[l.a1_]);
+ return unwrap(f, 0)(a[l.a1_]);
}
};
template<class L, class F, class A>
static void eval(L const& l, F f, A & a)
{
- f(a[l.a1_]);
+ unwrap(f, 0)(a[l.a1_]);
}
};
template<class L, class F, class A>
static R eval(L const& l, F f, A & a)
{
- return f(a[l.a1_], a[l.a2_]);
+ return unwrap(f, 0)(a[l.a1_], a[l.a2_]);
}
};
template<class L, class F, class A>
static void eval(L const& l, F f, A & a)
{
- f(a[l.a1_], a[l.a2_]);
+ unwrap(f, 0)(a[l.a1_], a[l.a2_]);
}
};
template<class L, class F, class A>
static R eval(L const& l, F f, A & a)
{
- return f(a[l.a1_], a[l.a2_], a[l.a3_]);
+ return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_]);
}
};
template<class L, class F, class A>
static void eval(L const& l, F f, A & a)
{
- f(a[l.a1_], a[l.a2_], a[l.a3_]);
+ unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_]);
}
};
template<class L, class F, class A>
static R eval(L const& l, F f, A & a)
{
- return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
+ return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
}
};
template<class L, class F, class A>
static void eval(L const& l, F f, A & a)
{
- f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
+ unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
}
};
template<class L, class F, class A>
static R eval(L const& l, F f, A & a)
{
- return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
+ return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
}
};
template<class L, class F, class A>
static void eval(L const& l, F f, A & a)
{
- f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
+ unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
}
};
template<class L, class F, class A>
static R eval(L const& l, F f, A & a)
{
- return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
+ return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
}
};
template<class L, class F, class A>
static void eval(L const& l, F f, A & a)
{
- f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
+ unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
}
};
template<class L, class F, class A>
static R eval(L const& l, F f, A & a)
{
- return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
+ return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
}
};
template<class L, class F, class A>
static void eval(L const& l, F f, A & a)
{
- f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
+ unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
}
};
template<class L, class F, class A>
static R eval(L const& l, F f, A & a)
{
- return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
+ return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
}
};
template<class L, class F, class A>
static void eval(L const& l, F f, A & a)
{
- f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
+ unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
}
};
template<class L, class F, class A>
static R eval(L const& l, F f, A & a)
{
- return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
+ return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
}
};
template<class L, class F, class A>
static void eval(L const& l, F f, A & a)
{
- f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
+ unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
}
};
#define BOOST_PLATFORM "Mac OS"
// If __MACH__, we're using the BSD standard C library, not the MSL:
-#if defined(__MACH__)
+#if __MACH__
# define BOOST_NO_CTYPE_FUNCTIONS
# define BOOST_NO_CWCHAR
#include <boost/regex/config.hpp>
#ifdef __BORLANDC__
- #pragma option push -a4 -b -Ve -pc
+ #pragma option push -a8 -b -Vx -Ve -pc
#endif
/* include these defs only for POSIX compatablity */
# include <iterator>
# include <cstddef>
-# if defined(BOOST_MSVC_STD_ITERATOR)
+# if defined(BOOST_MSVC_STD_ITERATOR) && !defined(__SGI_STL_PORT)
# include <xtree>
# include <deque>
# include <list>
-# if 0 && defined(__ICL) // Re-enable this to pick up the Intel fixes where they left off
-# include <iosfwd>
-# include <memory>
-# endif
# endif
typedef std::ptrdiff_t difference_type;
typedef std::random_access_iterator_tag iterator_category;
typedef Ptr pointer;
-#ifdef BOOST_MSVC
+#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
// Keeps MSVC happy under certain circumstances. It seems class template default
// arguments are partly instantiated even when not used when the class template
// is the return type of a function template.
};
# endif
-# if defined(BOOST_MSVC_STD_ITERATOR)
+# if defined(BOOST_MSVC_STD_ITERATOR) && !defined(__SGI_STL_PORT)
// We'll sort iterator types into one of these classifications, from which we
// can determine the difference_type, pointer, reference, and value_type
template <class Iterator>
struct traits
{
-# if defined(BOOST_MSVC_STD_ITERATOR)
+# if defined(BOOST_MSVC_STD_ITERATOR) && !defined(__SGI_STL_PORT)
typedef msvc_traits_select<(
msvc_iterator_classification<Iterator>::value
)>::template traits_<Iterator> inner_traits;
_Int __imin,
_Int __imax,
int __idigits = -1>
-class _Integer_limits : public _Numeric_limits_base<_Int>
+class _Integer_limits : public _Numeric_limits_base<_Int>
{
public:
BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true);
BOOST_STL_DECLARE_LIMITS_MEMBER(int,
digits,
(__idigits < 0) ? (int)(sizeof(_Int) * CHAR_BIT)
- - (__imin == 0 ? 0 : 1)
+ - (__imin == 0 ? 0 : 1)
: __idigits);
- BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, (digits * 301) / 1000);
+ BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, (digits * 301) / 1000);
// log 2 = 0.301029995664...
BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed, __imin != 0);
// sizeof(long double) == 16
const unsigned int _S_word[4] = { Word, 0, 0, 0 };
return *reinterpret_cast<const Number*>(&_S_word);
- }
+ }
};
#else
return *reinterpret_cast<const Number*>(
reinterpret_cast<const char *>(&_S_word)+16-
(sizeof(Number) == 12 ? 10 : sizeof(Number)));
- }
+ }
};
#endif
denorm_indeterminate);
BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss, false);
-
+
static __number infinity() throw() {
return float_helper<__number, __InfinityWord>::get_word();
}
// The unspecialized class.
-template<class T>
+template<class T>
class numeric_limits : public _Numeric_limits_base<T> {};
// Specializations for all built-in integral types.
#if !defined(LONGLONG_MIN)
# define LONGLONG_MIN (-LONGLONG_MAX - 1)
-#endif
+#endif
template<>
class numeric_limits<long long>
// Specializations for all built-in floating-point type.
template<> class numeric_limits<float>
- : public _Floating_limits<float,
+ : public _Floating_limits<float,
FLT_MANT_DIG, // Binary digits of precision
FLT_DIG, // Decimal digits of precision
FLT_MIN_EXP, // Minimum exponent
};
template<> class numeric_limits<double>
- : public _Floating_limits<double,
+ : public _Floating_limits<double,
DBL_MANT_DIG, // Binary digits of precision
DBL_DIG, // Decimal digits of precision
DBL_MIN_EXP, // Minimum exponent
};
template<> class numeric_limits<long double>
- : public _Floating_limits<long double,
+ : public _Floating_limits<long double,
LDBL_MANT_DIG, // Binary digits of precision
LDBL_DIG, // Decimal digits of precision
LDBL_MIN_EXP, // Minimum exponent
// Local Variables:
// mode:C++
// End:
+
+
+
namespace boost {
namespace detail {
namespace function {
- template<bool> struct truth {};
-
/*
* The ct_if implementation is temporary code. When a Boost metaprogramming
* library is introduced, Boost.Function will use it instead.
// purpose. It is provided "as is" without express or implied
// warranty.
// ------------------------------------------------------------------------------
-// $Id: functional.hpp,v 1.3 2000/11/22 09:04:28 mark_rodgers Exp $
+// $Id: functional.hpp,v 1.3 2002/06/16 13:12:16 lyx Exp $
// ------------------------------------------------------------------------------
#ifndef BOOST_FUNCTIONAL_HPP
* software for any purpose. It is provided "as is" without express or
* implied warranty.
*
- * $Id: integer_traits.hpp,v 1.18 2002/01/23 19:56:07 dgregor Exp $
+ * $Id: integer_traits.hpp,v 1.3 2002/06/16 13:12:16 lyx Exp $
*
* Idea by Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers
*/
#include <boost/preprocessor/max.hpp>
#include <boost/preprocessor/min.hpp>
#include <boost/preprocessor/repeat_from_to.hpp>
-#include <boost/preprocessor/repeat_from_to_2nd.hpp>
-#include <boost/preprocessor/repeat_from_to_3rd.hpp>
#include <boost/preprocessor/stringize.hpp>
#endif
<p>For example, <code>BOOST_PP_ADD(4,3)</code> expands to <code>7</code> (a
single token).</p>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_WHILE()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
*/
#define BOOST_PP_ADD(X,Y) BOOST_PP_ADD_D(0,X,Y)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_ADD_D(D,X,Y) BOOST_PP_TUPLE_ELEM(2,0,BOOST_PP_WHILE##D(BOOST_PP_ADD_C,BOOST_PP_ADD_F,(X,Y)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_ADD_C(D,P) BOOST_PP_TUPLE_ELEM(2,1,P)
-# define BOOST_PP_ADD_F(D,P) (BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(2,0,P)),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2,1,P)))
-#else
-# define BOOST_PP_ADD_C(D,P) BOOST_PP_TUPLE2_ELEM1 P
-# define BOOST_PP_ADD_F(D,P) (BOOST_PP_INC(BOOST_PP_TUPLE2_ELEM0 P),BOOST_PP_DEC(BOOST_PP_TUPLE2_ELEM1 P))
-#endif
-/* <p>Obsolete. Use BOOST_PP_ADD().</p> */
-#define BOOST_PREPROCESSOR_ADD(X,Y) BOOST_PP_ADD(X,Y)
+#define BOOST_PP_ADD_C(D,RC) BOOST_PP_TUPLE_ELEM(2,1,RC)
+#define BOOST_PP_ADD_F(D,RC) (BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(2,0,RC)),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2,1,RC)))
#endif
<p>For example, <code>BOOST_PP_DIV(4,3)</code> expands to <code>1</code> (a
single token).</p>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_WHILE()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
*/
#define BOOST_PP_DIV(X,Y) BOOST_PP_DIV_D(0,X,Y)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_DIV_D(D,X,Y) BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_WHILE##D(BOOST_PP_DIV_C,BOOST_PP_DIV_F,(0,X,Y)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_DIV_C(D,P) BOOST_PP_LESS_EQUAL_D(D,BOOST_PP_TUPLE_ELEM(3,2,P),BOOST_PP_TUPLE_ELEM(3,1,P))
-# define BOOST_PP_DIV_F(D,P) (BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(3,0,P)),BOOST_PP_SUB_D(D,BOOST_PP_TUPLE_ELEM(3,1,P),BOOST_PP_TUPLE_ELEM(3,2,P)),BOOST_PP_TUPLE_ELEM(3,2,P))
-#else
-# define BOOST_PP_DIV_C(D,P) BOOST_PP_LESS_EQUAL_D(D,BOOST_PP_TUPLE3_ELEM2 P,BOOST_PP_TUPLE3_ELEM1 P)
-# define BOOST_PP_DIV_F(D,P) (BOOST_PP_INC(BOOST_PP_TUPLE3_ELEM0 P),BOOST_PP_SUB_D(D,BOOST_PP_TUPLE3_ELEM1 P,BOOST_PP_TUPLE3_ELEM2 P),BOOST_PP_TUPLE3_ELEM2 P)
-#endif
-/* <p>Obsolete. Use BOOST_PP_DIV().</p> */
-#define BOOST_PREPROCESSOR_DIV(X,Y) BOOST_PP_DIV(X,Y)
+#define BOOST_PP_DIV_C(D,RCY) BOOST_PP_LESS_EQUAL_D(D,BOOST_PP_TUPLE_ELEM(3,2,RCY),BOOST_PP_TUPLE_ELEM(3,1,RCY))
+#define BOOST_PP_DIV_F(D,RCY) (BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(3,0,RCY)),BOOST_PP_SUB_D(D,BOOST_PP_TUPLE_ELEM(3,1,RCY),BOOST_PP_TUPLE_ELEM(3,2,RCY)),BOOST_PP_TUPLE_ELEM(3,2,RCY))
#endif
<p>For example, <code>BOOST_PP_MOD(4,3)</code> expands to <code>1</code> (a
single token).</p>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_WHILE()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
*/
#define BOOST_PP_MOD(X,Y) BOOST_PP_MOD_D(0,X,Y)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_MOD_D(D,X,Y) BOOST_PP_TUPLE_ELEM(2,0,BOOST_PP_WHILE##D(BOOST_PP_MOD_C,BOOST_PP_MOD_F,(X,Y)))
-#define BOOST_PP_MOD_C(D,P) BOOST_PP_LESS_EQUAL_D(D,BOOST_PP_TUPLE2_ELEM1 P,BOOST_PP_TUPLE2_ELEM0 P)
-#define BOOST_PP_MOD_F(D,P) (BOOST_PP_SUB_D(D,BOOST_PP_TUPLE2_ELEM0 P,BOOST_PP_TUPLE2_ELEM1 P),BOOST_PP_TUPLE2_ELEM1 P)
-
-/* <p>Obsolete. Use BOOST_PP_MOD().</p> */
-#define BOOST_PREPROCESSOR_MOD(X,Y) BOOST_PP_MOD(X,Y)
+#define BOOST_PP_MOD_C(D,RY) BOOST_PP_LESS_EQUAL_D(D,BOOST_PP_TUPLE_ELEM(2,1,RY),BOOST_PP_TUPLE_ELEM(2,0,RY))
+#define BOOST_PP_MOD_F(D,RY) (BOOST_PP_SUB_D(D,BOOST_PP_TUPLE_ELEM(2,0,RY),BOOST_PP_TUPLE_ELEM(2,1,RY)),BOOST_PP_TUPLE_ELEM(2,1,RY))
#endif
<p>For example, <code>BOOST_PP_MUL(4,3)</code> expands to <code>12</code> (a
single token).</p>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_WHILE()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
*/
#define BOOST_PP_MUL(X,Y) BOOST_PP_MUL_D(0,X,Y)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_MUL_D(D,X,Y) BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_WHILE##D(BOOST_PP_MUL_C,BOOST_PP_MUL_F,(0,X,Y)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_MUL_C(D,P) BOOST_PP_TUPLE_ELEM(3,2,P)
-# define BOOST_PP_MUL_F(D,P) (BOOST_PP_ADD_D(D,BOOST_PP_TUPLE_ELEM(3,0,P),BOOST_PP_TUPLE_ELEM(3,1,P)),BOOST_PP_TUPLE_ELEM(3,1,P),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(3,2,P)))
-#else
-# define BOOST_PP_MUL_C(D,P) BOOST_PP_TUPLE3_ELEM2 P
-# define BOOST_PP_MUL_F(D,P) (BOOST_PP_ADD_D(D,BOOST_PP_TUPLE3_ELEM0 P,BOOST_PP_TUPLE3_ELEM1 P),BOOST_PP_TUPLE3_ELEM1 P,BOOST_PP_DEC(BOOST_PP_TUPLE3_ELEM2 P))
-#endif
-/* <p>Obsolete. Use BOOST_PP_MUL().</p> */
-#define BOOST_PREPROCESSOR_MUL(X,Y) BOOST_PP_MUL(X,Y)
+#define BOOST_PP_MUL_C(D,RXC) BOOST_PP_TUPLE_ELEM(3,2,RXC)
+#define BOOST_PP_MUL_F(D,RXC) (BOOST_PP_ADD_D(D,BOOST_PP_TUPLE_ELEM(3,0,RXC),BOOST_PP_TUPLE_ELEM(3,1,RXC)),BOOST_PP_TUPLE_ELEM(3,1,RXC),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(3,2,RXC)))
#endif
<p>For example, <code>BOOST_PP_SUB(4,3)</code> expands to <code>1</code> (a
single token).</p>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_WHILE()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
*/
#define BOOST_PP_SUB(X,Y) BOOST_PP_SUB_D(0,X,Y)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_SUB_D(D,X,Y) BOOST_PP_TUPLE_ELEM(2,0,BOOST_PP_WHILE##D(BOOST_PP_SUB_C,BOOST_PP_SUB_F,(X,Y)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_SUB_C(D,P) BOOST_PP_TUPLE_ELEM(2,1,P)
-# define BOOST_PP_SUB_F(D,P) (BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2,0,P)),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2,1,P)))
-#else
-# define BOOST_PP_SUB_C(D,P) BOOST_PP_TUPLE2_ELEM1 P
-# define BOOST_PP_SUB_F(D,P) (BOOST_PP_DEC(BOOST_PP_TUPLE2_ELEM0 P),BOOST_PP_DEC(BOOST_PP_TUPLE2_ELEM1 P))
-#endif
-/* <p>Obsolete. Use BOOST_PP_SUB(X,Y).</p> */
-#define BOOST_PREPROCESSOR_SUB(X,Y) BOOST_PP_SUB(X,Y)
+#define BOOST_PP_SUB_C(D,RC) BOOST_PP_TUPLE_ELEM(2,1,RC)
+#define BOOST_PP_SUB_F(D,RC) (BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2,0,RC)),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2,1,RC)))
#endif
<p>For example, <code>BOOST_PP_ASSERT_MSG(1,A BUG!)</code> expands to <code>A BUG!</code>.</p>
*/
#define BOOST_PP_ASSERT_MSG(COND,MSG) BOOST_PP_EXPR_IF(BOOST_PP_NOT(COND),MSG)
-
-/* <p>Obsolete. Use BOOST_PP_ASSERT_MSG().</p> */
-#define BOOST_PREPROCESSOR_ASSERT_MSG(C,MSG) BOOST_PP_ASSERT_MSG(C,MSG)
#endif
#define BOOST_PP_CAT_DELAY(X,Y) BOOST_PP_DO_CAT(X,Y)
#define BOOST_PP_DO_CAT(X,Y) X##Y
-
-/* <p>Obsolete. Use BOOST_PP_CAT().</p> */
-#define BOOST_PREPROCESSOR_CAT(X,Y) BOOST_PP_CAT(X,Y)
#endif
</ul>
*/
#define BOOST_PP_COMMA() ,
-
-/* <p>Obsolete. Use BOOST_PP_COMMA().</p> */
-#define BOOST_PREPROCESSOR_COMMA() ,
#endif
<p>For example, <code>BOOST_PP_COMMA_IF(0)</code> expands to nothing.</p>
*/
#define BOOST_PP_COMMA_IF(COND) BOOST_PP_IF(COND,BOOST_PP_COMMA,BOOST_PP_EMPTY)()
-
-/* <p>Obsolete. Use BOOST_PP_COMMA_IF().</p> */
-#define BOOST_PREPROCESSOR_COMMA_IF(C) BOOST_PP_COMMA_IF(C)
#endif
<p>For example, <code>BOOST_PP_EQUAL(4,4)</code> expands to <code>1</code>.</p>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_WHILE()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
*/
#define BOOST_PP_EQUAL(X,Y) BOOST_PP_EQUAL_D(0,X,Y)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_EQUAL_D(D,X,Y) BOOST_PP_NOT(BOOST_PP_NOT_EQUAL_D(D,X,Y))
-
-/* <p>Obsolete. Use BOOST_PP_EQUAL().</p> */
-#define BOOST_PREPROCESSOR_EQUAL(X,Y) BOOST_PP_EQUAL(X,Y)
#endif
<p>For example, <code>BOOST_PP_GREATER(4,3)</code> expands to <code>1</code>.</p>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_WHILE()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
*/
#define BOOST_PP_GREATER(X,Y) BOOST_PP_GREATER_D(0,X,Y)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_GREATER_D(D,X,Y) BOOST_PP_LESS_D(D,Y,X)
-
-/* <p>Obsolete. Use BOOST_PP_GREATER().</p> */
-#define BOOST_PREPROCESSOR_GREATER(X,Y) BOOST_PP_GREATER(X,Y)
#endif
<p>For example, <code>BOOST_PP_GREATER_EQUAL(1,3)</code> expands to <code>0</code>.</p>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_WHILE()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
*/
#define BOOST_PP_GREATER_EQUAL(X,Y) BOOST_PP_GREATER_EQUAL_D(0,X,Y)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_GREATER_EQUAL_D(D,X,Y) BOOST_PP_LESS_EQUAL_D(D,Y,X)
-
-/* <p>Obsolete. Use BOOST_PP_GREATER_EQUAL().</p> */
-#define BOOST_PREPROCESSOR_GREATER_EQUAL(X,Y) BOOST_PP_GREATER_EQUAL(X,Y)
#endif
<p>For example, <code>BOOST_PP_LESS(2,6)</code> expands to <code>1</code>.</p>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_WHILE()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
*/
#define BOOST_PP_LESS(X,Y) BOOST_PP_LESS_D(0,X,Y)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_LESS_D(D,X,Y) BOOST_PP_AND(BOOST_PP_NOT_EQUAL_D(D,X,Y),BOOST_PP_LESS_EQUAL_D(D,X,Y))
-
-/* <p>Obsolete. Use BOOST_PP_LESS().</p> */
-#define BOOST_PREPROCESSOR_LESS(X,Y) BOOST_PP_LESS(X,Y)
#endif
<p>For example, <code>BOOST_PP_LESS_EQUAL(7,5)</code> expands to <code>0</code>.</p>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_WHILE()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
*/
#define BOOST_PP_LESS_EQUAL(X,Y) BOOST_PP_LESS_EQUAL_D(0,X,Y)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_LESS_EQUAL_D(D,X,Y) BOOST_PP_NOT(BOOST_PP_SUB_D(D,X,Y))
-
-/* <p>Obsolete. Use BOOST_PP_LESS_EQUAL().</p> */
-#define BOOST_PREPROCESSOR_LESS_EQUAL(X,Y) BOOST_PP_LESS_EQUAL(X,Y)
#endif
<p>For example, <code>BOOST_PP_NOT_EQUAL(4,4)</code> expands to <code>0</code>.</p>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_WHILE()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
*/
#define BOOST_PP_NOT_EQUAL(X,Y) BOOST_PP_NOT_EQUAL_D(0,X,Y)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_NOT_EQUAL_D(D,X,Y) BOOST_PP_BOOL(BOOST_PP_ADD_D(D,BOOST_PP_SUB_D(D,X,Y),BOOST_PP_SUB_D(D,Y,X)))
-
-/* <p>Obsolete. Use BOOST_PP_NOT_EQUAL().</p> */
-#define BOOST_PREPROCESSOR_NOT_EQUAL(X,Y) BOOST_PP_NOT_EQUAL(X,Y)
#endif
* See http://www.boost.org for most recent version.
*/
+#include <boost/preprocessor/detail/cat.hpp>
+
/** <p>Decrements <code>X</code> expanding to a single token.</p>
<p>For example, <code>BOOST_PP_DEC(3)</code> expands to <code>2</code> (a
<p>Only decimal integer literals in the range [0,BOOST_PP_LIMIT_MAG] are
supported.</p>
*/
-#define BOOST_PP_DEC(X) BOOST_PP_DEC_DELAY(X)
+#define BOOST_PP_DEC(X) BOOST_PP_DETAIL_CAT2(BOOST_PP_DEC,X)
-#define BOOST_PP_DEC_DELAY(X) BOOST_PP_DEC##X
#define BOOST_PP_DEC0 0
#define BOOST_PP_DEC1 0
#define BOOST_PP_DEC2 1
#define BOOST_PP_DEC126 125
#define BOOST_PP_DEC127 126
#define BOOST_PP_DEC128 127
-
-/* <p>Obsolete. Use BOOST_PP_DEC().</p> */
-#define BOOST_PREPROCESSOR_DEC(X) BOOST_PP_DEC(X)
#endif
</ul>
*/
#define BOOST_PP_EMPTY()
-
-/* <p>Obsolete. Use BOOST_PP_EMPTY().</p> */
-#define BOOST_PREPROCESSOR_EMPTY()
#endif
X0 x0, X1 x1, X2 x2
</pre>
-<h3>Uses</h3>
+<h3>2D and 3D repetition</h3>
+
+<p>BOOST_PP_ENUM() implements automatic recursion. 2D and 3D repetition
+are directly supported.</p>
+
+<h3>See</h3>
<ul>
- <li>BOOST_PP_REPEAT()</li>
+ <li>BOOST_PP_FOR()</li>
+ <li>BOOST_PP_LIMIT_DIM</li>
+ <li>BOOST_PP_LIMIT_MAG</li>
</ul>
<h3>Test</h3>
<li><a href="../../test/repeat_test.cpp">repeat_test.cpp</a></li>
</ul>
*/
-#define BOOST_PP_ENUM(COUNT,MACRO,DATA) BOOST_PP_REPEAT(COUNT,BOOST_PP_ENUM_F,(MACRO,DATA))
+#if 0
+# define BOOST_PP_ENUM(COUNT,MACRO,DATA)
+#endif
+
+#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
+
+/* This is a workaround for a MSVC++ PP bug. You'll need to add further
+ * BOOST_PP_ENUM_AUTO_REC3/4/etc. wrapping as the maximum level of
+ * nesting REPEATS increases
+ */
+# define BOOST_PP_ENUM\
+ BOOST_PP_AUTO_REC_CAT1(BOOST_PP_ENUM_,BOOST_PP_ENUM_AUTO_REC2(\
+ BOOST_PP_ENUM_AUTO_REC1,(BOOST_PP_AUTO_REC_ID,(1))\
+ ))
+
+# define BOOST_PP_ENUM_BOOST_PP_ENUM_AUTO_REC1(M,P)\
+ BOOST_PP_AUTO_REC_CAT2(BOOST_PP_ENUM_,BOOST_PP_ENUM_AUTO_REC2(BOOST_PP_AUTO_REC_ID,(2)))
+# define BOOST_PP_ENUM_BOOST_PP_ENUM_AUTO_REC2(M,P)\
+ BOOST_PP_AUTO_REC_CAT3(BOOST_PP_ENUM_,BOOST_PP_ENUM_AUTO_REC3(BOOST_PP_AUTO_REC_ID,(3)))
+# define BOOST_PP_ENUM_BOOST_PP_ENUM_AUTO_REC3(M,P)\
+ (TOO MANY NESTED REPEATS!)
+
+# define BOOST_PP_ENUM_AUTO_REC1(M,P) BOOST_PP_EXPAND(M P)
+# define BOOST_PP_ENUM_AUTO_REC2(M,P) BOOST_PP_EXPAND(M P)
+# define BOOST_PP_ENUM_AUTO_REC3(M,P) BOOST_PP_EXPAND(M P)
+
+# define BOOST_PP_ENUM_1(C,M,D) BOOST_PP_ENUM_AUTO_REC1(BOOST_PP_REPEAT,(C,BOOST_PP_ENUM_M1,(M,D)))
+# define BOOST_PP_ENUM_2(C,M,D) BOOST_PP_ENUM_AUTO_REC2(BOOST_PP_REPEAT,(C,BOOST_PP_ENUM_M2,(M,D)))
+# define BOOST_PP_ENUM_3(C,M,D) BOOST_PP_ENUM_AUTO_REC3(BOOST_PP_REPEAT,(C,BOOST_PP_ENUM_M3,(M,D)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_ENUM_F(I,FP) BOOST_PP_COMMA_IF(I) BOOST_PP_TUPLE_ELEM(2,0,FP)(I,BOOST_PP_TUPLE_ELEM(2,1,FP))
#else
-# define BOOST_PP_ENUM_F(I,FP) BOOST_PP_COMMA_IF(I) BOOST_PP_TUPLE2_ELEM0 FP(I,BOOST_PP_TUPLE2_ELEM1 FP)
+
+# define BOOST_PP_ENUM\
+ BOOST_PP_AUTO_REC_CAT1(BOOST_PP_ENUM,BOOST_PP_REPEAT_AUTO_REC1(BOOST_PP_AUTO_REC_ID,(1)))
+# define BOOST_PP_ENUMBOOST_PP_REPEAT_AUTO_REC1(M,P)\
+ BOOST_PP_AUTO_REC_CAT2(BOOST_PP_ENUM,BOOST_PP_REPEAT_AUTO_REC2(BOOST_PP_AUTO_REC_ID,(2)))
+# define BOOST_PP_ENUMBOOST_PP_REPEAT_AUTO_REC2(M,P)\
+ BOOST_PP_AUTO_REC_CAT3(BOOST_PP_ENUM,BOOST_PP_REPEAT_AUTO_REC3(BOOST_PP_AUTO_REC_ID,(3)))
+# define BOOST_PP_ENUMBOOST_PP_REPEAT_AUTO_REC3(M,P)\
+ (TOO MANY NESTED REPEATS!)
+
+# define BOOST_PP_ENUM1(C,M,D) BOOST_PP_REPEAT(C,BOOST_PP_ENUM_M1,(M,D))
+# define BOOST_PP_ENUM2(C,M,D) BOOST_PP_REPEAT(C,BOOST_PP_ENUM_M2,(M,D))
+# define BOOST_PP_ENUM3(C,M,D) BOOST_PP_REPEAT(C,BOOST_PP_ENUM_M3,(M,D))
+
#endif
+
+#define BOOST_PP_ENUM_M1(I,MD) BOOST_PP_COMMA_IF(I) BOOST_PP_TUPLE_ELEM(2,0,MD)(I,BOOST_PP_TUPLE_ELEM(2,1,MD))
+#define BOOST_PP_ENUM_M2(I,MD) BOOST_PP_COMMA_IF(I) BOOST_PP_TUPLE_ELEM(2,0,MD)(I,BOOST_PP_TUPLE_ELEM(2,1,MD))
+#define BOOST_PP_ENUM_M3(I,MD) BOOST_PP_COMMA_IF(I) BOOST_PP_TUPLE_ELEM(2,0,MD)(I,BOOST_PP_TUPLE_ELEM(2,1,MD))
#endif
#define BOOST_PP_ENUM_PARAMS(COUNT,PARAM) BOOST_PP_ENUM(COUNT,BOOST_PP_ENUM_PARAMS_F,PARAM)
#define BOOST_PP_ENUM_PARAMS_F(I,P) BOOST_PP_CAT(P,I)
-
-/* <p>Obsolete. Use BOOST_PP_ENUM_PARAMS().</p> */
-#define BOOST_PREPROCESSOR_ENUM_PARAMS(N,P) BOOST_PP_ENUM_PARAMS(N,P)
#endif
*/
#define BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(COUNT,PARAM,DEFAULT) BOOST_PP_ENUM(COUNT,BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT_F,(PARAM,DEFAULT))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT_F(I,PD) BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2,0,PD),I)=BOOST_PP_TUPLE_ELEM(2,1,PD)
-#else
-# define BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT_F(I,PD) BOOST_PP_CAT(BOOST_PP_TUPLE2_ELEM0 PD,I)=BOOST_PP_TUPLE2_ELEM1 PD
-#endif
-
-/* <p>Obsolete. Use BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT().</p> */
-#define BOOST_PREPROCESSOR_ENUM_PARAMS_WITH_A_DEFAULT(N,P,D) BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(N,P,D)
+#define BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT_F(I,PD) BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2,0,PD),I)=BOOST_PP_TUPLE_ELEM(2,1,PD)
#endif
*/
#define BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS(COUNT,PARAM,DEFAULT) BOOST_PP_ENUM(COUNT,BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS_F,(PARAM,DEFAULT))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS_F(I,PD) BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2,0,PD),I)=BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2,1,PD),I)
-#else
-# define BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS_F(I,PD) BOOST_PP_CAT(BOOST_PP_TUPLE2_ELEM0 PD,I)=BOOST_PP_CAT(BOOST_PP_TUPLE2_ELEM1 PD,I)
-#endif
-
-/* <p>Obsolete. Use BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS().</p> */
-#define BOOST_PREPROCESSOR_ENUM_PARAMS_WITH_DEFAULTS(N,P,D) BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS(N,P,D)
+#define BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS_F(I,PD) BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2,0,PD),I)=BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2,1,PD),I)
#endif
*/
#define BOOST_PP_ENUM_SHIFTED(COUNT,MACRO,DATA) BOOST_PP_ENUM(BOOST_PP_DEC(COUNT),BOOST_PP_ENUM_SHIFTED_F,(MACRO,DATA))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_ENUM_SHIFTED_F(I,FP) BOOST_PP_TUPLE_ELEM(2,0,FP)(BOOST_PP_INC(I),BOOST_PP_TUPLE_ELEM(2,1,FP))
-#else
-# define BOOST_PP_ENUM_SHIFTED_F(I,FP) BOOST_PP_TUPLE2_ELEM0 FP(BOOST_PP_INC(I),BOOST_PP_TUPLE2_ELEM1 FP)
-#endif
+#define BOOST_PP_ENUM_SHIFTED_F(I,MD) BOOST_PP_TUPLE_ELEM(2,0,MD)(BOOST_PP_INC(I),BOOST_PP_TUPLE_ELEM(2,1,MD))
#endif
#define BOOST_PP_ENUM_SHIFTED_PARAMS(COUNT,PARAM) BOOST_PP_ENUM_SHIFTED(COUNT,BOOST_PP_ENUM_SHIFTED_PARAMS_F,PARAM)
#define BOOST_PP_ENUM_SHIFTED_PARAMS_F(I,P) BOOST_PP_CAT(P,I)
-
-/* <p>Obsolete. Use BOOST_PP_ENUM_SHIFTED_PARAMS().</p> */
-#define BOOST_PREPROCESSOR_ENUM_SHIFTED_PARAMS(N,P) BOOST_PP_ENUM_SHIFTED_PARAMS(N,P)
#endif
* See http://www.boost.org for most recent version.
*/
+#include <boost/preprocessor/detail/cat.hpp>
#include <boost/preprocessor/logical/bool.hpp>
/** <p>Expands to <code>EXPR</code> if <code>COND != 0</code> and to nothing if <code>COND == 0</code>.</p>
<li>BOOST_PP_IF()</li>
</ul>
*/
-#define BOOST_PP_EXPR_IF(COND,EXPR) BOOST_PP_EXPR_IF_BOOL(BOOST_PP_BOOL(COND))(EXPR)
+#define BOOST_PP_EXPR_IF(COND,EXPR) BOOST_PP_DETAIL_CAT2(BOOST_PP_EXPR_IF,BOOST_PP_BOOL(COND))(EXPR)
-#define BOOST_PP_EXPR_IF_BOOL(C) BOOST_PP_EXPR_IF_BOOL_DELAY(C)
-#define BOOST_PP_EXPR_IF_BOOL_DELAY(C) BOOST_PP_EXPR_IF_BOOL##C
-#define BOOST_PP_EXPR_IF_BOOL0(E)
-#define BOOST_PP_EXPR_IF_BOOL1(E) E
+#define BOOST_PP_EXPR_IF0(E)
+#define BOOST_PP_EXPR_IF1(E) E
#endif
<p>BOOST_PP_FOR() can be used for multidimensional repetition simply by
invoking BOOST_PP_FOR##R() directly.</p>
+<h3>Automatic recursion?</h3>
+
+<p>BOOST_PP_FOR() currently does not implement automatic recursion. The reason
+for this is that it would lead to very poor performance. The automatic recursion
+technique takes O(N) steps just to find out that the Nth recursion should be used.
+This would dramatically effect the time complexity of macros using automatic
+recursion.</p>
+
<h3>Test</h3>
<ul>
<li><a href="../../test/for_test.cpp">for_test.cpp</a></li>
#define BOOST_PP_FOR126(S,P,O,M) BOOST_PP_FOR_C0(P,127,S,M)(127,S) BOOST_PP_FOR_C1(P,127,S)(O(127,S),P,O,M)
#define BOOST_PP_FOR127(S,P,O,M) BOOST_PP_FOR_C0(P,128,S,M)(128,S) BOOST_PP_FOR_C1(P,128,S)(O(128,S),P,O,M)
#define BOOST_PP_FOR128(S,P,O,M) BOOST_PP_FOR_C0(P,129,S,M)(129,S) BOOST_PP_FOR_C1(P,129,S)(O(129,S),P,O,M)
-#define BOOST_PP_FOR129(S,P,O,M) RECURSION DEPTH EXCEEDED!
+#define BOOST_PP_FOR129(S,P,O,M) (RECURSION DEPTH EXCEEDED!)
#endif
</ul>
*/
#define BOOST_PP_IDENTITY(X) X BOOST_PP_EMPTY
-
-/* <p>Obsolete. Use BOOST_PP_IDENTITY().</p> */
-#define BOOST_PREPROCESSOR_IDENTITY(X) BOOST_PP_IDENTITY(X)
#endif
* See http://www.boost.org for most recent version.
*/
+#include <boost/preprocessor/detail/cat.hpp>
#include <boost/preprocessor/logical/bool.hpp>
-#include <boost/preprocessor/tuple/elem.hpp>
/** <p>Expands to <code>THEN</code> if <code>COND != 0</code> and <code>ELSE</code> if
<code>COND == 0</code>.</p>
<li><a href="../../test/preprocessor_test.cpp">preprocessor_test.cpp</a></li>
</ul>
*/
-#define BOOST_PP_IF(COND,THEN,ELSE) BOOST_PP_IF_BOOL(BOOST_PP_BOOL(COND))(ELSE,THEN)
-
-#define BOOST_PP_IF_BOOL(C) BOOST_PP_IF_BOOL_DELAY(C)
-#define BOOST_PP_IF_BOOL_DELAY(C) BOOST_PP_TUPLE2_ELEM##C
-
-/* <p>Obsolete. Use BOOST_PP_IF().</p> */
-#define BOOST_PREPROCESSOR_IF(C,T,E) BOOST_PP_IF(C,T,E)
+#define BOOST_PP_IF(COND,THEN,ELSE) BOOST_PP_DETAIL_CAT2(BOOST_PP_IF,BOOST_PP_BOOL(COND))(ELSE,THEN)
+#define BOOST_PP_IF0(E,T) E
+#define BOOST_PP_IF1(E,T) T
#endif
* See http://www.boost.org for most recent version.
*/
+#include <boost/preprocessor/detail/cat.hpp>
+
/** <p>Increments <code>X</code> expanding to a single token.</p>
<p>For example, <code>BOOST_PP_INC(3)</code> expands to <code>4</code> (a
<p>Only decimal integer literals in the range [0,BOOST_PP_LIMIT_MAG] are
supported.</p>
*/
-#define BOOST_PP_INC(X) BOOST_PP_INC_DELAY(X)
+#define BOOST_PP_INC(X) BOOST_PP_DETAIL_CAT2(BOOST_PP_INC,X)
-#define BOOST_PP_INC_DELAY(X) BOOST_PP_INC##X
#define BOOST_PP_INC0 1
#define BOOST_PP_INC1 2
#define BOOST_PP_INC2 3
#define BOOST_PP_INC126 127
#define BOOST_PP_INC127 128
#define BOOST_PP_INC128 128
-
-/* <p>Obsolete. Use BOOST_PP_INC().</p> */
-#define BOOST_PREPROCESSOR_INC(X) BOOST_PP_INC(X)
#endif
/** <p>Expands to the number of dimensions of repeat supported by the
library.</p>
-<p>The repeat macros are named BOOST_PP_REPEAT(), BOOST_PP_REPEAT_2ND(),
-BOOST_PP_REPEAT_3RD(), ...</p>
+<p>This concerns the repetition primitives (BOOST_PP_ENUM(),
+BOOST_PP_REPEAT() and BOOST_PP_REPEAT_FROM_TO()).</p>
*/
#define BOOST_PP_LIMIT_DIM 3
/** <p>Expands to the maximum straight numeric literal supported by the
library.</p>
-<p>This is also the limit of the repetition primitives (BOOST_PP_ENUM family
-and BOOST_PP_REPEAT family).</p>
+<p>This is also the limit of the repetition primitives (BOOST_PP_ENUM(),
+BOOST_PP_REPEAT() and BOOST_PP_REPEAT_FROM_TO()).</p>
<h3>Note</h3>
<ul>
/** <p>Expands to the maximum tuple size supported by the library.</p> */
#define BOOST_PP_LIMIT_TUPLE 16
-
-/* <p>Obsolete. Use BOOST_PP_LIMIT_DIM.</p> */
-#define BOOST_PREPROCESSOR_LIMIT_DIM BOOST_PP_LIMIT_DIM
-
-/* <p>Obsolete. Use BOOST_PP_LIMIT_MAG.</p> */
-#define BOOST_PREPROCESSOR_LIMIT_MAG BOOST_PP_LIMIT_MAG
-
-/* <p>Obsolete. Use BOOST_PP_LIMIT_TUPLE.</p> */
-#define BOOST_PREPROCESSOR_LIMIT_TUPLE BOOST_PP_LIMIT_TUPLE
#endif
* See http://www.boost.org for most recent version.
*/
-/** <p>Includes all list headers.</p> */
+/** <p>Includes all list headers.</p>
+
+<p>A list is an arbitrary size collection of elements.</p>
+
+<p>In the preprocessor library, the internal representation of lists
+uses parts that are like macro parameter lists. Thus an element of a list
+can be any sequence of tokens that constitutes a single macro parameter.</p>
+
+<p>Lists are manipulated using both list ADT macros and higher-order macros. For an introduction to manipulation of lists in functional programming, see
+<a href="../bibliography.htm#[Thompson]">[Thompson]</a>,
+<a href="../bibliography.htm#[Abelson]">[Abelson]</a> or
+<a href="../bibliography.htm#[Cousineau]">[Cousineau]</a>.</p>
+*/
#include <boost/preprocessor/list/append.hpp>
#include <boost/preprocessor/list/at.hpp>
#include <boost/preprocessor/list/cat.hpp>
#include <boost/preprocessor/list/filter.hpp>
#include <boost/preprocessor/list/first_n.hpp>
-#include <boost/preprocessor/list/fold_right_2nd.hpp>
#include <boost/preprocessor/list/for_each.hpp>
#include <boost/preprocessor/list/for_each_product.hpp>
#include <boost/preprocessor/list/size.hpp>
<p>Both of the above lists contain 5 elements: 1, 2, 3, 4 and 5.</p>
<p>Longer lists can be built from short lists with BOOST_PP_LIST_APPEND_D()
-and BOOST_PP_LIST_FOLD_RIGHT_2ND():</p>
+and BOOST_PP_LIST_FOLD_RIGHT():</p>
<pre>
-BOOST_PP_LIST_FOLD_RIGHT_2ND
+BOOST_PP_LIST_FOLD_RIGHT
( BOOST_PP_LIST_APPEND_D
, BOOST_PP_TUPLE_TO_LIST
( N
, ...
, BOOST_PP_TUPLE_TO_LIST(M, (EN1, EN2, ..., ENM) )
)
+, BOOST_PP_LIST_NIL
)
</pre>
*/
#define BOOST_PP_LIST_NIL (_,_,0)
/** <p>Expands to 1 if the list is not nil and 0 otherwise.</p> */
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_LIST_IS_CONS(LIST) BOOST_PP_TUPLE_ELEM(3,2,LIST)
-#else
-# define BOOST_PP_LIST_IS_CONS(LIST) BOOST_PP_TUPLE3_ELEM2 LIST
-#endif
+#define BOOST_PP_LIST_IS_CONS(LIST) BOOST_PP_TUPLE_ELEM(3,2,LIST)
/** <p>Expands to 1 if the list is nil and 0 otherwise.</p> */
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_LIST_IS_NIL(LIST) BOOST_PP_NOT(BOOST_PP_TUPLE_ELEM(3,2,LIST))
-#else
-# define BOOST_PP_LIST_IS_NIL(LIST) BOOST_PP_NOT(BOOST_PP_TUPLE3_ELEM2 LIST)
-#endif
+#define BOOST_PP_LIST_IS_NIL(LIST) BOOST_PP_NOT(BOOST_PP_TUPLE_ELEM(3,2,LIST))
/** <p>Expands to the first element of the list. The list must not be nil.</p>
<p>expands to 1.</p>
*/
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_LIST_FIRST(LIST) BOOST_PP_TUPLE_ELEM(3,0,LIST)
-#else
-# define BOOST_PP_LIST_FIRST(LIST) BOOST_PP_TUPLE3_ELEM0 LIST
-#endif
+#define BOOST_PP_LIST_FIRST(LIST) BOOST_PP_TUPLE_ELEM(3,0,LIST)
/** <p>Expands to a list of all but the first element of the list.</p>
BOOST_PP_TUPLE_TO_LIST(4,(2,3,4,5))
</pre>
*/
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_LIST_REST(LIST) BOOST_PP_TUPLE_ELEM(3,1,LIST)
-#else
-# define BOOST_PP_LIST_REST(LIST) BOOST_PP_TUPLE3_ELEM1 LIST
-#endif
+#define BOOST_PP_LIST_REST(LIST) BOOST_PP_TUPLE_ELEM(3,1,LIST)
#endif
BOOST_PP_TUPLE_TO_LIST(4,(1,2,3,4))
</pre>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_LIST_FOLD_RIGHT()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
*/
#define BOOST_PP_LIST_APPEND(LIST_1ST,LIST_2ND) BOOST_PP_LIST_APPEND_D(0,LIST_1ST,LIST_2ND)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_LIST_APPEND_D(D,LIST_1ST,LIST_2ND) BOOST_PP_LIST_FOLD_RIGHT_D(D,BOOST_PP_LIST_APPEND_F,LIST_1ST,LIST_2ND)
-#define BOOST_PP_LIST_APPEND_F(D,H,P) (H,P,1)
+#define BOOST_PP_LIST_APPEND_F(D,X,S) (X,S,1)
#endif
<p>expands to <code>B</code>.</p>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_WHILE()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
*/
#define BOOST_PP_LIST_AT(LIST,INDEX) BOOST_PP_LIST_AT_D(0,LIST,INDEX)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_LIST_AT_D(D,LIST,INDEX) BOOST_PP_LIST_FIRST(BOOST_PP_LIST_REST_N_D(D,INDEX,LIST))
#endif
123
</pre>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_LIST_FOLD_LEFT()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
*/
#define BOOST_PP_LIST_CAT(LIST) BOOST_PP_LIST_CAT_D(0,LIST)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
-#define BOOST_PP_LIST_CAT_D(D,LIST) BOOST_PP_LIST_FOLD_LEFT_D(D,BOOST_PP_LIST_CAT_F,BOOST_PP_TUPLE3_ELEM0 LIST,BOOST_PP_TUPLE3_ELEM1 LIST)
-#define BOOST_PP_LIST_CAT_F(D,P,H) BOOST_PP_CAT(P,H)
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
+#define BOOST_PP_LIST_CAT_D(D,LIST) BOOST_PP_LIST_FOLD_LEFT_D(D,BOOST_PP_LIST_CAT_F,BOOST_PP_TUPLE_ELEM(3,0,LIST),BOOST_PP_TUPLE_ELEM(3,1,LIST))
+#define BOOST_PP_LIST_CAT_F(D,S,X) BOOST_PP_CAT(S,X)
#endif
*/
#define BOOST_PP_LIST_ENUM(LIST) BOOST_PP_LIST_ENUM_R(0,LIST)
-/** <p>Can be used inside BOOST_PP_FOR().</p> */
+/** <p>Can be used inside BOOST_PP_FOR() (see for an explanation of the R parameter).</p> */
#define BOOST_PP_LIST_ENUM_R(R,LIST) BOOST_PP_LIST_FOR_EACH_I_R(R,BOOST_PP_LIST_ENUM_F,_,LIST)
#define BOOST_PP_LIST_ENUM_F(R,_,I,X) BOOST_PP_COMMA_IF(I) X
#endif
BOOST_PP_TUPLE_TO_LIST(2,(1,3))
</pre>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_WHILE() (see for explanation of the D parameter)</li>
- <li>BOOST_PP_LIST_FOLD_RIGHT()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
*/
#define BOOST_PP_LIST_FILTER(PRED,DATA,LIST) BOOST_PP_LIST_FILTER_D(0,PRED,DATA,LIST)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_LIST_FILTER_D(D,PRED,DATA,LIST) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_LIST_FOLD_RIGHT_D(D,BOOST_PP_LIST_FILTER_F,LIST,(PRED,DATA,(_,_,0))))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_LIST_FILTER_F(D,H,P) (BOOST_PP_TUPLE_ELEM(3,0,P),BOOST_PP_TUPLE_ELEM(3,1,P),BOOST_PP_IF(BOOST_PP_TUPLE_ELEM(3,0,P)(D,BOOST_PP_TUPLE3_ELEM1 P,H),BOOST_PP_LIST_CONS,BOOST_PP_TUPLE2_ELEM1)(H,BOOST_PP_TUPLE_ELEM(3,2,P)))
-#elif !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
-# define BOOST_PP_LIST_FILTER_F(D,H,P) (BOOST_PP_TUPLE_ELEM(3,0,P),BOOST_PP_TUPLE3_ELEM1 P,BOOST_PP_IF(BOOST_PP_TUPLE3_ELEM0 P(D,BOOST_PP_TUPLE3_ELEM1 P,H),BOOST_PP_LIST_CONS,BOOST_PP_TUPLE2_ELEM1)(H,BOOST_PP_TUPLE3_ELEM2 P))
-#else
-# define BOOST_PP_LIST_FILTER_F(D,H,P) (BOOST_PP_TUPLE3_ELEM0 P,BOOST_PP_TUPLE3_ELEM1 P,BOOST_PP_IF(BOOST_PP_TUPLE3_ELEM0 P(D,BOOST_PP_TUPLE3_ELEM1 P,H),BOOST_PP_LIST_CONS,BOOST_PP_TUPLE2_ELEM1)(H,BOOST_PP_TUPLE3_ELEM2 P))
-#endif
+
+#define BOOST_PP_LIST_FILTER_F(D,X,PDR) (BOOST_PP_TUPLE_ELEM(3,0,PDR),BOOST_PP_TUPLE_ELEM(3,1,PDR),BOOST_PP_IF(BOOST_PP_TUPLE_ELEM(3,0,PDR)(D,BOOST_PP_TUPLE_ELEM(3,1,PDR),X),BOOST_PP_LIST_CONS,BOOST_PP_IF1)(X,BOOST_PP_TUPLE_ELEM(3,2,PDR)))
#endif
<li>BOOST_PP_LIST_REST_N()</li>
</ul>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_LIST_FOLD_LEFT()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
*/
#define BOOST_PP_LIST_FIRST_N(COUNT,LIST) BOOST_PP_LIST_FIRST_N_D(0,COUNT,LIST)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation the D parameter).</p> */
#define BOOST_PP_LIST_FIRST_N_D(D,COUNT,LIST) BOOST_PP_LIST_REVERSE_D(D,BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_WHILE##D(BOOST_PP_LIST_FIRST_N_C,BOOST_PP_LIST_FIRST_N_F,((_,_,0),LIST,COUNT))))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_LIST_FIRST_N_C(D,X) BOOST_PP_TUPLE_ELEM(3,2,X)
-# define BOOST_PP_LIST_FIRST_N_F(D,X) ((BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(3,1,X)),BOOST_PP_TUPLE_ELEM(3,0,X),1),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(3,1,X)),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(3,2,X)))
-#else
-# define BOOST_PP_LIST_FIRST_N_C(D,X) BOOST_PP_TUPLE3_ELEM2 X
-# define BOOST_PP_LIST_FIRST_N_F(D,X) ((BOOST_PP_TUPLE3_ELEM0 BOOST_PP_TUPLE3_ELEM1 X,BOOST_PP_TUPLE3_ELEM0 X,1),BOOST_PP_TUPLE3_ELEM1 BOOST_PP_TUPLE3_ELEM1 X,BOOST_PP_DEC(BOOST_PP_TUPLE3_ELEM2 X))
-#endif
+
+#define BOOST_PP_LIST_FIRST_N_C(D,RLC) BOOST_PP_TUPLE_ELEM(3,2,RLC)
+#define BOOST_PP_LIST_FIRST_N_F(D,RLC) ((BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(3,1,RLC)),BOOST_PP_TUPLE_ELEM(3,0,RLC),1),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(3,1,RLC)),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(3,2,RLC)))
+
#endif
* See http://www.boost.org for most recent version.
*/
+#include <boost/preprocessor/detail/auto_rec.hpp>
+#include <boost/preprocessor/expand.hpp>
#include <boost/preprocessor/list/adt.hpp>
#include <boost/preprocessor/while.hpp>
<li>BOOST_PP_LIST_FOLD_RIGHT()</li>
</ul>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_WHILE() (see for explanation of the D parameter)</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
*/
#define BOOST_PP_LIST_FOLD_LEFT(OP,STATE,LIST) BOOST_PP_LIST_FOLD_LEFT_D(0,OP,STATE,LIST)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
-#define BOOST_PP_LIST_FOLD_LEFT_D(D,OP,STATE,LIST) BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_WHILE##D(BOOST_PP_LIST_FOLD_LEFT_C,BOOST_PP_LIST_FOLD_LEFT_F,(OP,STATE,LIST)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_LIST_FOLD_LEFT_C(D,X) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(3,2,X))
-# define BOOST_PP_LIST_FOLD_LEFT_F(D,X) (BOOST_PP_TUPLE_ELEM(3,0,X),BOOST_PP_TUPLE_ELEM(3,0,X)(D,BOOST_PP_TUPLE_ELEM(3,1,X),BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(3,2,X))),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(3,2,X)))
-#elif !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
-# define BOOST_PP_LIST_FOLD_LEFT_C(D,X) BOOST_PP_TUPLE3_ELEM2 BOOST_PP_TUPLE3_ELEM2 X
-# define BOOST_PP_LIST_FOLD_LEFT_F(D,X) (BOOST_PP_TUPLE_ELEM(3,0,X),BOOST_PP_TUPLE3_ELEM0 X(D,BOOST_PP_TUPLE3_ELEM1 X,BOOST_PP_TUPLE3_ELEM0 BOOST_PP_TUPLE3_ELEM2 X),BOOST_PP_TUPLE3_ELEM1 BOOST_PP_TUPLE3_ELEM2 X)
-#else
-# define BOOST_PP_LIST_FOLD_LEFT_C(D,X) BOOST_PP_TUPLE3_ELEM2 BOOST_PP_TUPLE3_ELEM2 X
-# define BOOST_PP_LIST_FOLD_LEFT_F(D,X) (BOOST_PP_TUPLE3_ELEM0 X,BOOST_PP_TUPLE3_ELEM0 X(D,BOOST_PP_TUPLE3_ELEM1 X,BOOST_PP_TUPLE3_ELEM0 BOOST_PP_TUPLE3_ELEM2 X),BOOST_PP_TUPLE3_ELEM1 BOOST_PP_TUPLE3_ELEM2 X)
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p>
+
+<h3>Note</h3>
+<ul>
+ <li>BOOST_PP_LIST_FOLD_LEFT_D() implements automatic recursion. You
+ can use a fold in the OP macro.</li>
+</ul>
+*/
+#if 0
+# define BOOST_PP_LIST_FOLD_LEFT_D(D,OP,STATE,LIST)
#endif
+
+#define BOOST_PP_LIST_FOLD_LEFT_D\
+ BOOST_PP_AUTO_REC_CAT1(BOOST_PP_LIST_FOLD_LEFT_D,BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC1(BOOST_PP_AUTO_REC_ID,(1)))
+#define BOOST_PP_LIST_FOLD_LEFT_DBOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC1(M,P)\
+ BOOST_PP_AUTO_REC_CAT2(BOOST_PP_LIST_FOLD_LEFT_D,BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC2(BOOST_PP_AUTO_REC_ID,(2)))
+#define BOOST_PP_LIST_FOLD_LEFT_DBOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC2(M,P)\
+ BOOST_PP_AUTO_REC_CAT3(BOOST_PP_LIST_FOLD_LEFT_D,BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC3(BOOST_PP_AUTO_REC_ID,(3)))
+#define BOOST_PP_LIST_FOLD_LEFT_DBOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC3(M,P)\
+ (TOO MANY NESTED FOLDS!)
+
+#define BOOST_PP_LIST_FOLD_LEFT_D1(D,O,S,L) BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC1(BOOST_PP_WHILE##D,(BOOST_PP_LIST_FOLD_LEFT_P,BOOST_PP_LIST_FOLD_LEFT_O1,(O,S,L))))
+#define BOOST_PP_LIST_FOLD_LEFT_D2(D,O,S,L) BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC2(BOOST_PP_WHILE##D,(BOOST_PP_LIST_FOLD_LEFT_P,BOOST_PP_LIST_FOLD_LEFT_O2,(O,S,L))))
+#define BOOST_PP_LIST_FOLD_LEFT_D3(D,O,S,L) BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC3(BOOST_PP_WHILE##D,(BOOST_PP_LIST_FOLD_LEFT_P,BOOST_PP_LIST_FOLD_LEFT_O3,(O,S,L))))
+
+#define BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC1(M,P) BOOST_PP_EXPAND(M P)
+#define BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC2(M,P) BOOST_PP_EXPAND(M P)
+#define BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC3(M,P) BOOST_PP_EXPAND(M P)
+
+#define BOOST_PP_LIST_FOLD_LEFT_P(D,OSL) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(3,2,OSL))
+
+#define BOOST_PP_LIST_FOLD_LEFT_O1(D,OSL) (BOOST_PP_TUPLE_ELEM(3,0,OSL),BOOST_PP_TUPLE_ELEM(3,0,OSL)(D,BOOST_PP_TUPLE_ELEM(3,1,OSL),BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(3,2,OSL))),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(3,2,OSL)))
+#define BOOST_PP_LIST_FOLD_LEFT_O2(D,OSL) (BOOST_PP_TUPLE_ELEM(3,0,OSL),BOOST_PP_TUPLE_ELEM(3,0,OSL)(D,BOOST_PP_TUPLE_ELEM(3,1,OSL),BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(3,2,OSL))),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(3,2,OSL)))
+#define BOOST_PP_LIST_FOLD_LEFT_O3(D,OSL) (BOOST_PP_TUPLE_ELEM(3,0,OSL),BOOST_PP_TUPLE_ELEM(3,0,OSL)(D,BOOST_PP_TUPLE_ELEM(3,1,OSL),BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(3,2,OSL))),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(3,2,OSL)))
+
+/** <p>Obsolete, just use BOOST_PP_LIST_FOLD_LEFT().</p> */
+#define BOOST_PP_LIST_FOLD_LEFT_2ND BOOST_PP_LIST_FOLD_LEFT
+/** <p>Obsolete, just use BOOST_PP_LIST_FOLD_LEFT_D().</p> */
+#define BOOST_PP_LIST_FOLD_LEFT_2ND_D BOOST_PP_LIST_FOLD_LEFT_D
#endif
* See http://www.boost.org for most recent version.
*/
-#include <boost/preprocessor/list/adt.hpp>
-#include <boost/preprocessor/while.hpp>
+/** <p>This header is obsolete. Use the following code instead.</p>
-/** <p>Same as BOOST_PP_LIST_FOLD_LEFT(), but implemented independently.</p> */
-#define BOOST_PP_LIST_FOLD_LEFT_2ND(OP,STATE,LIST) BOOST_PP_LIST_FOLD_LEFT_2ND_D(0,OP,STATE,LIST)
+<pre>
+#include <boost/preprocessor/list/fold_left.hpp>
+</pre>
+*/
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
-#define BOOST_PP_LIST_FOLD_LEFT_2ND_D(D,OP,STATE,LIST) BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_WHILE##D(BOOST_PP_LIST_FOLD_LEFT_2ND_C,BOOST_PP_LIST_FOLD_LEFT_2ND_F,(OP,STATE,LIST)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_LIST_FOLD_LEFT_2ND_C(D,X) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(3,2,X))
-# define BOOST_PP_LIST_FOLD_LEFT_2ND_F(D,X) (BOOST_PP_TUPLE_ELEM(3,0,X),BOOST_PP_TUPLE_ELEM(3,0,X)(D,BOOST_PP_TUPLE_ELEM(3,1,X),BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(3,2,X))),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(3,2,X)))
-#elif !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
-# define BOOST_PP_LIST_FOLD_LEFT_2ND_C(D,X) BOOST_PP_TUPLE3_ELEM2 BOOST_PP_TUPLE3_ELEM2 X
-# define BOOST_PP_LIST_FOLD_LEFT_2ND_F(D,X) (BOOST_PP_TUPLE_ELEM(3,0,X),BOOST_PP_TUPLE3_ELEM0 X(D,BOOST_PP_TUPLE3_ELEM1 X,BOOST_PP_TUPLE3_ELEM0 BOOST_PP_TUPLE3_ELEM2 X),BOOST_PP_TUPLE3_ELEM1 BOOST_PP_TUPLE3_ELEM2 X)
-#else
-# define BOOST_PP_LIST_FOLD_LEFT_2ND_C(D,X) BOOST_PP_TUPLE3_ELEM2 BOOST_PP_TUPLE3_ELEM2 X
-# define BOOST_PP_LIST_FOLD_LEFT_2ND_F(D,X) (BOOST_PP_TUPLE3_ELEM0 X,BOOST_PP_TUPLE3_ELEM0 X(D,BOOST_PP_TUPLE3_ELEM1 X,BOOST_PP_TUPLE3_ELEM0 BOOST_PP_TUPLE3_ELEM2 X),BOOST_PP_TUPLE3_ELEM1 BOOST_PP_TUPLE3_ELEM2 X)
-#endif
+#include <boost/preprocessor/list/fold_left.hpp>
#endif
_CBA
</pre>
-<h3>Uses</h3>
+<h3>Note</h3>
<ul>
- <li>BOOST_PP_WHILE() (see for explanation of the D parameter)</li>
- <li>BOOST_PP_LIST_FOLD_LEFT()</li>
+ <li>Folding, or accumulation, is a very general pattern of computation.
+ Most list operations can be implemented in terms of folding.</li>
</ul>
<h3>Test</h3>
*/
#define BOOST_PP_LIST_FOLD_RIGHT(OP,LIST,STATE) BOOST_PP_LIST_FOLD_RIGHT_D(0,OP,LIST,STATE)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
-#define BOOST_PP_LIST_FOLD_RIGHT_D(D,OP,LIST,STATE) BOOST_PP_TUPLE_ELEM(2,1,BOOST_PP_LIST_FOLD_LEFT_D(D,BOOST_PP_LIST_FOLD_RIGHT_F,(OP,STATE),BOOST_PP_LIST_REVERSE_D(D,LIST)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_LIST_FOLD_RIGHT_F(D,P,H) (BOOST_PP_TUPLE_ELEM(2,0,P),BOOST_PP_TUPLE_ELEM(2,0,P)(D,H,BOOST_PP_TUPLE_ELEM(2,1,P)))
-#elif !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
-# define BOOST_PP_LIST_FOLD_RIGHT_F(D,P,H) (BOOST_PP_TUPLE_ELEM(2,0,P),BOOST_PP_TUPLE_ELEM(2,0,P)(D,H,BOOST_PP_TUPLE2_ELEM1 P))
-#else
-# define BOOST_PP_LIST_FOLD_RIGHT_F(D,P,H) (BOOST_PP_TUPLE2_ELEM0 P,BOOST_PP_TUPLE2_ELEM0 P(D,H,BOOST_PP_TUPLE2_ELEM1 P))
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p>
+
+<h3>Note</h3>
+<ul>
+ <li>BOOST_PP_LIST_FOLD_RIGHT_D() implements automatic recursion. You
+ can use a fold in the OP macro.</li>
+</ul>
+*/
+#if 0
+# define BOOST_PP_LIST_FOLD_RIGHT_D(D,OP,LIST,STATE)
#endif
+
+#define BOOST_PP_LIST_FOLD_RIGHT_D\
+ BOOST_PP_AUTO_REC_CAT1(BOOST_PP_LIST_FOLD_RIGHT_D,BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC1(BOOST_PP_AUTO_REC_ID,(1)))
+#define BOOST_PP_LIST_FOLD_RIGHT_DBOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC1(M,P)\
+ BOOST_PP_AUTO_REC_CAT2(BOOST_PP_LIST_FOLD_RIGHT_D,BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC2(BOOST_PP_AUTO_REC_ID,(2)))
+#define BOOST_PP_LIST_FOLD_RIGHT_DBOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC2(M,P)\
+ BOOST_PP_AUTO_REC_CAT3(BOOST_PP_LIST_FOLD_RIGHT_D,BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC3(BOOST_PP_AUTO_REC_ID,(3)))
+#define BOOST_PP_LIST_FOLD_RIGHT_DBOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC3(M,P)\
+ (TOO MANY NESTED FOLDS!)
+
+#define BOOST_PP_LIST_FOLD_RIGHT_D1(D,O,L,S) BOOST_PP_TUPLE_ELEM(2,1,BOOST_PP_LIST_FOLD_LEFT_D(D,BOOST_PP_LIST_FOLD_RIGHT_O1,(O,S),BOOST_PP_LIST_REVERSE_D(D,L)))
+#define BOOST_PP_LIST_FOLD_RIGHT_D2(D,O,L,S) BOOST_PP_TUPLE_ELEM(2,1,BOOST_PP_LIST_FOLD_LEFT_D(D,BOOST_PP_LIST_FOLD_RIGHT_O2,(O,S),BOOST_PP_LIST_REVERSE_D(D,L)))
+#define BOOST_PP_LIST_FOLD_RIGHT_D3(D,O,L,S) BOOST_PP_TUPLE_ELEM(2,1,BOOST_PP_LIST_FOLD_LEFT_D(D,BOOST_PP_LIST_FOLD_RIGHT_O3,(O,S),BOOST_PP_LIST_REVERSE_D(D,L)))
+
+#define BOOST_PP_LIST_FOLD_RIGHT_O1(D,OS,X) (BOOST_PP_TUPLE_ELEM(2,0,OS),BOOST_PP_TUPLE_ELEM(2,0,OS)(D,X,BOOST_PP_TUPLE_ELEM(2,1,OS)))
+#define BOOST_PP_LIST_FOLD_RIGHT_O2(D,OS,X) (BOOST_PP_TUPLE_ELEM(2,0,OS),BOOST_PP_TUPLE_ELEM(2,0,OS)(D,X,BOOST_PP_TUPLE_ELEM(2,1,OS)))
+#define BOOST_PP_LIST_FOLD_RIGHT_O3(D,OS,X) (BOOST_PP_TUPLE_ELEM(2,0,OS),BOOST_PP_TUPLE_ELEM(2,0,OS)(D,X,BOOST_PP_TUPLE_ELEM(2,1,OS)))
+
+/** <p>Obsolete, just use BOOST_PP_LIST_FOLD_RIGHT().</p> */
+#define BOOST_PP_LIST_FOLD_RIGHT_2ND BOOST_PP_LIST_FOLD_RIGHT
+/** <p>Obsolete, just use BOOST_PP_LIST_FOLD_RIGHT_D().</p> */
+#define BOOST_PP_LIST_FOLD_RIGHT_2ND_D BOOST_PP_LIST_FOLD_RIGHT_D
#endif
* See http://www.boost.org for most recent version.
*/
-#include <boost/preprocessor/list/fold_left_2nd.hpp>
-#include <boost/preprocessor/list/reverse.hpp>
+/** <p>This header is obsolete. Use the following code instead.</p>
-/** <p>Same as BOOST_PP_LIST_FOLD_RIGHT(), but implemented independently.</p> */
-#define BOOST_PP_LIST_FOLD_RIGHT_2ND(OP,LIST,STATE) BOOST_PP_LIST_FOLD_RIGHT_2ND_D(0,OP,LIST,STATE)
+<pre>
+#include <boost/preprocessor/list/fold_right.hpp>
+</pre>
+*/
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
-#define BOOST_PP_LIST_FOLD_RIGHT_2ND_D(D,OP,LIST,STATE) BOOST_PP_TUPLE_ELEM(2,1,BOOST_PP_LIST_FOLD_LEFT_2ND_D(D,BOOST_PP_LIST_FOLD_RIGHT_2ND_F,(OP,STATE),BOOST_PP_LIST_FOLD_LEFT_2ND_D(D,BOOST_PP_LIST_REVERSE_F,(_,_,0),LIST)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_LIST_FOLD_RIGHT_2ND_F(D,P,H) (BOOST_PP_TUPLE_ELEM(2,0,P),BOOST_PP_TUPLE_ELEM(2,0,P)(D,H,BOOST_PP_TUPLE_ELEM(2,1,P)))
-#elif !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
-# define BOOST_PP_LIST_FOLD_RIGHT_2ND_F(D,P,H) (BOOST_PP_TUPLE_ELEM(2,0,P),BOOST_PP_TUPLE_ELEM(2,0,P)(D,H,BOOST_PP_TUPLE2_ELEM1 P))
-#else
-# define BOOST_PP_LIST_FOLD_RIGHT_2ND_F(D,P,H) (BOOST_PP_TUPLE2_ELEM0 P,BOOST_PP_TUPLE2_ELEM0 P(D,H,BOOST_PP_TUPLE2_ELEM1 P))
-#endif
+#include <boost/preprocessor/list/fold_right.hpp>
#endif
<li><a href="../../example/catch_builtin.cpp">catch_builtin.cpp</a></li>
</ul>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_FOR() (see for explanation of the R parameter)</li>
- <li>BOOST_PP_LIST_FOR_EACH_I() </li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
*/
#define BOOST_PP_LIST_FOR_EACH(MACRO,DATA,LIST) BOOST_PP_LIST_FOR_EACH_R(0,MACRO,DATA,LIST)
-/** <p>Can be used inside BOOST_PP_FOR().</p> */
+/** <p>Can be used inside BOOST_PP_FOR() (see for an explanation of the R parameter).</p> */
#define BOOST_PP_LIST_FOR_EACH_R(R,MACRO,DATA,LIST) BOOST_PP_LIST_FOR_EACH_I_R(R,BOOST_PP_LIST_FOR_EACH_F,(MACRO,DATA),LIST)
-#define BOOST_PP_LIST_FOR_EACH_F(R,FP,I,X) BOOST_PP_TUPLE_ELEM(2,0,FP)(R,BOOST_PP_TUPLE_ELEM(2,1,FP),X)
+#define BOOST_PP_LIST_FOR_EACH_F(R,MD,I,X) BOOST_PP_TUPLE_ELEM(2,0,MD)(R,BOOST_PP_TUPLE_ELEM(2,1,MD),X)
#endif
<pre>
prefix_A(0); prefix_B(1); prefix_C(2);
</pre>
-
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_FOR() (see for explanation of the R parameter)</li>
-</ul>
*/
#define BOOST_PP_LIST_FOR_EACH_I(MACRO,DATA,LIST) BOOST_PP_LIST_FOR_EACH_I_R(0,MACRO,DATA,LIST)
-/** <p>Can be used inside BOOST_PP_FOR().</p> */
-#define BOOST_PP_LIST_FOR_EACH_I_R(R,MACRO,DATA,LIST) BOOST_PP_FOR##R((MACRO,DATA,LIST,0),BOOST_PP_LIST_FOR_EACH_I_C,BOOST_PP_LIST_FOR_EACH_I_F,BOOST_PP_LIST_FOR_EACH_I_I)
-#define BOOST_PP_LIST_FOR_EACH_I_C(R,FPLI) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(4,2,FPLI))
-#define BOOST_PP_LIST_FOR_EACH_I_F(R,FPLI) (BOOST_PP_TUPLE_ELEM(4,0,FPLI),BOOST_PP_TUPLE_ELEM(4,1,FPLI),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(4,2,FPLI)),BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4,3,FPLI)))
-#define BOOST_PP_LIST_FOR_EACH_I_I(R,FPLI) BOOST_PP_TUPLE_ELEM(4,0,FPLI)(R,BOOST_PP_TUPLE_ELEM(4,1,FPLI),BOOST_PP_TUPLE_ELEM(4,3,FPLI),BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(4,2,FPLI)))
+/** <p>Can be used inside BOOST_PP_FOR() (see for an explanation of the R parameter).</p> */
+#define BOOST_PP_LIST_FOR_EACH_I_R(R,MACRO,DATA,LIST) BOOST_PP_FOR##R((MACRO,DATA,LIST,0),BOOST_PP_LIST_FOR_EACH_I_P,BOOST_PP_LIST_FOR_EACH_I_O,BOOST_PP_LIST_FOR_EACH_I_M)
+#define BOOST_PP_LIST_FOR_EACH_I_P(R,MDLI) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(4,2,MDLI))
+#define BOOST_PP_LIST_FOR_EACH_I_O(R,MDLI) (BOOST_PP_TUPLE_ELEM(4,0,MDLI),BOOST_PP_TUPLE_ELEM(4,1,MDLI),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(4,2,MDLI)),BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4,3,MDLI)))
+#define BOOST_PP_LIST_FOR_EACH_I_M(R,MDLI) BOOST_PP_TUPLE_ELEM(4,0,MDLI)(R,BOOST_PP_TUPLE_ELEM(4,1,MDLI),BOOST_PP_TUPLE_ELEM(4,3,MDLI),BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(4,2,MDLI)))
#endif
<li><a href="../../example/array_arithmetic.c">array_arithmetic.c</a></li>
</ul>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_FOR() (see for explanation of the R parameter)</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
*/
#define BOOST_PP_LIST_FOR_EACH_PRODUCT(MACRO,SIZE_OF_TUPLE,TUPLE_OF_LISTS) BOOST_PP_LIST_FOR_EACH_PRODUCT_R(0,MACRO,SIZE_OF_TUPLE,TUPLE_OF_LISTS)
-/** <p>Can be used inside BOOST_PP_FOR().</p> */
+/** <p>Can be used inside BOOST_PP_FOR() (see for an explanation of the R parameter).</p> */
#define BOOST_PP_LIST_FOR_EACH_PRODUCT_R(R,MACRO,SIZE_OF_TUPLE,TUPLE_OF_LISTS) BOOST_PP_LIST_FOR_EACH_PRODUCT_R2(0,MACRO,BOOST_PP_TUPLE_TO_LIST(SIZE_OF_TUPLE,BOOST_PP_TUPLE_REVERSE(SIZE_OF_TUPLE,TUPLE_OF_LISTS)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__) ||\
- !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
-# define BOOST_PP_LIST_FOR_EACH_PRODUCT_R2(R,F,LL) BOOST_PP_FOR##R((BOOST_PP_TUPLE_ELEM(3,0,LL),BOOST_PP_TUPLE_ELEM(3,1,LL),(_,_,0),F),BOOST_PP_LIST_FOR_EACH_PRODUCT_C,BOOST_PP_LIST_FOR_EACH_PRODUCT_F,BOOST_PP_LIST_FOR_EACH_PRODUCT_I0)
-# define BOOST_PP_LIST_FOR_EACH_PRODUCT_C(R,P) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(4,0,P))
-# define BOOST_PP_LIST_FOR_EACH_PRODUCT_F(R,P) (BOOST_PP_LIST_REST(BOOST_PP_TUPLE_ELEM(4,0,P)),BOOST_PP_TUPLE_ELEM(4,1,P),BOOST_PP_TUPLE_ELEM(4,2,P),BOOST_PP_TUPLE_ELEM(4,3,P))
-# define BOOST_PP_LIST_FOR_EACH_PRODUCT_I(R,P) BOOST_PP_TUPLE_ELEM(4,3,P)(R,BOOST_PP_LIST_TO_TUPLE_R(R,(BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(4,0,P)),BOOST_PP_TUPLE_ELEM(4,2,P),1)))
-# define BOOST_PP_LIST_FOR_EACH_PRODUCT_I_C(P,I) BOOST_PP_IF(BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(4,1,P)),BOOST_PP_LIST_FOR_EACH_PRODUCT_I##I##_C,BOOST_PP_LIST_FOR_EACH_PRODUCT_I)
-# define BOOST_PP_LIST_FOR_EACH_PRODUCT_I_H(P) (BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(4,1,P)),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(4,1,P)),(BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(4,0,P)),BOOST_PP_TUPLE_ELEM(4,2,P),1),BOOST_PP_TUPLE_ELEM(4,3,P))
-#else
-# define BOOST_PP_LIST_FOR_EACH_PRODUCT_R2(R,F,LL) BOOST_PP_FOR##R((BOOST_PP_TUPLE3_ELEM0 LL,BOOST_PP_TUPLE3_ELEM1 LL,(_,_,0),F),BOOST_PP_LIST_FOR_EACH_PRODUCT_C,BOOST_PP_LIST_FOR_EACH_PRODUCT_F,BOOST_PP_LIST_FOR_EACH_PRODUCT_I0)
-# define BOOST_PP_LIST_FOR_EACH_PRODUCT_C(R,P) BOOST_PP_TUPLE3_ELEM2 BOOST_PP_TUPLE4_ELEM0 P
-# define BOOST_PP_LIST_FOR_EACH_PRODUCT_F(R,P) (BOOST_PP_LIST_REST(BOOST_PP_TUPLE4_ELEM0 P),BOOST_PP_TUPLE4_ELEM1 P,BOOST_PP_TUPLE4_ELEM2 P,BOOST_PP_TUPLE4_ELEM3 P)
+#define BOOST_PP_LIST_FOR_EACH_PRODUCT_R2(R,F,LL) BOOST_PP_FOR##R((BOOST_PP_TUPLE_ELEM(3,0,LL),BOOST_PP_TUPLE_ELEM(3,1,LL),(_,_,0),F),BOOST_PP_LIST_FOR_EACH_PRODUCT_C,BOOST_PP_LIST_FOR_EACH_PRODUCT_F,BOOST_PP_LIST_FOR_EACH_PRODUCT_I0)
+#define BOOST_PP_LIST_FOR_EACH_PRODUCT_C(R,P) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(4,0,P))
+#define BOOST_PP_LIST_FOR_EACH_PRODUCT_F(R,P) (BOOST_PP_LIST_REST(BOOST_PP_TUPLE_ELEM(4,0,P)),BOOST_PP_TUPLE_ELEM(4,1,P),BOOST_PP_TUPLE_ELEM(4,2,P),BOOST_PP_TUPLE_ELEM(4,3,P))
+
+#define BOOST_PP_LIST_FOR_EACH_PRODUCT_I(R,P) BOOST_PP_TUPLE_ELEM(4,3,P)(R,BOOST_PP_LIST_TO_TUPLE_R(R,(BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(4,0,P)),BOOST_PP_TUPLE_ELEM(4,2,P),1)))
+#define BOOST_PP_LIST_FOR_EACH_PRODUCT_I_C(P,I) BOOST_PP_IF(BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(4,1,P)),BOOST_PP_LIST_FOR_EACH_PRODUCT_I##I##_C,BOOST_PP_LIST_FOR_EACH_PRODUCT_I)
+#define BOOST_PP_LIST_FOR_EACH_PRODUCT_I_H(P) (BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(4,1,P)),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(4,1,P)),(BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(4,0,P)),BOOST_PP_TUPLE_ELEM(4,2,P),1),BOOST_PP_TUPLE_ELEM(4,3,P))
-# define BOOST_PP_LIST_FOR_EACH_PRODUCT_I(R,P) BOOST_PP_TUPLE4_ELEM3 P(R,BOOST_PP_LIST_TO_TUPLE_R(R,(BOOST_PP_TUPLE3_ELEM0 BOOST_PP_TUPLE4_ELEM0 P,BOOST_PP_TUPLE4_ELEM2 P,1)))
-# define BOOST_PP_LIST_FOR_EACH_PRODUCT_I_C(P,I) BOOST_PP_IF(BOOST_PP_TUPLE3_ELEM2 BOOST_PP_TUPLE4_ELEM1 P,BOOST_PP_LIST_FOR_EACH_PRODUCT_I##I##_C,BOOST_PP_LIST_FOR_EACH_PRODUCT_I)
-# define BOOST_PP_LIST_FOR_EACH_PRODUCT_I_H(P) (BOOST_PP_TUPLE3_ELEM0 BOOST_PP_TUPLE4_ELEM1 P,BOOST_PP_TUPLE3_ELEM1 BOOST_PP_TUPLE4_ELEM1 P,(BOOST_PP_TUPLE3_ELEM0 BOOST_PP_TUPLE4_ELEM0 P,BOOST_PP_TUPLE4_ELEM2 P,1),BOOST_PP_TUPLE4_ELEM3 P)
-#endif
#define BOOST_PP_LIST_FOR_EACH_PRODUCT_I0_C(R,P) BOOST_PP_FOR##R(BOOST_PP_LIST_FOR_EACH_PRODUCT_I_H(P),BOOST_PP_LIST_FOR_EACH_PRODUCT_C,BOOST_PP_LIST_FOR_EACH_PRODUCT_F,BOOST_PP_LIST_FOR_EACH_PRODUCT_I1)
#define BOOST_PP_LIST_FOR_EACH_PRODUCT_I0(R,P) BOOST_PP_LIST_FOR_EACH_PRODUCT_I_C(P,0)(R,P)
#define BOOST_PP_LIST_FOR_EACH_PRODUCT_I1_C(R,P) BOOST_PP_FOR##R(BOOST_PP_LIST_FOR_EACH_PRODUCT_I_H(P),BOOST_PP_LIST_FOR_EACH_PRODUCT_C,BOOST_PP_LIST_FOR_EACH_PRODUCT_F,BOOST_PP_LIST_FOR_EACH_PRODUCT_I2)
<li>BOOST_PP_LIST_FIRST_N()</li>
</ul>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_WHILE()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
*/
#define BOOST_PP_LIST_REST_N(COUNT,LIST) BOOST_PP_LIST_REST_N_D(0,COUNT,LIST)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_LIST_REST_N_D(D,COUNT,LIST) BOOST_PP_TUPLE_ELEM(2,0,BOOST_PP_WHILE##D(BOOST_PP_LIST_REST_N_C,BOOST_PP_LIST_REST_N_F,(LIST,COUNT)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_LIST_REST_N_C(D,X) BOOST_PP_TUPLE_ELEM(2,1,X)
-# define BOOST_PP_LIST_REST_N_F(D,X) (BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(2,0,X)),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2,1,X)))
-#else
-# define BOOST_PP_LIST_REST_N_C(D,X) BOOST_PP_TUPLE2_ELEM1 X
-# define BOOST_PP_LIST_REST_N_F(D,X) (BOOST_PP_TUPLE3_ELEM1 BOOST_PP_TUPLE2_ELEM0 X,BOOST_PP_DEC(BOOST_PP_TUPLE2_ELEM1 X))
-#endif
+
+#define BOOST_PP_LIST_REST_N_C(D,LC) BOOST_PP_TUPLE_ELEM(2,1,LC)
+#define BOOST_PP_LIST_REST_N_F(D,LC) (BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(2,0,LC)),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2,1,LC)))
#endif
BOOST_PP_TUPLE_TO_LIST(3,(C,B,A))
</pre>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_LIST_FOLD_LEFT()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
*/
#define BOOST_PP_LIST_REVERSE(LIST) BOOST_PP_LIST_REVERSE_D(0,LIST)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_LIST_REVERSE_D(D,LIST) BOOST_PP_LIST_FOLD_LEFT_D(D,BOOST_PP_LIST_REVERSE_F,(_,_,0),LIST)
-#define BOOST_PP_LIST_REVERSE_F(D,P,H) (H,P,1)
+#define BOOST_PP_LIST_REVERSE_F(D,S,X) (X,S,1)
#endif
<p>expands to <code>3</code>.</p>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_LIST_FOLD_LEFT()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
*/
#define BOOST_PP_LIST_SIZE(LIST) BOOST_PP_LIST_SIZE_D(0,LIST)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_LIST_SIZE_D(D,LIST) BOOST_PP_LIST_FOLD_LEFT_D(D,BOOST_PP_LIST_SIZE_F,0,LIST)
-#define BOOST_PP_LIST_SIZE_F(D,P,H) BOOST_PP_INC(P)
+#define BOOST_PP_LIST_SIZE_F(D,S,X) BOOST_PP_INC(S)
#endif
BOOST_PP_LIMIT_MAG rather than BOOST_PP_LIMIT_TUPLE.</li>
</ul>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_FOR()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
*/
#define BOOST_PP_LIST_TO_TUPLE(LIST) BOOST_PP_LIST_TO_TUPLE_R(0,LIST)
-/** <p>Can be used inside BOOST_PP_FOR().</p> */
+/** <p>Can be used inside BOOST_PP_FOR() (see for an explanation of the R parameter).</p> */
#define BOOST_PP_LIST_TO_TUPLE_R(R,LIST) (BOOST_PP_LIST_ENUM_R(R,LIST))
#endif
BOOST_PP_TUPLE_TO_LIST(2,(3,4))
</pre>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_WHILE() (see for explanation of the D parameter)</li>
- <li>BOOST_PP_LIST_FOLD_RIGHT()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
*/
#define BOOST_PP_LIST_TRANSFORM(OP,DATA,LIST) BOOST_PP_LIST_TRANSFORM_D(0,OP,DATA,LIST)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_LIST_TRANSFORM_D(D,OP,DATA,LIST) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_LIST_FOLD_RIGHT_D(D,BOOST_PP_LIST_TRANSFORM_F,LIST,(OP,DATA,(_,_,0))))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_LIST_TRANSFORM_F(D,H,P) (BOOST_PP_TUPLE_ELEM(3,0,P),BOOST_PP_TUPLE_ELEM(3,1,P),(BOOST_PP_TUPLE_ELEM(3,0,P)(D,BOOST_PP_TUPLE_ELEM(3,1,P),H),BOOST_PP_TUPLE_ELEM(3,2,P),1))
-#elif !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
-# define BOOST_PP_LIST_TRANSFORM_F(D,H,P) (BOOST_PP_TUPLE_ELEM(3,0,P),BOOST_PP_TUPLE3_ELEM1 P,(BOOST_PP_TUPLE_ELEM(3,0,P)(D,BOOST_PP_TUPLE3_ELEM1 P,H),BOOST_PP_TUPLE3_ELEM2 P,1))
-#else
-# define BOOST_PP_LIST_TRANSFORM_F(D,H,P) (BOOST_PP_TUPLE3_ELEM0 P,BOOST_PP_TUPLE3_ELEM1 P,(BOOST_PP_TUPLE3_ELEM0 P(D,BOOST_PP_TUPLE3_ELEM1 P,H),BOOST_PP_TUPLE3_ELEM2 P,1))
-#endif
+
+#define BOOST_PP_LIST_TRANSFORM_F(D,X,ODR) (BOOST_PP_TUPLE_ELEM(3,0,ODR),BOOST_PP_TUPLE_ELEM(3,1,ODR),(BOOST_PP_TUPLE_ELEM(3,0,ODR)(D,BOOST_PP_TUPLE_ELEM(3,1,ODR),X),BOOST_PP_TUPLE_ELEM(3,2,ODR),1))
#endif
</ul>
*/
#define BOOST_PP_AND(X,Y) BOOST_PP_NOR(BOOST_PP_NOT(X),BOOST_PP_NOT(Y))
-
-/* <p>Obsolete. Use BOOST_PP_AND().</p> */
-#define BOOST_PREPROCESSOR_AND(X,Y) BOOST_PP_AND(X,Y)
#endif
* See http://www.boost.org for most recent version.
*/
+#include <boost/preprocessor/detail/cat.hpp>
+
/** <p>Expands to <code>0</code> if <code>X == 0</code> and <code>1</code> if <code>X != 0</code>.</p>
<p><code>X</code> must be an integer literal in the range [0, BOOST_PP_LIMIT_MAG].</p>
<p>For example, <code>BOOST_PP_BOOL(3)</code> expands to <code>1</code>.</p>
*/
-#define BOOST_PP_BOOL(X) BOOST_PP_BOOL_DELAY(X)
+#define BOOST_PP_BOOL(X) BOOST_PP_DETAIL_CAT2(BOOST_PP_BOOL,X)
/* BOOL can be implemented in O(1) tokens using saturated ADD & SUB.
* Unfortunately, it would result in significantly slower preprocessing.
*/
-#define BOOST_PP_BOOL_DELAY(X) BOOST_PP_BOOL##X
#define BOOST_PP_BOOL0 0
#define BOOST_PP_BOOL1 1
#define BOOST_PP_BOOL2 1
#define BOOST_PP_BOOL126 1
#define BOOST_PP_BOOL127 1
#define BOOST_PP_BOOL128 1
-
-/* <p>Obsolete. Use BOOST_PP_BOOL().</p> */
-#define BOOST_PREPROCESSOR_BOOL(X) BOOST_PP_BOOL(X)
#endif
* See http://www.boost.org for most recent version.
*/
+#include <boost/preprocessor/detail/cat.hpp>
#include <boost/preprocessor/logical/bool.hpp>
/** <p>Expands to the logical NEITHER OR of the operands.</p>
<li><a href="../../test/logical_test.cpp">logical_test.cpp</a></li>
</ul>
*/
-#define BOOST_PP_NOR(X,Y) BOOST_PP_NOR_BOOL(BOOST_PP_BOOL(X),BOOST_PP_BOOL(Y))
+#define BOOST_PP_NOR(X,Y) BOOST_PP_DETAIL_CAT3(BOOST_PP_NOR,BOOST_PP_BOOL(X),BOOST_PP_BOOL(Y))
-#define BOOST_PP_NOR_BOOL(X,Y) BOOST_PP_NOR_BOOL_DELAY(X,Y)
-#define BOOST_PP_NOR_BOOL_DELAY(X,Y) BOOST_PP_NOR_BOOL##X##Y
-#define BOOST_PP_NOR_BOOL00 1
-#define BOOST_PP_NOR_BOOL01 0
-#define BOOST_PP_NOR_BOOL10 0
-#define BOOST_PP_NOR_BOOL11 0
-
-/* <p>Obsolete. Use BOOST_PP_NOR().</p> */
-#define BOOST_PREPROCESSOR_NOR(X,Y) BOOST_PP_NOR(X,Y)
+#define BOOST_PP_NOR00 1
+#define BOOST_PP_NOR01 0
+#define BOOST_PP_NOR10 0
+#define BOOST_PP_NOR11 0
#endif
</ul>
*/
#define BOOST_PP_NOT(X) BOOST_PP_NOR(X,X)
-
-/* <p>Obsolete. Use BOOST_PP_NOT().</p> */
-#define BOOST_PREPROCESSOR_NOT(X) BOOST_PP_NOT(X)
#endif
</ul>
*/
#define BOOST_PP_OR(X,Y) BOOST_PP_NOT(BOOST_PP_NOR(X,Y))
-
-/* <p>Obsolete. Use BOOST_PP_OR().</p> */
-#define BOOST_PREPROCESSOR_OR(X,Y) BOOST_PP_OR(X,Y)
#endif
</ul>
*/
#define BOOST_PP_XOR(X,Y) BOOST_PP_NOR(BOOST_PP_NOR(X,Y),BOOST_PP_AND(X,Y))
-
-/* <p>Obsolete. Use BOOST_PP_XOR().</p> */
-#define BOOST_PREPROCESSOR_XOR(X,Y) BOOST_PP_XOR(X,Y)
#endif
<p>For example, <code>BOOST_PP_MAX(5,7)</code> expands to <code>7</code> (a
single token).</p>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_WHILE()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
*/
#define BOOST_PP_MAX(X,Y) BOOST_PP_MAX_D(0,X,Y)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_MAX_D(D,X,Y) BOOST_PP_IF(BOOST_PP_LESS_EQUAL_D(D,X,Y),Y,X)
-
-/* <p>Obsolete. Use BOOST_PP_MAX().</p> */
-#define BOOST_PREPROCESSOR_MAX(X,Y) BOOST_PP_MAX(X,Y)
#endif
<p>For example, <code>BOOST_PP_MIN(5,7)</code> expands to <code>5</code> (a
single token).</p>
-<h3>Uses</h3>
-<ul>
- <li>BOOST_PP_WHILE()</li>
-</ul>
-
<h3>Test</h3>
<ul>
<li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
*/
#define BOOST_PP_MIN(X,Y) BOOST_PP_MIN_D(0,X,Y)
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
#define BOOST_PP_MIN_D(D,X,Y) BOOST_PP_IF(BOOST_PP_LESS_EQUAL_D(D,Y,X),Y,X)
-
-/* <p>Obsolete. Use BOOST_PP_MIN().</p> */
-#define BOOST_PREPROCESSOR_MIN(X,Y) BOOST_PP_MIN(X,Y)
#endif
* See http://www.boost.org for most recent version.
*/
+#include <boost/preprocessor/detail/cat.hpp>
+#include <boost/preprocessor/detail/auto_rec.hpp>
+#include <boost/preprocessor/expand.hpp>
+
/** <p>Repeats the macro <code>MACRO(INDEX,DATA)</code> for <code>INDEX = [0,COUNT)</code>.</p>
<p>In other words, expands to the sequence:</p>
<h3>2D and 3D repetition</h3>
-<p>2D and 3D repetition are supported with the BOOST_PP_REPEAT_2ND() and
-BOOST_PP_REPEAT_3RD() macros.</p>
+<p>BOOST_PP_REPEAT() implements automatic recursion. 2D and 3D repetition
+are directly supported.</p>
<h3>Example</h3>
<ul>
<h3>See</h3>
<ul>
<li>BOOST_PP_FOR()</li>
+ <li>BOOST_PP_LIMIT_DIM</li>
<li>BOOST_PP_LIMIT_MAG</li>
</ul>
+
+<h3>Test</h3>
+<ul>
+ <li><a href="../../test/repeat_test.cpp">repeat_test.cpp</a></li>
+ <li><a href="../../test/repeat_2nd_test.cpp">repeat_2nd_test.cpp</a></li>
+</ul>
*/
-#define BOOST_PP_REPEAT(COUNT,MACRO,DATA) BOOST_PP_REPEAT_DELAY(COUNT)(MACRO,DATA)
-
-#define BOOST_PP_REPEAT_DELAY(N) BOOST_PP_REPEAT##N
-#define BOOST_PP_REPEAT0(M,D)
-#define BOOST_PP_REPEAT1(M,D) M(0,D)
-#define BOOST_PP_REPEAT2(M,D) M(0,D) M(1,D)
-#define BOOST_PP_REPEAT3(M,D) M(0,D) M(1,D) M(2,D)
-#define BOOST_PP_REPEAT4(M,D) M(0,D) M(1,D) M(2,D) M(3,D)
-#define BOOST_PP_REPEAT5(M,D) BOOST_PP_REPEAT4(M,D) M(4,D)
-#define BOOST_PP_REPEAT6(M,D) BOOST_PP_REPEAT5(M,D) M(5,D)
-#define BOOST_PP_REPEAT7(M,D) BOOST_PP_REPEAT6(M,D) M(6,D)
-#define BOOST_PP_REPEAT8(M,D) BOOST_PP_REPEAT7(M,D) M(7,D)
-#define BOOST_PP_REPEAT9(M,D) BOOST_PP_REPEAT8(M,D) M(8,D)
-#define BOOST_PP_REPEAT10(M,D) BOOST_PP_REPEAT9(M,D) M(9,D)
-#define BOOST_PP_REPEAT11(M,D) BOOST_PP_REPEAT10(M,D) M(10,D)
-#define BOOST_PP_REPEAT12(M,D) BOOST_PP_REPEAT11(M,D) M(11,D)
-#define BOOST_PP_REPEAT13(M,D) BOOST_PP_REPEAT12(M,D) M(12,D)
-#define BOOST_PP_REPEAT14(M,D) BOOST_PP_REPEAT13(M,D) M(13,D)
-#define BOOST_PP_REPEAT15(M,D) BOOST_PP_REPEAT14(M,D) M(14,D)
-#define BOOST_PP_REPEAT16(M,D) BOOST_PP_REPEAT15(M,D) M(15,D)
-#define BOOST_PP_REPEAT17(M,D) BOOST_PP_REPEAT16(M,D) M(16,D)
-#define BOOST_PP_REPEAT18(M,D) BOOST_PP_REPEAT17(M,D) M(17,D)
-#define BOOST_PP_REPEAT19(M,D) BOOST_PP_REPEAT18(M,D) M(18,D)
-#define BOOST_PP_REPEAT20(M,D) BOOST_PP_REPEAT19(M,D) M(19,D)
-#define BOOST_PP_REPEAT21(M,D) BOOST_PP_REPEAT20(M,D) M(20,D)
-#define BOOST_PP_REPEAT22(M,D) BOOST_PP_REPEAT21(M,D) M(21,D)
-#define BOOST_PP_REPEAT23(M,D) BOOST_PP_REPEAT22(M,D) M(22,D)
-#define BOOST_PP_REPEAT24(M,D) BOOST_PP_REPEAT23(M,D) M(23,D)
-#define BOOST_PP_REPEAT25(M,D) BOOST_PP_REPEAT24(M,D) M(24,D)
-#define BOOST_PP_REPEAT26(M,D) BOOST_PP_REPEAT25(M,D) M(25,D)
-#define BOOST_PP_REPEAT27(M,D) BOOST_PP_REPEAT26(M,D) M(26,D)
-#define BOOST_PP_REPEAT28(M,D) BOOST_PP_REPEAT27(M,D) M(27,D)
-#define BOOST_PP_REPEAT29(M,D) BOOST_PP_REPEAT28(M,D) M(28,D)
-#define BOOST_PP_REPEAT30(M,D) BOOST_PP_REPEAT29(M,D) M(29,D)
-#define BOOST_PP_REPEAT31(M,D) BOOST_PP_REPEAT30(M,D) M(30,D)
-#define BOOST_PP_REPEAT32(M,D) BOOST_PP_REPEAT31(M,D) M(31,D)
-#define BOOST_PP_REPEAT33(M,D) BOOST_PP_REPEAT32(M,D) M(32,D)
-#define BOOST_PP_REPEAT34(M,D) BOOST_PP_REPEAT33(M,D) M(33,D)
-#define BOOST_PP_REPEAT35(M,D) BOOST_PP_REPEAT34(M,D) M(34,D)
-#define BOOST_PP_REPEAT36(M,D) BOOST_PP_REPEAT35(M,D) M(35,D)
-#define BOOST_PP_REPEAT37(M,D) BOOST_PP_REPEAT36(M,D) M(36,D)
-#define BOOST_PP_REPEAT38(M,D) BOOST_PP_REPEAT37(M,D) M(37,D)
-#define BOOST_PP_REPEAT39(M,D) BOOST_PP_REPEAT38(M,D) M(38,D)
-#define BOOST_PP_REPEAT40(M,D) BOOST_PP_REPEAT39(M,D) M(39,D)
-#define BOOST_PP_REPEAT41(M,D) BOOST_PP_REPEAT40(M,D) M(40,D)
-#define BOOST_PP_REPEAT42(M,D) BOOST_PP_REPEAT41(M,D) M(41,D)
-#define BOOST_PP_REPEAT43(M,D) BOOST_PP_REPEAT42(M,D) M(42,D)
-#define BOOST_PP_REPEAT44(M,D) BOOST_PP_REPEAT43(M,D) M(43,D)
-#define BOOST_PP_REPEAT45(M,D) BOOST_PP_REPEAT44(M,D) M(44,D)
-#define BOOST_PP_REPEAT46(M,D) BOOST_PP_REPEAT45(M,D) M(45,D)
-#define BOOST_PP_REPEAT47(M,D) BOOST_PP_REPEAT46(M,D) M(46,D)
-#define BOOST_PP_REPEAT48(M,D) BOOST_PP_REPEAT47(M,D) M(47,D)
-#define BOOST_PP_REPEAT49(M,D) BOOST_PP_REPEAT48(M,D) M(48,D)
-#define BOOST_PP_REPEAT50(M,D) BOOST_PP_REPEAT49(M,D) M(49,D)
-#define BOOST_PP_REPEAT51(M,D) BOOST_PP_REPEAT50(M,D) M(50,D)
-#define BOOST_PP_REPEAT52(M,D) BOOST_PP_REPEAT51(M,D) M(51,D)
-#define BOOST_PP_REPEAT53(M,D) BOOST_PP_REPEAT52(M,D) M(52,D)
-#define BOOST_PP_REPEAT54(M,D) BOOST_PP_REPEAT53(M,D) M(53,D)
-#define BOOST_PP_REPEAT55(M,D) BOOST_PP_REPEAT54(M,D) M(54,D)
-#define BOOST_PP_REPEAT56(M,D) BOOST_PP_REPEAT55(M,D) M(55,D)
-#define BOOST_PP_REPEAT57(M,D) BOOST_PP_REPEAT56(M,D) M(56,D)
-#define BOOST_PP_REPEAT58(M,D) BOOST_PP_REPEAT57(M,D) M(57,D)
-#define BOOST_PP_REPEAT59(M,D) BOOST_PP_REPEAT58(M,D) M(58,D)
-#define BOOST_PP_REPEAT60(M,D) BOOST_PP_REPEAT59(M,D) M(59,D)
-#define BOOST_PP_REPEAT61(M,D) BOOST_PP_REPEAT60(M,D) M(60,D)
-#define BOOST_PP_REPEAT62(M,D) BOOST_PP_REPEAT61(M,D) M(61,D)
-#define BOOST_PP_REPEAT63(M,D) BOOST_PP_REPEAT62(M,D) M(62,D)
-#define BOOST_PP_REPEAT64(M,D) BOOST_PP_REPEAT63(M,D) M(63,D)
-#define BOOST_PP_REPEAT65(M,D) BOOST_PP_REPEAT64(M,D) M(64,D)
-#define BOOST_PP_REPEAT66(M,D) BOOST_PP_REPEAT65(M,D) M(65,D)
-#define BOOST_PP_REPEAT67(M,D) BOOST_PP_REPEAT66(M,D) M(66,D)
-#define BOOST_PP_REPEAT68(M,D) BOOST_PP_REPEAT67(M,D) M(67,D)
-#define BOOST_PP_REPEAT69(M,D) BOOST_PP_REPEAT68(M,D) M(68,D)
-#define BOOST_PP_REPEAT70(M,D) BOOST_PP_REPEAT69(M,D) M(69,D)
-#define BOOST_PP_REPEAT71(M,D) BOOST_PP_REPEAT70(M,D) M(70,D)
-#define BOOST_PP_REPEAT72(M,D) BOOST_PP_REPEAT71(M,D) M(71,D)
-#define BOOST_PP_REPEAT73(M,D) BOOST_PP_REPEAT72(M,D) M(72,D)
-#define BOOST_PP_REPEAT74(M,D) BOOST_PP_REPEAT73(M,D) M(73,D)
-#define BOOST_PP_REPEAT75(M,D) BOOST_PP_REPEAT74(M,D) M(74,D)
-#define BOOST_PP_REPEAT76(M,D) BOOST_PP_REPEAT75(M,D) M(75,D)
-#define BOOST_PP_REPEAT77(M,D) BOOST_PP_REPEAT76(M,D) M(76,D)
-#define BOOST_PP_REPEAT78(M,D) BOOST_PP_REPEAT77(M,D) M(77,D)
-#define BOOST_PP_REPEAT79(M,D) BOOST_PP_REPEAT78(M,D) M(78,D)
-#define BOOST_PP_REPEAT80(M,D) BOOST_PP_REPEAT79(M,D) M(79,D)
-#define BOOST_PP_REPEAT81(M,D) BOOST_PP_REPEAT80(M,D) M(80,D)
-#define BOOST_PP_REPEAT82(M,D) BOOST_PP_REPEAT81(M,D) M(81,D)
-#define BOOST_PP_REPEAT83(M,D) BOOST_PP_REPEAT82(M,D) M(82,D)
-#define BOOST_PP_REPEAT84(M,D) BOOST_PP_REPEAT83(M,D) M(83,D)
-#define BOOST_PP_REPEAT85(M,D) BOOST_PP_REPEAT84(M,D) M(84,D)
-#define BOOST_PP_REPEAT86(M,D) BOOST_PP_REPEAT85(M,D) M(85,D)
-#define BOOST_PP_REPEAT87(M,D) BOOST_PP_REPEAT86(M,D) M(86,D)
-#define BOOST_PP_REPEAT88(M,D) BOOST_PP_REPEAT87(M,D) M(87,D)
-#define BOOST_PP_REPEAT89(M,D) BOOST_PP_REPEAT88(M,D) M(88,D)
-#define BOOST_PP_REPEAT90(M,D) BOOST_PP_REPEAT89(M,D) M(89,D)
-#define BOOST_PP_REPEAT91(M,D) BOOST_PP_REPEAT90(M,D) M(90,D)
-#define BOOST_PP_REPEAT92(M,D) BOOST_PP_REPEAT91(M,D) M(91,D)
-#define BOOST_PP_REPEAT93(M,D) BOOST_PP_REPEAT92(M,D) M(92,D)
-#define BOOST_PP_REPEAT94(M,D) BOOST_PP_REPEAT93(M,D) M(93,D)
-#define BOOST_PP_REPEAT95(M,D) BOOST_PP_REPEAT94(M,D) M(94,D)
-#define BOOST_PP_REPEAT96(M,D) BOOST_PP_REPEAT95(M,D) M(95,D)
-#define BOOST_PP_REPEAT97(M,D) BOOST_PP_REPEAT96(M,D) M(96,D)
-#define BOOST_PP_REPEAT98(M,D) BOOST_PP_REPEAT97(M,D) M(97,D)
-#define BOOST_PP_REPEAT99(M,D) BOOST_PP_REPEAT98(M,D) M(98,D)
-#define BOOST_PP_REPEAT100(M,D) BOOST_PP_REPEAT99(M,D) M(99,D)
-#define BOOST_PP_REPEAT101(M,D) BOOST_PP_REPEAT100(M,D) M(100,D)
-#define BOOST_PP_REPEAT102(M,D) BOOST_PP_REPEAT101(M,D) M(101,D)
-#define BOOST_PP_REPEAT103(M,D) BOOST_PP_REPEAT102(M,D) M(102,D)
-#define BOOST_PP_REPEAT104(M,D) BOOST_PP_REPEAT103(M,D) M(103,D)
-#define BOOST_PP_REPEAT105(M,D) BOOST_PP_REPEAT104(M,D) M(104,D)
-#define BOOST_PP_REPEAT106(M,D) BOOST_PP_REPEAT105(M,D) M(105,D)
-#define BOOST_PP_REPEAT107(M,D) BOOST_PP_REPEAT106(M,D) M(106,D)
-#define BOOST_PP_REPEAT108(M,D) BOOST_PP_REPEAT107(M,D) M(107,D)
-#define BOOST_PP_REPEAT109(M,D) BOOST_PP_REPEAT108(M,D) M(108,D)
-#define BOOST_PP_REPEAT110(M,D) BOOST_PP_REPEAT109(M,D) M(109,D)
-#define BOOST_PP_REPEAT111(M,D) BOOST_PP_REPEAT110(M,D) M(110,D)
-#define BOOST_PP_REPEAT112(M,D) BOOST_PP_REPEAT111(M,D) M(111,D)
-#define BOOST_PP_REPEAT113(M,D) BOOST_PP_REPEAT112(M,D) M(112,D)
-#define BOOST_PP_REPEAT114(M,D) BOOST_PP_REPEAT113(M,D) M(113,D)
-#define BOOST_PP_REPEAT115(M,D) BOOST_PP_REPEAT114(M,D) M(114,D)
-#define BOOST_PP_REPEAT116(M,D) BOOST_PP_REPEAT115(M,D) M(115,D)
-#define BOOST_PP_REPEAT117(M,D) BOOST_PP_REPEAT116(M,D) M(116,D)
-#define BOOST_PP_REPEAT118(M,D) BOOST_PP_REPEAT117(M,D) M(117,D)
-#define BOOST_PP_REPEAT119(M,D) BOOST_PP_REPEAT118(M,D) M(118,D)
-#define BOOST_PP_REPEAT120(M,D) BOOST_PP_REPEAT119(M,D) M(119,D)
-#define BOOST_PP_REPEAT121(M,D) BOOST_PP_REPEAT120(M,D) M(120,D)
-#define BOOST_PP_REPEAT122(M,D) BOOST_PP_REPEAT121(M,D) M(121,D)
-#define BOOST_PP_REPEAT123(M,D) BOOST_PP_REPEAT122(M,D) M(122,D)
-#define BOOST_PP_REPEAT124(M,D) BOOST_PP_REPEAT123(M,D) M(123,D)
-#define BOOST_PP_REPEAT125(M,D) BOOST_PP_REPEAT124(M,D) M(124,D)
-#define BOOST_PP_REPEAT126(M,D) BOOST_PP_REPEAT125(M,D) M(125,D)
-#define BOOST_PP_REPEAT127(M,D) BOOST_PP_REPEAT126(M,D) M(126,D)
-#define BOOST_PP_REPEAT128(M,D) BOOST_PP_REPEAT127(M,D) M(127,D)
-
-/* <p>Obsolete. Use BOOST_PP_REPEAT().</p> */
-#define BOOST_PREPROCESSOR_REPEAT(C,M,D) BOOST_PP_REPEAT(C,M,D)
+#if 0
+# define BOOST_PP_REPEAT(COUNT,MACRO,DATA)
+#endif
+
+#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
+/* This is a workaround for a MSVC++ PP bug. You'll need to add further
+ * BOOST_PP_REPEAT_AUTO_REC3/4/etc. wrapping as the maximum level of
+ * nesting REPEATS increases
+ */
+# define BOOST_PP_REPEAT\
+ BOOST_PP_AUTO_REC_CAT1(BOOST_PP_REPEAT_,BOOST_PP_REPEAT_AUTO_REC2(\
+ BOOST_PP_REPEAT_AUTO_REC1,(BOOST_PP_AUTO_REC_ID,(1))\
+ ))
+#else
+# define BOOST_PP_REPEAT\
+ BOOST_PP_AUTO_REC_CAT1(BOOST_PP_REPEAT_,BOOST_PP_REPEAT_AUTO_REC1(BOOST_PP_AUTO_REC_ID,(1)))
+#endif
+
+#define BOOST_PP_REPEAT_BOOST_PP_REPEAT_AUTO_REC1(M,P)\
+ BOOST_PP_AUTO_REC_CAT2(BOOST_PP_REPEAT_,BOOST_PP_REPEAT_AUTO_REC2(BOOST_PP_AUTO_REC_ID,(2)))
+#define BOOST_PP_REPEAT_BOOST_PP_REPEAT_AUTO_REC2(M,P)\
+ BOOST_PP_AUTO_REC_CAT3(BOOST_PP_REPEAT_,BOOST_PP_REPEAT_AUTO_REC3(BOOST_PP_AUTO_REC_ID,(3)))
+#define BOOST_PP_REPEAT_BOOST_PP_REPEAT_AUTO_REC3(M,P)\
+ (TOO MANY NESTED REPEATS!)
+
+#define BOOST_PP_REPEAT_AUTO_REC1(M,P) BOOST_PP_EXPAND(M P)
+#define BOOST_PP_REPEAT_AUTO_REC2(M,P) BOOST_PP_EXPAND(M P)
+#define BOOST_PP_REPEAT_AUTO_REC3(M,P) BOOST_PP_EXPAND(M P)
+
+#define BOOST_PP_REPEAT_1(C,M,D) BOOST_PP_REPEAT_AUTO_REC1(BOOST_PP_DETAIL_CAT2(BOOST_PP_R1_,C),(M,D))
+#define BOOST_PP_R1_0(M,D)
+#define BOOST_PP_R1_1(M,D) M(0,D)
+#define BOOST_PP_R1_2(M,D) M(0,D) M(1,D)
+#define BOOST_PP_R1_3(M,D) M(0,D) M(1,D) M(2,D)
+#define BOOST_PP_R1_4(M,D) M(0,D) M(1,D) M(2,D) M(3,D)
+#define BOOST_PP_R1_5(M,D) BOOST_PP_R1_4(M,D) M(4,D)
+#define BOOST_PP_R1_6(M,D) BOOST_PP_R1_5(M,D) M(5,D)
+#define BOOST_PP_R1_7(M,D) BOOST_PP_R1_6(M,D) M(6,D)
+#define BOOST_PP_R1_8(M,D) BOOST_PP_R1_7(M,D) M(7,D)
+#define BOOST_PP_R1_9(M,D) BOOST_PP_R1_8(M,D) M(8,D)
+#define BOOST_PP_R1_10(M,D) BOOST_PP_R1_9(M,D) M(9,D)
+#define BOOST_PP_R1_11(M,D) BOOST_PP_R1_10(M,D) M(10,D)
+#define BOOST_PP_R1_12(M,D) BOOST_PP_R1_11(M,D) M(11,D)
+#define BOOST_PP_R1_13(M,D) BOOST_PP_R1_12(M,D) M(12,D)
+#define BOOST_PP_R1_14(M,D) BOOST_PP_R1_13(M,D) M(13,D)
+#define BOOST_PP_R1_15(M,D) BOOST_PP_R1_14(M,D) M(14,D)
+#define BOOST_PP_R1_16(M,D) BOOST_PP_R1_15(M,D) M(15,D)
+#define BOOST_PP_R1_17(M,D) BOOST_PP_R1_16(M,D) M(16,D)
+#define BOOST_PP_R1_18(M,D) BOOST_PP_R1_17(M,D) M(17,D)
+#define BOOST_PP_R1_19(M,D) BOOST_PP_R1_18(M,D) M(18,D)
+#define BOOST_PP_R1_20(M,D) BOOST_PP_R1_19(M,D) M(19,D)
+#define BOOST_PP_R1_21(M,D) BOOST_PP_R1_20(M,D) M(20,D)
+#define BOOST_PP_R1_22(M,D) BOOST_PP_R1_21(M,D) M(21,D)
+#define BOOST_PP_R1_23(M,D) BOOST_PP_R1_22(M,D) M(22,D)
+#define BOOST_PP_R1_24(M,D) BOOST_PP_R1_23(M,D) M(23,D)
+#define BOOST_PP_R1_25(M,D) BOOST_PP_R1_24(M,D) M(24,D)
+#define BOOST_PP_R1_26(M,D) BOOST_PP_R1_25(M,D) M(25,D)
+#define BOOST_PP_R1_27(M,D) BOOST_PP_R1_26(M,D) M(26,D)
+#define BOOST_PP_R1_28(M,D) BOOST_PP_R1_27(M,D) M(27,D)
+#define BOOST_PP_R1_29(M,D) BOOST_PP_R1_28(M,D) M(28,D)
+#define BOOST_PP_R1_30(M,D) BOOST_PP_R1_29(M,D) M(29,D)
+#define BOOST_PP_R1_31(M,D) BOOST_PP_R1_30(M,D) M(30,D)
+#define BOOST_PP_R1_32(M,D) BOOST_PP_R1_31(M,D) M(31,D)
+#define BOOST_PP_R1_33(M,D) BOOST_PP_R1_32(M,D) M(32,D)
+#define BOOST_PP_R1_34(M,D) BOOST_PP_R1_33(M,D) M(33,D)
+#define BOOST_PP_R1_35(M,D) BOOST_PP_R1_34(M,D) M(34,D)
+#define BOOST_PP_R1_36(M,D) BOOST_PP_R1_35(M,D) M(35,D)
+#define BOOST_PP_R1_37(M,D) BOOST_PP_R1_36(M,D) M(36,D)
+#define BOOST_PP_R1_38(M,D) BOOST_PP_R1_37(M,D) M(37,D)
+#define BOOST_PP_R1_39(M,D) BOOST_PP_R1_38(M,D) M(38,D)
+#define BOOST_PP_R1_40(M,D) BOOST_PP_R1_39(M,D) M(39,D)
+#define BOOST_PP_R1_41(M,D) BOOST_PP_R1_40(M,D) M(40,D)
+#define BOOST_PP_R1_42(M,D) BOOST_PP_R1_41(M,D) M(41,D)
+#define BOOST_PP_R1_43(M,D) BOOST_PP_R1_42(M,D) M(42,D)
+#define BOOST_PP_R1_44(M,D) BOOST_PP_R1_43(M,D) M(43,D)
+#define BOOST_PP_R1_45(M,D) BOOST_PP_R1_44(M,D) M(44,D)
+#define BOOST_PP_R1_46(M,D) BOOST_PP_R1_45(M,D) M(45,D)
+#define BOOST_PP_R1_47(M,D) BOOST_PP_R1_46(M,D) M(46,D)
+#define BOOST_PP_R1_48(M,D) BOOST_PP_R1_47(M,D) M(47,D)
+#define BOOST_PP_R1_49(M,D) BOOST_PP_R1_48(M,D) M(48,D)
+#define BOOST_PP_R1_50(M,D) BOOST_PP_R1_49(M,D) M(49,D)
+#define BOOST_PP_R1_51(M,D) BOOST_PP_R1_50(M,D) M(50,D)
+#define BOOST_PP_R1_52(M,D) BOOST_PP_R1_51(M,D) M(51,D)
+#define BOOST_PP_R1_53(M,D) BOOST_PP_R1_52(M,D) M(52,D)
+#define BOOST_PP_R1_54(M,D) BOOST_PP_R1_53(M,D) M(53,D)
+#define BOOST_PP_R1_55(M,D) BOOST_PP_R1_54(M,D) M(54,D)
+#define BOOST_PP_R1_56(M,D) BOOST_PP_R1_55(M,D) M(55,D)
+#define BOOST_PP_R1_57(M,D) BOOST_PP_R1_56(M,D) M(56,D)
+#define BOOST_PP_R1_58(M,D) BOOST_PP_R1_57(M,D) M(57,D)
+#define BOOST_PP_R1_59(M,D) BOOST_PP_R1_58(M,D) M(58,D)
+#define BOOST_PP_R1_60(M,D) BOOST_PP_R1_59(M,D) M(59,D)
+#define BOOST_PP_R1_61(M,D) BOOST_PP_R1_60(M,D) M(60,D)
+#define BOOST_PP_R1_62(M,D) BOOST_PP_R1_61(M,D) M(61,D)
+#define BOOST_PP_R1_63(M,D) BOOST_PP_R1_62(M,D) M(62,D)
+#define BOOST_PP_R1_64(M,D) BOOST_PP_R1_63(M,D) M(63,D)
+#define BOOST_PP_R1_65(M,D) BOOST_PP_R1_64(M,D) M(64,D)
+#define BOOST_PP_R1_66(M,D) BOOST_PP_R1_65(M,D) M(65,D)
+#define BOOST_PP_R1_67(M,D) BOOST_PP_R1_66(M,D) M(66,D)
+#define BOOST_PP_R1_68(M,D) BOOST_PP_R1_67(M,D) M(67,D)
+#define BOOST_PP_R1_69(M,D) BOOST_PP_R1_68(M,D) M(68,D)
+#define BOOST_PP_R1_70(M,D) BOOST_PP_R1_69(M,D) M(69,D)
+#define BOOST_PP_R1_71(M,D) BOOST_PP_R1_70(M,D) M(70,D)
+#define BOOST_PP_R1_72(M,D) BOOST_PP_R1_71(M,D) M(71,D)
+#define BOOST_PP_R1_73(M,D) BOOST_PP_R1_72(M,D) M(72,D)
+#define BOOST_PP_R1_74(M,D) BOOST_PP_R1_73(M,D) M(73,D)
+#define BOOST_PP_R1_75(M,D) BOOST_PP_R1_74(M,D) M(74,D)
+#define BOOST_PP_R1_76(M,D) BOOST_PP_R1_75(M,D) M(75,D)
+#define BOOST_PP_R1_77(M,D) BOOST_PP_R1_76(M,D) M(76,D)
+#define BOOST_PP_R1_78(M,D) BOOST_PP_R1_77(M,D) M(77,D)
+#define BOOST_PP_R1_79(M,D) BOOST_PP_R1_78(M,D) M(78,D)
+#define BOOST_PP_R1_80(M,D) BOOST_PP_R1_79(M,D) M(79,D)
+#define BOOST_PP_R1_81(M,D) BOOST_PP_R1_80(M,D) M(80,D)
+#define BOOST_PP_R1_82(M,D) BOOST_PP_R1_81(M,D) M(81,D)
+#define BOOST_PP_R1_83(M,D) BOOST_PP_R1_82(M,D) M(82,D)
+#define BOOST_PP_R1_84(M,D) BOOST_PP_R1_83(M,D) M(83,D)
+#define BOOST_PP_R1_85(M,D) BOOST_PP_R1_84(M,D) M(84,D)
+#define BOOST_PP_R1_86(M,D) BOOST_PP_R1_85(M,D) M(85,D)
+#define BOOST_PP_R1_87(M,D) BOOST_PP_R1_86(M,D) M(86,D)
+#define BOOST_PP_R1_88(M,D) BOOST_PP_R1_87(M,D) M(87,D)
+#define BOOST_PP_R1_89(M,D) BOOST_PP_R1_88(M,D) M(88,D)
+#define BOOST_PP_R1_90(M,D) BOOST_PP_R1_89(M,D) M(89,D)
+#define BOOST_PP_R1_91(M,D) BOOST_PP_R1_90(M,D) M(90,D)
+#define BOOST_PP_R1_92(M,D) BOOST_PP_R1_91(M,D) M(91,D)
+#define BOOST_PP_R1_93(M,D) BOOST_PP_R1_92(M,D) M(92,D)
+#define BOOST_PP_R1_94(M,D) BOOST_PP_R1_93(M,D) M(93,D)
+#define BOOST_PP_R1_95(M,D) BOOST_PP_R1_94(M,D) M(94,D)
+#define BOOST_PP_R1_96(M,D) BOOST_PP_R1_95(M,D) M(95,D)
+#define BOOST_PP_R1_97(M,D) BOOST_PP_R1_96(M,D) M(96,D)
+#define BOOST_PP_R1_98(M,D) BOOST_PP_R1_97(M,D) M(97,D)
+#define BOOST_PP_R1_99(M,D) BOOST_PP_R1_98(M,D) M(98,D)
+#define BOOST_PP_R1_100(M,D) BOOST_PP_R1_99(M,D) M(99,D)
+#define BOOST_PP_R1_101(M,D) BOOST_PP_R1_100(M,D) M(100,D)
+#define BOOST_PP_R1_102(M,D) BOOST_PP_R1_101(M,D) M(101,D)
+#define BOOST_PP_R1_103(M,D) BOOST_PP_R1_102(M,D) M(102,D)
+#define BOOST_PP_R1_104(M,D) BOOST_PP_R1_103(M,D) M(103,D)
+#define BOOST_PP_R1_105(M,D) BOOST_PP_R1_104(M,D) M(104,D)
+#define BOOST_PP_R1_106(M,D) BOOST_PP_R1_105(M,D) M(105,D)
+#define BOOST_PP_R1_107(M,D) BOOST_PP_R1_106(M,D) M(106,D)
+#define BOOST_PP_R1_108(M,D) BOOST_PP_R1_107(M,D) M(107,D)
+#define BOOST_PP_R1_109(M,D) BOOST_PP_R1_108(M,D) M(108,D)
+#define BOOST_PP_R1_110(M,D) BOOST_PP_R1_109(M,D) M(109,D)
+#define BOOST_PP_R1_111(M,D) BOOST_PP_R1_110(M,D) M(110,D)
+#define BOOST_PP_R1_112(M,D) BOOST_PP_R1_111(M,D) M(111,D)
+#define BOOST_PP_R1_113(M,D) BOOST_PP_R1_112(M,D) M(112,D)
+#define BOOST_PP_R1_114(M,D) BOOST_PP_R1_113(M,D) M(113,D)
+#define BOOST_PP_R1_115(M,D) BOOST_PP_R1_114(M,D) M(114,D)
+#define BOOST_PP_R1_116(M,D) BOOST_PP_R1_115(M,D) M(115,D)
+#define BOOST_PP_R1_117(M,D) BOOST_PP_R1_116(M,D) M(116,D)
+#define BOOST_PP_R1_118(M,D) BOOST_PP_R1_117(M,D) M(117,D)
+#define BOOST_PP_R1_119(M,D) BOOST_PP_R1_118(M,D) M(118,D)
+#define BOOST_PP_R1_120(M,D) BOOST_PP_R1_119(M,D) M(119,D)
+#define BOOST_PP_R1_121(M,D) BOOST_PP_R1_120(M,D) M(120,D)
+#define BOOST_PP_R1_122(M,D) BOOST_PP_R1_121(M,D) M(121,D)
+#define BOOST_PP_R1_123(M,D) BOOST_PP_R1_122(M,D) M(122,D)
+#define BOOST_PP_R1_124(M,D) BOOST_PP_R1_123(M,D) M(123,D)
+#define BOOST_PP_R1_125(M,D) BOOST_PP_R1_124(M,D) M(124,D)
+#define BOOST_PP_R1_126(M,D) BOOST_PP_R1_125(M,D) M(125,D)
+#define BOOST_PP_R1_127(M,D) BOOST_PP_R1_126(M,D) M(126,D)
+#define BOOST_PP_R1_128(M,D) BOOST_PP_R1_127(M,D) M(127,D)
+
+#define BOOST_PP_REPEAT_2(C,M,D) BOOST_PP_REPEAT_AUTO_REC2(BOOST_PP_DETAIL_CAT2(BOOST_PP_R2_,C),(M,D))
+#define BOOST_PP_R2_0(M,D)
+#define BOOST_PP_R2_1(M,D) M(0,D)
+#define BOOST_PP_R2_2(M,D) M(0,D) M(1,D)
+#define BOOST_PP_R2_3(M,D) M(0,D) M(1,D) M(2,D)
+#define BOOST_PP_R2_4(M,D) M(0,D) M(1,D) M(2,D) M(3,D)
+#define BOOST_PP_R2_5(M,D) BOOST_PP_R2_4(M,D) M(4,D)
+#define BOOST_PP_R2_6(M,D) BOOST_PP_R2_5(M,D) M(5,D)
+#define BOOST_PP_R2_7(M,D) BOOST_PP_R2_6(M,D) M(6,D)
+#define BOOST_PP_R2_8(M,D) BOOST_PP_R2_7(M,D) M(7,D)
+#define BOOST_PP_R2_9(M,D) BOOST_PP_R2_8(M,D) M(8,D)
+#define BOOST_PP_R2_10(M,D) BOOST_PP_R2_9(M,D) M(9,D)
+#define BOOST_PP_R2_11(M,D) BOOST_PP_R2_10(M,D) M(10,D)
+#define BOOST_PP_R2_12(M,D) BOOST_PP_R2_11(M,D) M(11,D)
+#define BOOST_PP_R2_13(M,D) BOOST_PP_R2_12(M,D) M(12,D)
+#define BOOST_PP_R2_14(M,D) BOOST_PP_R2_13(M,D) M(13,D)
+#define BOOST_PP_R2_15(M,D) BOOST_PP_R2_14(M,D) M(14,D)
+#define BOOST_PP_R2_16(M,D) BOOST_PP_R2_15(M,D) M(15,D)
+#define BOOST_PP_R2_17(M,D) BOOST_PP_R2_16(M,D) M(16,D)
+#define BOOST_PP_R2_18(M,D) BOOST_PP_R2_17(M,D) M(17,D)
+#define BOOST_PP_R2_19(M,D) BOOST_PP_R2_18(M,D) M(18,D)
+#define BOOST_PP_R2_20(M,D) BOOST_PP_R2_19(M,D) M(19,D)
+#define BOOST_PP_R2_21(M,D) BOOST_PP_R2_20(M,D) M(20,D)
+#define BOOST_PP_R2_22(M,D) BOOST_PP_R2_21(M,D) M(21,D)
+#define BOOST_PP_R2_23(M,D) BOOST_PP_R2_22(M,D) M(22,D)
+#define BOOST_PP_R2_24(M,D) BOOST_PP_R2_23(M,D) M(23,D)
+#define BOOST_PP_R2_25(M,D) BOOST_PP_R2_24(M,D) M(24,D)
+#define BOOST_PP_R2_26(M,D) BOOST_PP_R2_25(M,D) M(25,D)
+#define BOOST_PP_R2_27(M,D) BOOST_PP_R2_26(M,D) M(26,D)
+#define BOOST_PP_R2_28(M,D) BOOST_PP_R2_27(M,D) M(27,D)
+#define BOOST_PP_R2_29(M,D) BOOST_PP_R2_28(M,D) M(28,D)
+#define BOOST_PP_R2_30(M,D) BOOST_PP_R2_29(M,D) M(29,D)
+#define BOOST_PP_R2_31(M,D) BOOST_PP_R2_30(M,D) M(30,D)
+#define BOOST_PP_R2_32(M,D) BOOST_PP_R2_31(M,D) M(31,D)
+#define BOOST_PP_R2_33(M,D) BOOST_PP_R2_32(M,D) M(32,D)
+#define BOOST_PP_R2_34(M,D) BOOST_PP_R2_33(M,D) M(33,D)
+#define BOOST_PP_R2_35(M,D) BOOST_PP_R2_34(M,D) M(34,D)
+#define BOOST_PP_R2_36(M,D) BOOST_PP_R2_35(M,D) M(35,D)
+#define BOOST_PP_R2_37(M,D) BOOST_PP_R2_36(M,D) M(36,D)
+#define BOOST_PP_R2_38(M,D) BOOST_PP_R2_37(M,D) M(37,D)
+#define BOOST_PP_R2_39(M,D) BOOST_PP_R2_38(M,D) M(38,D)
+#define BOOST_PP_R2_40(M,D) BOOST_PP_R2_39(M,D) M(39,D)
+#define BOOST_PP_R2_41(M,D) BOOST_PP_R2_40(M,D) M(40,D)
+#define BOOST_PP_R2_42(M,D) BOOST_PP_R2_41(M,D) M(41,D)
+#define BOOST_PP_R2_43(M,D) BOOST_PP_R2_42(M,D) M(42,D)
+#define BOOST_PP_R2_44(M,D) BOOST_PP_R2_43(M,D) M(43,D)
+#define BOOST_PP_R2_45(M,D) BOOST_PP_R2_44(M,D) M(44,D)
+#define BOOST_PP_R2_46(M,D) BOOST_PP_R2_45(M,D) M(45,D)
+#define BOOST_PP_R2_47(M,D) BOOST_PP_R2_46(M,D) M(46,D)
+#define BOOST_PP_R2_48(M,D) BOOST_PP_R2_47(M,D) M(47,D)
+#define BOOST_PP_R2_49(M,D) BOOST_PP_R2_48(M,D) M(48,D)
+#define BOOST_PP_R2_50(M,D) BOOST_PP_R2_49(M,D) M(49,D)
+#define BOOST_PP_R2_51(M,D) BOOST_PP_R2_50(M,D) M(50,D)
+#define BOOST_PP_R2_52(M,D) BOOST_PP_R2_51(M,D) M(51,D)
+#define BOOST_PP_R2_53(M,D) BOOST_PP_R2_52(M,D) M(52,D)
+#define BOOST_PP_R2_54(M,D) BOOST_PP_R2_53(M,D) M(53,D)
+#define BOOST_PP_R2_55(M,D) BOOST_PP_R2_54(M,D) M(54,D)
+#define BOOST_PP_R2_56(M,D) BOOST_PP_R2_55(M,D) M(55,D)
+#define BOOST_PP_R2_57(M,D) BOOST_PP_R2_56(M,D) M(56,D)
+#define BOOST_PP_R2_58(M,D) BOOST_PP_R2_57(M,D) M(57,D)
+#define BOOST_PP_R2_59(M,D) BOOST_PP_R2_58(M,D) M(58,D)
+#define BOOST_PP_R2_60(M,D) BOOST_PP_R2_59(M,D) M(59,D)
+#define BOOST_PP_R2_61(M,D) BOOST_PP_R2_60(M,D) M(60,D)
+#define BOOST_PP_R2_62(M,D) BOOST_PP_R2_61(M,D) M(61,D)
+#define BOOST_PP_R2_63(M,D) BOOST_PP_R2_62(M,D) M(62,D)
+#define BOOST_PP_R2_64(M,D) BOOST_PP_R2_63(M,D) M(63,D)
+#define BOOST_PP_R2_65(M,D) BOOST_PP_R2_64(M,D) M(64,D)
+#define BOOST_PP_R2_66(M,D) BOOST_PP_R2_65(M,D) M(65,D)
+#define BOOST_PP_R2_67(M,D) BOOST_PP_R2_66(M,D) M(66,D)
+#define BOOST_PP_R2_68(M,D) BOOST_PP_R2_67(M,D) M(67,D)
+#define BOOST_PP_R2_69(M,D) BOOST_PP_R2_68(M,D) M(68,D)
+#define BOOST_PP_R2_70(M,D) BOOST_PP_R2_69(M,D) M(69,D)
+#define BOOST_PP_R2_71(M,D) BOOST_PP_R2_70(M,D) M(70,D)
+#define BOOST_PP_R2_72(M,D) BOOST_PP_R2_71(M,D) M(71,D)
+#define BOOST_PP_R2_73(M,D) BOOST_PP_R2_72(M,D) M(72,D)
+#define BOOST_PP_R2_74(M,D) BOOST_PP_R2_73(M,D) M(73,D)
+#define BOOST_PP_R2_75(M,D) BOOST_PP_R2_74(M,D) M(74,D)
+#define BOOST_PP_R2_76(M,D) BOOST_PP_R2_75(M,D) M(75,D)
+#define BOOST_PP_R2_77(M,D) BOOST_PP_R2_76(M,D) M(76,D)
+#define BOOST_PP_R2_78(M,D) BOOST_PP_R2_77(M,D) M(77,D)
+#define BOOST_PP_R2_79(M,D) BOOST_PP_R2_78(M,D) M(78,D)
+#define BOOST_PP_R2_80(M,D) BOOST_PP_R2_79(M,D) M(79,D)
+#define BOOST_PP_R2_81(M,D) BOOST_PP_R2_80(M,D) M(80,D)
+#define BOOST_PP_R2_82(M,D) BOOST_PP_R2_81(M,D) M(81,D)
+#define BOOST_PP_R2_83(M,D) BOOST_PP_R2_82(M,D) M(82,D)
+#define BOOST_PP_R2_84(M,D) BOOST_PP_R2_83(M,D) M(83,D)
+#define BOOST_PP_R2_85(M,D) BOOST_PP_R2_84(M,D) M(84,D)
+#define BOOST_PP_R2_86(M,D) BOOST_PP_R2_85(M,D) M(85,D)
+#define BOOST_PP_R2_87(M,D) BOOST_PP_R2_86(M,D) M(86,D)
+#define BOOST_PP_R2_88(M,D) BOOST_PP_R2_87(M,D) M(87,D)
+#define BOOST_PP_R2_89(M,D) BOOST_PP_R2_88(M,D) M(88,D)
+#define BOOST_PP_R2_90(M,D) BOOST_PP_R2_89(M,D) M(89,D)
+#define BOOST_PP_R2_91(M,D) BOOST_PP_R2_90(M,D) M(90,D)
+#define BOOST_PP_R2_92(M,D) BOOST_PP_R2_91(M,D) M(91,D)
+#define BOOST_PP_R2_93(M,D) BOOST_PP_R2_92(M,D) M(92,D)
+#define BOOST_PP_R2_94(M,D) BOOST_PP_R2_93(M,D) M(93,D)
+#define BOOST_PP_R2_95(M,D) BOOST_PP_R2_94(M,D) M(94,D)
+#define BOOST_PP_R2_96(M,D) BOOST_PP_R2_95(M,D) M(95,D)
+#define BOOST_PP_R2_97(M,D) BOOST_PP_R2_96(M,D) M(96,D)
+#define BOOST_PP_R2_98(M,D) BOOST_PP_R2_97(M,D) M(97,D)
+#define BOOST_PP_R2_99(M,D) BOOST_PP_R2_98(M,D) M(98,D)
+#define BOOST_PP_R2_100(M,D) BOOST_PP_R2_99(M,D) M(99,D)
+#define BOOST_PP_R2_101(M,D) BOOST_PP_R2_100(M,D) M(100,D)
+#define BOOST_PP_R2_102(M,D) BOOST_PP_R2_101(M,D) M(101,D)
+#define BOOST_PP_R2_103(M,D) BOOST_PP_R2_102(M,D) M(102,D)
+#define BOOST_PP_R2_104(M,D) BOOST_PP_R2_103(M,D) M(103,D)
+#define BOOST_PP_R2_105(M,D) BOOST_PP_R2_104(M,D) M(104,D)
+#define BOOST_PP_R2_106(M,D) BOOST_PP_R2_105(M,D) M(105,D)
+#define BOOST_PP_R2_107(M,D) BOOST_PP_R2_106(M,D) M(106,D)
+#define BOOST_PP_R2_108(M,D) BOOST_PP_R2_107(M,D) M(107,D)
+#define BOOST_PP_R2_109(M,D) BOOST_PP_R2_108(M,D) M(108,D)
+#define BOOST_PP_R2_110(M,D) BOOST_PP_R2_109(M,D) M(109,D)
+#define BOOST_PP_R2_111(M,D) BOOST_PP_R2_110(M,D) M(110,D)
+#define BOOST_PP_R2_112(M,D) BOOST_PP_R2_111(M,D) M(111,D)
+#define BOOST_PP_R2_113(M,D) BOOST_PP_R2_112(M,D) M(112,D)
+#define BOOST_PP_R2_114(M,D) BOOST_PP_R2_113(M,D) M(113,D)
+#define BOOST_PP_R2_115(M,D) BOOST_PP_R2_114(M,D) M(114,D)
+#define BOOST_PP_R2_116(M,D) BOOST_PP_R2_115(M,D) M(115,D)
+#define BOOST_PP_R2_117(M,D) BOOST_PP_R2_116(M,D) M(116,D)
+#define BOOST_PP_R2_118(M,D) BOOST_PP_R2_117(M,D) M(117,D)
+#define BOOST_PP_R2_119(M,D) BOOST_PP_R2_118(M,D) M(118,D)
+#define BOOST_PP_R2_120(M,D) BOOST_PP_R2_119(M,D) M(119,D)
+#define BOOST_PP_R2_121(M,D) BOOST_PP_R2_120(M,D) M(120,D)
+#define BOOST_PP_R2_122(M,D) BOOST_PP_R2_121(M,D) M(121,D)
+#define BOOST_PP_R2_123(M,D) BOOST_PP_R2_122(M,D) M(122,D)
+#define BOOST_PP_R2_124(M,D) BOOST_PP_R2_123(M,D) M(123,D)
+#define BOOST_PP_R2_125(M,D) BOOST_PP_R2_124(M,D) M(124,D)
+#define BOOST_PP_R2_126(M,D) BOOST_PP_R2_125(M,D) M(125,D)
+#define BOOST_PP_R2_127(M,D) BOOST_PP_R2_126(M,D) M(126,D)
+#define BOOST_PP_R2_128(M,D) BOOST_PP_R2_127(M,D) M(127,D)
+
+#define BOOST_PP_REPEAT_3(C,M,D) BOOST_PP_REPEAT_AUTO_REC3(BOOST_PP_DETAIL_CAT2(BOOST_PP_R3_,C),(M,D))
+#define BOOST_PP_R3_0(M,D)
+#define BOOST_PP_R3_1(M,D) M(0,D)
+#define BOOST_PP_R3_2(M,D) M(0,D) M(1,D)
+#define BOOST_PP_R3_3(M,D) M(0,D) M(1,D) M(2,D)
+#define BOOST_PP_R3_4(M,D) M(0,D) M(1,D) M(2,D) M(3,D)
+#define BOOST_PP_R3_5(M,D) BOOST_PP_R3_4(M,D) M(4,D)
+#define BOOST_PP_R3_6(M,D) BOOST_PP_R3_5(M,D) M(5,D)
+#define BOOST_PP_R3_7(M,D) BOOST_PP_R3_6(M,D) M(6,D)
+#define BOOST_PP_R3_8(M,D) BOOST_PP_R3_7(M,D) M(7,D)
+#define BOOST_PP_R3_9(M,D) BOOST_PP_R3_8(M,D) M(8,D)
+#define BOOST_PP_R3_10(M,D) BOOST_PP_R3_9(M,D) M(9,D)
+#define BOOST_PP_R3_11(M,D) BOOST_PP_R3_10(M,D) M(10,D)
+#define BOOST_PP_R3_12(M,D) BOOST_PP_R3_11(M,D) M(11,D)
+#define BOOST_PP_R3_13(M,D) BOOST_PP_R3_12(M,D) M(12,D)
+#define BOOST_PP_R3_14(M,D) BOOST_PP_R3_13(M,D) M(13,D)
+#define BOOST_PP_R3_15(M,D) BOOST_PP_R3_14(M,D) M(14,D)
+#define BOOST_PP_R3_16(M,D) BOOST_PP_R3_15(M,D) M(15,D)
+#define BOOST_PP_R3_17(M,D) BOOST_PP_R3_16(M,D) M(16,D)
+#define BOOST_PP_R3_18(M,D) BOOST_PP_R3_17(M,D) M(17,D)
+#define BOOST_PP_R3_19(M,D) BOOST_PP_R3_18(M,D) M(18,D)
+#define BOOST_PP_R3_20(M,D) BOOST_PP_R3_19(M,D) M(19,D)
+#define BOOST_PP_R3_21(M,D) BOOST_PP_R3_20(M,D) M(20,D)
+#define BOOST_PP_R3_22(M,D) BOOST_PP_R3_21(M,D) M(21,D)
+#define BOOST_PP_R3_23(M,D) BOOST_PP_R3_22(M,D) M(22,D)
+#define BOOST_PP_R3_24(M,D) BOOST_PP_R3_23(M,D) M(23,D)
+#define BOOST_PP_R3_25(M,D) BOOST_PP_R3_24(M,D) M(24,D)
+#define BOOST_PP_R3_26(M,D) BOOST_PP_R3_25(M,D) M(25,D)
+#define BOOST_PP_R3_27(M,D) BOOST_PP_R3_26(M,D) M(26,D)
+#define BOOST_PP_R3_28(M,D) BOOST_PP_R3_27(M,D) M(27,D)
+#define BOOST_PP_R3_29(M,D) BOOST_PP_R3_28(M,D) M(28,D)
+#define BOOST_PP_R3_30(M,D) BOOST_PP_R3_29(M,D) M(29,D)
+#define BOOST_PP_R3_31(M,D) BOOST_PP_R3_30(M,D) M(30,D)
+#define BOOST_PP_R3_32(M,D) BOOST_PP_R3_31(M,D) M(31,D)
+#define BOOST_PP_R3_33(M,D) BOOST_PP_R3_32(M,D) M(32,D)
+#define BOOST_PP_R3_34(M,D) BOOST_PP_R3_33(M,D) M(33,D)
+#define BOOST_PP_R3_35(M,D) BOOST_PP_R3_34(M,D) M(34,D)
+#define BOOST_PP_R3_36(M,D) BOOST_PP_R3_35(M,D) M(35,D)
+#define BOOST_PP_R3_37(M,D) BOOST_PP_R3_36(M,D) M(36,D)
+#define BOOST_PP_R3_38(M,D) BOOST_PP_R3_37(M,D) M(37,D)
+#define BOOST_PP_R3_39(M,D) BOOST_PP_R3_38(M,D) M(38,D)
+#define BOOST_PP_R3_40(M,D) BOOST_PP_R3_39(M,D) M(39,D)
+#define BOOST_PP_R3_41(M,D) BOOST_PP_R3_40(M,D) M(40,D)
+#define BOOST_PP_R3_42(M,D) BOOST_PP_R3_41(M,D) M(41,D)
+#define BOOST_PP_R3_43(M,D) BOOST_PP_R3_42(M,D) M(42,D)
+#define BOOST_PP_R3_44(M,D) BOOST_PP_R3_43(M,D) M(43,D)
+#define BOOST_PP_R3_45(M,D) BOOST_PP_R3_44(M,D) M(44,D)
+#define BOOST_PP_R3_46(M,D) BOOST_PP_R3_45(M,D) M(45,D)
+#define BOOST_PP_R3_47(M,D) BOOST_PP_R3_46(M,D) M(46,D)
+#define BOOST_PP_R3_48(M,D) BOOST_PP_R3_47(M,D) M(47,D)
+#define BOOST_PP_R3_49(M,D) BOOST_PP_R3_48(M,D) M(48,D)
+#define BOOST_PP_R3_50(M,D) BOOST_PP_R3_49(M,D) M(49,D)
+#define BOOST_PP_R3_51(M,D) BOOST_PP_R3_50(M,D) M(50,D)
+#define BOOST_PP_R3_52(M,D) BOOST_PP_R3_51(M,D) M(51,D)
+#define BOOST_PP_R3_53(M,D) BOOST_PP_R3_52(M,D) M(52,D)
+#define BOOST_PP_R3_54(M,D) BOOST_PP_R3_53(M,D) M(53,D)
+#define BOOST_PP_R3_55(M,D) BOOST_PP_R3_54(M,D) M(54,D)
+#define BOOST_PP_R3_56(M,D) BOOST_PP_R3_55(M,D) M(55,D)
+#define BOOST_PP_R3_57(M,D) BOOST_PP_R3_56(M,D) M(56,D)
+#define BOOST_PP_R3_58(M,D) BOOST_PP_R3_57(M,D) M(57,D)
+#define BOOST_PP_R3_59(M,D) BOOST_PP_R3_58(M,D) M(58,D)
+#define BOOST_PP_R3_60(M,D) BOOST_PP_R3_59(M,D) M(59,D)
+#define BOOST_PP_R3_61(M,D) BOOST_PP_R3_60(M,D) M(60,D)
+#define BOOST_PP_R3_62(M,D) BOOST_PP_R3_61(M,D) M(61,D)
+#define BOOST_PP_R3_63(M,D) BOOST_PP_R3_62(M,D) M(62,D)
+#define BOOST_PP_R3_64(M,D) BOOST_PP_R3_63(M,D) M(63,D)
+#define BOOST_PP_R3_65(M,D) BOOST_PP_R3_64(M,D) M(64,D)
+#define BOOST_PP_R3_66(M,D) BOOST_PP_R3_65(M,D) M(65,D)
+#define BOOST_PP_R3_67(M,D) BOOST_PP_R3_66(M,D) M(66,D)
+#define BOOST_PP_R3_68(M,D) BOOST_PP_R3_67(M,D) M(67,D)
+#define BOOST_PP_R3_69(M,D) BOOST_PP_R3_68(M,D) M(68,D)
+#define BOOST_PP_R3_70(M,D) BOOST_PP_R3_69(M,D) M(69,D)
+#define BOOST_PP_R3_71(M,D) BOOST_PP_R3_70(M,D) M(70,D)
+#define BOOST_PP_R3_72(M,D) BOOST_PP_R3_71(M,D) M(71,D)
+#define BOOST_PP_R3_73(M,D) BOOST_PP_R3_72(M,D) M(72,D)
+#define BOOST_PP_R3_74(M,D) BOOST_PP_R3_73(M,D) M(73,D)
+#define BOOST_PP_R3_75(M,D) BOOST_PP_R3_74(M,D) M(74,D)
+#define BOOST_PP_R3_76(M,D) BOOST_PP_R3_75(M,D) M(75,D)
+#define BOOST_PP_R3_77(M,D) BOOST_PP_R3_76(M,D) M(76,D)
+#define BOOST_PP_R3_78(M,D) BOOST_PP_R3_77(M,D) M(77,D)
+#define BOOST_PP_R3_79(M,D) BOOST_PP_R3_78(M,D) M(78,D)
+#define BOOST_PP_R3_80(M,D) BOOST_PP_R3_79(M,D) M(79,D)
+#define BOOST_PP_R3_81(M,D) BOOST_PP_R3_80(M,D) M(80,D)
+#define BOOST_PP_R3_82(M,D) BOOST_PP_R3_81(M,D) M(81,D)
+#define BOOST_PP_R3_83(M,D) BOOST_PP_R3_82(M,D) M(82,D)
+#define BOOST_PP_R3_84(M,D) BOOST_PP_R3_83(M,D) M(83,D)
+#define BOOST_PP_R3_85(M,D) BOOST_PP_R3_84(M,D) M(84,D)
+#define BOOST_PP_R3_86(M,D) BOOST_PP_R3_85(M,D) M(85,D)
+#define BOOST_PP_R3_87(M,D) BOOST_PP_R3_86(M,D) M(86,D)
+#define BOOST_PP_R3_88(M,D) BOOST_PP_R3_87(M,D) M(87,D)
+#define BOOST_PP_R3_89(M,D) BOOST_PP_R3_88(M,D) M(88,D)
+#define BOOST_PP_R3_90(M,D) BOOST_PP_R3_89(M,D) M(89,D)
+#define BOOST_PP_R3_91(M,D) BOOST_PP_R3_90(M,D) M(90,D)
+#define BOOST_PP_R3_92(M,D) BOOST_PP_R3_91(M,D) M(91,D)
+#define BOOST_PP_R3_93(M,D) BOOST_PP_R3_92(M,D) M(92,D)
+#define BOOST_PP_R3_94(M,D) BOOST_PP_R3_93(M,D) M(93,D)
+#define BOOST_PP_R3_95(M,D) BOOST_PP_R3_94(M,D) M(94,D)
+#define BOOST_PP_R3_96(M,D) BOOST_PP_R3_95(M,D) M(95,D)
+#define BOOST_PP_R3_97(M,D) BOOST_PP_R3_96(M,D) M(96,D)
+#define BOOST_PP_R3_98(M,D) BOOST_PP_R3_97(M,D) M(97,D)
+#define BOOST_PP_R3_99(M,D) BOOST_PP_R3_98(M,D) M(98,D)
+#define BOOST_PP_R3_100(M,D) BOOST_PP_R3_99(M,D) M(99,D)
+#define BOOST_PP_R3_101(M,D) BOOST_PP_R3_100(M,D) M(100,D)
+#define BOOST_PP_R3_102(M,D) BOOST_PP_R3_101(M,D) M(101,D)
+#define BOOST_PP_R3_103(M,D) BOOST_PP_R3_102(M,D) M(102,D)
+#define BOOST_PP_R3_104(M,D) BOOST_PP_R3_103(M,D) M(103,D)
+#define BOOST_PP_R3_105(M,D) BOOST_PP_R3_104(M,D) M(104,D)
+#define BOOST_PP_R3_106(M,D) BOOST_PP_R3_105(M,D) M(105,D)
+#define BOOST_PP_R3_107(M,D) BOOST_PP_R3_106(M,D) M(106,D)
+#define BOOST_PP_R3_108(M,D) BOOST_PP_R3_107(M,D) M(107,D)
+#define BOOST_PP_R3_109(M,D) BOOST_PP_R3_108(M,D) M(108,D)
+#define BOOST_PP_R3_110(M,D) BOOST_PP_R3_109(M,D) M(109,D)
+#define BOOST_PP_R3_111(M,D) BOOST_PP_R3_110(M,D) M(110,D)
+#define BOOST_PP_R3_112(M,D) BOOST_PP_R3_111(M,D) M(111,D)
+#define BOOST_PP_R3_113(M,D) BOOST_PP_R3_112(M,D) M(112,D)
+#define BOOST_PP_R3_114(M,D) BOOST_PP_R3_113(M,D) M(113,D)
+#define BOOST_PP_R3_115(M,D) BOOST_PP_R3_114(M,D) M(114,D)
+#define BOOST_PP_R3_116(M,D) BOOST_PP_R3_115(M,D) M(115,D)
+#define BOOST_PP_R3_117(M,D) BOOST_PP_R3_116(M,D) M(116,D)
+#define BOOST_PP_R3_118(M,D) BOOST_PP_R3_117(M,D) M(117,D)
+#define BOOST_PP_R3_119(M,D) BOOST_PP_R3_118(M,D) M(118,D)
+#define BOOST_PP_R3_120(M,D) BOOST_PP_R3_119(M,D) M(119,D)
+#define BOOST_PP_R3_121(M,D) BOOST_PP_R3_120(M,D) M(120,D)
+#define BOOST_PP_R3_122(M,D) BOOST_PP_R3_121(M,D) M(121,D)
+#define BOOST_PP_R3_123(M,D) BOOST_PP_R3_122(M,D) M(122,D)
+#define BOOST_PP_R3_124(M,D) BOOST_PP_R3_123(M,D) M(123,D)
+#define BOOST_PP_R3_125(M,D) BOOST_PP_R3_124(M,D) M(124,D)
+#define BOOST_PP_R3_126(M,D) BOOST_PP_R3_125(M,D) M(125,D)
+#define BOOST_PP_R3_127(M,D) BOOST_PP_R3_126(M,D) M(126,D)
+#define BOOST_PP_R3_128(M,D) BOOST_PP_R3_127(M,D) M(127,D)
+
+/** <p>Obsolete, just use BOOST_PP_REPEAT().</p> */
+#define BOOST_PP_REPEAT_2ND BOOST_PP_REPEAT
+/** <p>Obsolete, just use BOOST_PP_REPEAT().</p> */
+#define BOOST_PP_REPEAT_3RD BOOST_PP_REPEAT
#endif
* See http://www.boost.org for most recent version.
*/
-/** <p>Same as BOOST_PP_REPEAT(), but implemented independently.</p>
+/** <p>This header is obsolete. Use the following code instead.</p>
-<h3>Test</h3>
-<ul>
- <li><a href="../../test/repeat_2nd_test.cpp">repeat_2nd_test.cpp</a></li>
-</ul>
+<pre>
+#include <boost/preprocessor/repeat.hpp>
+</pre>
*/
-#define BOOST_PP_REPEAT_2ND(COUNT,MACRO,DATA) BOOST_PP_REPEAT_2ND_DELAY(COUNT)(MACRO,DATA)
-#define BOOST_PP_REPEAT_2ND_DELAY(C) BOOST_PP_REPEAT_2ND##C
-#define BOOST_PP_REPEAT_2ND0(M,D)
-#define BOOST_PP_REPEAT_2ND1(M,D) M(0,D)
-#define BOOST_PP_REPEAT_2ND2(M,D) M(0,D) M(1,D)
-#define BOOST_PP_REPEAT_2ND3(M,D) M(0,D) M(1,D) M(2,D)
-#define BOOST_PP_REPEAT_2ND4(M,D) M(0,D) M(1,D) M(2,D) M(3,D)
-#define BOOST_PP_REPEAT_2ND5(M,D) BOOST_PP_REPEAT_2ND4(M,D) M(4,D)
-#define BOOST_PP_REPEAT_2ND6(M,D) BOOST_PP_REPEAT_2ND5(M,D) M(5,D)
-#define BOOST_PP_REPEAT_2ND7(M,D) BOOST_PP_REPEAT_2ND6(M,D) M(6,D)
-#define BOOST_PP_REPEAT_2ND8(M,D) BOOST_PP_REPEAT_2ND7(M,D) M(7,D)
-#define BOOST_PP_REPEAT_2ND9(M,D) BOOST_PP_REPEAT_2ND8(M,D) M(8,D)
-#define BOOST_PP_REPEAT_2ND10(M,D) BOOST_PP_REPEAT_2ND9(M,D) M(9,D)
-#define BOOST_PP_REPEAT_2ND11(M,D) BOOST_PP_REPEAT_2ND10(M,D) M(10,D)
-#define BOOST_PP_REPEAT_2ND12(M,D) BOOST_PP_REPEAT_2ND11(M,D) M(11,D)
-#define BOOST_PP_REPEAT_2ND13(M,D) BOOST_PP_REPEAT_2ND12(M,D) M(12,D)
-#define BOOST_PP_REPEAT_2ND14(M,D) BOOST_PP_REPEAT_2ND13(M,D) M(13,D)
-#define BOOST_PP_REPEAT_2ND15(M,D) BOOST_PP_REPEAT_2ND14(M,D) M(14,D)
-#define BOOST_PP_REPEAT_2ND16(M,D) BOOST_PP_REPEAT_2ND15(M,D) M(15,D)
-#define BOOST_PP_REPEAT_2ND17(M,D) BOOST_PP_REPEAT_2ND16(M,D) M(16,D)
-#define BOOST_PP_REPEAT_2ND18(M,D) BOOST_PP_REPEAT_2ND17(M,D) M(17,D)
-#define BOOST_PP_REPEAT_2ND19(M,D) BOOST_PP_REPEAT_2ND18(M,D) M(18,D)
-#define BOOST_PP_REPEAT_2ND20(M,D) BOOST_PP_REPEAT_2ND19(M,D) M(19,D)
-#define BOOST_PP_REPEAT_2ND21(M,D) BOOST_PP_REPEAT_2ND20(M,D) M(20,D)
-#define BOOST_PP_REPEAT_2ND22(M,D) BOOST_PP_REPEAT_2ND21(M,D) M(21,D)
-#define BOOST_PP_REPEAT_2ND23(M,D) BOOST_PP_REPEAT_2ND22(M,D) M(22,D)
-#define BOOST_PP_REPEAT_2ND24(M,D) BOOST_PP_REPEAT_2ND23(M,D) M(23,D)
-#define BOOST_PP_REPEAT_2ND25(M,D) BOOST_PP_REPEAT_2ND24(M,D) M(24,D)
-#define BOOST_PP_REPEAT_2ND26(M,D) BOOST_PP_REPEAT_2ND25(M,D) M(25,D)
-#define BOOST_PP_REPEAT_2ND27(M,D) BOOST_PP_REPEAT_2ND26(M,D) M(26,D)
-#define BOOST_PP_REPEAT_2ND28(M,D) BOOST_PP_REPEAT_2ND27(M,D) M(27,D)
-#define BOOST_PP_REPEAT_2ND29(M,D) BOOST_PP_REPEAT_2ND28(M,D) M(28,D)
-#define BOOST_PP_REPEAT_2ND30(M,D) BOOST_PP_REPEAT_2ND29(M,D) M(29,D)
-#define BOOST_PP_REPEAT_2ND31(M,D) BOOST_PP_REPEAT_2ND30(M,D) M(30,D)
-#define BOOST_PP_REPEAT_2ND32(M,D) BOOST_PP_REPEAT_2ND31(M,D) M(31,D)
-#define BOOST_PP_REPEAT_2ND33(M,D) BOOST_PP_REPEAT_2ND32(M,D) M(32,D)
-#define BOOST_PP_REPEAT_2ND34(M,D) BOOST_PP_REPEAT_2ND33(M,D) M(33,D)
-#define BOOST_PP_REPEAT_2ND35(M,D) BOOST_PP_REPEAT_2ND34(M,D) M(34,D)
-#define BOOST_PP_REPEAT_2ND36(M,D) BOOST_PP_REPEAT_2ND35(M,D) M(35,D)
-#define BOOST_PP_REPEAT_2ND37(M,D) BOOST_PP_REPEAT_2ND36(M,D) M(36,D)
-#define BOOST_PP_REPEAT_2ND38(M,D) BOOST_PP_REPEAT_2ND37(M,D) M(37,D)
-#define BOOST_PP_REPEAT_2ND39(M,D) BOOST_PP_REPEAT_2ND38(M,D) M(38,D)
-#define BOOST_PP_REPEAT_2ND40(M,D) BOOST_PP_REPEAT_2ND39(M,D) M(39,D)
-#define BOOST_PP_REPEAT_2ND41(M,D) BOOST_PP_REPEAT_2ND40(M,D) M(40,D)
-#define BOOST_PP_REPEAT_2ND42(M,D) BOOST_PP_REPEAT_2ND41(M,D) M(41,D)
-#define BOOST_PP_REPEAT_2ND43(M,D) BOOST_PP_REPEAT_2ND42(M,D) M(42,D)
-#define BOOST_PP_REPEAT_2ND44(M,D) BOOST_PP_REPEAT_2ND43(M,D) M(43,D)
-#define BOOST_PP_REPEAT_2ND45(M,D) BOOST_PP_REPEAT_2ND44(M,D) M(44,D)
-#define BOOST_PP_REPEAT_2ND46(M,D) BOOST_PP_REPEAT_2ND45(M,D) M(45,D)
-#define BOOST_PP_REPEAT_2ND47(M,D) BOOST_PP_REPEAT_2ND46(M,D) M(46,D)
-#define BOOST_PP_REPEAT_2ND48(M,D) BOOST_PP_REPEAT_2ND47(M,D) M(47,D)
-#define BOOST_PP_REPEAT_2ND49(M,D) BOOST_PP_REPEAT_2ND48(M,D) M(48,D)
-#define BOOST_PP_REPEAT_2ND50(M,D) BOOST_PP_REPEAT_2ND49(M,D) M(49,D)
-#define BOOST_PP_REPEAT_2ND51(M,D) BOOST_PP_REPEAT_2ND50(M,D) M(50,D)
-#define BOOST_PP_REPEAT_2ND52(M,D) BOOST_PP_REPEAT_2ND51(M,D) M(51,D)
-#define BOOST_PP_REPEAT_2ND53(M,D) BOOST_PP_REPEAT_2ND52(M,D) M(52,D)
-#define BOOST_PP_REPEAT_2ND54(M,D) BOOST_PP_REPEAT_2ND53(M,D) M(53,D)
-#define BOOST_PP_REPEAT_2ND55(M,D) BOOST_PP_REPEAT_2ND54(M,D) M(54,D)
-#define BOOST_PP_REPEAT_2ND56(M,D) BOOST_PP_REPEAT_2ND55(M,D) M(55,D)
-#define BOOST_PP_REPEAT_2ND57(M,D) BOOST_PP_REPEAT_2ND56(M,D) M(56,D)
-#define BOOST_PP_REPEAT_2ND58(M,D) BOOST_PP_REPEAT_2ND57(M,D) M(57,D)
-#define BOOST_PP_REPEAT_2ND59(M,D) BOOST_PP_REPEAT_2ND58(M,D) M(58,D)
-#define BOOST_PP_REPEAT_2ND60(M,D) BOOST_PP_REPEAT_2ND59(M,D) M(59,D)
-#define BOOST_PP_REPEAT_2ND61(M,D) BOOST_PP_REPEAT_2ND60(M,D) M(60,D)
-#define BOOST_PP_REPEAT_2ND62(M,D) BOOST_PP_REPEAT_2ND61(M,D) M(61,D)
-#define BOOST_PP_REPEAT_2ND63(M,D) BOOST_PP_REPEAT_2ND62(M,D) M(62,D)
-#define BOOST_PP_REPEAT_2ND64(M,D) BOOST_PP_REPEAT_2ND63(M,D) M(63,D)
-#define BOOST_PP_REPEAT_2ND65(M,D) BOOST_PP_REPEAT_2ND64(M,D) M(64,D)
-#define BOOST_PP_REPEAT_2ND66(M,D) BOOST_PP_REPEAT_2ND65(M,D) M(65,D)
-#define BOOST_PP_REPEAT_2ND67(M,D) BOOST_PP_REPEAT_2ND66(M,D) M(66,D)
-#define BOOST_PP_REPEAT_2ND68(M,D) BOOST_PP_REPEAT_2ND67(M,D) M(67,D)
-#define BOOST_PP_REPEAT_2ND69(M,D) BOOST_PP_REPEAT_2ND68(M,D) M(68,D)
-#define BOOST_PP_REPEAT_2ND70(M,D) BOOST_PP_REPEAT_2ND69(M,D) M(69,D)
-#define BOOST_PP_REPEAT_2ND71(M,D) BOOST_PP_REPEAT_2ND70(M,D) M(70,D)
-#define BOOST_PP_REPEAT_2ND72(M,D) BOOST_PP_REPEAT_2ND71(M,D) M(71,D)
-#define BOOST_PP_REPEAT_2ND73(M,D) BOOST_PP_REPEAT_2ND72(M,D) M(72,D)
-#define BOOST_PP_REPEAT_2ND74(M,D) BOOST_PP_REPEAT_2ND73(M,D) M(73,D)
-#define BOOST_PP_REPEAT_2ND75(M,D) BOOST_PP_REPEAT_2ND74(M,D) M(74,D)
-#define BOOST_PP_REPEAT_2ND76(M,D) BOOST_PP_REPEAT_2ND75(M,D) M(75,D)
-#define BOOST_PP_REPEAT_2ND77(M,D) BOOST_PP_REPEAT_2ND76(M,D) M(76,D)
-#define BOOST_PP_REPEAT_2ND78(M,D) BOOST_PP_REPEAT_2ND77(M,D) M(77,D)
-#define BOOST_PP_REPEAT_2ND79(M,D) BOOST_PP_REPEAT_2ND78(M,D) M(78,D)
-#define BOOST_PP_REPEAT_2ND80(M,D) BOOST_PP_REPEAT_2ND79(M,D) M(79,D)
-#define BOOST_PP_REPEAT_2ND81(M,D) BOOST_PP_REPEAT_2ND80(M,D) M(80,D)
-#define BOOST_PP_REPEAT_2ND82(M,D) BOOST_PP_REPEAT_2ND81(M,D) M(81,D)
-#define BOOST_PP_REPEAT_2ND83(M,D) BOOST_PP_REPEAT_2ND82(M,D) M(82,D)
-#define BOOST_PP_REPEAT_2ND84(M,D) BOOST_PP_REPEAT_2ND83(M,D) M(83,D)
-#define BOOST_PP_REPEAT_2ND85(M,D) BOOST_PP_REPEAT_2ND84(M,D) M(84,D)
-#define BOOST_PP_REPEAT_2ND86(M,D) BOOST_PP_REPEAT_2ND85(M,D) M(85,D)
-#define BOOST_PP_REPEAT_2ND87(M,D) BOOST_PP_REPEAT_2ND86(M,D) M(86,D)
-#define BOOST_PP_REPEAT_2ND88(M,D) BOOST_PP_REPEAT_2ND87(M,D) M(87,D)
-#define BOOST_PP_REPEAT_2ND89(M,D) BOOST_PP_REPEAT_2ND88(M,D) M(88,D)
-#define BOOST_PP_REPEAT_2ND90(M,D) BOOST_PP_REPEAT_2ND89(M,D) M(89,D)
-#define BOOST_PP_REPEAT_2ND91(M,D) BOOST_PP_REPEAT_2ND90(M,D) M(90,D)
-#define BOOST_PP_REPEAT_2ND92(M,D) BOOST_PP_REPEAT_2ND91(M,D) M(91,D)
-#define BOOST_PP_REPEAT_2ND93(M,D) BOOST_PP_REPEAT_2ND92(M,D) M(92,D)
-#define BOOST_PP_REPEAT_2ND94(M,D) BOOST_PP_REPEAT_2ND93(M,D) M(93,D)
-#define BOOST_PP_REPEAT_2ND95(M,D) BOOST_PP_REPEAT_2ND94(M,D) M(94,D)
-#define BOOST_PP_REPEAT_2ND96(M,D) BOOST_PP_REPEAT_2ND95(M,D) M(95,D)
-#define BOOST_PP_REPEAT_2ND97(M,D) BOOST_PP_REPEAT_2ND96(M,D) M(96,D)
-#define BOOST_PP_REPEAT_2ND98(M,D) BOOST_PP_REPEAT_2ND97(M,D) M(97,D)
-#define BOOST_PP_REPEAT_2ND99(M,D) BOOST_PP_REPEAT_2ND98(M,D) M(98,D)
-#define BOOST_PP_REPEAT_2ND100(M,D) BOOST_PP_REPEAT_2ND99(M,D) M(99,D)
-#define BOOST_PP_REPEAT_2ND101(M,D) BOOST_PP_REPEAT_2ND100(M,D) M(100,D)
-#define BOOST_PP_REPEAT_2ND102(M,D) BOOST_PP_REPEAT_2ND101(M,D) M(101,D)
-#define BOOST_PP_REPEAT_2ND103(M,D) BOOST_PP_REPEAT_2ND102(M,D) M(102,D)
-#define BOOST_PP_REPEAT_2ND104(M,D) BOOST_PP_REPEAT_2ND103(M,D) M(103,D)
-#define BOOST_PP_REPEAT_2ND105(M,D) BOOST_PP_REPEAT_2ND104(M,D) M(104,D)
-#define BOOST_PP_REPEAT_2ND106(M,D) BOOST_PP_REPEAT_2ND105(M,D) M(105,D)
-#define BOOST_PP_REPEAT_2ND107(M,D) BOOST_PP_REPEAT_2ND106(M,D) M(106,D)
-#define BOOST_PP_REPEAT_2ND108(M,D) BOOST_PP_REPEAT_2ND107(M,D) M(107,D)
-#define BOOST_PP_REPEAT_2ND109(M,D) BOOST_PP_REPEAT_2ND108(M,D) M(108,D)
-#define BOOST_PP_REPEAT_2ND110(M,D) BOOST_PP_REPEAT_2ND109(M,D) M(109,D)
-#define BOOST_PP_REPEAT_2ND111(M,D) BOOST_PP_REPEAT_2ND110(M,D) M(110,D)
-#define BOOST_PP_REPEAT_2ND112(M,D) BOOST_PP_REPEAT_2ND111(M,D) M(111,D)
-#define BOOST_PP_REPEAT_2ND113(M,D) BOOST_PP_REPEAT_2ND112(M,D) M(112,D)
-#define BOOST_PP_REPEAT_2ND114(M,D) BOOST_PP_REPEAT_2ND113(M,D) M(113,D)
-#define BOOST_PP_REPEAT_2ND115(M,D) BOOST_PP_REPEAT_2ND114(M,D) M(114,D)
-#define BOOST_PP_REPEAT_2ND116(M,D) BOOST_PP_REPEAT_2ND115(M,D) M(115,D)
-#define BOOST_PP_REPEAT_2ND117(M,D) BOOST_PP_REPEAT_2ND116(M,D) M(116,D)
-#define BOOST_PP_REPEAT_2ND118(M,D) BOOST_PP_REPEAT_2ND117(M,D) M(117,D)
-#define BOOST_PP_REPEAT_2ND119(M,D) BOOST_PP_REPEAT_2ND118(M,D) M(118,D)
-#define BOOST_PP_REPEAT_2ND120(M,D) BOOST_PP_REPEAT_2ND119(M,D) M(119,D)
-#define BOOST_PP_REPEAT_2ND121(M,D) BOOST_PP_REPEAT_2ND120(M,D) M(120,D)
-#define BOOST_PP_REPEAT_2ND122(M,D) BOOST_PP_REPEAT_2ND121(M,D) M(121,D)
-#define BOOST_PP_REPEAT_2ND123(M,D) BOOST_PP_REPEAT_2ND122(M,D) M(122,D)
-#define BOOST_PP_REPEAT_2ND124(M,D) BOOST_PP_REPEAT_2ND123(M,D) M(123,D)
-#define BOOST_PP_REPEAT_2ND125(M,D) BOOST_PP_REPEAT_2ND124(M,D) M(124,D)
-#define BOOST_PP_REPEAT_2ND126(M,D) BOOST_PP_REPEAT_2ND125(M,D) M(125,D)
-#define BOOST_PP_REPEAT_2ND127(M,D) BOOST_PP_REPEAT_2ND126(M,D) M(126,D)
-#define BOOST_PP_REPEAT_2ND128(M,D) BOOST_PP_REPEAT_2ND127(M,D) M(127,D)
-
-/* <p>Obsolete. Use BOOST_PP_REPEAT_2ND().</p> */
-#define BOOST_PREPROCESSOR_REPEAT_2ND(C,M,D) BOOST_PP_REPEAT_2ND(C,M,D)
+#include <boost/preprocessor/repeat.hpp>
#endif
* See http://www.boost.org for most recent version.
*/
-/** <p>Same as BOOST_PP_REPEAT(), but implemented independently.</p> */
-#define BOOST_PP_REPEAT_3RD(COUNT,MACRO,DATA) BOOST_PP_REPEAT_3RD_DELAY(COUNT)(MACRO,DATA)
+/** <p>This header is obsolete. Use the following code instead.</p>
-#define BOOST_PP_REPEAT_3RD_DELAY(C) BOOST_PP_REPEAT_3RD##C
-#define BOOST_PP_REPEAT_3RD0(M,D)
-#define BOOST_PP_REPEAT_3RD1(M,D) M(0,D)
-#define BOOST_PP_REPEAT_3RD2(M,D) M(0,D) M(1,D)
-#define BOOST_PP_REPEAT_3RD3(M,D) M(0,D) M(1,D) M(2,D)
-#define BOOST_PP_REPEAT_3RD4(M,D) M(0,D) M(1,D) M(2,D) M(3,D)
-#define BOOST_PP_REPEAT_3RD5(M,D) BOOST_PP_REPEAT_3RD4(M,D) M(4,D)
-#define BOOST_PP_REPEAT_3RD6(M,D) BOOST_PP_REPEAT_3RD5(M,D) M(5,D)
-#define BOOST_PP_REPEAT_3RD7(M,D) BOOST_PP_REPEAT_3RD6(M,D) M(6,D)
-#define BOOST_PP_REPEAT_3RD8(M,D) BOOST_PP_REPEAT_3RD7(M,D) M(7,D)
-#define BOOST_PP_REPEAT_3RD9(M,D) BOOST_PP_REPEAT_3RD8(M,D) M(8,D)
-#define BOOST_PP_REPEAT_3RD10(M,D) BOOST_PP_REPEAT_3RD9(M,D) M(9,D)
-#define BOOST_PP_REPEAT_3RD11(M,D) BOOST_PP_REPEAT_3RD10(M,D) M(10,D)
-#define BOOST_PP_REPEAT_3RD12(M,D) BOOST_PP_REPEAT_3RD11(M,D) M(11,D)
-#define BOOST_PP_REPEAT_3RD13(M,D) BOOST_PP_REPEAT_3RD12(M,D) M(12,D)
-#define BOOST_PP_REPEAT_3RD14(M,D) BOOST_PP_REPEAT_3RD13(M,D) M(13,D)
-#define BOOST_PP_REPEAT_3RD15(M,D) BOOST_PP_REPEAT_3RD14(M,D) M(14,D)
-#define BOOST_PP_REPEAT_3RD16(M,D) BOOST_PP_REPEAT_3RD15(M,D) M(15,D)
-#define BOOST_PP_REPEAT_3RD17(M,D) BOOST_PP_REPEAT_3RD16(M,D) M(16,D)
-#define BOOST_PP_REPEAT_3RD18(M,D) BOOST_PP_REPEAT_3RD17(M,D) M(17,D)
-#define BOOST_PP_REPEAT_3RD19(M,D) BOOST_PP_REPEAT_3RD18(M,D) M(18,D)
-#define BOOST_PP_REPEAT_3RD20(M,D) BOOST_PP_REPEAT_3RD19(M,D) M(19,D)
-#define BOOST_PP_REPEAT_3RD21(M,D) BOOST_PP_REPEAT_3RD20(M,D) M(20,D)
-#define BOOST_PP_REPEAT_3RD22(M,D) BOOST_PP_REPEAT_3RD21(M,D) M(21,D)
-#define BOOST_PP_REPEAT_3RD23(M,D) BOOST_PP_REPEAT_3RD22(M,D) M(22,D)
-#define BOOST_PP_REPEAT_3RD24(M,D) BOOST_PP_REPEAT_3RD23(M,D) M(23,D)
-#define BOOST_PP_REPEAT_3RD25(M,D) BOOST_PP_REPEAT_3RD24(M,D) M(24,D)
-#define BOOST_PP_REPEAT_3RD26(M,D) BOOST_PP_REPEAT_3RD25(M,D) M(25,D)
-#define BOOST_PP_REPEAT_3RD27(M,D) BOOST_PP_REPEAT_3RD26(M,D) M(26,D)
-#define BOOST_PP_REPEAT_3RD28(M,D) BOOST_PP_REPEAT_3RD27(M,D) M(27,D)
-#define BOOST_PP_REPEAT_3RD29(M,D) BOOST_PP_REPEAT_3RD28(M,D) M(28,D)
-#define BOOST_PP_REPEAT_3RD30(M,D) BOOST_PP_REPEAT_3RD29(M,D) M(29,D)
-#define BOOST_PP_REPEAT_3RD31(M,D) BOOST_PP_REPEAT_3RD30(M,D) M(30,D)
-#define BOOST_PP_REPEAT_3RD32(M,D) BOOST_PP_REPEAT_3RD31(M,D) M(31,D)
-#define BOOST_PP_REPEAT_3RD33(M,D) BOOST_PP_REPEAT_3RD32(M,D) M(32,D)
-#define BOOST_PP_REPEAT_3RD34(M,D) BOOST_PP_REPEAT_3RD33(M,D) M(33,D)
-#define BOOST_PP_REPEAT_3RD35(M,D) BOOST_PP_REPEAT_3RD34(M,D) M(34,D)
-#define BOOST_PP_REPEAT_3RD36(M,D) BOOST_PP_REPEAT_3RD35(M,D) M(35,D)
-#define BOOST_PP_REPEAT_3RD37(M,D) BOOST_PP_REPEAT_3RD36(M,D) M(36,D)
-#define BOOST_PP_REPEAT_3RD38(M,D) BOOST_PP_REPEAT_3RD37(M,D) M(37,D)
-#define BOOST_PP_REPEAT_3RD39(M,D) BOOST_PP_REPEAT_3RD38(M,D) M(38,D)
-#define BOOST_PP_REPEAT_3RD40(M,D) BOOST_PP_REPEAT_3RD39(M,D) M(39,D)
-#define BOOST_PP_REPEAT_3RD41(M,D) BOOST_PP_REPEAT_3RD40(M,D) M(40,D)
-#define BOOST_PP_REPEAT_3RD42(M,D) BOOST_PP_REPEAT_3RD41(M,D) M(41,D)
-#define BOOST_PP_REPEAT_3RD43(M,D) BOOST_PP_REPEAT_3RD42(M,D) M(42,D)
-#define BOOST_PP_REPEAT_3RD44(M,D) BOOST_PP_REPEAT_3RD43(M,D) M(43,D)
-#define BOOST_PP_REPEAT_3RD45(M,D) BOOST_PP_REPEAT_3RD44(M,D) M(44,D)
-#define BOOST_PP_REPEAT_3RD46(M,D) BOOST_PP_REPEAT_3RD45(M,D) M(45,D)
-#define BOOST_PP_REPEAT_3RD47(M,D) BOOST_PP_REPEAT_3RD46(M,D) M(46,D)
-#define BOOST_PP_REPEAT_3RD48(M,D) BOOST_PP_REPEAT_3RD47(M,D) M(47,D)
-#define BOOST_PP_REPEAT_3RD49(M,D) BOOST_PP_REPEAT_3RD48(M,D) M(48,D)
-#define BOOST_PP_REPEAT_3RD50(M,D) BOOST_PP_REPEAT_3RD49(M,D) M(49,D)
-#define BOOST_PP_REPEAT_3RD51(M,D) BOOST_PP_REPEAT_3RD50(M,D) M(50,D)
-#define BOOST_PP_REPEAT_3RD52(M,D) BOOST_PP_REPEAT_3RD51(M,D) M(51,D)
-#define BOOST_PP_REPEAT_3RD53(M,D) BOOST_PP_REPEAT_3RD52(M,D) M(52,D)
-#define BOOST_PP_REPEAT_3RD54(M,D) BOOST_PP_REPEAT_3RD53(M,D) M(53,D)
-#define BOOST_PP_REPEAT_3RD55(M,D) BOOST_PP_REPEAT_3RD54(M,D) M(54,D)
-#define BOOST_PP_REPEAT_3RD56(M,D) BOOST_PP_REPEAT_3RD55(M,D) M(55,D)
-#define BOOST_PP_REPEAT_3RD57(M,D) BOOST_PP_REPEAT_3RD56(M,D) M(56,D)
-#define BOOST_PP_REPEAT_3RD58(M,D) BOOST_PP_REPEAT_3RD57(M,D) M(57,D)
-#define BOOST_PP_REPEAT_3RD59(M,D) BOOST_PP_REPEAT_3RD58(M,D) M(58,D)
-#define BOOST_PP_REPEAT_3RD60(M,D) BOOST_PP_REPEAT_3RD59(M,D) M(59,D)
-#define BOOST_PP_REPEAT_3RD61(M,D) BOOST_PP_REPEAT_3RD60(M,D) M(60,D)
-#define BOOST_PP_REPEAT_3RD62(M,D) BOOST_PP_REPEAT_3RD61(M,D) M(61,D)
-#define BOOST_PP_REPEAT_3RD63(M,D) BOOST_PP_REPEAT_3RD62(M,D) M(62,D)
-#define BOOST_PP_REPEAT_3RD64(M,D) BOOST_PP_REPEAT_3RD63(M,D) M(63,D)
-#define BOOST_PP_REPEAT_3RD65(M,D) BOOST_PP_REPEAT_3RD64(M,D) M(64,D)
-#define BOOST_PP_REPEAT_3RD66(M,D) BOOST_PP_REPEAT_3RD65(M,D) M(65,D)
-#define BOOST_PP_REPEAT_3RD67(M,D) BOOST_PP_REPEAT_3RD66(M,D) M(66,D)
-#define BOOST_PP_REPEAT_3RD68(M,D) BOOST_PP_REPEAT_3RD67(M,D) M(67,D)
-#define BOOST_PP_REPEAT_3RD69(M,D) BOOST_PP_REPEAT_3RD68(M,D) M(68,D)
-#define BOOST_PP_REPEAT_3RD70(M,D) BOOST_PP_REPEAT_3RD69(M,D) M(69,D)
-#define BOOST_PP_REPEAT_3RD71(M,D) BOOST_PP_REPEAT_3RD70(M,D) M(70,D)
-#define BOOST_PP_REPEAT_3RD72(M,D) BOOST_PP_REPEAT_3RD71(M,D) M(71,D)
-#define BOOST_PP_REPEAT_3RD73(M,D) BOOST_PP_REPEAT_3RD72(M,D) M(72,D)
-#define BOOST_PP_REPEAT_3RD74(M,D) BOOST_PP_REPEAT_3RD73(M,D) M(73,D)
-#define BOOST_PP_REPEAT_3RD75(M,D) BOOST_PP_REPEAT_3RD74(M,D) M(74,D)
-#define BOOST_PP_REPEAT_3RD76(M,D) BOOST_PP_REPEAT_3RD75(M,D) M(75,D)
-#define BOOST_PP_REPEAT_3RD77(M,D) BOOST_PP_REPEAT_3RD76(M,D) M(76,D)
-#define BOOST_PP_REPEAT_3RD78(M,D) BOOST_PP_REPEAT_3RD77(M,D) M(77,D)
-#define BOOST_PP_REPEAT_3RD79(M,D) BOOST_PP_REPEAT_3RD78(M,D) M(78,D)
-#define BOOST_PP_REPEAT_3RD80(M,D) BOOST_PP_REPEAT_3RD79(M,D) M(79,D)
-#define BOOST_PP_REPEAT_3RD81(M,D) BOOST_PP_REPEAT_3RD80(M,D) M(80,D)
-#define BOOST_PP_REPEAT_3RD82(M,D) BOOST_PP_REPEAT_3RD81(M,D) M(81,D)
-#define BOOST_PP_REPEAT_3RD83(M,D) BOOST_PP_REPEAT_3RD82(M,D) M(82,D)
-#define BOOST_PP_REPEAT_3RD84(M,D) BOOST_PP_REPEAT_3RD83(M,D) M(83,D)
-#define BOOST_PP_REPEAT_3RD85(M,D) BOOST_PP_REPEAT_3RD84(M,D) M(84,D)
-#define BOOST_PP_REPEAT_3RD86(M,D) BOOST_PP_REPEAT_3RD85(M,D) M(85,D)
-#define BOOST_PP_REPEAT_3RD87(M,D) BOOST_PP_REPEAT_3RD86(M,D) M(86,D)
-#define BOOST_PP_REPEAT_3RD88(M,D) BOOST_PP_REPEAT_3RD87(M,D) M(87,D)
-#define BOOST_PP_REPEAT_3RD89(M,D) BOOST_PP_REPEAT_3RD88(M,D) M(88,D)
-#define BOOST_PP_REPEAT_3RD90(M,D) BOOST_PP_REPEAT_3RD89(M,D) M(89,D)
-#define BOOST_PP_REPEAT_3RD91(M,D) BOOST_PP_REPEAT_3RD90(M,D) M(90,D)
-#define BOOST_PP_REPEAT_3RD92(M,D) BOOST_PP_REPEAT_3RD91(M,D) M(91,D)
-#define BOOST_PP_REPEAT_3RD93(M,D) BOOST_PP_REPEAT_3RD92(M,D) M(92,D)
-#define BOOST_PP_REPEAT_3RD94(M,D) BOOST_PP_REPEAT_3RD93(M,D) M(93,D)
-#define BOOST_PP_REPEAT_3RD95(M,D) BOOST_PP_REPEAT_3RD94(M,D) M(94,D)
-#define BOOST_PP_REPEAT_3RD96(M,D) BOOST_PP_REPEAT_3RD95(M,D) M(95,D)
-#define BOOST_PP_REPEAT_3RD97(M,D) BOOST_PP_REPEAT_3RD96(M,D) M(96,D)
-#define BOOST_PP_REPEAT_3RD98(M,D) BOOST_PP_REPEAT_3RD97(M,D) M(97,D)
-#define BOOST_PP_REPEAT_3RD99(M,D) BOOST_PP_REPEAT_3RD98(M,D) M(98,D)
-#define BOOST_PP_REPEAT_3RD100(M,D) BOOST_PP_REPEAT_3RD99(M,D) M(99,D)
-#define BOOST_PP_REPEAT_3RD101(M,D) BOOST_PP_REPEAT_3RD100(M,D) M(100,D)
-#define BOOST_PP_REPEAT_3RD102(M,D) BOOST_PP_REPEAT_3RD101(M,D) M(101,D)
-#define BOOST_PP_REPEAT_3RD103(M,D) BOOST_PP_REPEAT_3RD102(M,D) M(102,D)
-#define BOOST_PP_REPEAT_3RD104(M,D) BOOST_PP_REPEAT_3RD103(M,D) M(103,D)
-#define BOOST_PP_REPEAT_3RD105(M,D) BOOST_PP_REPEAT_3RD104(M,D) M(104,D)
-#define BOOST_PP_REPEAT_3RD106(M,D) BOOST_PP_REPEAT_3RD105(M,D) M(105,D)
-#define BOOST_PP_REPEAT_3RD107(M,D) BOOST_PP_REPEAT_3RD106(M,D) M(106,D)
-#define BOOST_PP_REPEAT_3RD108(M,D) BOOST_PP_REPEAT_3RD107(M,D) M(107,D)
-#define BOOST_PP_REPEAT_3RD109(M,D) BOOST_PP_REPEAT_3RD108(M,D) M(108,D)
-#define BOOST_PP_REPEAT_3RD110(M,D) BOOST_PP_REPEAT_3RD109(M,D) M(109,D)
-#define BOOST_PP_REPEAT_3RD111(M,D) BOOST_PP_REPEAT_3RD110(M,D) M(110,D)
-#define BOOST_PP_REPEAT_3RD112(M,D) BOOST_PP_REPEAT_3RD111(M,D) M(111,D)
-#define BOOST_PP_REPEAT_3RD113(M,D) BOOST_PP_REPEAT_3RD112(M,D) M(112,D)
-#define BOOST_PP_REPEAT_3RD114(M,D) BOOST_PP_REPEAT_3RD113(M,D) M(113,D)
-#define BOOST_PP_REPEAT_3RD115(M,D) BOOST_PP_REPEAT_3RD114(M,D) M(114,D)
-#define BOOST_PP_REPEAT_3RD116(M,D) BOOST_PP_REPEAT_3RD115(M,D) M(115,D)
-#define BOOST_PP_REPEAT_3RD117(M,D) BOOST_PP_REPEAT_3RD116(M,D) M(116,D)
-#define BOOST_PP_REPEAT_3RD118(M,D) BOOST_PP_REPEAT_3RD117(M,D) M(117,D)
-#define BOOST_PP_REPEAT_3RD119(M,D) BOOST_PP_REPEAT_3RD118(M,D) M(118,D)
-#define BOOST_PP_REPEAT_3RD120(M,D) BOOST_PP_REPEAT_3RD119(M,D) M(119,D)
-#define BOOST_PP_REPEAT_3RD121(M,D) BOOST_PP_REPEAT_3RD120(M,D) M(120,D)
-#define BOOST_PP_REPEAT_3RD122(M,D) BOOST_PP_REPEAT_3RD121(M,D) M(121,D)
-#define BOOST_PP_REPEAT_3RD123(M,D) BOOST_PP_REPEAT_3RD122(M,D) M(122,D)
-#define BOOST_PP_REPEAT_3RD124(M,D) BOOST_PP_REPEAT_3RD123(M,D) M(123,D)
-#define BOOST_PP_REPEAT_3RD125(M,D) BOOST_PP_REPEAT_3RD124(M,D) M(124,D)
-#define BOOST_PP_REPEAT_3RD126(M,D) BOOST_PP_REPEAT_3RD125(M,D) M(125,D)
-#define BOOST_PP_REPEAT_3RD127(M,D) BOOST_PP_REPEAT_3RD126(M,D) M(126,D)
-#define BOOST_PP_REPEAT_3RD128(M,D) BOOST_PP_REPEAT_3RD127(M,D) M(127,D)
+<pre>
+#include <boost/preprocessor/repeat.hpp>
+</pre>
+*/
-/* <p>Obsolete. Use BOOST_PP_REPEAT_3RD().</p> */
-#define BOOST_PREPROCESSOR_REPEAT_3RD(C,M,D) BOOST_PP_REPEAT_3RD(C,M,D)
+#include <boost/preprocessor/repeat.hpp>
#endif
* See http://www.boost.org for most recent version.
*/
-#include <boost/preprocessor/repeat.hpp>
#include <boost/preprocessor/arithmetic/sub.hpp>
#include <boost/preprocessor/arithmetic/add.hpp>
+#include <boost/preprocessor/repeat.hpp>
/** <p>Repeats the macro <code>MACRO(INDEX,DATA)</code> for <code>INDEX = [FIRST,LAST)</code>.</p>
X(4); X(5); X(6);
</pre>
-<h3>Uses</h3>
+<h3>2D and 3D repetition</h3>
+
+<p>BOOST_PP_REPEAT_FROM_TO() implements automatic recursion. 2D and 3D repetition
+are directly supported.</p>
+
+<h3>See</h3>
<ul>
- <li>BOOST_PP_REPEAT()</li>
+ <li>BOOST_PP_FOR()</li>
+ <li>BOOST_PP_LIMIT_DIM</li>
+ <li>BOOST_PP_LIMIT_MAG</li>
</ul>
<h3>Test</h3>
<ul>
<li><a href="../../test/repeat_test.cpp">repeat_test.cpp</a></li>
+ <li><a href="../../test/repeat_2nd_test.cpp">repeat_2nd_test.cpp</a></li>
</ul>
*/
-#define BOOST_PP_REPEAT_FROM_TO(FIRST,LAST,MACRO,DATA) BOOST_PP_REPEAT(BOOST_PP_SUB(LAST,FIRST),BOOST_PP_REPEAT_FROM_TO_F,(FIRST,MACRO,DATA))
-#define BOOST_PP_REPEAT_FROM_TO_F(I,SMP) BOOST_PP_TUPLE_ELEM(3,1,SMP)(BOOST_PP_ADD(I,BOOST_PP_TUPLE_ELEM(3,0,SMP)),BOOST_PP_TUPLE_ELEM(3,2,SMP))
+#if 0
+# define BOOST_PP_REPEAT_FROM_TO(FIRST,LAST,MACRO,DATA)
+#endif
+
+#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
+
+/* This is a workaround for a MSVC++ PP bug. You'll need to add further
+ * BOOST_PP_REPEAT_FT_AUTO_REC3/4/etc. wrapping as the maximum level of
+ * nesting REPEATS increases
+ */
+# define BOOST_PP_REPEAT_FROM_TO\
+ BOOST_PP_AUTO_REC_CAT1(BOOST_PP_REPEAT_FROM_TO_,BOOST_PP_REPEAT_FT_AUTO_REC2(\
+ BOOST_PP_REPEAT_FT_AUTO_REC1,(BOOST_PP_AUTO_REC_ID,(1))\
+ ))
+
+# define BOOST_PP_REPEAT_FROM_TO_BOOST_PP_REPEAT_FT_AUTO_REC1(M,P)\
+ BOOST_PP_AUTO_REC_CAT2(BOOST_PP_REPEAT_FROM_TO_,BOOST_PP_REPEAT_FT_AUTO_REC2(BOOST_PP_AUTO_REC_ID,(2)))
+# define BOOST_PP_REPEAT_FROM_TO_BOOST_PP_REPEAT_FT_AUTO_REC2(M,P)\
+ BOOST_PP_AUTO_REC_CAT3(BOOST_PP_REPEAT_FROM_TO_,BOOST_PP_REPEAT_FT_AUTO_REC3(BOOST_PP_AUTO_REC_ID,(3)))
+# define BOOST_PP_REPEAT_FROM_TO_BOOST_PP_REPEAT_FT_AUTO_REC3(M,P)\
+ (TOO MANY NESTED REPEATS!)
+
+# define BOOST_PP_REPEAT_FT_AUTO_REC1(M,P) BOOST_PP_EXPAND(M P)
+# define BOOST_PP_REPEAT_FT_AUTO_REC2(M,P) BOOST_PP_EXPAND(M P)
+# define BOOST_PP_REPEAT_FT_AUTO_REC3(M,P) BOOST_PP_EXPAND(M P)
+
+# define BOOST_PP_REPEAT_FROM_TO_1(F,L,M,D) BOOST_PP_REPEAT_FT_AUTO_REC1(BOOST_PP_REPEAT,(BOOST_PP_SUB(L,F),BOOST_PP_REPEAT_FROM_TO_M1,(F,M,D)))
+# define BOOST_PP_REPEAT_FROM_TO_2(F,L,M,D) BOOST_PP_REPEAT_FT_AUTO_REC2(BOOST_PP_REPEAT,(BOOST_PP_SUB(L,F),BOOST_PP_REPEAT_FROM_TO_M2,(F,M,D)))
+# define BOOST_PP_REPEAT_FROM_TO_3(F,L,M,D) BOOST_PP_REPEAT_FT_AUTO_REC3(BOOST_PP_REPEAT,(BOOST_PP_SUB(L,F),BOOST_PP_REPEAT_FROM_TO_M3,(F,M,D)))
+
+#else
+
+# define BOOST_PP_REPEAT_FROM_TO\
+ BOOST_PP_AUTO_REC_CAT1(BOOST_PP_REPEAT_FROM_TO_,BOOST_PP_REPEAT_AUTO_REC1(BOOST_PP_AUTO_REC_ID,(1)))
+# define BOOST_PP_REPEAT_FROM_TO_BOOST_PP_REPEAT_AUTO_REC1(M,P)\
+ BOOST_PP_AUTO_REC_CAT2(BOOST_PP_REPEAT_FROM_TO_,BOOST_PP_REPEAT_AUTO_REC2(BOOST_PP_AUTO_REC_ID,(2)))
+# define BOOST_PP_REPEAT_FROM_TO_BOOST_PP_REPEAT_AUTO_REC2(M,P)\
+ BOOST_PP_AUTO_REC_CAT3(BOOST_PP_REPEAT_FROM_TO_,BOOST_PP_REPEAT_AUTO_REC3(BOOST_PP_AUTO_REC_ID,(3)))
+# define BOOST_PP_REPEAT_FROM_TO_BOOST_PP_REPEAT_AUTO_REC3(M,P)\
+ (TOO MANY NESTED REPEATS!)
+
+# define BOOST_PP_REPEAT_FROM_TO_1(F,L,M,D) BOOST_PP_REPEAT(BOOST_PP_SUB(L,F),BOOST_PP_REPEAT_FROM_TO_M1,(F,M,D))
+# define BOOST_PP_REPEAT_FROM_TO_2(F,L,M,D) BOOST_PP_REPEAT(BOOST_PP_SUB(L,F),BOOST_PP_REPEAT_FROM_TO_M2,(F,M,D))
+# define BOOST_PP_REPEAT_FROM_TO_3(F,L,M,D) BOOST_PP_REPEAT(BOOST_PP_SUB(L,F),BOOST_PP_REPEAT_FROM_TO_M3,(F,M,D))
+
+#endif
+
+#define BOOST_PP_REPEAT_FROM_TO_M1(I,FMD) BOOST_PP_TUPLE_ELEM(3,1,FMD)(BOOST_PP_ADD(I,BOOST_PP_TUPLE_ELEM(3,0,FMD)),BOOST_PP_TUPLE_ELEM(3,2,FMD))
+#define BOOST_PP_REPEAT_FROM_TO_M2(I,FMD) BOOST_PP_TUPLE_ELEM(3,1,FMD)(BOOST_PP_ADD(I,BOOST_PP_TUPLE_ELEM(3,0,FMD)),BOOST_PP_TUPLE_ELEM(3,2,FMD))
+#define BOOST_PP_REPEAT_FROM_TO_M3(I,FMD) BOOST_PP_TUPLE_ELEM(3,1,FMD)(BOOST_PP_ADD(I,BOOST_PP_TUPLE_ELEM(3,0,FMD)),BOOST_PP_TUPLE_ELEM(3,2,FMD))
+
+/** <p>Obsolete, just use BOOST_PP_REPEAT_FROM_TO().</p> */
+#define BOOST_PP_REPEAT_FROM_TO_2ND BOOST_PP_REPEAT_FROM_TO
+/** <p>Obsolete, just use BOOST_PP_REPEAT_FROM_TO().</p> */
+#define BOOST_PP_REPEAT_FROM_TO_3RD BOOST_PP_REPEAT_FROM_TO
#endif
* See http://www.boost.org for most recent version.
*/
-#include <boost/preprocessor/repeat_2nd.hpp>
-#include <boost/preprocessor/arithmetic/sub.hpp>
-#include <boost/preprocessor/arithmetic/add.hpp>
+/** <p>This header is obsolete. Use the following code instead.</p>
-/** <p>Same as BOOST_PP_REPEAT_FROM_TO(), but implemented independently.</p> */
-#define BOOST_PP_REPEAT_FROM_TO_2ND(FIRST,LAST,MACRO,DATA) BOOST_PP_REPEAT_2ND(BOOST_PP_SUB(LAST,FIRST),BOOST_PP_REPEAT_FROM_TO_2ND_F,(FIRST,MACRO,DATA))
-#define BOOST_PP_REPEAT_FROM_TO_2ND_F(I,SMP) BOOST_PP_TUPLE_ELEM(3,1,SMP)(BOOST_PP_ADD(I,BOOST_PP_TUPLE_ELEM(3,0,SMP)),BOOST_PP_TUPLE_ELEM(3,2,SMP))
+<pre>
+#include <boost/preprocessor/repeat_from_to.hpp>
+</pre>
+*/
+
+#include <boost/preprocessor/repeat_from_to.hpp>
#endif
* See http://www.boost.org for most recent version.
*/
-#include <boost/preprocessor/repeat_3rd.hpp>
-#include <boost/preprocessor/arithmetic/sub.hpp>
-#include <boost/preprocessor/arithmetic/add.hpp>
+/** <p>This header is obsolete. Use the following code instead.</p>
-/** <p>Same as BOOST_PP_REPEAT_FROM_TO(), but implemented independently.</p> */
-#define BOOST_PP_REPEAT_FROM_TO_3RD(FIRST,LAST,MACRO,DATA) BOOST_PP_REPEAT_3RD(BOOST_PP_SUB(LAST,FIRST),BOOST_PP_REPEAT_FROM_TO_3RD_F,(FIRST,MACRO,DATA))
-#define BOOST_PP_REPEAT_FROM_TO_3RD_F(I,SMP) BOOST_PP_TUPLE_ELEM(3,1,SMP)(BOOST_PP_ADD(I,BOOST_PP_TUPLE_ELEM(3,0,SMP)),BOOST_PP_TUPLE_ELEM(3,2,SMP))
+<pre>
+#include <boost/preprocessor/repeat_from_to.hpp>
+</pre>
+*/
+
+#include <boost/preprocessor/repeat_from_to.hpp>
#endif
#define BOOST_PP_STRINGIZE_DELAY(X) BOOST_PP_DO_STRINGIZE(X)
#define BOOST_PP_DO_STRINGIZE(X) #X
-
-/* <p>Obsolete. Use BOOST_PP_STRINGIZE().</p> */
-#define BOOST_PREPROCESSOR_STRINGIZE(E) BOOST_PP_STRINGIZE(E)
#endif
* See http://www.boost.org for most recent version.
*/
+#include <boost/preprocessor/detail/cat.hpp>
+
/** <p>Expands to a macro that eats a tuple of the specified size.</p>
<p>BOOST_PP_TUPLE_EAT() is designed to be used with BOOST_PP_IF() like
<p>expands to nothing.</p>
*/
-#define BOOST_PP_TUPLE_EAT(SIZE_OF_TUPLE) BOOST_PP_TUPLE_EAT_DELAY(SIZE_OF_TUPLE)
+#define BOOST_PP_TUPLE_EAT(SIZE_OF_TUPLE) BOOST_PP_DETAIL_CAT3(BOOST_PP_TUPLE,SIZE_OF_TUPLE,_EAT)
-#define BOOST_PP_TUPLE_EAT_DELAY(N) BOOST_PP_TUPLE##N##_EAT
#define BOOST_PP_TUPLE0_EAT()
#define BOOST_PP_TUPLE1_EAT(A)
#define BOOST_PP_TUPLE2_EAT(A,B)
* See http://www.boost.org for most recent version.
*/
+#include <boost/preprocessor/detail/cat.hpp>
+#include <boost/preprocessor/detail/expand.hpp>
+
/** <p>Expands to the <code>INDEX</code>:th element of an <code>SIZE_OF_TUPLE</code>-tuple.</p>
<p>For example,</p>
<li>BOOST_PP_LIMIT_TUPLE</li>
</ul>
*/
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-# define BOOST_PP_TUPLE_ELEM(SIZE_OF_TUPLE,INDEX,TUPLE) BOOST_PP_TUPLE_ELEM_DELAY(SIZE_OF_TUPLE,INDEX,TUPLE)
-/* This is a workaround for a CodeWarrior PP bug. Strictly speaking
- * this workaround invokes undefined behavior, but it works as desired.
- */
-# define BOOST_PP_TUPLE_ELEM_DELAY(N,I,T) BOOST_PP_TUPLE##N##_ELEM##I##T
-#elif !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
-# include <boost/preprocessor/expand.hpp>
-/* This is a workaround for a MSVC++ PP bug. It should not be necessary
- * to use BOOST_PP_EXPAND(). Works on standard conforming compilers, too.
- */
-# define BOOST_PP_TUPLE_ELEM(SIZE_OF_TUPLE,INDEX,TUPLE) BOOST_PP_EXPAND(BOOST_PP_TUPLE_ELEM_DELAY(SIZE_OF_TUPLE,INDEX)TUPLE)
-# define BOOST_PP_TUPLE_ELEM_DELAY(N,I) BOOST_PP_TUPLE##N##_ELEM##I
-#else
-# define BOOST_PP_TUPLE_ELEM(SIZE_OF_TUPLE,INDEX,TUPLE) BOOST_PP_TUPLE_ELEM_DELAY(SIZE_OF_TUPLE,INDEX)TUPLE
-# define BOOST_PP_TUPLE_ELEM_DELAY(N,I) BOOST_PP_TUPLE##N##_ELEM##I
-#endif
-
-/* TUPLE_ELEM can be implemented in O(N*N) space and O(N) time instead
- * of O(N*N*N) space and O(1) time. The current trade-off seems better.
- */
-#define BOOST_PP_TUPLE1_ELEM0(A) A
-
-#define BOOST_PP_TUPLE2_ELEM0(A,B) A
-#define BOOST_PP_TUPLE2_ELEM1(A,B) B
-
-#define BOOST_PP_TUPLE3_ELEM0(A,B,C) A
-#define BOOST_PP_TUPLE3_ELEM1(A,B,C) B
-#define BOOST_PP_TUPLE3_ELEM2(A,B,C) C
-
-#define BOOST_PP_TUPLE4_ELEM0(A,B,C,D) A
-#define BOOST_PP_TUPLE4_ELEM1(A,B,C,D) B
-#define BOOST_PP_TUPLE4_ELEM2(A,B,C,D) C
-#define BOOST_PP_TUPLE4_ELEM3(A,B,C,D) D
-
-#define BOOST_PP_TUPLE5_ELEM0(A,B,C,D,E) A
-#define BOOST_PP_TUPLE5_ELEM1(A,B,C,D,E) B
-#define BOOST_PP_TUPLE5_ELEM2(A,B,C,D,E) C
-#define BOOST_PP_TUPLE5_ELEM3(A,B,C,D,E) D
-#define BOOST_PP_TUPLE5_ELEM4(A,B,C,D,E) E
-
-#define BOOST_PP_TUPLE6_ELEM0(A,B,C,D,E,F) A
-#define BOOST_PP_TUPLE6_ELEM1(A,B,C,D,E,F) B
-#define BOOST_PP_TUPLE6_ELEM2(A,B,C,D,E,F) C
-#define BOOST_PP_TUPLE6_ELEM3(A,B,C,D,E,F) D
-#define BOOST_PP_TUPLE6_ELEM4(A,B,C,D,E,F) E
-#define BOOST_PP_TUPLE6_ELEM5(A,B,C,D,E,F) F
-
-#define BOOST_PP_TUPLE7_ELEM0(A,B,C,D,E,F,G) A
-#define BOOST_PP_TUPLE7_ELEM1(A,B,C,D,E,F,G) B
-#define BOOST_PP_TUPLE7_ELEM2(A,B,C,D,E,F,G) C
-#define BOOST_PP_TUPLE7_ELEM3(A,B,C,D,E,F,G) D
-#define BOOST_PP_TUPLE7_ELEM4(A,B,C,D,E,F,G) E
-#define BOOST_PP_TUPLE7_ELEM5(A,B,C,D,E,F,G) F
-#define BOOST_PP_TUPLE7_ELEM6(A,B,C,D,E,F,G) G
-
-#define BOOST_PP_TUPLE8_ELEM0(A,B,C,D,E,F,G,H) A
-#define BOOST_PP_TUPLE8_ELEM1(A,B,C,D,E,F,G,H) B
-#define BOOST_PP_TUPLE8_ELEM2(A,B,C,D,E,F,G,H) C
-#define BOOST_PP_TUPLE8_ELEM3(A,B,C,D,E,F,G,H) D
-#define BOOST_PP_TUPLE8_ELEM4(A,B,C,D,E,F,G,H) E
-#define BOOST_PP_TUPLE8_ELEM5(A,B,C,D,E,F,G,H) F
-#define BOOST_PP_TUPLE8_ELEM6(A,B,C,D,E,F,G,H) G
-#define BOOST_PP_TUPLE8_ELEM7(A,B,C,D,E,F,G,H) H
-
-#define BOOST_PP_TUPLE9_ELEM0(A,B,C,D,E,F,G,H,I) A
-#define BOOST_PP_TUPLE9_ELEM1(A,B,C,D,E,F,G,H,I) B
-#define BOOST_PP_TUPLE9_ELEM2(A,B,C,D,E,F,G,H,I) C
-#define BOOST_PP_TUPLE9_ELEM3(A,B,C,D,E,F,G,H,I) D
-#define BOOST_PP_TUPLE9_ELEM4(A,B,C,D,E,F,G,H,I) E
-#define BOOST_PP_TUPLE9_ELEM5(A,B,C,D,E,F,G,H,I) F
-#define BOOST_PP_TUPLE9_ELEM6(A,B,C,D,E,F,G,H,I) G
-#define BOOST_PP_TUPLE9_ELEM7(A,B,C,D,E,F,G,H,I) H
-#define BOOST_PP_TUPLE9_ELEM8(A,B,C,D,E,F,G,H,I) I
-
-#define BOOST_PP_TUPLE10_ELEM0(A,B,C,D,E,F,G,H,I,J) A
-#define BOOST_PP_TUPLE10_ELEM1(A,B,C,D,E,F,G,H,I,J) B
-#define BOOST_PP_TUPLE10_ELEM2(A,B,C,D,E,F,G,H,I,J) C
-#define BOOST_PP_TUPLE10_ELEM3(A,B,C,D,E,F,G,H,I,J) D
-#define BOOST_PP_TUPLE10_ELEM4(A,B,C,D,E,F,G,H,I,J) E
-#define BOOST_PP_TUPLE10_ELEM5(A,B,C,D,E,F,G,H,I,J) F
-#define BOOST_PP_TUPLE10_ELEM6(A,B,C,D,E,F,G,H,I,J) G
-#define BOOST_PP_TUPLE10_ELEM7(A,B,C,D,E,F,G,H,I,J) H
-#define BOOST_PP_TUPLE10_ELEM8(A,B,C,D,E,F,G,H,I,J) I
-#define BOOST_PP_TUPLE10_ELEM9(A,B,C,D,E,F,G,H,I,J) J
-
-#define BOOST_PP_TUPLE11_ELEM0(A,B,C,D,E,F,G,H,I,J,K) A
-#define BOOST_PP_TUPLE11_ELEM1(A,B,C,D,E,F,G,H,I,J,K) B
-#define BOOST_PP_TUPLE11_ELEM2(A,B,C,D,E,F,G,H,I,J,K) C
-#define BOOST_PP_TUPLE11_ELEM3(A,B,C,D,E,F,G,H,I,J,K) D
-#define BOOST_PP_TUPLE11_ELEM4(A,B,C,D,E,F,G,H,I,J,K) E
-#define BOOST_PP_TUPLE11_ELEM5(A,B,C,D,E,F,G,H,I,J,K) F
-#define BOOST_PP_TUPLE11_ELEM6(A,B,C,D,E,F,G,H,I,J,K) G
-#define BOOST_PP_TUPLE11_ELEM7(A,B,C,D,E,F,G,H,I,J,K) H
-#define BOOST_PP_TUPLE11_ELEM8(A,B,C,D,E,F,G,H,I,J,K) I
-#define BOOST_PP_TUPLE11_ELEM9(A,B,C,D,E,F,G,H,I,J,K) J
-#define BOOST_PP_TUPLE11_ELEM10(A,B,C,D,E,F,G,H,I,J,K) K
-
-#define BOOST_PP_TUPLE12_ELEM0(A,B,C,D,E,F,G,H,I,J,K,L) A
-#define BOOST_PP_TUPLE12_ELEM1(A,B,C,D,E,F,G,H,I,J,K,L) B
-#define BOOST_PP_TUPLE12_ELEM2(A,B,C,D,E,F,G,H,I,J,K,L) C
-#define BOOST_PP_TUPLE12_ELEM3(A,B,C,D,E,F,G,H,I,J,K,L) D
-#define BOOST_PP_TUPLE12_ELEM4(A,B,C,D,E,F,G,H,I,J,K,L) E
-#define BOOST_PP_TUPLE12_ELEM5(A,B,C,D,E,F,G,H,I,J,K,L) F
-#define BOOST_PP_TUPLE12_ELEM6(A,B,C,D,E,F,G,H,I,J,K,L) G
-#define BOOST_PP_TUPLE12_ELEM7(A,B,C,D,E,F,G,H,I,J,K,L) H
-#define BOOST_PP_TUPLE12_ELEM8(A,B,C,D,E,F,G,H,I,J,K,L) I
-#define BOOST_PP_TUPLE12_ELEM9(A,B,C,D,E,F,G,H,I,J,K,L) J
-#define BOOST_PP_TUPLE12_ELEM10(A,B,C,D,E,F,G,H,I,J,K,L) K
-#define BOOST_PP_TUPLE12_ELEM11(A,B,C,D,E,F,G,H,I,J,K,L) L
-
-#define BOOST_PP_TUPLE13_ELEM0(A,B,C,D,E,F,G,H,I,J,K,L,M) A
-#define BOOST_PP_TUPLE13_ELEM1(A,B,C,D,E,F,G,H,I,J,K,L,M) B
-#define BOOST_PP_TUPLE13_ELEM2(A,B,C,D,E,F,G,H,I,J,K,L,M) C
-#define BOOST_PP_TUPLE13_ELEM3(A,B,C,D,E,F,G,H,I,J,K,L,M) D
-#define BOOST_PP_TUPLE13_ELEM4(A,B,C,D,E,F,G,H,I,J,K,L,M) E
-#define BOOST_PP_TUPLE13_ELEM5(A,B,C,D,E,F,G,H,I,J,K,L,M) F
-#define BOOST_PP_TUPLE13_ELEM6(A,B,C,D,E,F,G,H,I,J,K,L,M) G
-#define BOOST_PP_TUPLE13_ELEM7(A,B,C,D,E,F,G,H,I,J,K,L,M) H
-#define BOOST_PP_TUPLE13_ELEM8(A,B,C,D,E,F,G,H,I,J,K,L,M) I
-#define BOOST_PP_TUPLE13_ELEM9(A,B,C,D,E,F,G,H,I,J,K,L,M) J
-#define BOOST_PP_TUPLE13_ELEM10(A,B,C,D,E,F,G,H,I,J,K,L,M) K
-#define BOOST_PP_TUPLE13_ELEM11(A,B,C,D,E,F,G,H,I,J,K,L,M) L
-#define BOOST_PP_TUPLE13_ELEM12(A,B,C,D,E,F,G,H,I,J,K,L,M) M
-
-#define BOOST_PP_TUPLE14_ELEM0(A,B,C,D,E,F,G,H,I,J,K,L,M,N) A
-#define BOOST_PP_TUPLE14_ELEM1(A,B,C,D,E,F,G,H,I,J,K,L,M,N) B
-#define BOOST_PP_TUPLE14_ELEM2(A,B,C,D,E,F,G,H,I,J,K,L,M,N) C
-#define BOOST_PP_TUPLE14_ELEM3(A,B,C,D,E,F,G,H,I,J,K,L,M,N) D
-#define BOOST_PP_TUPLE14_ELEM4(A,B,C,D,E,F,G,H,I,J,K,L,M,N) E
-#define BOOST_PP_TUPLE14_ELEM5(A,B,C,D,E,F,G,H,I,J,K,L,M,N) F
-#define BOOST_PP_TUPLE14_ELEM6(A,B,C,D,E,F,G,H,I,J,K,L,M,N) G
-#define BOOST_PP_TUPLE14_ELEM7(A,B,C,D,E,F,G,H,I,J,K,L,M,N) H
-#define BOOST_PP_TUPLE14_ELEM8(A,B,C,D,E,F,G,H,I,J,K,L,M,N) I
-#define BOOST_PP_TUPLE14_ELEM9(A,B,C,D,E,F,G,H,I,J,K,L,M,N) J
-#define BOOST_PP_TUPLE14_ELEM10(A,B,C,D,E,F,G,H,I,J,K,L,M,N) K
-#define BOOST_PP_TUPLE14_ELEM11(A,B,C,D,E,F,G,H,I,J,K,L,M,N) L
-#define BOOST_PP_TUPLE14_ELEM12(A,B,C,D,E,F,G,H,I,J,K,L,M,N) M
-#define BOOST_PP_TUPLE14_ELEM13(A,B,C,D,E,F,G,H,I,J,K,L,M,N) N
-
-#define BOOST_PP_TUPLE15_ELEM0(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) A
-#define BOOST_PP_TUPLE15_ELEM1(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) B
-#define BOOST_PP_TUPLE15_ELEM2(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) C
-#define BOOST_PP_TUPLE15_ELEM3(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) D
-#define BOOST_PP_TUPLE15_ELEM4(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) E
-#define BOOST_PP_TUPLE15_ELEM5(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) F
-#define BOOST_PP_TUPLE15_ELEM6(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) G
-#define BOOST_PP_TUPLE15_ELEM7(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) H
-#define BOOST_PP_TUPLE15_ELEM8(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) I
-#define BOOST_PP_TUPLE15_ELEM9(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) J
-#define BOOST_PP_TUPLE15_ELEM10(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) K
-#define BOOST_PP_TUPLE15_ELEM11(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) L
-#define BOOST_PP_TUPLE15_ELEM12(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) M
-#define BOOST_PP_TUPLE15_ELEM13(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) N
-#define BOOST_PP_TUPLE15_ELEM14(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) O
+#define BOOST_PP_TUPLE_ELEM(SIZE_OF_TUPLE,INDEX,TUPLE) BOOST_PP_DETAIL_EXPAND(BOOST_PP_DETAIL_CAT2(BOOST_PP_TUPLE16_ELEM,INDEX) BOOST_PP_DETAIL_CAT2(BOOST_PP_TUPLE_ELEM_EX,SIZE_OF_TUPLE) TUPLE)
+
+#define BOOST_PP_TUPLE_ELEM_EX1(A) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX2(A,B) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX3(A,B,C) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX4(A,B,C,D) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX5(A,B,C,D,E) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX6(A,B,C,D,E,F) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX7(A,B,C,D,E,F,G) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX8(A,B,C,D,E,F,G,H) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX9(A,B,C,D,E,F,G,H,I) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX10(A,B,C,D,E,F,G,H,I,J) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX11(A,B,C,D,E,F,G,H,I,J,K) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX12(A,B,C,D,E,F,G,H,I,J,K,L) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX13(A,B,C,D,E,F,G,H,I,J,K,L,M) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX14(A,B,C,D,E,F,G,H,I,J,K,L,M,N) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX15(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX16(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
#define BOOST_PP_TUPLE16_ELEM0(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) A
#define BOOST_PP_TUPLE16_ELEM1(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) B
#define BOOST_PP_TUPLE16_ELEM13(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) N
#define BOOST_PP_TUPLE16_ELEM14(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) O
#define BOOST_PP_TUPLE16_ELEM15(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) P
-
-/* <p>Obsolete. Use BOOST_PP_TUPLE_ELEM().</p> */
-#define BOOST_PREPROCESSOR_TUPLE_ELEM(N,I,T) BOOST_PP_TUPLE_ELEM(N,I,T)
#endif
C++ preprocessor.</li>
</ul>
+<h3>Automatic recursion?</h3>
+
+<p>BOOST_PP_WHILE() currently does not implement automatic recursion. The reason
+for this is that it would lead to very poor performance. The automatic recursion
+technique takes O(N) steps just to find out that the Nth recursion should be used.
+This would dramatically effect the time complexity of macros using automatic
+recursion.</p>
+
<h3>Note</h3>
<ul>
<li>The value of the D parameter may exceed BOOST_PP_LIMIT_MAG.</li>
<li>Using BOOST_PP_WHILE() is a bit tricky. This is due to the C++
preprocessor limitations. It is recommended to take a look at the
- implementations of the various PREPROCESSOR library primitives such as
- BOOST_PP_ADD() for additional examples.</li>
+ implementations of the various PREPROCESSOR library primitives
+ such as BOOST_PP_ADD() for additional examples.</li>
</ul>
<h3>Example</h3>
#define BOOST_PP_WHILE255(P,O,S) BOOST_PP_WHILE_C(P(257,S),256,S)(P,O,O(257,S))
#define BOOST_PP_WHILE256(P,O,S) BOOST_PP_WHILE_C(P(258,S),257,S)(P,O,O(258,S))
#define BOOST_PP_WHILE257(P,O,S) BOOST_PP_WHILE_C(P(259,S),258,S)(P,O,O(259,S))
-#define BOOST_PP_WHILE258(P,O,S) RECURSION DEPTH EXCEEDED!
-#define BOOST_PP_WHILE259(P,O,S) RECURSION DEPTH EXCEEDED!
+#define BOOST_PP_WHILE258(P,O,S) (RECURSION DEPTH EXCEEDED!)
+#define BOOST_PP_WHILE259(P,O,S) (RECURSION DEPTH EXCEEDED!)
#endif
return (*m_c)[k];
}
private:
- C* m_c;
+ C const* m_c;
};
template <class UniquePairAssociativeContainer>
namespace boost{
#ifdef __BORLANDC__
- #pragma option push -a4 -b -Ve -pc
+ #pragma option push -a8 -b -Vx -Ve -pc -w-8027
#endif
namespace re_detail{
namespace re_detail{
#ifdef __BORLANDC__
- #pragma option push -a4 -b -Ve -pc
+ #pragma option push -a8 -b -Vx -Ve -pc
#endif
struct _fi_find_data
#ifdef __BORLANDC__
+#pragma option push -a8 -b -Vx -Ve -pc
+
# ifndef BOOST_REGEX_INSTANTIATE
# pragma option push -Jgx
# endif
# pragma option pop
# endif
+#pragma option pop
+
#elif defined(BOOST_MSVC)
# ifndef BOOST_REGEX_INSTANTIATE
namespace boost{
#ifdef __BORLANDC__
- #pragma option push -a4 -b -Ve -pc
+ #pragma option push -a8 -b -Vx -Ve -pc -w-8004
#endif
namespace re_detail{
template <class charT, class traits, class Allocator>
void BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::move_offsets(re_detail::re_syntax_base* j, unsigned size)
{
+# ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable: 4127)
+#endif
// move all offsets starting with j->link forward by size
// called after an insert:
j = reinterpret_cast<re_detail::re_syntax_base*>(reinterpret_cast<char*>(data.data()) + j->next.i);
break;
j = reinterpret_cast<re_detail::re_syntax_base*>(reinterpret_cast<char*>(data.data()) + j->next.i);
}
+# ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
}
template <class charT, class traits, class Allocator>
template <class charT, class traits, class Allocator>
unsigned int BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::set_expression(const charT* p, const charT* end, flag_type f)
{
+# ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable: 4127)
+#endif
+
if(p == expression())
{
traits_string_type s(p, end);
} // sentry
return REG_EMPTY;
+
+# ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
}
template <class charT, class traits, class Allocator>
namespace re_detail{
#ifdef __BORLANDC__
- #pragma option push -a4 -b -Ve -pc
+ #pragma option push -a8 -b -Vx -Ve -pc
#endif
//
namespace re_detail{
#ifdef __BORLANDC__
- #pragma option push -a4 -b -Ve -pc -w-8037
+ #pragma option push -a8 -b -Vx -Ve -pc -w-8037
#endif
template <class O, class I>
namespace re_detail{
#ifdef __BORLANDC__
- #pragma option push -a4 -b -Ve -pc
+ #pragma option push -a8 -b -Vx -Ve -pc
#endif
template <class charT>
struct kmp_info
{
- std::size_t size;
- std::size_t len;
+ unsigned int size;
+ unsigned int len;
const charT* pstr;
- std::ptrdiff_t kmp_next[1];
+ int kmp_next[1];
};
template <class charT, class Allocator>
kmp_info<charT>* kmp_compile(iterator first, iterator last, charT, Trans translate, const Allocator& a)
{
typedef typename boost::detail::rebind_allocator<char, Allocator>::type atype;
- std::ptrdiff_t i, j, m;
+ int i, j, m;
i = 0;
- m = boost::re_detail::distance(first, last);
+ m = static_cast<int>(boost::re_detail::distance(first, last));
++m;
- std::size_t size = sizeof(kmp_info<charT>) + sizeof(int)*m + sizeof(charT)*m;
+ unsigned int size = sizeof(kmp_info<charT>) + sizeof(int)*m + sizeof(charT)*m;
--m;
//
// allocate struct and fill it in:
-
-
-
namespace re_detail{
#ifdef __BORLANDC__
- #pragma option push -a4 -b -Ve -pc -w-8026
+ #pragma option push -a8 -b -Vx -Ve -pc -w-8026 -w-8027
#endif
//
# define STR_COMP(s,p) string_compare(s,p)
#endif
+template<class charT>
+inline const charT* re_skip_past_null(const charT* p)
+{
+ while (*p != 0) ++p;
+ return ++p;
+}
+
template <class iterator, class charT, class traits_type, class Allocator>
iterator BOOST_REGEX_CALL re_is_set_member(iterator next,
iterator last,
if(*p == 0) // if null we've matched
return set_->isnot ? next : (ptr == next) ? ++next : ptr;
- while(*p)++p;
- ++p; // skip null
+ p = re_skip_past_null(p); // skip null
}
}
_priv_match_data<iterator, Allocator>& pd,
iterator* restart)
{
+# ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable: 4127)
+#endif
+
typedef access_t<charT, traits, Allocator2> access;
if(e.flags() & regbase::failbit)
// longer one.
if((flags & match_not_null) && (first == temp_match[0].first))
goto failure;
+ if((flags & match_all) && (first != last))
+ goto failure;
temp_match.set_second(first);
m.maybe_assign(temp_match);
match_found = true;
// if we get to here then everything has failed
// and no match was found:
return false;
+# ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
}
#if defined(BOOST_REGEX_NO_TEMPLATE_SWITCH_MERGE)
} // namespace
case regbase::restart_fixed_lit:
{
const kmp_info<charT>* info = access::get_kmp(e);
- std::ptrdiff_t len = info->len;
+ int len = info->len;
const charT* x = info->pstr;
- std::ptrdiff_t j = 0;
+ int j = 0;
bool icase = e.flags() & regbase::icase;
while (first != last)
{
re_detail::_priv_match_data<iterator, Allocator> pd(m);
iterator restart;
bool result = re_detail::query_match_aux(first, last, m, e, flags, pd, &restart);
- if(result && (last == m[0].second))
- return true;
- return false;
+ return result;
}
template <class iterator, class charT, class traits, class Allocator2>
bool regex_match(iterator first, iterator last, const reg_expression<charT, traits, Allocator2>& e, unsigned flags = match_default)
+
+
namespace re_detail{
#ifdef __BORLANDC__
- #pragma option push -a4 -b -Ve -pc
+ #pragma option push -a8 -b -Vx -Ve -pc
#endif
struct empty_padding{};
namespace boost{
#ifdef __BORLANDC__
- #pragma option push -a4 -b -Ve -pc
+ #pragma option push -a8 -b -Vx -Ve -pc
#endif
namespace re_detail{
namespace re_detail{
#ifdef __BORLANDC__
- #pragma option push -a4 -b -Ve -pc
+ #pragma option push -a8 -b -Vx -Ve -pc
#endif
//
namespace re_detail{
#ifdef __BORLANDC__
- #pragma option push -a4 -b -Ve -pc
+ #pragma option push -a8 -b -Vx -Ve -pc
#endif
void BOOST_REGEX_CALL re_init_threads();
namespace boost{
#ifdef __BORLANDC__
- #pragma option push -a4 -b -Ve -pc
+ #pragma option push -a8 -b -Vx -Ve -pc
#endif
class BOOST_REGEX_DECL bad_pattern : public std::runtime_error
namespace boost{
#ifdef __BORLANDC__
- #pragma option push -a4 -b -Ve -pc
+ #pragma option push -a8 -b -Vx -Ve -pc
#endif
template <class charT>
syntax_max = 54
};
+#ifdef __BORLANDC__
+private:
+ char dummy_member;
+#endif
};
struct BOOST_REGEX_DECL c_traits_base : public regex_traits_base
#include <boost/signals/signal10.hpp>
namespace boost {
- namespace signals {
+ namespace BOOST_SIGNALS_NAMESPACE {
namespace detail {
// The unusable class is a placeholder for unused function arguments.
struct unused {};
struct real_get_signal_impl<0>
{
template<
- typename R,
+ typename R,
typename T1,
typename T2,
typename T3,
typename T8,
typename T9,
typename T10,
- typename Combiner = last_value<R>
+ typename Combiner
>
struct params
{
typename T8,
typename T9,
typename T10,
- typename Combiner = last_value<R>
+ typename Combiner
>
struct params
{
typename T8,
typename T9,
typename T10,
- typename Combiner = last_value<R>
+ typename Combiner
>
struct params
{
typename T8,
typename T9,
typename T10,
- typename Combiner = last_value<R>
+ typename Combiner
>
struct params
{
typename T8,
typename T9,
typename T10,
- typename Combiner = last_value<R>
+ typename Combiner
>
struct params
{
typename T8,
typename T9,
typename T10,
- typename Combiner = last_value<R>
+ typename Combiner
>
struct params
{
typename T8,
typename T9,
typename T10,
- typename Combiner = last_value<R>
+ typename Combiner
>
struct params
{
typename T8,
typename T9,
typename T10,
- typename Combiner = last_value<R>
+ typename Combiner
>
struct params
{
typename T8,
typename T9,
typename T10,
- typename Combiner = last_value<R>
+ typename Combiner
>
struct params
{
typename T8,
typename T9,
typename T10,
- typename Combiner = last_value<R>
+ typename Combiner
>
struct params
{
typename T8,
typename T9,
typename T10,
- typename Combiner = last_value<R>
+ typename Combiner
>
struct params
{
typename T8,
typename T9,
typename T10,
- typename Combiner = last_value<R>
+ typename Combiner
>
struct get_signal_impl
{
- typedef typename real_get_signal_impl<
- (count_used_args<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value)
- >::template params<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
- Combiner>::type
- type;
+ private:
+ typedef real_get_signal_impl<
+ (::boost::BOOST_SIGNALS_NAMESPACE::detail::count_used_args<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value)> t1;
+ typedef typename t1::template params<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
+ Combiner> t2;
+ public:
+ typedef typename t2::type type;
};
} // end namespace detail
- } // end namespace signals
+ } // end namespace BOOST_SIGNALS_NAMESPACE
// Very lightweight wrapper around the signalN classes that allows signals to
// be created where the number of arguments does not need to be part of the
// class name.
template<
typename R,
- typename T1 = signals::detail::unused,
- typename T2 = signals::detail::unused,
- typename T3 = signals::detail::unused,
- typename T4 = signals::detail::unused,
- typename T5 = signals::detail::unused,
- typename T6 = signals::detail::unused,
- typename T7 = signals::detail::unused,
- typename T8 = signals::detail::unused,
- typename T9 = signals::detail::unused,
- typename T10 = signals::detail::unused
+ typename T1 = BOOST_SIGNALS_NAMESPACE::detail::unused,
+ typename T2 = BOOST_SIGNALS_NAMESPACE::detail::unused,
+ typename T3 = BOOST_SIGNALS_NAMESPACE::detail::unused,
+ typename T4 = BOOST_SIGNALS_NAMESPACE::detail::unused,
+ typename T5 = BOOST_SIGNALS_NAMESPACE::detail::unused,
+ typename T6 = BOOST_SIGNALS_NAMESPACE::detail::unused,
+ typename T7 = BOOST_SIGNALS_NAMESPACE::detail::unused,
+ typename T8 = BOOST_SIGNALS_NAMESPACE::detail::unused,
+ typename T9 = BOOST_SIGNALS_NAMESPACE::detail::unused,
+ typename T10 = BOOST_SIGNALS_NAMESPACE::detail::unused
>
class signal :
- public signals::detail::get_signal_impl<R, T1, T2, T3, T4, T5, T6, T7,
- T8, T9, T10>::type
+ public BOOST_SIGNALS_NAMESPACE::detail::get_signal_impl<R, T1, T2, T3, T4, T5, T6, T7,
+ T8, T9, T10, boost::last_value<R> >::type
{
public:
template<typename Combiner>
struct combiner {
- typedef typename signals::detail::get_signal_impl<R, T1, T2, T3, T4, T5,
- T6, T7, T8, T9, T10,
- Combiner>::type
- type;
+ private:
+ typedef BOOST_SIGNALS_NAMESPACE::detail::get_signal_impl<R, T1, T2, T3, T4, T5,
+ T6, T7, T8, T9, T10, Combiner> t1;
+ public:
+ typedef typename t1::type type;
};
};
} // end namespace boost
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.
-
+
// For more information, see http://www.boost.org
#ifndef BOOST_SIGNALS_CONNECTION_HPP
#include <utility>
namespace boost {
- namespace signals {
+ namespace BOOST_SIGNALS_NAMESPACE {
class trackable;
namespace detail {
// Represents an object that has been bound as part of a slot, and how
// to notify that object of a disconnect
struct bound_object {
- void* obj;
- void* data;
- void (*disconnect)(void*, void*);
-
- bool operator==(const bound_object& other) const
- { return obj == other.obj && data == other.data; }
- bool operator<(const bound_object& other) const
- { return obj < other.obj; }
+ void* obj;
+ void* data;
+ void (*disconnect)(void*, void*);
+
+ bool operator==(const bound_object& other) const
+ { return obj == other.obj && data == other.data; }
+ bool operator<(const bound_object& other) const
+ { return obj < other.obj; }
};
-
+
// Describes the connection between a signal and the objects that are
// bound for a specific slot. Enables notification of the signal and the
// slots when a disconnect is requested.
struct basic_connection {
- void* signal;
- void* signal_data;
- void (*signal_disconnect)(void*, void*);
-
- std::list<bound_object> bound_objects;
+ void* signal;
+ void* signal_data;
+ void (*signal_disconnect)(void*, void*);
+
+ std::list<bound_object> bound_objects;
};
} // end namespace detail
// The user may freely pass around the "connection" object and terminate
// the connection at any time using disconnect().
- class connection :
+ class connection :
private less_than_comparable1<connection>,
private equality_comparable1<connection>
{
friend class trackable;
// Reset this connection to refer to a different actual connection
- void reset(signals::detail::basic_connection*);
+ void reset(BOOST_SIGNALS_NAMESPACE::detail::basic_connection*);
// Add a bound object to this connection (not for users)
- void add_bound_object(const signals::detail::bound_object& b);
+ void add_bound_object(const BOOST_SIGNALS_NAMESPACE::detail::bound_object& b);
- friend class signals::detail::bound_objects_visitor;
+ friend class BOOST_SIGNALS_NAMESPACE::detail::bound_objects_visitor;
// Pointer to the actual contents of the connection
- shared_ptr<signals::detail::basic_connection> con;
+ shared_ptr<BOOST_SIGNALS_NAMESPACE::detail::basic_connection> con;
// True if the destruction of this connection object should disconnect
bool controlling_connection;
}
inline connection::connection(const connection& other) :
- con(other.con), controlling_connection(other.controlling_connection)
+ con(other.con), controlling_connection(other.controlling_connection)
{
}
inline connection::~connection()
{
if (controlling_connection) {
- disconnect();
+ disconnect();
}
}
- inline void
- connection::reset(signals::detail::basic_connection* new_con)
+ inline void
+ connection::reset(BOOST_SIGNALS_NAMESPACE::detail::basic_connection* new_con)
{
con.reset(new_con);
}
- inline void
- connection::add_bound_object(const signals::detail::bound_object& b)
+ inline void
+ connection::add_bound_object(const BOOST_SIGNALS_NAMESPACE::detail::bound_object& b)
{
- // c-assert expects an int, so don't pass it a pointer
- assert(con.get() != 0);
+ assert(con.get());
con->bound_objects.push_back(b);
}
}
inline connection& connection::operator=(const connection& other)
- {
+ {
connection(other).swap(*this);
return *this;
}
{
}
- inline
+ inline
scoped_connection::scoped_connection(const scoped_connection& other) :
connection(other),
released(other.released)
inline scoped_connection::~scoped_connection()
{
if (!released) {
- this->disconnect();
+ this->disconnect();
}
}
c1.swap(c2);
}
- inline scoped_connection&
+ inline scoped_connection&
scoped_connection::operator=(const connection& other)
{
scoped_connection(other).swap(*this);
return *this;
}
- inline scoped_connection&
+ inline scoped_connection&
scoped_connection::operator=(const scoped_connection& other)
{
scoped_connection(other).swap(*this);
namespace detail {
struct connection_slot_pair {
- connection first;
- any second;
+ connection first;
+ any second;
- connection_slot_pair() {}
+ connection_slot_pair() {}
- connection_slot_pair(const connection& c, const any& a)
- : first(c), second(a)
- {
- }
+ connection_slot_pair(const connection& c, const any& a)
+ : first(c), second(a)
+ {
+ }
- // Dummys to allow explicit instantiation to work
- bool operator==(const connection_slot_pair&) const { return false; }
- bool operator<(const connection_slot_pair&) const { return false;}
+ // Dummys to allow explicit instantiation to work
+ bool operator==(const connection_slot_pair&) const { return false; }
+ bool operator<(const connection_slot_pair&) const { return false;}
};
-
+
// Determines if the underlying connection is disconnected
struct is_disconnected {
- typedef std::pair<const any, connection_slot_pair> argument_type;
- typedef bool result_type;
+ typedef std::pair<const any, connection_slot_pair> argument_type;
+ typedef bool result_type;
- inline bool operator()(const argument_type& c) const
- {
- return !c.second.first.connected();
- }
+ inline bool operator()(const argument_type& c) const
+ {
+ return !c.second.first.connected();
+ }
};
// Autodisconnects the bound object when it is destroyed unless the
// release method is invoked.
class auto_disconnect_bound_object {
public:
- auto_disconnect_bound_object(const bound_object& b) :
- binding(b), auto_disconnect(true)
- {
- }
+ auto_disconnect_bound_object(const bound_object& b) :
+ binding(b), auto_disconnect(true)
+ {
+ }
- ~auto_disconnect_bound_object()
- {
- if (auto_disconnect)
- binding.disconnect(binding.obj, binding.data);
- }
+ ~auto_disconnect_bound_object()
+ {
+ if (auto_disconnect)
+ binding.disconnect(binding.obj, binding.data);
+ }
- void release() { auto_disconnect = false; }
+ void release() { auto_disconnect = false; }
private:
- bound_object binding;
- bool auto_disconnect;
+ bound_object binding;
+ bool auto_disconnect;
};
} // end namespace detail
- } // end namespace signals
+ } // end namespace BOOST_SIGNALS_NAMESPACE
} // end namespace boost
#endif // BOOST_SIGNALS_CONNECTION_HPP
#include <vector>
namespace boost {
- namespace signals {
+ namespace BOOST_SIGNALS_NAMESPACE {
namespace detail {
// Forward declaration for the mapping from slot names to connections
class named_slot_map;
slot_container_type;
typedef slot_container_type::iterator slot_iterator;
typedef slot_container_type::value_type stored_slot_type;
- mutable slot_container_type slots;
+ mutable slot_container_type slots_;
};
class signal_base : public noncopyable {
shared_ptr<signal_base_impl> impl;
};
} // end namespace detail
- } // end namespace signals
+ } // end namespace BOOST_SIGNALS_NAMESPACE
} // end namespace boost
#endif // BOOST_SIGNALS_SIGNAL_BASE_HEADER
#ifndef BOOST_SIGNALS_COMMON_HEADER
#define BOOST_SIGNALS_COMMON_HEADER
+#ifndef BOOST_SIGNALS_NAMESPACE
+# define BOOST_SIGNALS_NAMESPACE signals
+#endif
+
#include <boost/type_traits/conversion_traits.hpp>
#include <boost/ref.hpp>
namespace boost {
- namespace signals {
+ namespace BOOST_SIGNALS_NAMESPACE {
namespace detail {
// The unusable class is a placeholder for unused function arguments
// It is also completely unusable except that it constructable from
class bound_objects_visitor;
class slot_base;
} // end namespace detail
- } // end namespace signals
+ } // end namespace BOOST_SIGNALS_NAMESPACE
} // end namespace boost
#endif // BOOST_SIGNALS_COMMON_HEADER
#include <boost/signals/connection.hpp>
namespace boost {
- namespace signals {
+ namespace BOOST_SIGNALS_NAMESPACE {
namespace detail {
// A cached return value from a slot
template<typename T>
return sc_iterator(first, sc_policy(last, f));
}
} // end namespace detail
- } // end namespace signals
+ } // end namespace BOOST_SIGNALS_NAMESPACE
} // end namespace boost
#endif // BOOST_SIGNALS_SLOT_CALL_ITERATOR
// Define commonly-used instantiations
#define BOOST_SIGNALS_ARGS_STRUCT_INST \
- signals::detail::BOOST_SIGNALS_ARGS_STRUCT<BOOST_SIGNALS_TEMPLATE_ARGS>
+ BOOST_SIGNALS_NAMESPACE::detail::BOOST_SIGNALS_ARGS_STRUCT<BOOST_SIGNALS_TEMPLATE_ARGS>
namespace boost {
- namespace signals {
+ namespace BOOST_SIGNALS_NAMESPACE {
namespace detail {
// Holds the arguments for a bound slot call in a single place
template<BOOST_SIGNALS_TEMPLATE_PARMS
};
};
} // namespace detail
- } // namespace signals
+ } // namespace BOOST_SIGNALS_NAMESPACE
// The actual signalN class
template<
BOOST_SIGNALS_TEMPLATE_ARGS>
>
class BOOST_SIGNALS_SIGNAL :
- public signals::detail::signal_base, // management of slot list
- public signals::trackable // signals are trackable
+ public BOOST_SIGNALS_NAMESPACE::detail::signal_base, // management of slot list
+ public BOOST_SIGNALS_NAMESPACE::trackable // signals are trackable
{
public:
// The slot function type
typedef SlotFunction slot_function_type;
// Result type of a slot
- typedef typename signals::detail::slot_result_type<R>::type
+ typedef typename BOOST_SIGNALS_NAMESPACE::detail::slot_result_type<R>::type
slot_result_type;
// Argument types
private:
// The real slot name comparison object type
- typedef signals::detail::any_bridge_compare<GroupCompare, Group>
+ typedef BOOST_SIGNALS_NAMESPACE::detail::any_bridge_compare<GroupCompare, Group>
real_group_compare_type;
// The function object passed to the slot call iterator that will call
// the underlying slot function with its arguments bound
- typedef signals::detail::BOOST_SIGNALS_CALL_BOUND<R>
+ typedef BOOST_SIGNALS_NAMESPACE::detail::BOOST_SIGNALS_CALL_BOUND<R>
outer_bound_slot_caller;
typedef typename outer_bound_slot_caller::template
caller<BOOST_SIGNALS_TEMPLATE_ARGS
typedef Group group_type;
typedef GroupCompare group_compare_type;
- typedef typename signals::detail::slot_call_iterator_generator<
+ typedef typename BOOST_SIGNALS_NAMESPACE::detail::slot_call_iterator_generator<
call_bound_slot,
slot_iterator>::type slot_call_iterator;
explicit
BOOST_SIGNALS_SIGNAL(const Combiner& c = Combiner(),
const GroupCompare& comp = GroupCompare()) :
- signals::detail::signal_base(real_group_compare_type(comp)),
+ BOOST_SIGNALS_NAMESPACE::detail::signal_base(real_group_compare_type(comp)),
combiner(c)
{
}
// Connect a slot to this signal
- signals::connection connect(const slot_type&);
- signals::connection connect(const group_type&, const slot_type&);
+ BOOST_SIGNALS_NAMESPACE::connection connect(const slot_type&);
+ BOOST_SIGNALS_NAMESPACE::connection connect(const group_type&, const slot_type&);
// Disconnect a named slot
void disconnect(const group_type& group)
typename GroupCompare,
typename SlotFunction
>
- signals::connection
+ BOOST_SIGNALS_NAMESPACE::connection
BOOST_SIGNALS_SIGNAL<
R, BOOST_SIGNALS_TEMPLATE_ARGS
BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS
// If the slot has been disconnected, just return a disconnected
// connection
if (!in_slot.is_active()) {
- return signals::connection();
+ return BOOST_SIGNALS_NAMESPACE::connection();
}
return impl->connect_slot(in_slot.get_slot_function(),
typename GroupCompare,
typename SlotFunction
>
- signals::connection
+ BOOST_SIGNALS_NAMESPACE::connection
BOOST_SIGNALS_SIGNAL<
R, BOOST_SIGNALS_TEMPLATE_ARGS
BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS
>::operator()(BOOST_SIGNALS_PARMS)
{
// Notify the slot handling code that we are making a call
- signals::detail::call_notification notification(this->impl);
+ BOOST_SIGNALS_NAMESPACE::detail::call_notification notification(this->impl);
// Construct a function object that will call the underlying slots
// with the given arguments.
call_bound_slot f(&args);
// Let the combiner call the slots via a pair of input iterators
- return combiner(signals::detail::make_slot_call_iterator(
- notification.impl->slots.begin(), impl->slots.end(), f),
- signals::detail::make_slot_call_iterator(
- notification.impl->slots.end(), impl->slots.end(), f));
+ return combiner(BOOST_SIGNALS_NAMESPACE::detail::make_slot_call_iterator(
+ notification.impl->slots_.begin(), impl->slots_.end(), f),
+ BOOST_SIGNALS_NAMESPACE::detail::make_slot_call_iterator(
+ notification.impl->slots_.end(), impl->slots_.end(), f));
}
template<
>::operator()(BOOST_SIGNALS_PARMS) const
{
// Notify the slot handling code that we are making a call
- signals::detail::call_notification notification(this->impl);
+ BOOST_SIGNALS_NAMESPACE::detail::call_notification notification(this->impl);
// Construct a function object that will call the underlying slots
// with the given arguments.
call_bound_slot f(&args);
// Let the combiner call the slots via a pair of input iterators
- return combiner(signals::detail::make_slot_call_iterator(
- notification.impl->slots.begin(), impl->slots.end(), f),
- signals::detail::make_slot_call_iterator(
- notification.impl->slots.end(), impl->slots.end(), f));
+ return combiner(BOOST_SIGNALS_NAMESPACE::detail::make_slot_call_iterator(
+ notification.impl->slots_.begin(), impl->slots_.end(), f),
+ BOOST_SIGNALS_NAMESPACE::detail::make_slot_call_iterator(
+ notification.impl->slots_.end(), impl->slots_.end(), f));
}
} // namespace boost
#include <cassert>
namespace boost {
- namespace signals {
+ namespace BOOST_SIGNALS_NAMESPACE {
namespace detail {
class slot_base {
// We would have to enumerate all of the signalN classes here as
// Get the slot so that it can be copied
template<typename F>
reference_wrapper<const F>
- get_invocable_slot(const F& f, signals::detail::signal_tag)
+ get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::signal_tag)
{ return reference_wrapper<const F>(f); }
template<typename F>
- const F& get_invocable_slot(const F& f, signals::detail::reference_tag)
+ const F& get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::reference_tag)
{ return f; }
template<typename F>
- const F& get_invocable_slot(const F& f, signals::detail::value_tag)
+ const F& get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::value_tag)
{ return f; }
// Get the slot so that it can be inspected for trackable objects
template<typename F>
const F& get_inspectable_slot(const F& f,
- signals::detail::signal_tag)
+ BOOST_SIGNALS_NAMESPACE::detail::signal_tag)
{ return f; }
template<typename F>
const F& get_inspectable_slot(const F& f,
- signals::detail::reference_tag)
+ BOOST_SIGNALS_NAMESPACE::detail::reference_tag)
{ return f.get(); }
template<typename F>
- const F& get_inspectable_slot(const F& f, signals::detail::value_tag)
+ const F& get_inspectable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::value_tag)
{ return f; }
// Determines the type of the slot - is it a signal, a reference to a
// slot or just a normal slot.
template<typename F>
- typename signals::detail::get_slot_tag<F>::type
+ typename BOOST_SIGNALS_NAMESPACE::detail::get_slot_tag<F>::type
tag_type(const F&)
{
- typename signals::detail::get_slot_tag<F>::type tag;
+ typename BOOST_SIGNALS_NAMESPACE::detail::get_slot_tag<F>::type tag;
return tag;
}
static void bound_object_destructed(void*, void*) {}
};
} // end namespace detail
- } // end namespace signals
+ } // end namespace BOOST_SIGNALS_NAMESPACE
template<typename SlotFunction>
- class slot : public signals::detail::slot_base {
+ class slot : public BOOST_SIGNALS_NAMESPACE::detail::slot_base {
public:
template<typename F>
slot(const F& f) : slot_function(get_invocable_slot(f, tag_type(f)))
// An exception thrown here will allow the basic_connection to be
// destroyed when this goes out of scope, and no other connections
// have been made.
- signals::detail::bound_objects_visitor do_bind(bound_objects);
+ BOOST_SIGNALS_NAMESPACE::detail::bound_objects_visitor do_bind(bound_objects);
visit_each(do_bind, get_inspectable_slot(f, tag_type(f)));
create_connection();
#include <vector>
namespace boost {
- namespace signals {
+ namespace BOOST_SIGNALS_NAMESPACE {
// Base class for "trackable" objects that can be tracked when they are
// bound in slot target functions. When a trackable object is destroyed,
// the signal/slot connections are disconnected automatically.
friend class detail::signal_base_impl;
friend class detail::slot_base;
- void signal_connected(connection, signals::detail::bound_object&) const;
+ void signal_connected(connection, BOOST_SIGNALS_NAMESPACE::detail::bound_object&) const;
protected:
trackable() : connected_signals(), dying(false) {}
mutable std::vector<const trackable*>& bound_objects;
};
} // end namespace detail
- } // end namespace signals
+ } // end namespace BOOST_SIGNALS_NAMESPACE
}
#endif // BOOST_SIGNALS_TRACKABLE_HPP
neq(lhs.get_tail(), rhs.get_tail());
}
template<>
-inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return true; }
+inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return false; }
template<class T1, class T2>
inline bool lt(const T1& lhs, const T2& rhs) {
//
#ifndef BOOST_TT_ARRAY_TRAITS_HPP
# define BOOST_TT_ARRAY_TRAITS_HPP
+# include <cstddef>
# include <boost/type_traits/utility.hpp>
# include <boost/type_traits/ice.hpp>
#define BOOST_REGEX_SOURCE
+#include <boost/config.hpp>
+
+# ifdef BOOST_MSVC
+# pragma warning(disable: 4702)
+# endif
+
#include <clocale>
#include <cstdio>
#include <list>
map_size = UCHAR_MAX + 1
};
+std::size_t BOOST_REGEX_CALL _re_get_message(char* buf, std::size_t len, std::size_t id);
+
#ifndef BOOST_NO_WREGEX
BOOST_REGEX_DECL wchar_t re_zero_w;
std::list<syntax_map_t>* syntax;
-#endif
-
-
-std::size_t BOOST_REGEX_CALL _re_get_message(char* buf, std::size_t len, std::size_t id);
-
-template <class charT>
-std::size_t BOOST_REGEX_CALL re_get_message(charT* buf, std::size_t len, std::size_t id)
+std::size_t BOOST_REGEX_CALL re_get_message(wchar_t* buf, std::size_t len, std::size_t id)
{
std::size_t size = _re_get_message(static_cast<char*>(0), 0, id);
if(len < size)
size = boost::c_regex_traits<wchar_t>::strwiden(buf, len, cb.get());
return size;
}
+#endif
inline std::size_t BOOST_REGEX_CALL re_get_message(char* buf, std::size_t len, std::size_t id)
{
re_free_classes();
re_free_collate();
--entry_count;
- if(entry_count == 0)
+ // add reference to static member here to ensure
+ // that the linker includes it in the .exe:
+ if((entry_count == 0) && (0 != &c_regex_traits<char>::i))
{
delete ctype_name;
delete collate_name;
re_message_free();
re_free_classes();
re_free_collate();
- if(nlsw_count == 0)
+ // add reference to static member here to ensure
+ // that the linker includes it in the .exe:
+ if((nlsw_count == 0) && (0 != &c_regex_traits<wchar_t>::init_))
{
// cleanup:
delete wlocale_name;
#ifndef BOOST_NO_STD_LOCALE
+# ifdef BOOST_MSVC
+# pragma warning(disable:4786 4702 4127 4244)
+# endif
+
#include <clocale>
#include <locale>
#include <cstdio>
#include <boost/scoped_array.hpp>
#include "primary_transform.hpp"
-
# ifdef BOOST_MSVC
-# pragma warning(disable:4786)
+# pragma warning(disable:4786 4702 4127 4244)
# endif
namespace{
std::size_t BOOST_REGEX_CALL _re_get_message(char* buf, std::size_t len, unsigned id);
-template <class charT>
-std::size_t BOOST_REGEX_CALL get_message(charT* buf, std::size_t len, unsigned id)
+std::size_t BOOST_REGEX_CALL get_message(wchar_t* buf, std::size_t len, unsigned id)
{
std::size_t size = _re_get_message(static_cast<char*>(0), 0, id);
if(len < size)
{
BOOST_RE_GUARD_STACK
delete[] pclasses;
+ pclasses = 0;
delete pcoll_names;
+ pcoll_names = 0;
#ifndef BOOST_NO_WREGEX
delete syntax;
+ syntax = 0;
#endif
if(hresmod)
{
re_custom_error_messages[i] = 0;
}
}
+ is_init = false;
}
std::string BOOST_REGEX_CALL w32_traits_base::error_string(unsigned id)
#ifdef BOOST_HAS_THREADS
re_detail::cs_guard g(*re_detail::p_re_lock);
#endif
- if(--entry_count == 0)
+ // add reference to static member here to ensure
+ // that the linker includes it in the .exe:
+ if((--entry_count == 0) && (0 != &w32_regex_traits<char>::i))
do_free();
#ifdef BOOST_HAS_THREADS
g.acquire(false);
#ifdef BOOST_HAS_THREADS
re_detail::cs_guard g(*re_detail::p_re_lock);
#endif
- if(--entry_count == 0)
+ // add reference to static member here to ensure
+ // that the linker includes it in the .exe:
+ if((--entry_count == 0) && (0 != &w32_regex_traits<wchar_t>::init_))
do_free();
#ifdef BOOST_HAS_THREADS
g.acquire(false);
#endif // #if defined(_WIN32) && !defined(BOOST_REGEX_NO_W32)
+
#include <cassert>
namespace boost {
- namespace signals {
+ namespace BOOST_SIGNALS_NAMESPACE {
void connection::disconnect() const
{
if (this->connected()) {
signal_disconnect(local_con->signal, local_con->signal_data);
// Disconnect all bound objects
- typedef std::list<signals::detail::bound_object>::iterator iterator;
+ typedef std::list<BOOST_SIGNALS_NAMESPACE::detail::bound_object>::iterator iterator;
for (iterator i = local_con->bound_objects.begin();
i != local_con->bound_objects.end(); ++i) {
- // c-assert expects an int, so don't pass it a pointer
- assert(i->disconnect != 0);
+ assert(i->disconnect);
i->disconnect(i->obj, i->data);
}
}
#ifndef BOOST_MSVC
// Explicit instantiations to keep everything in the library
-template class std::list<boost::signals::detail::bound_object>;
+template class std::list<boost::BOOST_SIGNALS_NAMESPACE::detail::bound_object>;
#endif
#include <cassert>
namespace boost {
- namespace signals {
+ namespace BOOST_SIGNALS_NAMESPACE {
namespace detail {
signal_base_impl::signal_base_impl(const compare_type& comp) :
call_depth(0),
- slots(comp)
+ slots_(comp)
{
flags.delayed_disconnect = false;
flags.clearing = false;
if (call_depth == 0) {
// Clearing the slot list will disconnect all slots automatically
temporarily_set_clearing set_clearing(this);
- slots.clear();
+ slots_.clear();
}
else {
// We can't actually remove elements from the slot list because there
// reach zero, the call list will be cleared.
flags.delayed_disconnect = true;
temporarily_set_clearing set_clearing(this);
- for (slot_iterator i = slots.begin(); i != slots.end(); ++i) {
+ for (slot_iterator i = slots_.begin(); i != slots_.end(); ++i) {
i->second.first.disconnect();
}
}
// Add the slot to the list.
slot_iterator pos =
- slots.insert(stored_slot_type(name,
+ slots_.insert(stored_slot_type(name,
connection_slot_pair(slot_connection,
slot)));
// Disconnected slots may still be in the list of slots if
// a) this is called while slots are being invoked (call_depth > 0)
// b) an exception was thrown in remove_disconnected_slots
- for (slot_iterator i = slots.begin(); i != slots.end(); ++i) {
+ for (slot_iterator i = slots_.begin(); i != slots_.end(); ++i) {
if (i->second.first.connected())
return false;
}
void signal_base_impl::disconnect(const any& group)
{
std::pair<slot_iterator, slot_iterator> group_slots =
- slots.equal_range(group);
+ slots_.equal_range(group);
while (group_slots.first != group_slots.second) {
slot_iterator next = group_slots.first;
++next;
}
else {
// Just remove the slot now, it's safe
- self->slots.erase(*slot);
+ self->slots_.erase(*slot);
}
}
}
void signal_base_impl::remove_disconnected_slots() const
{
// Remove any disconnected slots
- for (slot_iterator i = slots.begin(); i != slots.end(); /* none */) {
+ for (slot_iterator i = slots_.begin(); i != slots_.end(); /* none */) {
if (!i->second.first.connected())
- slots.erase(i++);
+ slots_.erase(i++);
else
++i;
}
{
}
} // namespace detail
- } // namespace signals
+ } // namespace BOOST_SIGNALS_NAMESPACE
} // namespace boost
#ifndef BOOST_MSVC
// Explicit instantiations to keep in the library
template class boost::function2<bool, boost::any, boost::any>;
template class std::multimap<boost::any,
- boost::signals::detail::connection_slot_pair,
+ boost::BOOST_SIGNALS_NAMESPACE::detail::connection_slot_pair,
boost::function2<bool, boost::any, boost::any> >;
#endif
#include <boost/signals/slot.hpp>
namespace boost {
- namespace signals {
+ namespace BOOST_SIGNALS_NAMESPACE {
namespace detail {
void slot_base::create_connection()
{
for(std::vector<const trackable*>::iterator i = bound_objects.begin();
i != bound_objects.end(); ++i) {
// Notify the object that the slot is connecting to it
- signals::detail::bound_object binding;
+ BOOST_SIGNALS_NAMESPACE::detail::bound_object binding;
(*i)->signal_connected(watch_bound_objects, binding);
// This will notify the bound object that the connection just made
// should be disconnected if an exception is thrown before the
// end of this iteration
- signals::detail::auto_disconnect_bound_object disconnector(binding);
+ BOOST_SIGNALS_NAMESPACE::detail::auto_disconnect_bound_object disconnector(binding);
// Add the binding to the list of bindings for the connection
con->bound_objects.push_back(binding);
safe_connection.release();
}
} // end namespace detail
- } // end namespace signals
+ } // end namespace BOOST_SIGNALS_NAMESPACE
} // end namespace boost
#include <algorithm>
namespace boost {
- namespace signals {
+ namespace BOOST_SIGNALS_NAMESPACE {
void trackable::signal_disconnected(void* obj, void* data)
{
trackable* self = reinterpret_cast<trackable*>(obj);
void
trackable::signal_connected(connection c,
- signals::detail::bound_object& binding) const
+ BOOST_SIGNALS_NAMESPACE::detail::bound_object& binding) const
{
// Insert the connection
connection_iterator pos =
{
dying = true;
}
- } // end namespace signals
+ } // end namespace BOOST_SIGNALS_NAMESPACE
}
#ifndef BOOST_MSVC
// Explicit instantiations to keep in the library
-template class std::list<boost::signals::connection>;
+template class std::list<boost::BOOST_SIGNALS_NAMESPACE::connection>;
#endif
projects / lyx.git / commitdiff