anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-12-28 14:58:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

update

Browse Source 
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@4415 a592a061-630c-0410-9148-cb99ea01b6c8
This commit is contained in:
Lars Gullik Bjønnes 2002-06-18 15:39:27 +00:00
parent 355838e9f8
commit fa06f3acc2
111 changed files with 1192 additions and 1344 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
boost/ChangeLog
View File

@ -1,3 +1,7 @@
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:

4
boost/boost/any.hpp
View File

@ -82,7 +82,7 @@ namespace boost
class placeholder
{
public: // structors
virtual ~placeholder()
{
}
@ -92,7 +92,7 @@ namespace boost
virtual const std::type_info & type() const = 0;
virtual placeholder * clone() const = 0;
};
template<typename ValueType>

2
boost/boost/array_traits.hpp
View File

@ -13,7 +13,7 @@
// 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

82
boost/boost/bind.hpp
View File

@ -59,6 +59,11 @@ template<class F> struct result_traits<unspecified, F>
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
@ -85,6 +90,23 @@ private:
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
@ -120,7 +142,7 @@ public:
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
@ -160,7 +182,7 @@ public:
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
@ -208,7 +230,7 @@ public:
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
@ -260,7 +282,7 @@ public:
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
@ -316,7 +338,7 @@ public:
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
@ -376,7 +398,7 @@ public:
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
@ -440,7 +462,7 @@ public:
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
@ -508,7 +530,7 @@ public:
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
@ -580,7 +602,7 @@ public:
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
@ -656,7 +678,7 @@ public:
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
@ -703,7 +725,7 @@ template <class R> struct evaluator0
template<class L, class F, class A>
static R eval(L const&, F f, A &)
{
return f();
return unwrap(f, 0)();
}
};
@ -712,7 +734,7 @@ template <> struct evaluator0<void>
template<class L, class F, class A>
static void eval(L const&, F f, A &)
{
f();
unwrap(f, 0)();
}
};
@ -721,7 +743,7 @@ template <class R> struct evaluator1
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_]);
}
};
@ -730,7 +752,7 @@ template <> struct evaluator1<void>
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_]);
}
};
@ -739,7 +761,7 @@ template <class R> struct evaluator2
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_]);
}
};
@ -748,7 +770,7 @@ template <> struct evaluator2<void>
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_]);
}
};
@ -757,7 +779,7 @@ template <class R> struct evaluator3
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_]);
}
};
@ -766,7 +788,7 @@ template <> struct evaluator3<void>
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_]);
}
};
@ -775,7 +797,7 @@ template <class R> struct evaluator4
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_]);
}
};
@ -784,7 +806,7 @@ template <> struct evaluator4<void>
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_]);
}
};
@ -793,7 +815,7 @@ template <class R> struct evaluator5
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_]);
}
};
@ -802,7 +824,7 @@ template <> struct evaluator5<void>
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_]);
}
};
@ -811,7 +833,7 @@ template <class R> struct evaluator6
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_]);
}
};
@ -820,7 +842,7 @@ template <> struct evaluator6<void>
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_]);
}
};
@ -829,7 +851,7 @@ template <class R> struct evaluator7
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_]);
}
};
@ -838,7 +860,7 @@ template <> struct evaluator7<void>
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_]);
}
};
@ -847,7 +869,7 @@ template <class R> struct evaluator8
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_]);
}
};
@ -856,7 +878,7 @@ template <> struct evaluator8<void>
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_]);
}
};
@ -865,7 +887,7 @@ template <class R> struct evaluator9
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_]);
}
};
@ -874,7 +896,7 @@ template <> struct evaluator9<void>
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_]);
}
};

2
boost/boost/config/platform/macos.hpp
View File

@ -10,7 +10,7 @@
#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

2
boost/boost/cregex.hpp
View File

@ -27,7 +27,7 @@
#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 */

12
boost/boost/detail/iterator.hpp
View File

@ -62,14 +62,10 @@
# 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
@ -110,7 +106,7 @@ template <> struct iterator_traits_select<true>
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.
@ -183,7 +179,7 @@ struct bad_output_iterator_select<false>
};
# 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
@ -291,7 +287,7 @@ template <> struct iterator_traits_select<false>
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;

