Automatic recursion

[SVN r14100]

doc/acknowledgements.htm

@@ -25,6 +25,8 @@
 <p>Thanks to everyone who participated in the review: David Abrahams, Beman Dawes, 
   Ronald Garcia, Douglas Gregor, Aleksey Gurtovoy, Jeremy Siek, and Daryle Walker.</p>
 <p>Thanks to Chris Little and Mat Marcus for providing help with MWCW.</p>
+<p>The original automatic recursion technique, which makes many of the library
+primitives easier to use, was invented by Paul Mensonides.</p>
 <p>The PREPROCESSOR library has been developed by Vesa Karvonen. </p>
 <hr>
 <p>Revised 

doc/examples.htm

@@ -21,56 +21,56 @@
 <hr>
 
 <table>
-  <tr><td><a href="../example/array_arithmetic.c">array_arithmetic.c</a></td><td>This example implements over 2200 functions for 1-dimensional arithmetic
+  <tr><td><a href="../example/array_arithmetic.c">array_arithmetic.c</a></td><td>Implements over 2200 functions for 1-dimensional arithmetic
 array manipulation in C. The idea is to use preprocessor data structures,
 lists and tuples, for storing metainformation to be used for generating
 the actual C code.</td></tr>
   <tr>
     <td><a href="../example/catch_builtin.cpp">catch_builtin.cpp</a></td>
-    <td>This example demonstrates the usage of lists and BOOST_PP_LIST_FOR_EACH().</td>
+    <td>Demonstrates the usage of lists and BOOST_PP_LIST_FOR_EACH().</td>
   </tr>
   <tr>
     <td><a href="../example/count_down.c">count_down.c</a></td>
-    <td> This is a trivial example of using BOOST_PP_WHILE() that simply counts 
+    <td> Trivial example of using BOOST_PP_WHILE() that simply counts 
       down from N to 0 ultimately expanding to a 0.</td>
   </tr>
   <tr>
     <td><a href="../example/delay.c">delay.c</a></td>
-    <td>This example implements a macro whose expansion takes exponential amount 
+    <td>Implements a macro whose expansion takes exponential amount 
       of time.</td>
   </tr>
   <tr>
     <td><a href="../example/duffs_device.c">duffs_device.c</a></td>
-    <td>This example uses the preprocessor library to implement a generalized 
+    <td>Uses the preprocessor library to implement a generalized 
       macro for implementing a Duff's Device.</td>
   </tr>
   <tr>
     <td><a href="../example/is_integral.cpp">is_integral.cpp</a></td>
-    <td>This example demonstrates the usage of preprocessor lists for generating 
+    <td>Demonstrates the usage of preprocessor lists for generating 
       C++ code.</td>
   </tr>
   <tr>
     <td><a href="../example/linear_fib.c">linear_fib.c</a></td>
-    <td>This example shows how BOOST_PP_WHILE() can be used for implementing macros.</td>
+    <td>Shows how BOOST_PP_WHILE() can be used for implementing macros.</td>
   </tr>
   <tr>
     <td><a href="../example/note.c">note.c</a></td>
-    <td>This example shows how BOOST_PP_STRINGIZE() can be used to allow macro 
+    <td>Shows how BOOST_PP_STRINGIZE() can be used to allow macro 
       expansion before stringization.</td>
   </tr>
   <tr>
     <td><a href="../example/repeat_2d.c">repeat_2d.c</a></td>
-    <td>This example implements a generalized macro for 2D repetition using the 
+    <td>Implements a generalized macro for 2D repetition using the 
       simple repetition primitives of the preprocessor library.</td>
   </tr>
   <tr>
     <td><a href="../example/static_assert.c">static_assert.c</a></td>
-    <td>This example shows how BOOST_PP_CAT() can be used to allow macro expansion 
+    <td>Shows how BOOST_PP_CAT() can be used to allow macro expansion 
       before token concatenation.</td>
   </tr>
   <tr>
     <td><a href="../example/subscript_layer.cpp">subscript_layer.cpp</a></td>
-    <td>This example shows how BOOST_PP_EMPTY can be used as an unused or empty 
+    <td>Shows how BOOST_PP_EMPTY can be used as an unused or empty 
       parameter.</td>
   </tr>
 </table>

doc/keywords.txt

@@ -51,12 +51,8 @@ BOOST_PP_LIST_FIRST_N
 BOOST_PP_LIST_FIRST_N_D
 BOOST_PP_LIST_FOLD_LEFT
 BOOST_PP_LIST_FOLD_LEFT_D
-BOOST_PP_LIST_FOLD_LEFT_2ND
-BOOST_PP_LIST_FOLD_LEFT_2ND_D
 BOOST_PP_LIST_FOLD_RIGHT
 BOOST_PP_LIST_FOLD_RIGHT_D
-BOOST_PP_LIST_FOLD_RIGHT_2ND
-BOOST_PP_LIST_FOLD_RIGHT_2ND_D
 BOOST_PP_LIST_FOR_EACH
 BOOST_PP_LIST_FOR_EACH_I
 BOOST_PP_LIST_FOR_EACH_I_R
@@ -91,11 +87,7 @@ BOOST_PP_NOT_EQUAL
 BOOST_PP_NOT_EQUAL_D
 BOOST_PP_OR
 BOOST_PP_REPEAT
-BOOST_PP_REPEAT_2ND
-BOOST_PP_REPEAT_3RD
 BOOST_PP_REPEAT_FROM_TO
-BOOST_PP_REPEAT_FROM_TO_2ND
-BOOST_PP_REPEAT_FROM_TO_3RD
 BOOST_PP_STRINGIZE
 BOOST_PP_SUB
 BOOST_PP_SUB_D

doc/reference/arithmetic_add.htm

@@ -33,11 +33,6 @@ in the range [0, <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>]
 <p>For example, <code><a href="arithmetic_add.htm#BOOST_PP_ADD">BOOST_PP_ADD</a>(4,3)</code> expands to <code>7</code> (a
 single token).</p>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -46,7 +41,7 @@ single token).</p>
 <hr>
 
 <h3><a name="BOOST_PP_ADD_D">#define BOOST_PP_ADD_D</a>(D,X,Y)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="arithmetic.htm">Prev</a> <a href="arithmetic_div.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/arithmetic_div.htm

@@ -33,11 +33,6 @@ in the range [0, <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>]
 <p>For example, <code><a href="arithmetic_div.htm#BOOST_PP_DIV">BOOST_PP_DIV</a>(4,3)</code> expands to <code>1</code> (a
 single token).</p>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -46,7 +41,7 @@ single token).</p>
 <hr>
 
 <h3><a name="BOOST_PP_DIV_D">#define BOOST_PP_DIV_D</a>(D,X,Y)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="arithmetic_add.htm">Prev</a> <a href="arithmetic_mod.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/arithmetic_mod.htm

@@ -33,11 +33,6 @@ in the range [0, <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>]
 <p>For example, <code><a href="arithmetic_mod.htm#BOOST_PP_MOD">BOOST_PP_MOD</a>(4,3)</code> expands to <code>1</code> (a
 single token).</p>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -46,7 +41,7 @@ single token).</p>
 <hr>
 
 <h3><a name="BOOST_PP_MOD_D">#define BOOST_PP_MOD_D</a>(D,X,Y)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="arithmetic_div.htm">Prev</a> <a href="arithmetic_mul.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/arithmetic_mul.htm

@@ -33,11 +33,6 @@ in the range [0, <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>]
 <p>For example, <code><a href="arithmetic_mul.htm#BOOST_PP_MUL">BOOST_PP_MUL</a>(4,3)</code> expands to <code>12</code> (a
 single token).</p>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -46,7 +41,7 @@ single token).</p>
 <hr>
 
 <h3><a name="BOOST_PP_MUL_D">#define BOOST_PP_MUL_D</a>(D,X,Y)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="arithmetic_mod.htm">Prev</a> <a href="arithmetic_sub.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/arithmetic_sub.htm

@@ -33,11 +33,6 @@ in the range [0, <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>]
 <p>For example, <code><a href="arithmetic_sub.htm#BOOST_PP_SUB">BOOST_PP_SUB</a>(4,3)</code> expands to <code>1</code> (a
 single token).</p>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -46,7 +41,7 @@ single token).</p>
 <hr>
 
 <h3><a name="BOOST_PP_SUB_D">#define BOOST_PP_SUB_D</a>(D,X,Y)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="arithmetic_mul.htm">Prev</a> <a href="assert_msg.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/comparison_equal.htm

@@ -33,11 +33,6 @@ in the range [0, <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>]
 
 <p>For example, <code><a href="comparison_equal.htm#BOOST_PP_EQUAL">BOOST_PP_EQUAL</a>(4,4)</code> expands to <code>1</code>.</p>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -46,7 +41,7 @@ in the range [0, <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>]
 <hr>
 
 <h3><a name="BOOST_PP_EQUAL_D">#define BOOST_PP_EQUAL_D</a>(D,X,Y)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="comparison.htm">Prev</a> <a href="comparison_greater.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/comparison_greater.htm

@@ -33,11 +33,6 @@ in the range [0, <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>]
 
 <p>For example, <code><a href="comparison_greater.htm#BOOST_PP_GREATER">BOOST_PP_GREATER</a>(4,3)</code> expands to <code>1</code>.</p>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -46,7 +41,7 @@ in the range [0, <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>]
 <hr>
 
 <h3><a name="BOOST_PP_GREATER_D">#define BOOST_PP_GREATER_D</a>(D,X,Y)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="comparison_equal.htm">Prev</a> <a href="comparison_greater_equal.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/comparison_greater_equal.htm

@@ -33,11 +33,6 @@ in the range [0, <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>]
 
 <p>For example, <code><a href="comparison_greater_equal.htm#BOOST_PP_GREATER_EQUAL">BOOST_PP_GREATER_EQUAL</a>(1,3)</code> expands to <code>0</code>.</p>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -46,7 +41,7 @@ in the range [0, <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>]
 <hr>
 
 <h3><a name="BOOST_PP_GREATER_EQUAL_D">#define BOOST_PP_GREATER_EQUAL_D</a>(D,X,Y)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="comparison_greater.htm">Prev</a> <a href="comparison_less.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/comparison_less.htm

@@ -33,11 +33,6 @@ in the range [0, <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>]
 
 <p>For example, <code><a href="comparison_less.htm#BOOST_PP_LESS">BOOST_PP_LESS</a>(2,6)</code> expands to <code>1</code>.</p>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -46,7 +41,7 @@ in the range [0, <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>]
 <hr>
 
 <h3><a name="BOOST_PP_LESS_D">#define BOOST_PP_LESS_D</a>(D,X,Y)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="comparison_greater_equal.htm">Prev</a> <a href="comparison_less_equal.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/comparison_less_equal.htm

@@ -33,11 +33,6 @@ in the range [0, <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>]
 
 <p>For example, <code><a href="comparison_less_equal.htm#BOOST_PP_LESS_EQUAL">BOOST_PP_LESS_EQUAL</a>(7,5)</code> expands to <code>0</code>.</p>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -46,7 +41,7 @@ in the range [0, <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>]
 <hr>
 
 <h3><a name="BOOST_PP_LESS_EQUAL_D">#define BOOST_PP_LESS_EQUAL_D</a>(D,X,Y)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="comparison_less.htm">Prev</a> <a href="comparison_not_equal.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/comparison_not_equal.htm

@@ -33,11 +33,6 @@ in the range [0, <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>]
 
 <p>For example, <code><a href="comparison_not_equal.htm#BOOST_PP_NOT_EQUAL">BOOST_PP_NOT_EQUAL</a>(4,4)</code> expands to <code>0</code>.</p>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -46,7 +41,7 @@ in the range [0, <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>]
 <hr>
 
 <h3><a name="BOOST_PP_NOT_EQUAL_D">#define BOOST_PP_NOT_EQUAL_D</a>(D,X,Y)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="comparison_less_equal.htm">Prev</a> <a href="dec.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/enum.htm

