boostorg/preprocessor
1
0
Fork 1
mirror of https://github.com/boostorg/preprocessor.git synced 2025-07-14 13:06:33 +02:00
Code Issues Packages Projects Releases Wiki Activity

Automatic recursion

Browse Source 
[SVN r14100]
This commit is contained in:
Vesa Karvonen
2002-06-07 13:04:18 +00:00
parent a18d5f79fc
commit 9f9048e805
82 changed files with 971 additions and 869 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/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

42
include/boost/preprocessor/detail/auto_rec.hpp Normal file
View File

@ -0,0 +1,42 @@
#ifndef BOOST_PREPROCESSOR_DETAIL_AUTO_REC_HPP
#define BOOST_PREPROCESSOR_DETAIL_AUTO_REC_HPP
/* Copyright (C) 2002 Vesa Karvonen
*
* Permission to copy, use, modify, sell and distribute this software is
* granted provided this copyright notice appears in all copies. This
* software is provided "as is" without express or implied warranty, and
* with no claim as to its suitability for any purpose.
*
* Based on an original idea by Paul Mensonides this header defines macros
* for the definition of automatically recursive macros.
*
* See http://www.boost.org for most recent version.
*/
/* Identity macro for auto rec support. */
#define BOOST_PP_AUTO_REC_ID(X) X
/* Catenation macros for auto rec support. */
#define BOOST_PP_AUTO_REC_CAT0(X,Y) BOOST_PP_AUTO_REC_DO_CAT0(X,Y)
#define BOOST_PP_AUTO_REC_CAT1(X,Y) BOOST_PP_AUTO_REC_DO_CAT1(X,Y)
#define BOOST_PP_AUTO_REC_CAT2(X,Y) BOOST_PP_AUTO_REC_DO_CAT2(X,Y)
#define BOOST_PP_AUTO_REC_CAT3(X,Y) BOOST_PP_AUTO_REC_DO_CAT3(X,Y)
#define BOOST_PP_AUTO_REC_CAT4(X,Y) BOOST_PP_AUTO_REC_DO_CAT4(X,Y)
#define BOOST_PP_AUTO_REC_CAT5(X,Y) BOOST_PP_AUTO_REC_DO_CAT5(X,Y)
#define BOOST_PP_AUTO_REC_CAT6(X,Y) BOOST_PP_AUTO_REC_DO_CAT6(X,Y)
#define BOOST_PP_AUTO_REC_CAT7(X,Y) BOOST_PP_AUTO_REC_DO_CAT7(X,Y)
#define BOOST_PP_AUTO_REC_CAT8(X,Y) BOOST_PP_AUTO_REC_DO_CAT8(X,Y)
#define BOOST_PP_AUTO_REC_CAT9(X,Y) BOOST_PP_AUTO_REC_DO_CAT9(X,Y)
#define BOOST_PP_AUTO_REC_DO_CAT0(X,Y) X##Y
#define BOOST_PP_AUTO_REC_DO_CAT1(X,Y) X##Y
#define BOOST_PP_AUTO_REC_DO_CAT2(X,Y) X##Y
#define BOOST_PP_AUTO_REC_DO_CAT3(X,Y) X##Y
#define BOOST_PP_AUTO_REC_DO_CAT4(X,Y) X##Y
#define BOOST_PP_AUTO_REC_DO_CAT5(X,Y) X##Y
#define BOOST_PP_AUTO_REC_DO_CAT6(X,Y) X##Y
#define BOOST_PP_AUTO_REC_DO_CAT7(X,Y) X##Y
#define BOOST_PP_AUTO_REC_DO_CAT8(X,Y) X##Y
#define BOOST_PP_AUTO_REC_DO_CAT9(X,Y) X##Y
#endif

36
include/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,30 @@ 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
#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))
#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))
# 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))
#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_M1(I,MD) BOOST_PP_COMMA_IF(I) BOOST_PP_TUPLE2_ELEM0 MD(I,BOOST_PP_TUPLE2_ELEM1 MD)
# define BOOST_PP_ENUM_M2(I,MD) BOOST_PP_COMMA_IF(I) BOOST_PP_TUPLE2_ELEM0 MD(I,BOOST_PP_TUPLE2_ELEM1 MD)
# define BOOST_PP_ENUM_M3(I,MD) BOOST_PP_COMMA_IF(I) BOOST_PP_TUPLE2_ELEM0 MD(I,BOOST_PP_TUPLE2_ELEM1 MD)
#endif
#endif

10
include/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

15
include/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>

5
include/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>
*/

9
include/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
include/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