25
boost/boost/detail/limits.hpp
View File

@ -159,7 +159,7 @@ template <class _Int,
_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);
@ -170,9 +170,9 @@ public:
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);
@ -192,7 +192,7 @@ public:
// sizeof(long double) == 16
const unsigned int _S_word[4] = { Word, 0, 0, 0 };
return *reinterpret_cast<const Number*>(&_S_word);
}
}
};
#else
@ -205,7 +205,7 @@ public:
return *reinterpret_cast<const Number*>(
reinterpret_cast<const char *>(&_S_word)+16-
(sizeof(Number) == 12 ? 10 : sizeof(Number)));
}
}
};
#endif
@ -244,7 +244,7 @@ public:
denorm_indeterminate);
BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss, false);
static __number infinity() throw() {
return float_helper<__number, __InfinityWord>::get_word();
}
@ -267,7 +267,7 @@ public:
// The unspecialized class.
template<class T>
template<class T>
class numeric_limits : public _Numeric_limits_base<T> {};
// Specializations for all built-in integral types.
@ -356,7 +356,7 @@ class numeric_limits<unsigned long>
#if !defined(LONGLONG_MIN)
# define LONGLONG_MIN (-LONGLONG_MAX - 1)
#endif
#endif
template<>
class numeric_limits<long long>
@ -373,7 +373,7 @@ class numeric_limits<unsigned 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
@ -401,7 +401,7 @@ public:
};
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
@ -429,7 +429,7 @@ public:
};
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
@ -463,3 +463,6 @@ public:
// Local Variables:
// mode:C++
// End:

2
boost/boost/function/function_base.hpp
View File

@ -34,8 +34,6 @@
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.

2
boost/boost/functional.hpp
View File

@ -14,7 +14,7 @@
// 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

2
boost/boost/integer_traits.hpp
View File

@ -10,7 +10,7 @@
* 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
*/

2
boost/boost/preprocessor.hpp
View File

@ -30,7 +30,5 @@
#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

18
boost/boost/preprocessor/arithmetic/add.hpp
View File

@ -26,11 +26,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
<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>
@ -38,16 +33,9 @@ single token).</p>
*/
#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

18
boost/boost/preprocessor/arithmetic/div.hpp
View File

@ -24,11 +24,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
<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>
@ -36,16 +31,9 @@ single token).</p>
*/
#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

14
boost/boost/preprocessor/arithmetic/mod.hpp
View File

@ -23,11 +23,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
<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>
@ -35,11 +30,8 @@ single token).</p>
*/
#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

18
boost/boost/preprocessor/arithmetic/mul.hpp
View File

@ -23,11 +23,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
<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>
@ -35,16 +30,9 @@ single token).</p>
*/
#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

18
boost/boost/preprocessor/arithmetic/sub.hpp
View File

@ -25,11 +25,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
<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>
@ -37,16 +32,9 @@ single token).</p>
*/
#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

3
boost/boost/preprocessor/assert_msg.hpp
View File

@ -24,7 +24,4 @@
<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

3
boost/boost/preprocessor/cat.hpp
View File

@ -32,7 +32,4 @@ expanded.</p>
#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

3
boost/boost/preprocessor/comma.hpp
View File

@ -32,7 +32,4 @@ BOOST_PP_IF(1,BOOST_PP_COMMA,BOOST_PP_EMPTY)()
</ul>
*/
#define BOOST_PP_COMMA() ,
/* <p>Obsolete. Use BOOST_PP_COMMA().</p> */
#define BOOST_PREPROCESSOR_COMMA() ,
#endif

3
boost/boost/preprocessor/comma_if.hpp
View File

@ -25,7 +25,4 @@
<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

10
boost/boost/preprocessor/comparison/equal.hpp
View File

@ -24,11 +24,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
<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>
@ -36,9 +31,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
*/
#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

10
boost/boost/preprocessor/comparison/greater.hpp
View File

@ -23,11 +23,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
<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>
@ -35,9 +30,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
*/
#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