@@ -47,9 +47,16 @@ MACRO(0,DATA), MACRO(1,DATA), ..., MACRO(<a href="dec.htm#BOOST_PP_DEC">BOOST_PP
 X0 x0, X1 x1, X2 x2
 </pre>
 
-<h3>Uses</h3>
+<h3>2D and 3D repetition</h3>
+
+<p><a href="enum.htm#BOOST_PP_ENUM">BOOST_PP_ENUM</a>() implements automatic recursion. 2D and 3D repetition
+are directly supported.</p>
+
+<h3>See</h3>
 <ul>
-  <li><a href="repeat.htm#BOOST_PP_REPEAT">BOOST_PP_REPEAT</a>()</li>
+  <li><a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>()</li>
+  <li><a href="limits.htm#BOOST_PP_LIMIT_DIM">BOOST_PP_LIMIT_DIM</a></li>
+  <li><a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a></li>
 </ul>
 
 <h3>Test</h3>

doc/reference/for.htm

@@ -84,6 +84,14 @@ still quite useful on its own.</p>
 <p><a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>() can be used for multidimensional repetition simply by
 invoking <a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>##R() directly.</p>
 
+<h3>Automatic recursion?</h3>
+
+<p><a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>() 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>

doc/reference/index.htm

@@ -74,12 +74,12 @@
   <dt><a href="list_first_n.htm#BOOST_PP_LIST_FIRST_N">BOOST_PP_LIST_FIRST_N</a></dt>
   <dt><a href="list_first_n.htm#BOOST_PP_LIST_FIRST_N_D">BOOST_PP_LIST_FIRST_N_D</a></dt>
   <dt><a href="list_fold_left.htm#BOOST_PP_LIST_FOLD_LEFT">BOOST_PP_LIST_FOLD_LEFT</a></dt>
-  <dt><a href="list_fold_left_2nd.htm#BOOST_PP_LIST_FOLD_LEFT_2ND">BOOST_PP_LIST_FOLD_LEFT_2ND</a></dt>
+  <dt><a href="list_fold_left.htm#BOOST_PP_LIST_FOLD_LEFT_2ND">BOOST_PP_LIST_FOLD_LEFT_2ND</a></dt>
-  <dt><a href="list_fold_left_2nd.htm#BOOST_PP_LIST_FOLD_LEFT_2ND_D">BOOST_PP_LIST_FOLD_LEFT_2ND_D</a></dt>
+  <dt><a href="list_fold_left.htm#BOOST_PP_LIST_FOLD_LEFT_2ND_D">BOOST_PP_LIST_FOLD_LEFT_2ND_D</a></dt>
   <dt><a href="list_fold_left.htm#BOOST_PP_LIST_FOLD_LEFT_D">BOOST_PP_LIST_FOLD_LEFT_D</a></dt>
   <dt><a href="list_fold_right.htm#BOOST_PP_LIST_FOLD_RIGHT">BOOST_PP_LIST_FOLD_RIGHT</a></dt>
-  <dt><a href="list_fold_right_2nd.htm#BOOST_PP_LIST_FOLD_RIGHT_2ND">BOOST_PP_LIST_FOLD_RIGHT_2ND</a></dt>
+  <dt><a href="list_fold_right.htm#BOOST_PP_LIST_FOLD_RIGHT_2ND">BOOST_PP_LIST_FOLD_RIGHT_2ND</a></dt>
-  <dt><a href="list_fold_right_2nd.htm#BOOST_PP_LIST_FOLD_RIGHT_2ND_D">BOOST_PP_LIST_FOLD_RIGHT_2ND_D</a></dt>
+  <dt><a href="list_fold_right.htm#BOOST_PP_LIST_FOLD_RIGHT_2ND_D">BOOST_PP_LIST_FOLD_RIGHT_2ND_D</a></dt>
   <dt><a href="list_fold_right.htm#BOOST_PP_LIST_FOLD_RIGHT_D">BOOST_PP_LIST_FOLD_RIGHT_D</a></dt>
   <dt><a href="list_for_each.htm#BOOST_PP_LIST_FOR_EACH">BOOST_PP_LIST_FOR_EACH</a></dt>
   <dt><a href="list_for_each_i.htm#BOOST_PP_LIST_FOR_EACH_I">BOOST_PP_LIST_FOR_EACH_I</a></dt>
@@ -115,11 +115,11 @@
   <dt><a href="comparison_not_equal.htm#BOOST_PP_NOT_EQUAL_D">BOOST_PP_NOT_EQUAL_D</a></dt>
   <dt><a href="logical_or.htm#BOOST_PP_OR">BOOST_PP_OR</a></dt>
   <dt><a href="repeat.htm#BOOST_PP_REPEAT">BOOST_PP_REPEAT</a></dt>
-  <dt><a href="repeat_2nd.htm#BOOST_PP_REPEAT_2ND">BOOST_PP_REPEAT_2ND</a></dt>
+  <dt><a href="repeat.htm#BOOST_PP_REPEAT_2ND">BOOST_PP_REPEAT_2ND</a></dt>
-  <dt><a href="repeat_3rd.htm#BOOST_PP_REPEAT_3RD">BOOST_PP_REPEAT_3RD</a></dt>
+  <dt><a href="repeat.htm#BOOST_PP_REPEAT_3RD">BOOST_PP_REPEAT_3RD</a></dt>
   <dt><a href="repeat_from_to.htm#BOOST_PP_REPEAT_FROM_TO">BOOST_PP_REPEAT_FROM_TO</a></dt>
-  <dt><a href="repeat_from_to_2nd.htm#BOOST_PP_REPEAT_FROM_TO_2ND">BOOST_PP_REPEAT_FROM_TO_2ND</a></dt>
+  <dt><a href="repeat_from_to.htm#BOOST_PP_REPEAT_FROM_TO_2ND">BOOST_PP_REPEAT_FROM_TO_2ND</a></dt>
-  <dt><a href="repeat_from_to_3rd.htm#BOOST_PP_REPEAT_FROM_TO_3RD">BOOST_PP_REPEAT_FROM_TO_3RD</a></dt>
+  <dt><a href="repeat_from_to.htm#BOOST_PP_REPEAT_FROM_TO_3RD">BOOST_PP_REPEAT_FROM_TO_3RD</a></dt>
   <dt><a href="stringize.htm#BOOST_PP_STRINGIZE">BOOST_PP_STRINGIZE</a></dt>
   <dt><a href="arithmetic_sub.htm#BOOST_PP_SUB">BOOST_PP_SUB</a></dt>
   <dt><a href="arithmetic_sub.htm#BOOST_PP_SUB_D">BOOST_PP_SUB_D</a></dt>

doc/reference/limits.htm

@@ -28,8 +28,8 @@
  <p>Expands to the number of dimensions of repeat supported by the
 library.</p>
 
-<p>The repeat macros are named <a href="repeat.htm#BOOST_PP_REPEAT">BOOST_PP_REPEAT</a>(), <a href="repeat_2nd.htm#BOOST_PP_REPEAT_2ND">BOOST_PP_REPEAT_2ND</a>(),
+<p>This concerns the repetition primitives (<a href="enum.htm#BOOST_PP_ENUM">BOOST_PP_ENUM</a>(),
-<a href="repeat_3rd.htm#BOOST_PP_REPEAT_3RD">BOOST_PP_REPEAT_3RD</a>(), ...</p>
+<a href="repeat.htm#BOOST_PP_REPEAT">BOOST_PP_REPEAT</a>() and <a href="repeat_from_to.htm#BOOST_PP_REPEAT_FROM_TO">BOOST_PP_REPEAT_FROM_TO</a>()).</p>
 
 <hr>
 
@@ -37,8 +37,8 @@ library.</p>
  <p>Expands to the maximum straight numeric literal supported by the
 library.</p>
 
-<p>This is also the limit of the repetition primitives (<a href="enum.htm#BOOST_PP_ENUM">BOOST_PP_ENUM</a> family
+<p>This is also the limit of the repetition primitives (<a href="enum.htm#BOOST_PP_ENUM">BOOST_PP_ENUM</a>(),
-and <a href="repeat.htm#BOOST_PP_REPEAT">BOOST_PP_REPEAT</a> family).</p>
+<a href="repeat.htm#BOOST_PP_REPEAT">BOOST_PP_REPEAT</a>() and <a href="repeat_from_to.htm#BOOST_PP_REPEAT_FROM_TO">BOOST_PP_REPEAT_FROM_TO</a>()).</p>
 
 <h3>Note</h3>
 <ul>

doc/reference/list.htm

@@ -24,6 +24,18 @@
 <hr>
 
  <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>
+
 <hr>
 
 <a href="limits.htm">Prev</a> <a href="list_adt.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/list_adt.htm

@@ -58,10 +58,10 @@
 <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 <a href="list_append.htm#BOOST_PP_LIST_APPEND_D">BOOST_PP_LIST_APPEND_D</a>()
-and <a href="list_fold_right_2nd.htm#BOOST_PP_LIST_FOLD_RIGHT_2ND">BOOST_PP_LIST_FOLD_RIGHT_2ND</a>():</p>
+and <a href="list_fold_right.htm#BOOST_PP_LIST_FOLD_RIGHT">BOOST_PP_LIST_FOLD_RIGHT</a>():</p>
 
 <pre>
-<a href="list_fold_right_2nd.htm#BOOST_PP_LIST_FOLD_RIGHT_2ND">BOOST_PP_LIST_FOLD_RIGHT_2ND</a>
+<a href="list_fold_right.htm#BOOST_PP_LIST_FOLD_RIGHT">BOOST_PP_LIST_FOLD_RIGHT</a>
 ( <a href="list_append.htm#BOOST_PP_LIST_APPEND_D">BOOST_PP_LIST_APPEND_D</a>
 , <a href="tuple_to_list.htm#BOOST_PP_TUPLE_TO_LIST">BOOST_PP_TUPLE_TO_LIST</a>
   ( N
@@ -70,6 +70,7 @@ and <a href="list_fold_right_2nd.htm#BOOST_PP_LIST_FOLD_RIGHT_2ND">BOOST_PP_LIST
   , ...
   , <a href="tuple_to_list.htm#BOOST_PP_TUPLE_TO_LIST">BOOST_PP_TUPLE_TO_LIST</a>(M, (EN1, EN2, ..., ENM) )
   )
+, <a href="list_adt.htm#BOOST_PP_LIST_NIL">BOOST_PP_LIST_NIL</a>
 )
 </pre>
 

doc/reference/list_append.htm

@@ -42,11 +42,6 @@
 <a href="tuple_to_list.htm#BOOST_PP_TUPLE_TO_LIST">BOOST_PP_TUPLE_TO_LIST</a>(4,(1,2,3,4))
 </pre>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="list_fold_right.htm#BOOST_PP_LIST_FOLD_RIGHT">BOOST_PP_LIST_FOLD_RIGHT</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -55,7 +50,7 @@
 <hr>
 
 <h3><a name="BOOST_PP_LIST_APPEND_D">#define BOOST_PP_LIST_APPEND_D</a>(D,LIST_1ST,LIST_2ND)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="list_adt.htm">Prev</a> <a href="list_at.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/list_at.htm

@@ -36,11 +36,6 @@ first element is at index <code>0</code>.</p>
 
 <p>expands to <code>B</code>.</p>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -49,7 +44,7 @@ first element is at index <code>0</code>.</p>
 <hr>
 
 <h3><a name="BOOST_PP_LIST_AT_D">#define BOOST_PP_LIST_AT_D</a>(D,LIST,INDEX)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="list_append.htm">Prev</a> <a href="list_cat.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/list_cat.htm

@@ -39,11 +39,6 @@
 123
 </pre>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="list_fold_left.htm#BOOST_PP_LIST_FOLD_LEFT">BOOST_PP_LIST_FOLD_LEFT</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -52,7 +47,7 @@
 <hr>
 
 <h3><a name="BOOST_PP_LIST_CAT_D">#define BOOST_PP_LIST_CAT_D</a>(D,LIST)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="list_at.htm">Prev</a> <a href="list_enum.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/list_enum.htm

@@ -47,7 +47,7 @@ A,B,C
 <hr>
 
 <h3><a name="BOOST_PP_LIST_ENUM_R">#define BOOST_PP_LIST_ENUM_R</a>(R,LIST)</h3>
- <p>Can be used inside <a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>().</p> 
+ <p>Can be used inside <a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>() (see for an explanation of the R parameter).</p> 
 <hr>
 
 <a href="list_cat.htm">Prev</a> <a href="list_filter.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/list_filter.htm

@@ -40,12 +40,6 @@ for which <code>PRED(D,DATA,X)</code> is true.</p>
 <a href="tuple_to_list.htm#BOOST_PP_TUPLE_TO_LIST">BOOST_PP_TUPLE_TO_LIST</a>(2,(1,3))
 </pre>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for explanation of the D parameter)</li>