9
include/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> */
/** <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_TUPLE3_ELEM0 LIST,BOOST_PP_TUPLE3_ELEM1 LIST)
#define BOOST_PP_LIST_CAT_F(D,P,H) BOOST_PP_CAT(P,H)
#define BOOST_PP_LIST_CAT_F(D,S,X) BOOST_PP_CAT(S,X)
#endif

2
include/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

14
include/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,13 @@ 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)))
# 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_TUPLE3_ELEM1 PDR,X),BOOST_PP_LIST_CONS,BOOST_PP_TUPLE2_ELEM1)(X,BOOST_PP_TUPLE_ELEM(3,2,PDR)))
#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))
# define BOOST_PP_LIST_FILTER_F(D,X,PDR) (BOOST_PP_TUPLE_ELEM(3,0,PDR),BOOST_PP_TUPLE3_ELEM1 PDR,BOOST_PP_IF(BOOST_PP_TUPLE3_ELEM0 PDR(D,BOOST_PP_TUPLE3_ELEM1 PDR,X),BOOST_PP_LIST_CONS,BOOST_PP_TUPLE2_ELEM1)(X,BOOST_PP_TUPLE3_ELEM2 PDR))
#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))
# define BOOST_PP_LIST_FILTER_F(D,X,PDR) (BOOST_PP_TUPLE3_ELEM0 PDR,BOOST_PP_TUPLE3_ELEM1 PDR,BOOST_PP_IF(BOOST_PP_TUPLE3_ELEM0 PDR(D,BOOST_PP_TUPLE3_ELEM1 PDR,X),BOOST_PP_LIST_CONS,BOOST_PP_TUPLE2_ELEM1)(X,BOOST_PP_TUPLE3_ELEM2 PDR))
#endif
#endif

15
include/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,13 @@ 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)))
# 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)))
#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))
# define BOOST_PP_LIST_FIRST_N_C(D,RLC) BOOST_PP_TUPLE3_ELEM2 RLC
# define BOOST_PP_LIST_FIRST_N_F(D,RLC) ((BOOST_PP_TUPLE3_ELEM0 BOOST_PP_TUPLE3_ELEM1 RLC,BOOST_PP_TUPLE3_ELEM0 RLC,1),BOOST_PP_TUPLE3_ELEM1 BOOST_PP_TUPLE3_ELEM1 RLC,BOOST_PP_DEC(BOOST_PP_TUPLE3_ELEM2 RLC))
#endif
#endif

55
include/boost/preprocessor/list/fold_left.hpp
View File

@ -13,6 +13,7 @@
* See http://www.boost.org for most recent version.
*/
#include <boost/preprocessor/detail/auto_rec.hpp>
#include <boost/preprocessor/list/adt.hpp>
#include <boost/preprocessor/while.hpp>
@ -53,11 +54,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 +61,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) M P
#define BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC2(M,P) M P
#define BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC3(M,P) 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
include/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
include/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
include/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
include/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

13
include/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> */
/** <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_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)))
#define BOOST_PP_LIST_FOR_EACH_I_C(R,MDLI) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(4,2,MDLI))
#define BOOST_PP_LIST_FOR_EACH_I_F(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_I(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

7
include/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,7 +57,7 @@ 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)

15
include/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,13 @@ 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)))
# 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)))
#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))
# define BOOST_PP_LIST_REST_N_C(D,LC) BOOST_PP_TUPLE2_ELEM1 LC
# define BOOST_PP_LIST_REST_N_F(D,LC) (BOOST_PP_TUPLE3_ELEM1 BOOST_PP_TUPLE2_ELEM0 LC,BOOST_PP_DEC(BOOST_PP_TUPLE2_ELEM1 LC))
#endif
#endif

9
include/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
include/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
include/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

14
include/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,13 @@ 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))
# 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))
#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))
# define BOOST_PP_LIST_TRANSFORM_F(D,X,ODR) (BOOST_PP_TUPLE_ELEM(3,0,ODR),BOOST_PP_TUPLE3_ELEM1 ODR,(BOOST_PP_TUPLE_ELEM(3,0,ODR)(D,BOOST_PP_TUPLE3_ELEM1 ODR,X),BOOST_PP_TUPLE3_ELEM2 ODR,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))
# define BOOST_PP_LIST_TRANSFORM_F(D,X,ODR) (BOOST_PP_TUPLE3_ELEM0 ODR,BOOST_PP_TUPLE3_ELEM1 ODR,(BOOST_PP_TUPLE3_ELEM0 ODR(D,BOOST_PP_TUPLE3_ELEM1 ODR,X),BOOST_PP_TUPLE3_ELEM2 ODR,1))
#endif
#endif

565
include/boost/preprocessor/repeat.hpp
View File

@ -13,6 +13,8 @@
* See http://www.boost.org for most recent version.
*/
#include <boost/preprocessor/detail/auto_rec.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 +38,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 +50,431 @@ 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
#define BOOST_PP_REPEAT\
BOOST_PP_AUTO_REC_CAT1(BOOST_PP_REPEAT,BOOST_PP_REPEAT_AUTO_REC1(BOOST_PP_AUTO_REC_ID,(1)))
#define BOOST_PP_REPEATBOOST_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_REPEATBOOST_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_REPEATBOOST_PP_REPEAT_AUTO_REC3(M,P)\
(TOO MANY NESTED REPEATS!)
#define BOOST_PP_REPEAT_AUTO_REC1(M,P) M P
#define BOOST_PP_REPEAT_AUTO_REC2(M,P) M P
#define BOOST_PP_REPEAT_AUTO_REC3(M,P) M P
#define BOOST_PP_REPEAT1(C,M,D) BOOST_PP_REPEAT_AUTO_REC1(BOOST_PP_R1_DELAY(C),(M,D))
#define BOOST_PP_R1_DELAY(C) BOOST_PP_R1_##C
#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_REPEAT2(C,M,D) BOOST_PP_REPEAT_AUTO_REC2(BOOST_PP_R2_DELAY(C),(M,D))
#define BOOST_PP_R2_DELAY(C) BOOST_PP_R2_##C
#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_REPEAT3(C,M,D) BOOST_PP_REPEAT_AUTO_REC3(BOOST_PP_R3_DELAY(C),(M,D))
#define BOOST_PP_R3_DELAY(C) BOOST_PP_R3_##C
#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
include/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
include/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

41
include/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,47 @@ 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
#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_TOBOOST_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_TOBOOST_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_TOBOOST_PP_REPEAT_AUTO_REC3(M,P)\
(TOO MANY NESTED REPEATS!)
#define BOOST_PP_REPEAT_FROM_TO1(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_TO2(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_TO3(F,L,M,D) BOOST_PP_REPEAT(BOOST_PP_SUB(L,F),BOOST_PP_REPEAT_FROM_TO_M3,(F,M,D))
#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
include/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
include/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

16
include/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