10
boost/boost/preprocessor/comparison/greater_equal.hpp
View File

@ -23,11 +23,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
<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>
@ -35,9 +30,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
*/
#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

10
boost/boost/preprocessor/comparison/less.hpp
View File

@ -25,11 +25,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
<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>
@ -37,9 +32,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
*/
#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

10
boost/boost/preprocessor/comparison/less_equal.hpp
View File

@ -24,11 +24,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
<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>
@ -36,9 +31,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
*/
#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

10
boost/boost/preprocessor/comparison/not_equal.hpp
View File

@ -25,11 +25,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
<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>
@ -37,9 +32,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
*/
#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

8
boost/boost/preprocessor/dec.hpp
View File

@ -13,6 +13,8 @@
* 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
@ -23,9 +25,8 @@ single token).</p>
<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
@ -155,7 +156,4 @@ supported.</p>
#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

3
boost/boost/preprocessor/empty.hpp
View File

@ -34,7 +34,4 @@ BOOST_PP_IF(0,BOOST_PP_COMMA,BOOST_PP_EMPTY)()
</ul>
*/
#define BOOST_PP_EMPTY()
/* <p>Obsolete. Use BOOST_PP_EMPTY().</p> */
#define BOOST_PREPROCESSOR_EMPTY()
#endif

62
boost/boost/preprocessor/enum.hpp
View File

@ -39,9 +39,16 @@ BOOST_PP_ENUM(3,TYPED_PARAM,(X,x))
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>
@ -49,11 +56,54 @@ X0 x0, X1 x1, X2 x2
<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

3
boost/boost/preprocessor/enum_params.hpp
View File

@ -49,7 +49,4 @@ x0, x1, x2
#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

9
boost/boost/preprocessor/enum_params_with_a_default.hpp
View File

@ -51,12 +51,5 @@ x0 = y, x1 = y, x2 = y
*/
#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

9
boost/boost/preprocessor/enum_params_with_defaults.hpp
View File

@ -51,12 +51,5 @@ x0 = y0, x1 = y1, x2 = y2
*/
#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

6
boost/boost/preprocessor/enum_shifted.hpp
View File

@ -46,9 +46,5 @@ X1 x1, X2 x2
*/
#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

3
boost/boost/preprocessor/enum_shifted_params.hpp
View File

@ -54,7 +54,4 @@ x1, x2
#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

9
boost/boost/preprocessor/expr_if.hpp
View File

@ -13,6 +13,7 @@
* 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>
@ -26,10 +27,8 @@
<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

10
boost/boost/preprocessor/for.hpp
View File

@ -75,6 +75,14 @@ still quite useful on its own.</p>
<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>
@ -213,5 +221,5 @@ invoking BOOST_PP_FOR##R() directly.</p>
#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

3
boost/boost/preprocessor/identity.hpp
View File

@ -38,7 +38,4 @@ X
</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

12
boost/boost/preprocessor/if.hpp
View File

@ -13,8 +13,8 @@
* 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>
@ -33,11 +33,7 @@
<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

8
boost/boost/preprocessor/inc.hpp
View File

@ -13,6 +13,8 @@
* 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
@ -24,9 +26,8 @@ BOOST_PP_LIMIT_MAG yields a BOOST_PP_LIMIT_MAG.</p>
<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
@ -156,7 +157,4 @@ supported.</p>
#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

17
boost/boost/preprocessor/limits.hpp
View File

@ -16,16 +16,16 @@
/** <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>
@ -41,13 +41,4 @@ and BOOST_PP_REPEAT family).</p>
/** <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

15
boost/boost/preprocessor/list.hpp
View File

@ -13,14 +13,25 @@
* 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>

29
boost/boost/preprocessor/list/adt.hpp
View File

@ -49,10 +49,10 @@ BOOST_PP_TUPLE_TO_LIST(5,(1,2,3,4,5))
<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
@ -61,6 +61,7 @@ BOOST_PP_LIST_FOLD_RIGHT_2ND
, ...
, BOOST_PP_TUPLE_TO_LIST(M, (EN1, EN2, ..., ENM) )
)
, BOOST_PP_LIST_NIL
)
</pre>
*/
@ -70,18 +71,10 @@ BOOST_PP_LIST_FOLD_RIGHT_2ND
#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>
@ -93,11 +86,7 @@ BOOST_PP_LIST_FIRST(BOOST_PP_TUPLE_TO_LIST(5,(1,2,3,4,5)))
<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>
@ -115,9 +104,5 @@ BOOST_PP_LIST_REST(BOOST_PP_TUPLE_TO_LIST(5,(1,2,3,4,5)))
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