-  <li><a href="list_fold_right.htm#BOOST_PP_LIST_FOLD_RIGHT">BOOST_PP_LIST_FOLD_RIGHT</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -54,7 +48,7 @@ for which <code>PRED(D,DATA,X)</code> is true.</p>
 <hr>
 
 <h3><a name="BOOST_PP_LIST_FILTER_D">#define BOOST_PP_LIST_FILTER_D</a>(D,PRED,DATA,LIST)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="list_enum.htm">Prev</a> <a href="list_first_n.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/list_first_n.htm

@@ -45,11 +45,6 @@
   <li><a href="list_rest_n.htm#BOOST_PP_LIST_REST_N">BOOST_PP_LIST_REST_N</a>()</li>
 </ul>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="list_fold_left.htm#BOOST_PP_LIST_FOLD_LEFT">BOOST_PP_LIST_FOLD_LEFT</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -58,7 +53,7 @@
 <hr>
 
 <h3><a name="BOOST_PP_LIST_FIRST_N_D">#define BOOST_PP_LIST_FIRST_N_D</a>(D,COUNT,LIST)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation the D parameter).</p> 
 <hr>
 
 <a href="list_filter.htm">Prev</a> <a href="list_fold_left.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/list_fold_left.htm

@@ -62,11 +62,6 @@ _ABC
   <li><a href="list_fold_right.htm#BOOST_PP_LIST_FOLD_RIGHT">BOOST_PP_LIST_FOLD_RIGHT</a>()</li>
 </ul>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (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>
@@ -75,7 +70,22 @@ _ABC
 <hr>
 
 <h3><a name="BOOST_PP_LIST_FOLD_LEFT_D">#define BOOST_PP_LIST_FOLD_LEFT_D</a>(D,OP,STATE,LIST)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p>
+
+<h3>Note</h3>
+<ul>
+  <li><a href="list_fold_left.htm#BOOST_PP_LIST_FOLD_LEFT_D">BOOST_PP_LIST_FOLD_LEFT_D</a>() implements automatic recursion. You
+      can use a fold in the OP macro.</li>
+</ul>
+
+<hr>
+
+<h3><a name="BOOST_PP_LIST_FOLD_LEFT_2ND">#define BOOST_PP_LIST_FOLD_LEFT_2ND</a></h3>
+ <p>Obsolete, just use <a href="list_fold_left.htm#BOOST_PP_LIST_FOLD_LEFT">BOOST_PP_LIST_FOLD_LEFT</a>().</p> 
+<hr>
+
+<h3><a name="BOOST_PP_LIST_FOLD_LEFT_2ND_D">#define BOOST_PP_LIST_FOLD_LEFT_2ND_D</a></h3>
+ <p>Obsolete, just use <a href="list_fold_left.htm#BOOST_PP_LIST_FOLD_LEFT_D">BOOST_PP_LIST_FOLD_LEFT_D</a>().</p> 
 <hr>
 
 <a href="list_first_n.htm">Prev</a> <a href="list_fold_left_2nd.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/list_fold_left_2nd.htm

@@ -21,15 +21,14 @@
 <hr>
 
 <a href="list_fold_left.htm">Prev</a> <a href="list_fold_right.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>
-
 <hr>
 
-<h3><a name="BOOST_PP_LIST_FOLD_LEFT_2ND">#define BOOST_PP_LIST_FOLD_LEFT_2ND</a>(OP,STATE,LIST)</h3>
+ <p>This header is obsolete. Use the following code instead.</p>
- <p>Same as <a href="list_fold_left.htm#BOOST_PP_LIST_FOLD_LEFT">BOOST_PP_LIST_FOLD_LEFT</a>(), but implemented independently.</p> 
+
-<hr>
+<pre>
+#include &lt;boost/preprocessor/list/fold_left.hpp&gt;
+</pre>
 
-<h3><a name="BOOST_PP_LIST_FOLD_LEFT_2ND_D">#define BOOST_PP_LIST_FOLD_LEFT_2ND_D</a>(D,OP,STATE,LIST)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
 <hr>
 
 <a href="list_fold_left.htm">Prev</a> <a href="list_fold_right.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/list_fold_right.htm

@@ -59,10 +59,10 @@ OP
 _CBA
 </pre>
 
-<h3>Uses</h3>
+<h3>Note</h3>
 <ul>
-  <li><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for explanation of the D parameter)</li>
+  <li>Folding, or accumulation, is a very general pattern of computation.
-  <li><a href="list_fold_left.htm#BOOST_PP_LIST_FOLD_LEFT">BOOST_PP_LIST_FOLD_LEFT</a>()</li>
+      Most list operations can be implemented in terms of folding.</li>
 </ul>
 
 <h3>Test</h3>
@@ -73,7 +73,22 @@ _CBA
 <hr>
 
 <h3><a name="BOOST_PP_LIST_FOLD_RIGHT_D">#define BOOST_PP_LIST_FOLD_RIGHT_D</a>(D,OP,LIST,STATE)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p>
+
+<h3>Note</h3>
+<ul>
+  <li><a href="list_fold_right.htm#BOOST_PP_LIST_FOLD_RIGHT_D">BOOST_PP_LIST_FOLD_RIGHT_D</a>() implements automatic recursion. You
+      can use a fold in the OP macro.</li>
+</ul>
+
+<hr>
+
+<h3><a name="BOOST_PP_LIST_FOLD_RIGHT_2ND">#define BOOST_PP_LIST_FOLD_RIGHT_2ND</a></h3>
+ <p>Obsolete, just use <a href="list_fold_right.htm#BOOST_PP_LIST_FOLD_RIGHT">BOOST_PP_LIST_FOLD_RIGHT</a>().</p> 
+<hr>
+
+<h3><a name="BOOST_PP_LIST_FOLD_RIGHT_2ND_D">#define BOOST_PP_LIST_FOLD_RIGHT_2ND_D</a></h3>
+ <p>Obsolete, just use <a href="list_fold_right.htm#BOOST_PP_LIST_FOLD_RIGHT_D">BOOST_PP_LIST_FOLD_RIGHT_D</a>().</p> 
 <hr>
 
 <a href="list_fold_left_2nd.htm">Prev</a> <a href="list_fold_right_2nd.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/list_fold_right_2nd.htm

@@ -21,15 +21,14 @@
 <hr>
 
 <a href="list_fold_right.htm">Prev</a> <a href="list_for_each.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>
-
 <hr>
 
-<h3><a name="BOOST_PP_LIST_FOLD_RIGHT_2ND">#define BOOST_PP_LIST_FOLD_RIGHT_2ND</a>(OP,LIST,STATE)</h3>
+ <p>This header is obsolete. Use the following code instead.</p>
- <p>Same as <a href="list_fold_right.htm#BOOST_PP_LIST_FOLD_RIGHT">BOOST_PP_LIST_FOLD_RIGHT</a>(), but implemented independently.</p> 
+
-<hr>
+<pre>
+#include &lt;boost/preprocessor/list/fold_right.hpp&gt;
+</pre>
 
-<h3><a name="BOOST_PP_LIST_FOLD_RIGHT_2ND_D">#define BOOST_PP_LIST_FOLD_RIGHT_2ND_D</a>(D,OP,LIST,STATE)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
 <hr>
 
 <a href="list_fold_right.htm">Prev</a> <a href="list_for_each.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/list_for_each.htm

@@ -55,12 +55,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><a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>() (see for explanation of the R parameter)</li>
-  <li><a href="list_for_each_i.htm#BOOST_PP_LIST_FOR_EACH_I">BOOST_PP_LIST_FOR_EACH_I</a>() </li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -69,7 +63,7 @@ prefix_A(); prefix_B(); prefix_C();
 <hr>
 
 <h3><a name="BOOST_PP_LIST_FOR_EACH_R">#define BOOST_PP_LIST_FOR_EACH_R</a>(R,MACRO,DATA,LIST)</h3>
- <p>Can be used inside <a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>().</p> 
+ <p>Can be used inside <a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>() (see for an explanation of the R parameter).</p> 
 <hr>
 
 <a href="list_fold_right_2nd.htm">Prev</a> <a href="list_for_each_i.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/list_for_each_i.htm

@@ -50,15 +50,10 @@ MACRO(R,DATA,<a href="dec.htm#BOOST_PP_DEC">BOOST_PP_DEC</a>(<a href="list_size.
 prefix_A(0); prefix_B(1); prefix_C(2);
 </pre>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>() (see for explanation of the R parameter)</li>
-</ul>
-
 <hr>
 
 <h3><a name="BOOST_PP_LIST_FOR_EACH_I_R">#define BOOST_PP_LIST_FOR_EACH_I_R</a>(R,MACRO,DATA,LIST)</h3>
- <p>Can be used inside <a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>().</p> 
+ <p>Can be used inside <a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>() (see for an explanation of the R parameter).</p> 
 <hr>
 
 <a href="list_for_each.htm">Prev</a> <a href="list_for_each_product.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/list_for_each_product.htm

@@ -56,11 +56,6 @@ explosion.</p>
   <li><a href="../../example/array_arithmetic.c">array_arithmetic.c</a></li>
 </ul>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>() (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>
@@ -69,7 +64,7 @@ explosion.</p>
 <hr>
 
 <h3><a name="BOOST_PP_LIST_FOR_EACH_PRODUCT_R">#define BOOST_PP_LIST_FOR_EACH_PRODUCT_R</a>(R,MACRO,SIZE_OF_TUPLE,TUPLE_OF_LISTS)</h3>
- <p>Can be used inside <a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>().</p> 
+ <p>Can be used inside <a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>() (see for an explanation of the R parameter).</p> 
 <hr>
 
 <a href="list_for_each_i.htm">Prev</a> <a href="list_rest_n.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/list_rest_n.htm

@@ -45,11 +45,6 @@ list <code>LIST</code>.</p>
   <li><a href="list_first_n.htm#BOOST_PP_LIST_FIRST_N">BOOST_PP_LIST_FIRST_N</a>()</li>
 </ul>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -58,7 +53,7 @@ list <code>LIST</code>.</p>
 <hr>
 
 <h3><a name="BOOST_PP_LIST_REST_N_D">#define BOOST_PP_LIST_REST_N_D</a>(D,COUNT,LIST)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="list_for_each_product.htm">Prev</a> <a href="list_reverse.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/list_reverse.htm

@@ -39,11 +39,6 @@
 <a href="tuple_to_list.htm#BOOST_PP_TUPLE_TO_LIST">BOOST_PP_TUPLE_TO_LIST</a>(3,(C,B,A))
 </pre>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="list_fold_left.htm#BOOST_PP_LIST_FOLD_LEFT">BOOST_PP_LIST_FOLD_LEFT</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -52,7 +47,7 @@
 <hr>
 
 <h3><a name="BOOST_PP_LIST_REVERSE_D">#define BOOST_PP_LIST_REVERSE_D</a>(D,LIST)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="list_rest_n.htm">Prev</a> <a href="list_size.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/list_size.htm

@@ -35,11 +35,6 @@
 
 <p>expands to <code>3</code>.</p>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="list_fold_left.htm#BOOST_PP_LIST_FOLD_LEFT">BOOST_PP_LIST_FOLD_LEFT</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -48,7 +43,7 @@
 <hr>
 
 <h3><a name="BOOST_PP_LIST_SIZE_D">#define BOOST_PP_LIST_SIZE_D</a>(D,LIST)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="list_reverse.htm">Prev</a> <a href="list_to_tuple.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/list_to_tuple.htm

@@ -41,11 +41,6 @@
       <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a> rather than <a href="limits.htm#BOOST_PP_LIMIT_TUPLE">BOOST_PP_LIMIT_TUPLE</a>.</li>
 </ul>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -54,7 +49,7 @@
 <hr>
 
 <h3><a name="BOOST_PP_LIST_TO_TUPLE_R">#define BOOST_PP_LIST_TO_TUPLE_R</a>(R,LIST)</h3>
- <p>Can be used inside <a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>().</p> 
+ <p>Can be used inside <a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>() (see for an explanation of the R parameter).</p> 
 <hr>
 
 <a href="list_size.htm">Prev</a> <a href="list_transform.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/list_transform.htm

@@ -50,12 +50,6 @@ of the list producing a new list.</p>
 <a href="tuple_to_list.htm#BOOST_PP_TUPLE_TO_LIST">BOOST_PP_TUPLE_TO_LIST</a>(2,(3,4))
 </pre>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for explanation of the D parameter)</li>
-  <li><a href="list_fold_right.htm#BOOST_PP_LIST_FOLD_RIGHT">BOOST_PP_LIST_FOLD_RIGHT</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -64,7 +58,7 @@ of the list producing a new list.</p>
 <hr>
 
 <h3><a name="BOOST_PP_LIST_TRANSFORM_D">#define BOOST_PP_LIST_TRANSFORM_D</a>(D,OP,DATA,LIST)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="list_to_tuple.htm">Prev</a> <a href="logical.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/max.htm

@@ -33,11 +33,6 @@ in the range [0, <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>]
 <p>For example, <code><a href="max.htm#BOOST_PP_MAX">BOOST_PP_MAX</a>(5,7)</code> expands to <code>7</code> (a
 single token).</p>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -46,7 +41,7 @@ single token).</p>
 <hr>
 
 <h3><a name="BOOST_PP_MAX_D">#define BOOST_PP_MAX_D</a>(D,X,Y)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="logical_xor.htm">Prev</a> <a href="min.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/min.htm

@@ -33,11 +33,6 @@ in the range [0, <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>]
 <p>For example, <code><a href="min.htm#BOOST_PP_MIN">BOOST_PP_MIN</a>(5,7)</code> expands to <code>5</code> (a
 single token).</p>
 
-<h3>Uses</h3>
-<ul>
-  <li><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -46,7 +41,7 @@ single token).</p>
 <hr>
 
 <h3><a name="BOOST_PP_MIN_D">#define BOOST_PP_MIN_D</a>(D,X,Y)</h3>
- <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>().</p> 
+ <p>Can be used inside <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() (see for an explanation of the D parameter).</p> 
 <hr>
 
 <a href="max.htm">Prev</a> <a href="repeat.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/repeat.htm

@@ -48,8 +48,8 @@ X(0); X(1); X(2);
 
 <h3>2D and 3D repetition</h3>
 
-<p>2D and 3D repetition are supported with the <a href="repeat_2nd.htm#BOOST_PP_REPEAT_2ND">BOOST_PP_REPEAT_2ND</a>() and
+<p><a href="repeat.htm#BOOST_PP_REPEAT">BOOST_PP_REPEAT</a>() implements automatic recursion. 2D and 3D repetition
-<a href="repeat_3rd.htm#BOOST_PP_REPEAT_3RD">BOOST_PP_REPEAT_3RD</a>() macros.</p>
+are directly supported.</p>
 
 <h3>Example</h3>
 <ul>
@@ -60,9 +60,24 @@ X(0); X(1); X(2);
 <h3>See</h3>
 <ul>
   <li><a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>()</li>
+  <li><a href="limits.htm#BOOST_PP_LIMIT_DIM">BOOST_PP_LIMIT_DIM</a></li>
   <li><a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a></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>
+
+<hr>
+
+<h3><a name="BOOST_PP_REPEAT_2ND">#define BOOST_PP_REPEAT_2ND</a></h3>
+ <p>Obsolete, just use <a href="repeat.htm#BOOST_PP_REPEAT">BOOST_PP_REPEAT</a>().</p> 
+<hr>
+
+<h3><a name="BOOST_PP_REPEAT_3RD">#define BOOST_PP_REPEAT_3RD</a></h3>
+ <p>Obsolete, just use <a href="repeat.htm#BOOST_PP_REPEAT">BOOST_PP_REPEAT</a>().</p> 
 <hr>
 
 <a href="min.htm">Prev</a> <a href="repeat_2nd.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/repeat_2nd.htm

@@ -21,16 +21,13 @@
 <hr>
 
 <a href="repeat.htm">Prev</a> <a href="repeat_3rd.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>
-
 <hr>
 
-<h3><a name="BOOST_PP_REPEAT_2ND">#define BOOST_PP_REPEAT_2ND</a>(COUNT,MACRO,DATA)</h3>
+ <p>This header is obsolete. Use the following code instead.</p>
- <p>Same as <a href="repeat.htm#BOOST_PP_REPEAT">BOOST_PP_REPEAT</a>(), but implemented independently.</p>
 
-<h3>Test</h3>
+<pre>
-<ul>
+#include &lt;boost/preprocessor/repeat.hpp&gt;
-  <li><a href="../../test/repeat_2nd_test.cpp">repeat_2nd_test.cpp</a></li>
+</pre>
-</ul>
 
 <hr>
 

doc/reference/repeat_3rd.htm

@@ -21,11 +21,14 @@
 <hr>
 
 <a href="repeat_2nd.htm">Prev</a> <a href="repeat_from_to.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>
-
 <hr>
 
-<h3><a name="BOOST_PP_REPEAT_3RD">#define BOOST_PP_REPEAT_3RD</a>(COUNT,MACRO,DATA)</h3>
+ <p>This header is obsolete. Use the following code instead.</p>
- <p>Same as <a href="repeat.htm#BOOST_PP_REPEAT">BOOST_PP_REPEAT</a>(), but implemented independently.</p> 
+
+<pre>
+#include &lt;boost/preprocessor/repeat.hpp&gt;
+</pre>
+
 <hr>
 
 <a href="repeat_2nd.htm">Prev</a> <a href="repeat_from_to.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/repeat_from_to.htm