9
boost/boost/preprocessor/list/append.hpp
View File

@ -32,11 +32,6 @@ BOOST_PP_LIST_APPEND
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>
@ -44,7 +39,7 @@ BOOST_PP_TUPLE_TO_LIST(4,(1,2,3,4))
*/
#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

7
boost/boost/preprocessor/list/at.hpp
View File

@ -26,11 +26,6 @@ BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(3,(A,B,C)),1)
<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>
@ -38,6 +33,6 @@ BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(3,(A,B,C)),1)
*/
#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

11
boost/boost/preprocessor/list/cat.hpp
View File

@ -30,11 +30,6 @@ BOOST_PP_LIST_CAT(BOOST_PP_TUPLE_TO_LIST(3,(1,2,3)))
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>
@ -42,7 +37,7 @@ BOOST_PP_LIST_CAT(BOOST_PP_TUPLE_TO_LIST(3,(1,2,3)))
*/
#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

2
boost/boost/preprocessor/list/enum.hpp
View File

@ -37,7 +37,7 @@ A,B,C
*/
#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

17
boost/boost/preprocessor/list/filter.hpp
View File

@ -30,12 +30,6 @@ BOOST_PP_LIST_FILTER(BOOST_PP_NOT_EQUAL_D,2,BOOST_PP_TUPLE_TO_LIST(3,(1,2,3)))
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>
@ -43,13 +37,8 @@ BOOST_PP_TUPLE_TO_LIST(2,(1,3))
*/
#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

18
boost/boost/preprocessor/list/first_n.hpp
View File

@ -37,11 +37,6 @@ BOOST_PP_TUPLE_TO_LIST(2,(+,-))
<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>
@ -49,13 +44,10 @@ BOOST_PP_TUPLE_TO_LIST(2,(+,-))
*/
#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

56
boost/boost/preprocessor/list/fold_left.hpp
View File

@ -13,6 +13,8 @@
* 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>
@ -53,11 +55,6 @@ _ABC
<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>
@ -65,16 +62,43 @@ _ABC
*/
#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

22
boost/boost/preprocessor/list/fold_left_2nd.hpp
View File

@ -13,22 +13,12 @@
* 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 &lt;boost/preprocessor/list/fold_left.hpp&gt;
</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

46
boost/boost/preprocessor/list/fold_right.hpp
View File

@ -49,10 +49,10 @@ BOOST_PP_LIST_FOLD_RIGHT(TEST,_,BOOST_PP_TUPLE_TO_LIST(3,(A,B,C)))
_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>
@ -62,13 +62,37 @@ _CBA
*/
#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

19
boost/boost/preprocessor/list/fold_right_2nd.hpp
View File

@ -13,19 +13,12 @@
* 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 &lt;boost/preprocessor/list/fold_right.hpp&gt;
</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

10
boost/boost/preprocessor/list/for_each.hpp
View File

@ -45,12 +45,6 @@ prefix_A(); prefix_B(); prefix_C();
<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>
@ -58,7 +52,7 @@ prefix_A(); prefix_B(); prefix_C();
*/
#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

15
boost/boost/preprocessor/list/for_each_i.hpp
View File

@ -41,17 +41,12 @@ BOOST_PP_LIST_FOR_EACH_I(TEST,prefix_,BOOST_PP_TUPLE_TO_LIST(3,(A,B,C)))
<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

30
boost/boost/preprocessor/list/for_each_product.hpp
View File