@@ -46,18 +46,34 @@ MACRO(FIRST,DATA) MACRO(<a href="inc.htm#BOOST_PP_INC">BOOST_PP_INC</a>(FIRST),D
 X(4); X(5); X(6);
 </pre>
 
-<h3>Uses</h3>
+<h3>2D and 3D repetition</h3>
+
+<p><a href="repeat_from_to.htm#BOOST_PP_REPEAT_FROM_TO">BOOST_PP_REPEAT_FROM_TO</a>() implements automatic recursion. 2D and 3D repetition
+are directly supported.</p>
+
+<h3>See</h3>
 <ul>
-  <li><a href="repeat.htm#BOOST_PP_REPEAT">BOOST_PP_REPEAT</a>()</li>
+  <li><a href="for.htm#BOOST_PP_FOR">BOOST_PP_FOR</a>()</li>
+  <li><a href="limits.htm#BOOST_PP_LIMIT_DIM">BOOST_PP_LIMIT_DIM</a></li>
+  <li><a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a></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>
 
 <hr>
 
+<h3><a name="BOOST_PP_REPEAT_FROM_TO_2ND">#define BOOST_PP_REPEAT_FROM_TO_2ND</a></h3>
+ <p>Obsolete, just use <a href="repeat_from_to.htm#BOOST_PP_REPEAT_FROM_TO">BOOST_PP_REPEAT_FROM_TO</a>().</p> 
+<hr>
+
+<h3><a name="BOOST_PP_REPEAT_FROM_TO_3RD">#define BOOST_PP_REPEAT_FROM_TO_3RD</a></h3>
+ <p>Obsolete, just use <a href="repeat_from_to.htm#BOOST_PP_REPEAT_FROM_TO">BOOST_PP_REPEAT_FROM_TO</a>().</p> 
+<hr>
+
 <a href="repeat_3rd.htm">Prev</a> <a href="repeat_from_to_2nd.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>
 <hr>
 

doc/reference/repeat_from_to_2nd.htm

@@ -21,11 +21,14 @@
 <hr>
 
 <a href="repeat_from_to.htm">Prev</a> <a href="repeat_from_to_3rd.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>
-
 <hr>
 
-<h3><a name="BOOST_PP_REPEAT_FROM_TO_2ND">#define BOOST_PP_REPEAT_FROM_TO_2ND</a>(FIRST,LAST,MACRO,DATA)</h3>
+ <p>This header is obsolete. Use the following code instead.</p>
- <p>Same as <a href="repeat_from_to.htm#BOOST_PP_REPEAT_FROM_TO">BOOST_PP_REPEAT_FROM_TO</a>(), but implemented independently.</p> 
+
+<pre>
+#include &lt;boost/preprocessor/repeat_from_to.hpp&gt;
+</pre>
+
 <hr>
 
 <a href="repeat_from_to.htm">Prev</a> <a href="repeat_from_to_3rd.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/repeat_from_to_3rd.htm

@@ -21,11 +21,14 @@
 <hr>
 
 <a href="repeat_from_to_2nd.htm">Prev</a> <a href="stringize.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>
-
 <hr>
 
-<h3><a name="BOOST_PP_REPEAT_FROM_TO_3RD">#define BOOST_PP_REPEAT_FROM_TO_3RD</a>(FIRST,LAST,MACRO,DATA)</h3>
+ <p>This header is obsolete. Use the following code instead.</p>
- <p>Same as <a href="repeat_from_to.htm#BOOST_PP_REPEAT_FROM_TO">BOOST_PP_REPEAT_FROM_TO</a>(), but implemented independently.</p> 
+
+<pre>
+#include &lt;boost/preprocessor/repeat_from_to.hpp&gt;
+</pre>
+
 <hr>
 
 <a href="repeat_from_to_2nd.htm">Prev</a> <a href="stringize.htm">Next</a> <a href="index.htm#Macros">Macros</a> <a href="index.htm#Headers">Headers</a>

doc/reference/while.htm

@@ -66,13 +66,21 @@ OP(D, ... OP(D, OP(D,STATE) ) ... )
       C++ preprocessor.</li>
 </ul>
 
+<h3>Automatic recursion?</h3>
+
+<p><a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() 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 <a href="limits.htm#BOOST_PP_LIMIT_MAG">BOOST_PP_LIMIT_MAG</a>.</li>
   <li>Using <a href="while.htm#BOOST_PP_WHILE">BOOST_PP_WHILE</a>() 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
+      implementations of the various PREPROCESSOR library primitives
-      <a href="arithmetic_add.htm#BOOST_PP_ADD">BOOST_PP_ADD</a>() for additional examples.</li>
+      such as <a href="arithmetic_add.htm#BOOST_PP_ADD">BOOST_PP_ADD</a>() for additional examples.</li>
 </ul>
 
 <h3>Example</h3>

doc/tutorial.htm

@@ -32,7 +32,7 @@
       <dt><a href="#ENUM_PARAMS">Avoid O(N) repetition on lists in general</a></dt>
       <dt><a href="#Conditional Define">Use a Conditional Define to enable user configuration of code repetition</a></dt>
       <dt><a href="#Token Look-Up">Use Token Look-Up Function to eliminate categorical repetition</a></dt>
-      <dt><a href="#2ND_REPEAT">Use BOOST_PP_REPEAT_2ND to avoid O(N*N) repetition</a></dt>
+      <dt><a href="#2ND_REPEAT">Use BOOST_PP_REPEAT to avoid O(N*N) repetition</a></dt>
       <dt><a href="#IF">Use BOOST_PP_IF to implement special case for the first element</a></dt>
       <dt><a href="#Arithmetic">Use arithmetic, logical and comparison operations when necessary</a></dt>
     </dl>
@@ -69,8 +69,8 @@ yes_type is_function_tester(R (*)(A0, A1, A2));
 <P>The need for this kind of repetition occurs particularly frequently while implementing 
   generic components or metaprogramming facilities, but the need also manifests 
   itself in many far simpler situations. </P>
-<h3>Typical solutions</h3>
 
+<h3>Typical solutions</h3>
 
 <p>Typically the repetition is done manually. Manual code repetition is highly 
   unproductive, but sometimes more readable to the untrained eye.</p>
@@ -111,7 +111,7 @@ yes_type is_function_tester(R (*)(A0, A1, A2));
   template&lt;class R BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM_PARAMS(N, class A)&gt;\
   yes_type is_function_tester(R (*)(BOOST_PP_ENUM_PARAMS(N,A)));
 
-BOOST_PP_REPEAT_2ND(BOOST_PP_INC(MAX_IS_FUNCTION_TESTER_PARAMS),IS_FUNCTION_TESTER,_)
+BOOST_PP_REPEAT(BOOST_PP_INC(MAX_IS_FUNCTION_TESTER_PARAMS),IS_FUNCTION_TESTER,_)
 #undef IS_FUNCTION_TESTER
 </pre>
 
@@ -189,12 +189,12 @@ of the line continuation operators without making the code too unreadable.</P>
 <P><B>TIP:</B> Use syntax highlighting on preprocessor metaprogramming macro and 
   parameter identifiers such as</P>
 <ul>
-  <li> BOOST_PP_DEF,</li>
+  <li>BOOST_PP_DEF,</li>
   <li>BOOST_PP_EMPTY,</li>
-  <li> BOOST_PP_REPEAT,</li>
+  <li>BOOST_PP_REPEAT,</li>
-  <li> OP,</li>
+  <li>OP,</li>
-  <li> CV,</li>
+  <li>CV,</li>
-  <li> ...</li>
+  <li>...</li>
 </ul>
 <p>It can greatly improve readability.</p>
 <HR>
@@ -235,12 +235,12 @@ STATIC_ASSERT(sizeof(int) &lt;= sizeof(long));
 <P><B><a name="ENUM_PARAMS"></a><a href="examples_preprocessed.htm#ENUM_PARAMS">EXAMPLE</a>:</B> 
   Use:</P>
 <ul>
-  <li> BOOST_PP_ENUM_PARAMS,</li>
+  <li>BOOST_PP_ENUM_PARAMS,</li>
-  <li> BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT,</li>
+  <li>BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT,</li>
-  <li> BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS,</li>
+  <li>BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS,</li>
-  <li> BOOST_PP_ENUM_SHIFTED_PARAMS, or</li>
+  <li>BOOST_PP_ENUM_SHIFTED_PARAMS, or</li>
   <li>BOOST_PP_REPEAT, and</li>
-  <li> BOOST_PP_COMMA_IF</li>
+  <li>BOOST_PP_COMMA_IF</li>
 </ul>
 <p>to avoid O(N) repetition on lists in general</p>
 
@@ -359,7 +359,7 @@ categorical repetition of operator tokens can not be completely eliminated by
 using template metaprogramming.</P>
 <HR>
 <P><B><a name="2ND_REPEAT"></a><a href="examples_preprocessed.htm#2ND_REPEAT">EXAMPLE</a>:</B> 
-  Use BOOST_PP_REPEAT_2ND to avoid O(N*N) repetition</P>
+  Use BOOST_PP_REPEAT to avoid O(N*N) repetition</P>
 
 <pre>#ifndef MAX_VEC_ARG_CNT
 #define MAX_VEC_ARG_CNT 8
@@ -375,7 +375,7 @@ vec( BOOST_PP_REPEAT(I,ARG_FUN,_) )\
 { BOOST_PP_REPEAT(I,ASSIGN_FUN,_)\
 }
 
-BOOST_PP_REPEAT_2ND
+BOOST_PP_REPEAT
 ( BOOST_PP_INC(MAX_VEC_ARG_CNT)
 , DEF_VEC_CTOR_FUN
 , _
@@ -388,8 +388,9 @@ BOOST_PP_REPEAT_2ND
 // ...
 </pre>
 
-<P><B>HOW:</B> BOOST_PP_REPEAT_2ND is implemented separately, so it 
+<P><B>HOW:</B> BOOST_PP_REPEAT is implemented in a special way to enable
-  is possible to combine BOOST_PP_REPEAT and BOOST_PP_REPEAT_2ND.</P>
+automatic recursion.</P>
+
 <HR>
 
 <P><a name="IF"></a><a href="examples_preprocessed.htm#IF"><B>EXAMPLE:</B></a> Use BOOST_PP_IF to implement special case for the first element</P>

example/repeat_2d.c

@@ -15,7 +15,6 @@
  */
 
 #include <boost/preprocessor/repeat.hpp>
-#include <boost/preprocessor/repeat_2nd.hpp>
 
 /** Repeats the macro M(X,Y,P) for X = [0,W[ and Y = [0,H[.
 
@@ -28,13 +27,13 @@ In other words, expands to the sequence:
   M(  0,H-1,  P) M(  1,H-1,  P) ... M(W-1,H-1,  P)
 \endverbatim</PRE>
 
-Uses BOOST_PP_REPEAT() and BOOST_PP_REPEAT_2ND().
+Uses BOOST_PP_REPEAT().
 */
 #define REPEAT_2D(W,H,M,P)\
-  /* Here we must use BOOST_PP_REPEAT_2ND(), because\
+  /* Here we can simply use BOOST_PP_REPEAT(), because\
-   * we use BOOST_PP_REPEAT() in REPEAT_2D_ROW().\
+   * it implements automatic recursion.\
    */\
-  BOOST_PP_REPEAT_2ND\
+  BOOST_PP_REPEAT\
   ( H\
   , REPEAT_2D_ROW\
   , (W,M,P)\

include/boost/preprocessor.hpp

@@ -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

include/boost/preprocessor/detail/auto_rec.hpp

@@ -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

include/boost/preprocessor/enum.hpp

@@ -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

include/boost/preprocessor/for.hpp

@@ -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

include/boost/preprocessor/list.hpp

@@ -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>

include/boost/preprocessor/list/adt.hpp

@@ -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>
 */

include/boost/preprocessor/list/append.hpp

@@ -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

include/boost/preprocessor/list/at.hpp

@@ -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

include/boost/preprocessor/list/cat.hpp

@@ -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

include/boost/preprocessor/list/enum.hpp

@@ -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

include/boost/preprocessor/list/filter.hpp

@@ -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

include/boost/preprocessor/list/first_n.hpp

@@ -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_C(D,RLC) BOOST_PP_TUPLE_ELEM(3,2,RLC)
-#  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_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_C(D,RLC) BOOST_PP_TUPLE3_ELEM2 RLC
-#  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_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

include/boost/preprocessor/list/fold_left.hpp

@@ -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> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</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__)
+<h3>Note</h3>
-#  define BOOST_PP_LIST_FOLD_LEFT_C(D,X) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(3,2,X))
+<ul>
-#  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)))
+  <li>BOOST_PP_LIST_FOLD_LEFT_D() implements automatic recursion. You
-#elif !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
+      can use a fold in the OP macro.</li>
-#  define BOOST_PP_LIST_FOLD_LEFT_C(D,X) BOOST_PP_TUPLE3_ELEM2 BOOST_PP_TUPLE3_ELEM2 X
+</ul>
-#  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
+#if 0
-#  define BOOST_PP_LIST_FOLD_LEFT_C(D,X) BOOST_PP_TUPLE3_ELEM2 BOOST_PP_TUPLE3_ELEM2 X
+#  define BOOST_PP_LIST_FOLD_LEFT_D(D,OP,STATE,LIST)
-#  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)
 #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

include/boost/preprocessor/list/fold_left_2nd.hpp

@@ -13,22 +13,12 @@
  * See http://www.boost.org for most recent version.
  */
 
-#include <boost/preprocessor/list/adt.hpp>
+/** <p>This header is obsolete. Use the following code instead.</p>
-#include <boost/preprocessor/while.hpp>
 
-/** <p>Same as BOOST_PP_LIST_FOLD_LEFT(), but implemented independently.</p> */
+<pre>
-#define BOOST_PP_LIST_FOLD_LEFT_2ND(OP,STATE,LIST) BOOST_PP_LIST_FOLD_LEFT_2ND_D(0,OP,STATE,LIST)
+#include &lt;boost/preprocessor/list/fold_left.hpp&gt;
+</pre>
+*/
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+#include <boost/preprocessor/list/fold_left.hpp>
-#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
 #endif

include/boost/preprocessor/list/fold_right.hpp

@@ -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>Folding, or accumulation, is a very general pattern of computation.
-  <li>BOOST_PP_LIST_FOLD_LEFT()</li>
+      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> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</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__)
+<h3>Note</h3>
-#  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)))
+<ul>
-#elif !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
+  <li>BOOST_PP_LIST_FOLD_RIGHT_D() implements automatic recursion. You
-#  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))
+      can use a fold in the OP macro.</li>
-#else
+</ul>
-#  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))
+*/
+#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

include/boost/preprocessor/list/fold_right_2nd.hpp

@@ -13,19 +13,12 @@
  * See http://www.boost.org for most recent version.
  */
 
-#include <boost/preprocessor/list/fold_left_2nd.hpp>
+/** <p>This header is obsolete. Use the following code instead.</p>
-#include <boost/preprocessor/list/reverse.hpp>
 
-/** <p>Same as BOOST_PP_LIST_FOLD_RIGHT(), but implemented independently.</p> */
+<pre>
-#define BOOST_PP_LIST_FOLD_RIGHT_2ND(OP,LIST,STATE) BOOST_PP_LIST_FOLD_RIGHT_2ND_D(0,OP,LIST,STATE)
+#include &lt;boost/preprocessor/list/fold_right.hpp&gt;
+</pre>
+*/
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+#include <boost/preprocessor/list/fold_right.hpp>
-#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
 #endif

include/boost/preprocessor/list/for_each.hpp

@@ -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

include/boost/preprocessor/list/for_each_i.hpp

@@ -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_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,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_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,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_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

include/boost/preprocessor/list/for_each_product.hpp

@@ -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)

include/boost/preprocessor/list/rest_n.hpp

@@ -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_C(D,LC) BOOST_PP_TUPLE_ELEM(2,1,LC)
-#  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_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_C(D,LC) BOOST_PP_TUPLE2_ELEM1 LC
-#  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_F(D,LC) (BOOST_PP_TUPLE3_ELEM1 BOOST_PP_TUPLE2_ELEM0 LC,BOOST_PP_DEC(BOOST_PP_TUPLE2_ELEM1 LC))
 #endif
 #endif

include/boost/preprocessor/list/reverse.hpp

@@ -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

include/boost/preprocessor/list/size.hpp

@@ -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

include/boost/preprocessor/list/to_tuple.hpp

@@ -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

include/boost/preprocessor/list/transform.hpp

@@ -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

include/boost/preprocessor/repeat.hpp

@@ -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
+<p>BOOST_PP_REPEAT() implements automatic recursion. 2D and 3D repetition
-BOOST_PP_REPEAT_3RD() macros.</p>
+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)
+#if 0
-
+#  define BOOST_PP_REPEAT(COUNT,MACRO,DATA)
-#define BOOST_PP_REPEAT_DELAY(N) BOOST_PP_REPEAT##N
+#endif
-#define BOOST_PP_REPEAT0(M,D)
+
-#define BOOST_PP_REPEAT1(M,D) M(0,D)
+#define BOOST_PP_REPEAT\
-#define BOOST_PP_REPEAT2(M,D) M(0,D) M(1,D)
+  BOOST_PP_AUTO_REC_CAT1(BOOST_PP_REPEAT,BOOST_PP_REPEAT_AUTO_REC1(BOOST_PP_AUTO_REC_ID,(1)))
-#define BOOST_PP_REPEAT3(M,D) M(0,D) M(1,D) M(2,D)
+#define BOOST_PP_REPEATBOOST_PP_REPEAT_AUTO_REC1(M,P)\
-#define BOOST_PP_REPEAT4(M,D) M(0,D) M(1,D) M(2,D) M(3,D)
+  BOOST_PP_AUTO_REC_CAT2(BOOST_PP_REPEAT,BOOST_PP_REPEAT_AUTO_REC2(BOOST_PP_AUTO_REC_ID,(2)))
-#define BOOST_PP_REPEAT5(M,D) BOOST_PP_REPEAT4(M,D) M(4,D)
+#define BOOST_PP_REPEATBOOST_PP_REPEAT_AUTO_REC2(M,P)\
-#define BOOST_PP_REPEAT6(M,D) BOOST_PP_REPEAT5(M,D) M(5,D)
+  BOOST_PP_AUTO_REC_CAT3(BOOST_PP_REPEAT,BOOST_PP_REPEAT_AUTO_REC3(BOOST_PP_AUTO_REC_ID,(3)))
-#define BOOST_PP_REPEAT7(M,D) BOOST_PP_REPEAT6(M,D) M(6,D)
+#define BOOST_PP_REPEATBOOST_PP_REPEAT_AUTO_REC3(M,P)\
-#define BOOST_PP_REPEAT8(M,D) BOOST_PP_REPEAT7(M,D) M(7,D)
+  (TOO MANY NESTED REPEATS!)
-#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_REPEAT_AUTO_REC1(M,P) M P
-#define BOOST_PP_REPEAT11(M,D) BOOST_PP_REPEAT10(M,D) M(10,D)
+#define BOOST_PP_REPEAT_AUTO_REC2(M,P) M P
-#define BOOST_PP_REPEAT12(M,D) BOOST_PP_REPEAT11(M,D) M(11,D)
+#define BOOST_PP_REPEAT_AUTO_REC3(M,P) M P
-#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_REPEAT1(C,M,D) BOOST_PP_REPEAT_AUTO_REC1(BOOST_PP_R1_DELAY(C),(M,D))
-#define BOOST_PP_REPEAT15(M,D) BOOST_PP_REPEAT14(M,D) M(14,D)
+#define BOOST_PP_R1_DELAY(C) BOOST_PP_R1_##C
-#define BOOST_PP_REPEAT16(M,D) BOOST_PP_REPEAT15(M,D) M(15,D)
+#define BOOST_PP_R1_0(M,D)
-#define BOOST_PP_REPEAT17(M,D) BOOST_PP_REPEAT16(M,D) M(16,D)
+#define BOOST_PP_R1_1(M,D) M(0,D)
-#define BOOST_PP_REPEAT18(M,D) BOOST_PP_REPEAT17(M,D) M(17,D)
+#define BOOST_PP_R1_2(M,D) M(0,D) M(1,D)
-#define BOOST_PP_REPEAT19(M,D) BOOST_PP_REPEAT18(M,D) M(18,D)
+#define BOOST_PP_R1_3(M,D) M(0,D) M(1,D) M(2,D)
-#define BOOST_PP_REPEAT20(M,D) BOOST_PP_REPEAT19(M,D) M(19,D)
+#define BOOST_PP_R1_4(M,D) M(0,D) M(1,D) M(2,D) M(3,D)
-#define BOOST_PP_REPEAT21(M,D) BOOST_PP_REPEAT20(M,D) M(20,D)
+#define BOOST_PP_R1_5(M,D) BOOST_PP_R1_4(M,D) M(4,D)
-#define BOOST_PP_REPEAT22(M,D) BOOST_PP_REPEAT21(M,D) M(21,D)
+#define BOOST_PP_R1_6(M,D) BOOST_PP_R1_5(M,D) M(5,D)
-#define BOOST_PP_REPEAT23(M,D) BOOST_PP_REPEAT22(M,D) M(22,D)
+#define BOOST_PP_R1_7(M,D) BOOST_PP_R1_6(M,D) M(6,D)
-#define BOOST_PP_REPEAT24(M,D) BOOST_PP_REPEAT23(M,D) M(23,D)
+#define BOOST_PP_R1_8(M,D) BOOST_PP_R1_7(M,D) M(7,D)
-#define BOOST_PP_REPEAT25(M,D) BOOST_PP_REPEAT24(M,D) M(24,D)
+#define BOOST_PP_R1_9(M,D) BOOST_PP_R1_8(M,D) M(8,D)
-#define BOOST_PP_REPEAT26(M,D) BOOST_PP_REPEAT25(M,D) M(25,D)
+#define BOOST_PP_R1_10(M,D) BOOST_PP_R1_9(M,D) M(9,D)
-#define BOOST_PP_REPEAT27(M,D) BOOST_PP_REPEAT26(M,D) M(26,D)
+#define BOOST_PP_R1_11(M,D) BOOST_PP_R1_10(M,D) M(10,D)
-#define BOOST_PP_REPEAT28(M,D) BOOST_PP_REPEAT27(M,D) M(27,D)
+#define BOOST_PP_R1_12(M,D) BOOST_PP_R1_11(M,D) M(11,D)
-#define BOOST_PP_REPEAT29(M,D) BOOST_PP_REPEAT28(M,D) M(28,D)
+#define BOOST_PP_R1_13(M,D) BOOST_PP_R1_12(M,D) M(12,D)
-#define BOOST_PP_REPEAT30(M,D) BOOST_PP_REPEAT29(M,D) M(29,D)
+#define BOOST_PP_R1_14(M,D) BOOST_PP_R1_13(M,D) M(13,D)
-#define BOOST_PP_REPEAT31(M,D) BOOST_PP_REPEAT30(M,D) M(30,D)
+#define BOOST_PP_R1_15(M,D) BOOST_PP_R1_14(M,D) M(14,D)
-#define BOOST_PP_REPEAT32(M,D) BOOST_PP_REPEAT31(M,D) M(31,D)
+#define BOOST_PP_R1_16(M,D) BOOST_PP_R1_15(M,D) M(15,D)
-#define BOOST_PP_REPEAT33(M,D) BOOST_PP_REPEAT32(M,D) M(32,D)
+#define BOOST_PP_R1_17(M,D) BOOST_PP_R1_16(M,D) M(16,D)
-#define BOOST_PP_REPEAT34(M,D) BOOST_PP_REPEAT33(M,D) M(33,D)
+#define BOOST_PP_R1_18(M,D) BOOST_PP_R1_17(M,D) M(17,D)
-#define BOOST_PP_REPEAT35(M,D) BOOST_PP_REPEAT34(M,D) M(34,D)
+#define BOOST_PP_R1_19(M,D) BOOST_PP_R1_18(M,D) M(18,D)
-#define BOOST_PP_REPEAT36(M,D) BOOST_PP_REPEAT35(M,D) M(35,D)
+#define BOOST_PP_R1_20(M,D) BOOST_PP_R1_19(M,D) M(19,D)
-#define BOOST_PP_REPEAT37(M,D) BOOST_PP_REPEAT36(M,D) M(36,D)
+#define BOOST_PP_R1_21(M,D) BOOST_PP_R1_20(M,D) M(20,D)
-#define BOOST_PP_REPEAT38(M,D) BOOST_PP_REPEAT37(M,D) M(37,D)
+#define BOOST_PP_R1_22(M,D) BOOST_PP_R1_21(M,D) M(21,D)
-#define BOOST_PP_REPEAT39(M,D) BOOST_PP_REPEAT38(M,D) M(38,D)
+#define BOOST_PP_R1_23(M,D) BOOST_PP_R1_22(M,D) M(22,D)
-#define BOOST_PP_REPEAT40(M,D) BOOST_PP_REPEAT39(M,D) M(39,D)
+#define BOOST_PP_R1_24(M,D) BOOST_PP_R1_23(M,D) M(23,D)
-#define BOOST_PP_REPEAT41(M,D) BOOST_PP_REPEAT40(M,D) M(40,D)
+#define BOOST_PP_R1_25(M,D) BOOST_PP_R1_24(M,D) M(24,D)
-#define BOOST_PP_REPEAT42(M,D) BOOST_PP_REPEAT41(M,D) M(41,D)
+#define BOOST_PP_R1_26(M,D) BOOST_PP_R1_25(M,D) M(25,D)
-#define BOOST_PP_REPEAT43(M,D) BOOST_PP_REPEAT42(M,D) M(42,D)
+#define BOOST_PP_R1_27(M,D) BOOST_PP_R1_26(M,D) M(26,D)
-#define BOOST_PP_REPEAT44(M,D) BOOST_PP_REPEAT43(M,D) M(43,D)
+#define BOOST_PP_R1_28(M,D) BOOST_PP_R1_27(M,D) M(27,D)
-#define BOOST_PP_REPEAT45(M,D) BOOST_PP_REPEAT44(M,D) M(44,D)
+#define BOOST_PP_R1_29(M,D) BOOST_PP_R1_28(M,D) M(28,D)
-#define BOOST_PP_REPEAT46(M,D) BOOST_PP_REPEAT45(M,D) M(45,D)
+#define BOOST_PP_R1_30(M,D) BOOST_PP_R1_29(M,D) M(29,D)
-#define BOOST_PP_REPEAT47(M,D) BOOST_PP_REPEAT46(M,D) M(46,D)
+#define BOOST_PP_R1_31(M,D) BOOST_PP_R1_30(M,D) M(30,D)
-#define BOOST_PP_REPEAT48(M,D) BOOST_PP_REPEAT47(M,D) M(47,D)
+#define BOOST_PP_R1_32(M,D) BOOST_PP_R1_31(M,D) M(31,D)
-#define BOOST_PP_REPEAT49(M,D) BOOST_PP_REPEAT48(M,D) M(48,D)
+#define BOOST_PP_R1_33(M,D) BOOST_PP_R1_32(M,D) M(32,D)
-#define BOOST_PP_REPEAT50(M,D) BOOST_PP_REPEAT49(M,D) M(49,D)
+#define BOOST_PP_R1_34(M,D) BOOST_PP_R1_33(M,D) M(33,D)
-#define BOOST_PP_REPEAT51(M,D) BOOST_PP_REPEAT50(M,D) M(50,D)
+#define BOOST_PP_R1_35(M,D) BOOST_PP_R1_34(M,D) M(34,D)
-#define BOOST_PP_REPEAT52(M,D) BOOST_PP_REPEAT51(M,D) M(51,D)
+#define BOOST_PP_R1_36(M,D) BOOST_PP_R1_35(M,D) M(35,D)
-#define BOOST_PP_REPEAT53(M,D) BOOST_PP_REPEAT52(M,D) M(52,D)
+#define BOOST_PP_R1_37(M,D) BOOST_PP_R1_36(M,D) M(36,D)
-#define BOOST_PP_REPEAT54(M,D) BOOST_PP_REPEAT53(M,D) M(53,D)
+#define BOOST_PP_R1_38(M,D) BOOST_PP_R1_37(M,D) M(37,D)
-#define BOOST_PP_REPEAT55(M,D) BOOST_PP_REPEAT54(M,D) M(54,D)
+#define BOOST_PP_R1_39(M,D) BOOST_PP_R1_38(M,D) M(38,D)
-#define BOOST_PP_REPEAT56(M,D) BOOST_PP_REPEAT55(M,D) M(55,D)
+#define BOOST_PP_R1_40(M,D) BOOST_PP_R1_39(M,D) M(39,D)
-#define BOOST_PP_REPEAT57(M,D) BOOST_PP_REPEAT56(M,D) M(56,D)
+#define BOOST_PP_R1_41(M,D) BOOST_PP_R1_40(M,D) M(40,D)
-#define BOOST_PP_REPEAT58(M,D) BOOST_PP_REPEAT57(M,D) M(57,D)
+#define BOOST_PP_R1_42(M,D) BOOST_PP_R1_41(M,D) M(41,D)
-#define BOOST_PP_REPEAT59(M,D) BOOST_PP_REPEAT58(M,D) M(58,D)
+#define BOOST_PP_R1_43(M,D) BOOST_PP_R1_42(M,D) M(42,D)
-#define BOOST_PP_REPEAT60(M,D) BOOST_PP_REPEAT59(M,D) M(59,D)
+#define BOOST_PP_R1_44(M,D) BOOST_PP_R1_43(M,D) M(43,D)
-#define BOOST_PP_REPEAT61(M,D) BOOST_PP_REPEAT60(M,D) M(60,D)
+#define BOOST_PP_R1_45(M,D) BOOST_PP_R1_44(M,D) M(44,D)
-#define BOOST_PP_REPEAT62(M,D) BOOST_PP_REPEAT61(M,D) M(61,D)
+#define BOOST_PP_R1_46(M,D) BOOST_PP_R1_45(M,D) M(45,D)
-#define BOOST_PP_REPEAT63(M,D) BOOST_PP_REPEAT62(M,D) M(62,D)
+#define BOOST_PP_R1_47(M,D) BOOST_PP_R1_46(M,D) M(46,D)
-#define BOOST_PP_REPEAT64(M,D) BOOST_PP_REPEAT63(M,D) M(63,D)
+#define BOOST_PP_R1_48(M,D) BOOST_PP_R1_47(M,D) M(47,D)
-#define BOOST_PP_REPEAT65(M,D) BOOST_PP_REPEAT64(M,D) M(64,D)
+#define BOOST_PP_R1_49(M,D) BOOST_PP_R1_48(M,D) M(48,D)
-#define BOOST_PP_REPEAT66(M,D) BOOST_PP_REPEAT65(M,D) M(65,D)
+#define BOOST_PP_R1_50(M,D) BOOST_PP_R1_49(M,D) M(49,D)
-#define BOOST_PP_REPEAT67(M,D) BOOST_PP_REPEAT66(M,D) M(66,D)
+#define BOOST_PP_R1_51(M,D) BOOST_PP_R1_50(M,D) M(50,D)
-#define BOOST_PP_REPEAT68(M,D) BOOST_PP_REPEAT67(M,D) M(67,D)
+#define BOOST_PP_R1_52(M,D) BOOST_PP_R1_51(M,D) M(51,D)
-#define BOOST_PP_REPEAT69(M,D) BOOST_PP_REPEAT68(M,D) M(68,D)
+#define BOOST_PP_R1_53(M,D) BOOST_PP_R1_52(M,D) M(52,D)
-#define BOOST_PP_REPEAT70(M,D) BOOST_PP_REPEAT69(M,D) M(69,D)
+#define BOOST_PP_R1_54(M,D) BOOST_PP_R1_53(M,D) M(53,D)
-#define BOOST_PP_REPEAT71(M,D) BOOST_PP_REPEAT70(M,D) M(70,D)
+#define BOOST_PP_R1_55(M,D) BOOST_PP_R1_54(M,D) M(54,D)
-#define BOOST_PP_REPEAT72(M,D) BOOST_PP_REPEAT71(M,D) M(71,D)
+#define BOOST_PP_R1_56(M,D) BOOST_PP_R1_55(M,D) M(55,D)
-#define BOOST_PP_REPEAT73(M,D) BOOST_PP_REPEAT72(M,D) M(72,D)
+#define BOOST_PP_R1_57(M,D) BOOST_PP_R1_56(M,D) M(56,D)
-#define BOOST_PP_REPEAT74(M,D) BOOST_PP_REPEAT73(M,D) M(73,D)
+#define BOOST_PP_R1_58(M,D) BOOST_PP_R1_57(M,D) M(57,D)
-#define BOOST_PP_REPEAT75(M,D) BOOST_PP_REPEAT74(M,D) M(74,D)
+#define BOOST_PP_R1_59(M,D) BOOST_PP_R1_58(M,D) M(58,D)
-#define BOOST_PP_REPEAT76(M,D) BOOST_PP_REPEAT75(M,D) M(75,D)
+#define BOOST_PP_R1_60(M,D) BOOST_PP_R1_59(M,D) M(59,D)
-#define BOOST_PP_REPEAT77(M,D) BOOST_PP_REPEAT76(M,D) M(76,D)
+#define BOOST_PP_R1_61(M,D) BOOST_PP_R1_60(M,D) M(60,D)
-#define BOOST_PP_REPEAT78(M,D) BOOST_PP_REPEAT77(M,D) M(77,D)
+#define BOOST_PP_R1_62(M,D) BOOST_PP_R1_61(M,D) M(61,D)
-#define BOOST_PP_REPEAT79(M,D) BOOST_PP_REPEAT78(M,D) M(78,D)
+#define BOOST_PP_R1_63(M,D) BOOST_PP_R1_62(M,D) M(62,D)
-#define BOOST_PP_REPEAT80(M,D) BOOST_PP_REPEAT79(M,D) M(79,D)
+#define BOOST_PP_R1_64(M,D) BOOST_PP_R1_63(M,D) M(63,D)
-#define BOOST_PP_REPEAT81(M,D) BOOST_PP_REPEAT80(M,D) M(80,D)
+#define BOOST_PP_R1_65(M,D) BOOST_PP_R1_64(M,D) M(64,D)
-#define BOOST_PP_REPEAT82(M,D) BOOST_PP_REPEAT81(M,D) M(81,D)
+#define BOOST_PP_R1_66(M,D) BOOST_PP_R1_65(M,D) M(65,D)
-#define BOOST_PP_REPEAT83(M,D) BOOST_PP_REPEAT82(M,D) M(82,D)
+#define BOOST_PP_R1_67(M,D) BOOST_PP_R1_66(M,D) M(66,D)
-#define BOOST_PP_REPEAT84(M,D) BOOST_PP_REPEAT83(M,D) M(83,D)
+#define BOOST_PP_R1_68(M,D) BOOST_PP_R1_67(M,D) M(67,D)
-#define BOOST_PP_REPEAT85(M,D) BOOST_PP_REPEAT84(M,D) M(84,D)
+#define BOOST_PP_R1_69(M,D) BOOST_PP_R1_68(M,D) M(68,D)
-#define BOOST_PP_REPEAT86(M,D) BOOST_PP_REPEAT85(M,D) M(85,D)
+#define BOOST_PP_R1_70(M,D) BOOST_PP_R1_69(M,D) M(69,D)
-#define BOOST_PP_REPEAT87(M,D) BOOST_PP_REPEAT86(M,D) M(86,D)
+#define BOOST_PP_R1_71(M,D) BOOST_PP_R1_70(M,D) M(70,D)
-#define BOOST_PP_REPEAT88(M,D) BOOST_PP_REPEAT87(M,D) M(87,D)
+#define BOOST_PP_R1_72(M,D) BOOST_PP_R1_71(M,D) M(71,D)
-#define BOOST_PP_REPEAT89(M,D) BOOST_PP_REPEAT88(M,D) M(88,D)
+#define BOOST_PP_R1_73(M,D) BOOST_PP_R1_72(M,D) M(72,D)
-#define BOOST_PP_REPEAT90(M,D) BOOST_PP_REPEAT89(M,D) M(89,D)
+#define BOOST_PP_R1_74(M,D) BOOST_PP_R1_73(M,D) M(73,D)
-#define BOOST_PP_REPEAT91(M,D) BOOST_PP_REPEAT90(M,D) M(90,D)
+#define BOOST_PP_R1_75(M,D) BOOST_PP_R1_74(M,D) M(74,D)
-#define BOOST_PP_REPEAT92(M,D) BOOST_PP_REPEAT91(M,D) M(91,D)
+#define BOOST_PP_R1_76(M,D) BOOST_PP_R1_75(M,D) M(75,D)
-#define BOOST_PP_REPEAT93(M,D) BOOST_PP_REPEAT92(M,D) M(92,D)
+#define BOOST_PP_R1_77(M,D) BOOST_PP_R1_76(M,D) M(76,D)
-#define BOOST_PP_REPEAT94(M,D) BOOST_PP_REPEAT93(M,D) M(93,D)
+#define BOOST_PP_R1_78(M,D) BOOST_PP_R1_77(M,D) M(77,D)
-#define BOOST_PP_REPEAT95(M,D) BOOST_PP_REPEAT94(M,D) M(94,D)
+#define BOOST_PP_R1_79(M,D) BOOST_PP_R1_78(M,D) M(78,D)
-#define BOOST_PP_REPEAT96(M,D) BOOST_PP_REPEAT95(M,D) M(95,D)
+#define BOOST_PP_R1_80(M,D) BOOST_PP_R1_79(M,D) M(79,D)
-#define BOOST_PP_REPEAT97(M,D) BOOST_PP_REPEAT96(M,D) M(96,D)
+#define BOOST_PP_R1_81(M,D) BOOST_PP_R1_80(M,D) M(80,D)
-#define BOOST_PP_REPEAT98(M,D) BOOST_PP_REPEAT97(M,D) M(97,D)
+#define BOOST_PP_R1_82(M,D) BOOST_PP_R1_81(M,D) M(81,D)
-#define BOOST_PP_REPEAT99(M,D) BOOST_PP_REPEAT98(M,D) M(98,D)
+#define BOOST_PP_R1_83(M,D) BOOST_PP_R1_82(M,D) M(82,D)
-#define BOOST_PP_REPEAT100(M,D) BOOST_PP_REPEAT99(M,D) M(99,D)
+#define BOOST_PP_R1_84(M,D) BOOST_PP_R1_83(M,D) M(83,D)
-#define BOOST_PP_REPEAT101(M,D) BOOST_PP_REPEAT100(M,D) M(100,D)
+#define BOOST_PP_R1_85(M,D) BOOST_PP_R1_84(M,D) M(84,D)
-#define BOOST_PP_REPEAT102(M,D) BOOST_PP_REPEAT101(M,D) M(101,D)
+#define BOOST_PP_R1_86(M,D) BOOST_PP_R1_85(M,D) M(85,D)
-#define BOOST_PP_REPEAT103(M,D) BOOST_PP_REPEAT102(M,D) M(102,D)
+#define BOOST_PP_R1_87(M,D) BOOST_PP_R1_86(M,D) M(86,D)
-#define BOOST_PP_REPEAT104(M,D) BOOST_PP_REPEAT103(M,D) M(103,D)
+#define BOOST_PP_R1_88(M,D) BOOST_PP_R1_87(M,D) M(87,D)
-#define BOOST_PP_REPEAT105(M,D) BOOST_PP_REPEAT104(M,D) M(104,D)
+#define BOOST_PP_R1_89(M,D) BOOST_PP_R1_88(M,D) M(88,D)
-#define BOOST_PP_REPEAT106(M,D) BOOST_PP_REPEAT105(M,D) M(105,D)
+#define BOOST_PP_R1_90(M,D) BOOST_PP_R1_89(M,D) M(89,D)
-#define BOOST_PP_REPEAT107(M,D) BOOST_PP_REPEAT106(M,D) M(106,D)
+#define BOOST_PP_R1_91(M,D) BOOST_PP_R1_90(M,D) M(90,D)
-#define BOOST_PP_REPEAT108(M,D) BOOST_PP_REPEAT107(M,D) M(107,D)
+#define BOOST_PP_R1_92(M,D) BOOST_PP_R1_91(M,D) M(91,D)
-#define BOOST_PP_REPEAT109(M,D) BOOST_PP_REPEAT108(M,D) M(108,D)
+#define BOOST_PP_R1_93(M,D) BOOST_PP_R1_92(M,D) M(92,D)
-#define BOOST_PP_REPEAT110(M,D) BOOST_PP_REPEAT109(M,D) M(109,D)
+#define BOOST_PP_R1_94(M,D) BOOST_PP_R1_93(M,D) M(93,D)
-#define BOOST_PP_REPEAT111(M,D) BOOST_PP_REPEAT110(M,D) M(110,D)
+#define BOOST_PP_R1_95(M,D) BOOST_PP_R1_94(M,D) M(94,D)
-#define BOOST_PP_REPEAT112(M,D) BOOST_PP_REPEAT111(M,D) M(111,D)
+#define BOOST_PP_R1_96(M,D) BOOST_PP_R1_95(M,D) M(95,D)
-#define BOOST_PP_REPEAT113(M,D) BOOST_PP_REPEAT112(M,D) M(112,D)
+#define BOOST_PP_R1_97(M,D) BOOST_PP_R1_96(M,D) M(96,D)
-#define BOOST_PP_REPEAT114(M,D) BOOST_PP_REPEAT113(M,D) M(113,D)
+#define BOOST_PP_R1_98(M,D) BOOST_PP_R1_97(M,D) M(97,D)
-#define BOOST_PP_REPEAT115(M,D) BOOST_PP_REPEAT114(M,D) M(114,D)
+#define BOOST_PP_R1_99(M,D) BOOST_PP_R1_98(M,D) M(98,D)
-#define BOOST_PP_REPEAT116(M,D) BOOST_PP_REPEAT115(M,D) M(115,D)
+#define BOOST_PP_R1_100(M,D) BOOST_PP_R1_99(M,D) M(99,D)
-#define BOOST_PP_REPEAT117(M,D) BOOST_PP_REPEAT116(M,D) M(116,D)
+#define BOOST_PP_R1_101(M,D) BOOST_PP_R1_100(M,D) M(100,D)
-#define BOOST_PP_REPEAT118(M,D) BOOST_PP_REPEAT117(M,D) M(117,D)
+#define BOOST_PP_R1_102(M,D) BOOST_PP_R1_101(M,D) M(101,D)
-#define BOOST_PP_REPEAT119(M,D) BOOST_PP_REPEAT118(M,D) M(118,D)
+#define BOOST_PP_R1_103(M,D) BOOST_PP_R1_102(M,D) M(102,D)
-#define BOOST_PP_REPEAT120(M,D) BOOST_PP_REPEAT119(M,D) M(119,D)
+#define BOOST_PP_R1_104(M,D) BOOST_PP_R1_103(M,D) M(103,D)
-#define BOOST_PP_REPEAT121(M,D) BOOST_PP_REPEAT120(M,D) M(120,D)
+#define BOOST_PP_R1_105(M,D) BOOST_PP_R1_104(M,D) M(104,D)
-#define BOOST_PP_REPEAT122(M,D) BOOST_PP_REPEAT121(M,D) M(121,D)
+#define BOOST_PP_R1_106(M,D) BOOST_PP_R1_105(M,D) M(105,D)
-#define BOOST_PP_REPEAT123(M,D) BOOST_PP_REPEAT122(M,D) M(122,D)
+#define BOOST_PP_R1_107(M,D) BOOST_PP_R1_106(M,D) M(106,D)
-#define BOOST_PP_REPEAT124(M,D) BOOST_PP_REPEAT123(M,D) M(123,D)
+#define BOOST_PP_R1_108(M,D) BOOST_PP_R1_107(M,D) M(107,D)
-#define BOOST_PP_REPEAT125(M,D) BOOST_PP_REPEAT124(M,D) M(124,D)
+#define BOOST_PP_R1_109(M,D) BOOST_PP_R1_108(M,D) M(108,D)
-#define BOOST_PP_REPEAT126(M,D) BOOST_PP_REPEAT125(M,D) M(125,D)
+#define BOOST_PP_R1_110(M,D) BOOST_PP_R1_109(M,D) M(109,D)
-#define BOOST_PP_REPEAT127(M,D) BOOST_PP_REPEAT126(M,D) M(126,D)
+#define BOOST_PP_R1_111(M,D) BOOST_PP_R1_110(M,D) M(110,D)
-#define BOOST_PP_REPEAT128(M,D) BOOST_PP_REPEAT127(M,D) M(127,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)
-/* <p>Obsolete. Use BOOST_PP_REPEAT().</p> */
+#define BOOST_PP_R1_114(M,D) BOOST_PP_R1_113(M,D) M(113,D)
-#define BOOST_PREPROCESSOR_REPEAT(C,M,D) BOOST_PP_REPEAT(C,M,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