@ -50,11 +50,6 @@ BOOST_PP_LIST_FOR_EACH_PRODUCT
<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>
@ -62,26 +57,17 @@ BOOST_PP_LIST_FOR_EACH_PRODUCT
*/
#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)

17
boost/boost/preprocessor/list/rest_n.hpp
View File

@ -37,11 +37,6 @@ BOOST_PP_TUPLE_TO_LIST(2,(*,/))
<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>
@ -49,13 +44,9 @@ BOOST_PP_TUPLE_TO_LIST(2,(*,/))
*/
#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

9
boost/boost/preprocessor/list/reverse.hpp
View File

@ -29,11 +29,6 @@ BOOST_PP_LIST_REVERSE(BOOST_PP_TUPLE_TO_LIST(3,(A,B,C)))
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>
@ -41,7 +36,7 @@ BOOST_PP_TUPLE_TO_LIST(3,(C,B,A))
*/
#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

9
boost/boost/preprocessor/list/size.hpp
View File

@ -26,11 +26,6 @@ BOOST_PP_LIST_SIZE(BOOST_PP_TUPLE_TO_LIST(3,(A,B,C)))
<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>
@ -38,7 +33,7 @@ BOOST_PP_LIST_SIZE(BOOST_PP_TUPLE_TO_LIST(3,(A,B,C)))
*/
#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

7
boost/boost/preprocessor/list/to_tuple.hpp
View File

@ -31,11 +31,6 @@ BOOST_PP_LIST_TO_TUPLE(BOOST_PP_TUPLE_TO_LIST(3,(A,B,C)))
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>
@ -43,6 +38,6 @@ BOOST_PP_LIST_TO_TUPLE(BOOST_PP_TUPLE_TO_LIST(3,(A,B,C)))
*/
#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

17
boost/boost/preprocessor/list/transform.hpp
View File

@ -40,12 +40,6 @@ BOOST_PP_LIST_TRANSFORM(BOOST_PP_ADD_D,2,BOOST_PP_TUPLE_TO_LIST(2,(1,2)))
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>
@ -53,13 +47,8 @@ BOOST_PP_TUPLE_TO_LIST(2,(3,4))
*/
#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

3
boost/boost/preprocessor/logical/and.hpp
View File

@ -28,7 +28,4 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
</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

8
boost/boost/preprocessor/logical/bool.hpp
View File

@ -13,18 +13,19 @@
* 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
@ -154,7 +155,4 @@
#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

16
boost/boost/preprocessor/logical/nor.hpp
View File

@ -13,6 +13,7 @@
* 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>
@ -27,15 +28,10 @@ in the range [0, BOOST_PP_LIMIT_MAG].</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

3
boost/boost/preprocessor/logical/not.hpp
View File

@ -27,7 +27,4 @@
</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

3
boost/boost/preprocessor/logical/or.hpp
View File

@ -28,7 +28,4 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
</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

3
boost/boost/preprocessor/logical/xor.hpp
View File

@ -28,7 +28,4 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
</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

10
boost/boost/preprocessor/max.hpp
View File

@ -24,11 +24,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
<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>
@ -36,9 +31,6 @@ single token).</p>
*/
#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

10
boost/boost/preprocessor/min.hpp
View File

@ -24,11 +24,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
<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>
@ -36,9 +31,6 @@ single token).</p>
*/
#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

576
boost/boost/preprocessor/repeat.hpp
View File

@ -13,6 +13,10 @@
* 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>
@ -36,8 +40,8 @@ X(0); X(1); X(2);
<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>
@ -48,142 +52,440 @@ BOOST_PP_REPEAT_3RD() macros.</p>
<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

144
boost/boost/preprocessor/repeat_2nd.hpp
View File

@ -13,146 +13,12 @@
* 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 &lt;boost/preprocessor/repeat.hpp&gt;
</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

140
boost/boost/preprocessor/repeat_3rd.hpp
View File

@ -13,140 +13,12 @@
* 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 &lt;boost/preprocessor/repeat.hpp&gt;
</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

71
boost/boost/preprocessor/repeat_from_to.hpp
View File

@ -13,9 +13,9 @@
* 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>
@ -38,16 +38,77 @@ BOOST_PP_REPEAT_FROM_TO(4,7,TEST,X)
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