include/boost/preprocessor/repeat_2nd.hpp

@@ -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>
+<pre>
-<ul>
+#include &lt;boost/preprocessor/repeat.hpp&gt;
-  <li><a href="../../test/repeat_2nd_test.cpp">repeat_2nd_test.cpp</a></li>
+</pre>
-</ul>
 */
-#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
+#include <boost/preprocessor/repeat.hpp>
-#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)
 #endif

include/boost/preprocessor/repeat_3rd.hpp

@@ -13,140 +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>
-#define BOOST_PP_REPEAT_3RD(COUNT,MACRO,DATA) BOOST_PP_REPEAT_3RD_DELAY(COUNT)(MACRO,DATA)
 
-#define BOOST_PP_REPEAT_3RD_DELAY(C) BOOST_PP_REPEAT_3RD##C
+<pre>
-#define BOOST_PP_REPEAT_3RD0(M,D)
+#include &lt;boost/preprocessor/repeat.hpp&gt;
-#define BOOST_PP_REPEAT_3RD1(M,D) M(0,D)
+</pre>
-#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)
 
-/* <p>Obsolete. Use BOOST_PP_REPEAT_3RD().</p> */
+#include <boost/preprocessor/repeat.hpp>
-#define BOOST_PREPROCESSOR_REPEAT_3RD(C,M,D) BOOST_PP_REPEAT_3RD(C,M,D)
 #endif

include/boost/preprocessor/repeat_from_to.hpp

@@ -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))
+#if 0
-#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))
+#  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

include/boost/preprocessor/repeat_from_to_2nd.hpp

@@ -13,11 +13,12 @@
  * See http://www.boost.org for most recent version.
  */
 
-#include <boost/preprocessor/repeat_2nd.hpp>
+/** <p>This header is obsolete. Use the following code instead.</p>
-#include <boost/preprocessor/arithmetic/sub.hpp>
-#include <boost/preprocessor/arithmetic/add.hpp>
 
-/** <p>Same as BOOST_PP_REPEAT_FROM_TO(), but implemented independently.</p> */
+<pre>
-#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))
+#include &lt;boost/preprocessor/repeat_from_to.hpp&gt;
-#define BOOST_PP_REPEAT_FROM_TO_2ND_F(I,SMP) BOOST_PP_TUPLE_ELEM(3,1,SMP)(BOOST_PP_ADD(I,BOOST_PP_TUPLE_ELEM(3,0,SMP)),BOOST_PP_TUPLE_ELEM(3,2,SMP))
+</pre>
+*/
+
+#include <boost/preprocessor/repeat_from_to.hpp>
 #endif

include/boost/preprocessor/repeat_from_to_3rd.hpp

@@ -13,11 +13,12 @@
  * See http://www.boost.org for most recent version.
  */
 
-#include <boost/preprocessor/repeat_3rd.hpp>
+/** <p>This header is obsolete. Use the following code instead.</p>
-#include <boost/preprocessor/arithmetic/sub.hpp>
-#include <boost/preprocessor/arithmetic/add.hpp>
 
-/** <p>Same as BOOST_PP_REPEAT_FROM_TO(), but implemented independently.</p> */
+<pre>
-#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))
+#include &lt;boost/preprocessor/repeat_from_to.hpp&gt;
-#define BOOST_PP_REPEAT_FROM_TO_3RD_F(I,SMP) BOOST_PP_TUPLE_ELEM(3,1,SMP)(BOOST_PP_ADD(I,BOOST_PP_TUPLE_ELEM(3,0,SMP)),BOOST_PP_TUPLE_ELEM(3,2,SMP))
+</pre>
+*/
+
+#include <boost/preprocessor/repeat_from_to.hpp>
 #endif

include/boost/preprocessor/while.hpp

@@ -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
+      implementations of the various PREPROCESSOR library primitives
-      BOOST_PP_ADD() for additional examples.</li>
+      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_WHILE258(P,O,S) (RECURSION DEPTH EXCEEDED!)
-#define BOOST_PP_WHILE259(P,O,S) RECURSION DEPTH EXCEEDED!
+#define BOOST_PP_WHILE259(P,O,S) (RECURSION DEPTH EXCEEDED!)
 #endif

test/list_test.cpp

@@ -48,3 +48,17 @@ TEST_B BOOST_PP_LIST_CAT(BOOST_PP_LIST_FILTER(BOOST_PP_LESS_D,3,TEST_LIST)) == 4
 #define F(R,X) +BOOST_PP_TUPLE_ELEM(2,0,X)+2-BOOST_PP_TUPLE_ELEM(2,1,X)
 TEST_B BOOST_PP_LIST_FOR_EACH_PRODUCT(F,2,(BOOST_PP_TUPLE_TO_LIST(2,(1,0)),BOOST_PP_TUPLE_TO_LIST(2,(2,3)))) == 0 TEST_E
 #undef F
+
+TEST_B BOOST_PP_LIST_CAT
+       ( BOOST_PP_LIST_FOLD_RIGHT
+         ( BOOST_PP_LIST_APPEND_D
+         , BOOST_PP_TUPLE_TO_LIST
+           ( 3
+           , ( BOOST_PP_TUPLE_TO_LIST(2,(0,x))
+             , BOOST_PP_TUPLE_TO_LIST(4,(A,1,B,2))
+             , BOOST_PP_TUPLE_TO_LIST(3,(C,3,D))
+             )
+           )
+	 , BOOST_PP_LIST_NIL
+         )
+       ) == 0xA1B2C3D TEST_E

test/repeat_2nd_test.cpp

@@ -13,13 +13,14 @@
 #include <boost/preprocessor/enum_params.hpp>
 #include <boost/preprocessor/enum_shifted_params.hpp>
 #include <boost/preprocessor/inc.hpp>
-#include <boost/preprocessor/repeat_2nd.hpp>
+#include <boost/preprocessor/repeat_from_to.hpp>
+#include <libs/preprocessor/test/test.hpp>
 
 /* *** */
 
 /* RATIONALE:
- * - BOOST_PP_REPEAT, BOOST_PP_REPEAT_2ND, ... must work
+ * - BOOST_PP_REPEAT, BOOST_PP_ENUM, BOOST_PP_REPEAT_FROM_TO and must work
- * together.
+ * recursively together.
  * - BOOST_PP_REPEAT is already tested with
  * BOOST_PP_ENUM_PARAMS.
  * - The tested repeat count should exceed imaginable usage.
@@ -44,6 +45,18 @@ typedef char yes_type;
   yes_type is_function_helper(\
     P0 (*)(BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_INC(I),P)));
 
-BOOST_PP_REPEAT_2ND(BOOST_PP_INC(IS_FUNCTION_HELPER_TEST_MAX),IS_FUNCTION_HELPER,A)
+BOOST_PP_REPEAT(BOOST_PP_INC(IS_FUNCTION_HELPER_TEST_MAX),IS_FUNCTION_HELPER,A)
 
 #undef IS_FUNCTION_HELPER
+
+/* *** */
+
+#define ELEM(_,X) X
+#define COL(I,_) +(BOOST_PP_ENUM(2,ELEM,-I))
+#define ROW(I,_) BOOST_PP_REPEAT(I,COL,_)
+
+TEST_B 0 == (+1 +1+2 +1+2+3) + BOOST_PP_REPEAT_FROM_TO(2,5,ROW,_) TEST_E
+
+#undef ROW
+#undef COL
+#undef ELEM