13
boost/boost/preprocessor/repeat_from_to_2nd.hpp
View File

@ -13,11 +13,12 @@
* 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 &lt;boost/preprocessor/repeat_from_to.hpp&gt;
</pre>
*/
#include <boost/preprocessor/repeat_from_to.hpp>
#endif

13
boost/boost/preprocessor/repeat_from_to_3rd.hpp
View File

@ -13,11 +13,12 @@
* 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 &lt;boost/preprocessor/repeat_from_to.hpp&gt;
</pre>
*/
#include <boost/preprocessor/repeat_from_to.hpp>
#endif

3
boost/boost/preprocessor/stringize.hpp
View File

@ -31,7 +31,4 @@
#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

5
boost/boost/preprocessor/tuple/eat.hpp
View File

@ -13,6 +13,8 @@
* 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
@ -26,9 +28,8 @@ BOOST_PP_IF(0,BOOST_PP_ENUM_PARAMS,BOOST_PP_TUPLE_EAT(2))(10,P)
<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)

177
boost/boost/preprocessor/tuple/elem.hpp
View File

@ -13,6 +13,9 @@
* 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>
@ -28,161 +31,24 @@ BOOST_PP_TUPLE_ELEM(2,1,(A,B))
<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
#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)
/* 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_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
@ -200,7 +66,4 @@ BOOST_PP_TUPLE_ELEM(2,1,(A,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

16
boost/boost/preprocessor/while.hpp
View File

@ -57,13 +57,21 @@ BOOST_PP_WHILE(PRED,OP,(0,3))
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>
@ -334,6 +342,6 @@ BOOST_PP_WHILE(PRED,OP,(0,3))
#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

2
boost/boost/property_map.hpp
View File

@ -477,7 +477,7 @@ namespace boost {
return (*m_c)[k];
}
private:
C* m_c;
C const* m_c;
};
template <class UniquePairAssociativeContainer>

2
boost/boost/regex.hpp
View File

@ -54,7 +54,7 @@
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{

2
boost/boost/regex/detail/fileiter.hpp
View File

@ -81,7 +81,7 @@ namespace boost{
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

4
boost/boost/regex/detail/instances.hpp
View File

@ -40,6 +40,8 @@ namespace boost{
#ifdef __BORLANDC__
#pragma option push -a8 -b -Vx -Ve -pc
# ifndef BOOST_REGEX_INSTANTIATE
# pragma option push -Jgx
# endif
@ -55,6 +57,8 @@ template class BOOST_REGEX_DECL match_results<std::basic_string<BOOST_REGEX_CHAR
# pragma option pop
# endif
#pragma option pop
#elif defined(BOOST_MSVC)
# ifndef BOOST_REGEX_INSTANTIATE

19
boost/boost/regex/detail/regex_compile.hpp
View File

@ -26,7 +26,7 @@
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{
@ -607,6 +607,10 @@ void BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::compile_map(
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);
@ -631,6 +635,9 @@ void BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::move_offsets(re_
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>
@ -1245,6 +1252,11 @@ void BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::fixup_apply(re_d
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);
@ -1912,6 +1924,11 @@ unsigned int BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::set_expr
} // sentry
return REG_EMPTY;
# ifdef BOOST_MSVC
# pragma warning(pop)
#endif
}
template <class charT, class traits, class Allocator>

2
boost/boost/regex/detail/regex_cstring.hpp
View File

@ -35,7 +35,7 @@ namespace boost{
namespace re_detail{
#ifdef __BORLANDC__
#pragma option push -a4 -b -Ve -pc
#pragma option push -a8 -b -Vx -Ve -pc
#endif
//

2
boost/boost/regex/detail/regex_format.hpp
View File

@ -40,7 +40,7 @@ enum format_flags_t{
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>

17
boost/boost/regex/detail/regex_kmp.hpp
View File

@ -34,16 +34,16 @@ namespace boost{
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>
@ -57,11 +57,11 @@ template <class iterator, class charT, class Trans, 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:
@ -109,6 +109,3 @@ kmp_info<charT>* kmp_compile(iterator first, iterator last, charT, Trans transla

32
boost/boost/regex/detail/regex_match.hpp
View File

@ -31,7 +31,7 @@ namespace boost{
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
//
@ -55,6 +55,13 @@ inline int string_compare(const std::wstring& s, const wchar_t* p)
# 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,
@ -103,8 +110,7 @@ iterator BOOST_REGEX_CALL re_is_set_member(iterator next,
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
}
}
@ -283,6 +289,11 @@ bool query_match_aux(iterator first,
_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)
@ -340,6 +351,8 @@ bool query_match_aux(iterator first,
// 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;
@ -1030,6 +1043,9 @@ bool query_match_aux(iterator first,
// 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
@ -1257,9 +1273,9 @@ unsigned int reg_grep2(Predicate foo, I first, I last, const reg_expression<char
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)
{
@ -1639,9 +1655,7 @@ bool regex_match(iterator first, iterator last, match_results<iterator, Allocato
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)
@ -1913,3 +1927,5 @@ inline unsigned int regex_grep(bool (*foo)(const match_results<std::basic_string

2
boost/boost/regex/detail/regex_raw_buffer.hpp
View File

@ -33,7 +33,7 @@ namespace boost{
namespace re_detail{
#ifdef __BORLANDC__
#pragma option push -a4 -b -Ve -pc
#pragma option push -a8 -b -Vx -Ve -pc
#endif
struct empty_padding{};

2
boost/boost/regex/detail/regex_split.hpp
View File

@ -28,7 +28,7 @@
namespace boost{
#ifdef __BORLANDC__
#pragma option push -a4 -b -Ve -pc
#pragma option push -a8 -b -Vx -Ve -pc
#endif
namespace re_detail{

2
boost/boost/regex/detail/regex_stack.hpp
View File

@ -36,7 +36,7 @@ namespace boost{
namespace re_detail{
#ifdef __BORLANDC__
#pragma option push -a4 -b -Ve -pc
#pragma option push -a8 -b -Vx -Ve -pc
#endif
//

2
boost/boost/regex/detail/regex_synch.hpp
View File

@ -47,7 +47,7 @@ namespace boost{
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();

2
boost/boost/regex/pattern_except.hpp
View File

@ -28,7 +28,7 @@
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

6
boost/boost/regex/regex_traits.hpp
View File

@ -30,7 +30,7 @@
namespace boost{
#ifdef __BORLANDC__
#pragma option push -a4 -b -Ve -pc
#pragma option push -a8 -b -Vx -Ve -pc
#endif
template <class charT>
@ -123,6 +123,10 @@ struct BOOST_REGEX_DECL regex_traits_base
syntax_max = 54
};
#ifdef __BORLANDC__
private:
char dummy_member;
#endif
};
struct BOOST_REGEX_DECL c_traits_base : public regex_traits_base

75
boost/boost/signal.hpp
View File

@ -32,7 +32,7 @@
#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 {};
@ -78,7 +78,7 @@ namespace boost {
struct real_get_signal_impl<0>
{
template<
typename R,
typename R,
typename T1,
typename T2,
typename T3,
@ -89,7 +89,7 @@ namespace boost {
typename T8,
typename T9,
typename T10,
typename Combiner = last_value<R>
typename Combiner
>
struct params
{
@ -112,7 +112,7 @@ namespace boost {
typename T8,
typename T9,
typename T10,
typename Combiner = last_value<R>
typename Combiner
>
struct params
{
@ -135,7 +135,7 @@ namespace boost {
typename T8,
typename T9,
typename T10,
typename Combiner = last_value<R>
typename Combiner
>
struct params
{
@ -158,7 +158,7 @@ namespace boost {
typename T8,
typename T9,
typename T10,
typename Combiner = last_value<R>
typename Combiner
>
struct params
{
@ -181,7 +181,7 @@ namespace boost {
typename T8,
typename T9,
typename T10,
typename Combiner = last_value<R>
typename Combiner
>
struct params
{
@ -204,7 +204,7 @@ namespace boost {
typename T8,
typename T9,
typename T10,
typename Combiner = last_value<R>
typename Combiner
>
struct params
{
@ -228,7 +228,7 @@ namespace boost {
typename T8,
typename T9,
typename T10,
typename Combiner = last_value<R>
typename Combiner
>
struct params
{
@ -251,7 +251,7 @@ namespace boost {
typename T8,
typename T9,
typename T10,
typename Combiner = last_value<R>
typename Combiner
>
struct params
{
@ -274,7 +274,7 @@ namespace boost {
typename T8,
typename T9,
typename T10,
typename Combiner = last_value<R>
typename Combiner
>
struct params
{
@ -297,7 +297,7 @@ namespace boost {
typename T8,
typename T9,
typename T10,
typename Combiner = last_value<R>
typename Combiner
>
struct params
{
@ -320,7 +320,7 @@ namespace boost {
typename T8,
typename T9,
typename T10,
typename Combiner = last_value<R>
typename Combiner
>
struct params
{
@ -341,46 +341,49 @@ namespace boost {
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

125
boost/boost/signals/connection.hpp
View File

@ -10,7 +10,7 @@
//
// 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
@ -25,38 +25,38 @@
#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*);
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; }
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>
{
@ -91,15 +91,15 @@ namespace boost {
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;
@ -131,28 +131,27 @@ namespace boost {
}
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);
}
@ -167,7 +166,7 @@ namespace boost {
}
inline connection& connection::operator=(const connection& other)
{
{
connection(other).swap(*this);
return *this;
}
@ -189,7 +188,7 @@ namespace boost {
{
}
inline
inline
scoped_connection::scoped_connection(const scoped_connection& other) :
connection(other),
released(other.released)
@ -199,7 +198,7 @@ namespace boost {
inline scoped_connection::~scoped_connection()
{
if (!released) {
this->disconnect();
this->disconnect();
}
}
@ -222,14 +221,14 @@ namespace boost {
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);
@ -238,55 +237,55 @@ namespace boost {
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

6
boost/boost/signals/detail/signal_base.hpp
View File

@ -28,7 +28,7 @@
#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;
@ -145,7 +145,7 @@ namespace boost {
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 {
@ -182,7 +182,7 @@ namespace boost {
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

8
boost/boost/signals/detail/signals_common.hpp
View File

@ -16,11 +16,15 @@
#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
@ -149,7 +153,7 @@ namespace boost {
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

4
boost/boost/signals/detail/slot_call_iterator.hpp
View File

@ -22,7 +22,7 @@
#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>
@ -114,6 +114,6 @@ namespace boost {
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

50
boost/boost/signals/signal_template.hpp
View File

@ -52,10 +52,10 @@
// 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
@ -122,7 +122,7 @@ namespace boost {
};
};
} // namespace detail
} // namespace signals
} // namespace BOOST_SIGNALS_NAMESPACE
// The actual signalN class
template<
@ -137,15 +137,15 @@ namespace boost {
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
@ -160,12 +160,12 @@ namespace boost {
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
@ -187,21 +187,21 @@ namespace boost {
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)
@ -226,7 +226,7 @@ namespace boost {
typename GroupCompare,
typename SlotFunction
>
signals::connection
BOOST_SIGNALS_NAMESPACE::connection
BOOST_SIGNALS_SIGNAL<
R, BOOST_SIGNALS_TEMPLATE_ARGS
BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS
@ -236,7 +236,7 @@ namespace boost {
// 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(),
@ -253,7 +253,7 @@ namespace boost {
typename GroupCompare,
typename SlotFunction
>
signals::connection
BOOST_SIGNALS_NAMESPACE::connection
BOOST_SIGNALS_SIGNAL<
R, BOOST_SIGNALS_TEMPLATE_ARGS
BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS
@ -286,7 +286,7 @@ namespace boost {
>::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.
@ -298,10 +298,10 @@ namespace boost {
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<
@ -324,7 +324,7 @@ namespace boost {
>::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.
@ -337,10 +337,10 @@ namespace boost {
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

Some files were not shown because too many files have changed in this diff Show More