From 00d05d4f042c46b564df4d6f43ac78b28b2f9db1 Mon Sep 17 00:00:00 2001 From: Edward Diener Date: Thu, 27 Feb 2014 17:06:00 -0500 Subject: [PATCH] Added links to topics with macros which use re-entrancy versions. --- doc/ref/for_r.html | 157 ++++++++++++++++++++--------------------- doc/ref/repeat_z.html | 140 +++++++++++++++++-------------------- doc/ref/while_d.html | 158 +++++++++++++++++++----------------------- 3 files changed, 211 insertions(+), 244 deletions(-) diff --git a/doc/ref/for_r.html b/doc/ref/for_r.html index 1c23bb4..a566ea7 100644 --- a/doc/ref/for_r.html +++ b/doc/ref/for_r.html @@ -1,75 +1,68 @@ - - BOOST_PP_FOR_r - - - -
- The BOOST_PP_FOR_r macro represents a reentry into the BOOST_PP_FOR repetition construct. -
-

Usage

-
- BOOST_PP_FOR_ ## r(state, pred, op, macro) -
-

Arguments

-
-
r
-
- The next available BOOST_PP_FOR repetition. -
-
state
-
- The initial state. -
-
pred
-
- A binary predicate of the form pred(r, state).  - This macro must expand to an integer in the range of 0 to BOOST_PP_LIMIT_MAG.  - BOOST_PP_FOR repeatedly expands macro while this predicate returns non-zero.  - This macro is called with the next available BOOST_PP_FOR repetition and the current state. -
-
op
-
- A binary operation of the form op(r, state).  - This operation is expanded by BOOST_PP_FOR with the next available BOOST_PP_FOR repetition and the current state.  - This macro is repeatedly applied to the state, each time producing a new state, until pred returns 0. -
-
macro
-
- A binary macro of the form macro(r, state).  - This macro is expanded by BOOST_PP_FOR with the next available BOOST_PP_FOR repetition and the current state.  - This macro is is repeated by BOOST_PP_FOR until pred returns 0. -
-
-

Remarks

-
- This macro expands to the sequence: -
- macro(r, state) macro(r, op(r, state)) ... macro(r, op(r, ... op(r, state) ... )) -
-
-
- At certain times, it may be necessary to perform the concatenation with BOOST_PP_CAT rather than the preprocessor token-pasting operator.  - This happens when the r value is a macro invocation itself.  - It needs a delay to allow it to expand.  - The syntax in such a scenario becomes: -
- BOOST_PP_CAT(BOOST_PP_FOR_, r)(state, pred, op, macro) -
-
-

See Also

- -

Requirements

-
- Header:  <boost/preprocessor/repetition/for.hpp> -
-

Sample Code

-
-#include <boost/preprocessor/arithmetic/dec.hpp>
+  
+    
+    BOOST_PP_FOR_r
+    
+  
+  
+    
 The BOOST_PP_FOR_r macro
+      represents a reentry into the BOOST_PP_FOR repetition construct. 

+    
Usage

+    
 BOOST_PP_FOR_ ## r(state, pred,
+      op, macro) 

+    
Arguments

+    

+      
r

+      
 The next available BOOST_PP_FOR repetition. 

+      
state

+      
 The initial state. 

+      
pred

+      
 A binary predicate of the form pred(r, state). 
+        This macro must expand to an integer in the range of 0 to BOOST_PP_LIMIT_MAG. 
+        BOOST_PP_FOR repeatedly expands macro while this
+        predicate returns non-zero.  This macro is called with the next
+        available BOOST_PP_FOR repetition and the current state.
+      

+      
op

+      
 A binary operation of the form op(r, state). 
+        This operation is expanded by BOOST_PP_FOR with the next
+        available BOOST_PP_FOR repetition and the current state. 
+        This macro is repeatedly applied to the state, each time
+        producing a new state, until pred returns 0. 

+      
macro

+      
 A binary macro of the form macro(r, state). 
+        This macro is expanded by BOOST_PP_FOR with the next available BOOST_PP_FOR
+        repetition and the current state.  This macro is is
+        repeated by BOOST_PP_FOR until pred returns 0. 

+    

+    
Remarks

+    
 This macro expands to the sequence:
+      
 macro(r, state) macro(r, op(r,
+        state)) ... macro(r, op(r, ... op(r,
+        state) ... )) 

+    

+    
 At certain times, it may be necessary to perform the concatenation
+      with BOOST_PP_CAT rather than the preprocessor token-pasting
+      operator.  This happens when the r value is a macro
+      invocation itself.  It needs a delay to allow it to expand.  The
+      syntax in such a scenario becomes:
+      
 BOOST_PP_CAT(BOOST_PP_FOR_, r)(state,
+        pred, op, macro) 

+    

+    
See Also

+    
+    
Requirements

+    
 Header:  <boost/preprocessor/repetition/for.hpp>
+    

+    
Sample Code

+    

+      
#include <boost/preprocessor/arithmetic/dec.hpp>
 #include <boost/preprocessor/arithmetic/inc.hpp>
 #include <boost/preprocessor/comparison/not_equal.hpp>
 #include <boost/preprocessor/punctuation/comma_if.hpp>
@@ -140,16 +133,14 @@ TEMPLATE_TEMPLATE(2, 4, T)
    template<class, class, class, class> class T4
 */
 

-	

-	

-		© Copyright Housemarque Oy 2002
-		
© Copyright Paul Mensonides 2002
-	

-	

-		
Distributed under the Boost Software License, Version 1.0. (See
-		accompanying file LICENSE_1_0.txt or
-		copy at www.boost.org/LICENSE_1_0.txt)

-	

-
+    

+    
 © Copyright Housemarque Oy 2002 

+      © Copyright Paul Mensonides 2002 

+    

+      
Distributed under the Boost Software License, Version 1.0. (See
+          accompanying file LICENSE_1_0.txt
+          or copy at www.boost.org/LICENSE_1_0.txt)

+    

+  
 
diff --git a/doc/ref/repeat_z.html b/doc/ref/repeat_z.html
index 36d0d03..e808135 100644
--- a/doc/ref/repeat_z.html
+++ b/doc/ref/repeat_z.html
@@ -1,67 +1,59 @@
 
-
-	BOOST_PP_REPEAT_z
-	
-
-
-	

-		The BOOST_PP_REPEAT_z macro represents a reentry into the BOOST_PP_REPEAT repetition construct.
-	

-	
Usage

-		

-			BOOST_PP_REPEAT_ ## z(count, macro, data)
-		

-	
Arguments

-		

-			
z

-			

-				The next available BOOST_PP_REPEAT dimension.
-			

-			
count

-			

-				The number of repetitious calls to macro. 
-				Valid values range from 0 to BOOST_PP_LIMIT_REPEAT.
-			

-			
macro

-			

-				A ternary operation of the form macro(z, n, data). 
-				This macro is expanded by BOOST_PP_REPEAT with the next available repetition depth,
-				the current repetition number, and the auxiliary data argument. 
-			

-			
data

-			

-				Auxiliary data passed to macro.
-			

-		

-	
Remarks

-		

-			This macro expands to the sequence:
-			

-				macro(z, 0, data) macro(z, 1, data) ... macro(z, count - 1, data)
-			

-		

-		

-			At certain times, it may be necessary to perform the concatenation with BOOST_PP_CAT rather than the preprocessor token-pasting operator. 
-			This happens when the z value is a macro invocation itself. 
-			It needs a delay to allow it to expand. 
-			The syntax in such a scenario becomes:
-			

-				BOOST_PP_CAT(BOOST_PP_REPEAT_, z)(count, macro, data)
-			

-		

-	
See Also

-		
-	
Requirements

-		

-			Header:  <boost/preprocessor/repetition/repeat.hpp>
-		

-	
Sample Code

-
-#include <boost/preprocessor/arithmetic/inc.hpp>
+  
+    
+    BOOST_PP_REPEAT_z
+    
+  
+  
+    
 The BOOST_PP_REPEAT_z macro
+      represents a reentry into the BOOST_PP_REPEAT repetition
+      construct. 

+    
Usage

+    
 BOOST_PP_REPEAT_ ## z(count, macro,
+      data) 

+    
Arguments

+    

+      
z

+      
 The next available BOOST_PP_REPEAT dimension. 

+      
count

+      
 The number of repetitious calls to macro.  Valid values
+        range from 0 to BOOST_PP_LIMIT_REPEAT. 

+      
macro

+      
 A ternary operation of the form macro(z, n, data). 
+        This macro is expanded by BOOST_PP_REPEAT with the next
+        available repetition depth, the current repetition number, and the
+        auxiliary data argument.  

+      
data

+      
 Auxiliary data passed to macro. 

+    

+    
Remarks

+    
 This macro expands to the sequence:
+      
 macro(z, 0, data) macro(z,
+        1, data) ... macro(z, count - 1,
+        data) 

+    

+    
 At certain times, it may be necessary to perform the concatenation
+      with BOOST_PP_CAT rather than the preprocessor token-pasting
+      operator.  This happens when the z value is a macro
+      invocation itself.  It needs a delay to allow it to expand.  The
+      syntax in such a scenario becomes:
+      
 BOOST_PP_CAT(BOOST_PP_REPEAT_, z)(count,
+        macro, data) 

+    

+    
See Also

+    
+    
Requirements

+    
+    
Sample Code

+    

+      
#include <boost/preprocessor/arithmetic/inc.hpp>
 #include <boost/preprocessor/punctuation/comma_if.hpp>
 #include <boost/preprocessor/repetition/repeat.hpp>
 
@@ -85,16 +77,14 @@
       template<class, class, class> class T2
    */
 

-	

-	

-		© Copyright Housemarque Oy 2002
-		
© Copyright Paul Mensonides 2002
-	

-	

-		
Distributed under the Boost Software License, Version 1.0. (See
-		accompanying file LICENSE_1_0.txt or
-		copy at www.boost.org/LICENSE_1_0.txt)

-	

-
+    

+    
 © Copyright Housemarque Oy 2002 

+      © Copyright Paul Mensonides 2002 

+    

+      
Distributed under the Boost Software License, Version 1.0. (See
+          accompanying file LICENSE_1_0.txt
+          or copy at www.boost.org/LICENSE_1_0.txt)

+    

+  
 
diff --git a/doc/ref/while_d.html b/doc/ref/while_d.html
index 8b59f10..0be1bcb 100644
--- a/doc/ref/while_d.html
+++ b/doc/ref/while_d.html
@@ -1,78 +1,66 @@
 
-
-	BOOST_PP_WHILE_d
-	
-
-
-	

-		The BOOST_PP_WHILE_d macro represents a reentry into the BOOST_PP_WHILE looping construct.
-	

-	
Usage

-		

-			BOOST_PP_WHILE_ ## d(pred, op, state)
-		

-	
Arguments

-		

-			
d

-			

-				The next available BOOST_PP_WHILE iteration.
-			

-			
pred

-			

-				A binary predicate of the form pred(d, state). 
-				This predicate is expanded by BOOST_PP_WHILE with the next available
-				iteration d and the current state. 
-				This predicate must expand to value in the range of 0 to BOOST_PP_LIMIT_MAG.
-				The construct continues to loop until this predicate returns 0. 
-				When this predicate returns 0, BOOST_PP_WHILE returns the current state.
-			

-			
op

-			

-				A binary operation of the form op(d, state). 
-				This operation is expanded by BOOST_PP_WHILE with the next available
-				iteration d and the current state. 
-				This macro is repeatedly applied to the state, each time producing a new state, until pred returns 0.
-			

-			
state

-			

-				The initial state. 
-				Often this argument is a tuple.
-			

-		

-	
Remarks

-		

-			This macro iterates op(d, state) while pred(d, state) is non-zero. 
-			In other words expands to:
-			

-				op(d, ... op(d, op(d, state)) ... ).
-			

-		

-		

-			At certain times, it may be necessary to perform the concatenation with BOOST_PP_CAT rather than the preprocessor token-pasting operator. 
-			This happens when the d value is a macro invocation itself. 
-			It needs a delay to allow it to expand. 
-			The syntax in such a scenario becomes:
-			

-				BOOST_PP_CAT(BOOST_PP_WHILE_, d)(pred, op, state).
-			

-		

-		

-			Previously, it was possible to concatenate d directly to BOOST_PP_WHILE (without the trailing underscore). 
-			This is no longer supported.
-		

-	
See Also

-		
-	
Requirements

-		
-	
Sample Code

-
-#include <boost/preprocessor/arithmetic/add.hpp>
+  
+    
+    BOOST_PP_WHILE_d
+    
+  
+  
+    
 The BOOST_PP_WHILE_d macro
+      represents a reentry into the BOOST_PP_WHILE looping construct. 

+    
Usage

+    
 BOOST_PP_WHILE_ ## d(pred, op,
+      state) 

+    
Arguments

+    

+      
d

+      
 The next available BOOST_PP_WHILE iteration. 

+      
pred

+      
 A binary predicate of the form pred(d, state). 
+        This predicate is expanded by BOOST_PP_WHILE with the next
+        available iteration d and the current state.  This
+        predicate must expand to value in the range of 0 to BOOST_PP_LIMIT_MAG.
+        The construct continues to loop until this predicate returns 0. 
+        When this predicate returns 0, BOOST_PP_WHILE returns
+        the current state. 

+      
op

+      
 A binary operation of the form op(d, state). 
+        This operation is expanded by BOOST_PP_WHILE with the next
+        available iteration d and the current state.  This
+        macro is repeatedly applied to the state, each time producing a
+        new state, until pred returns 0. 

+      
state

+      
 The initial state.  Often this argument is a tuple. 

+    

+    
Remarks

+    
 This macro iterates op(d, state) while pred(d,
+      state) is non-zero.  In other words expands to:
+      
 op(d, ... op(d, op(d, state))
+        ... ). 

+    

+    
 At certain times, it may be necessary to perform the concatenation
+      with BOOST_PP_CAT rather than the preprocessor token-pasting
+      operator.  This happens when the d value is a macro
+      invocation itself.  It needs a delay to allow it to expand.  The
+      syntax in such a scenario becomes:
+      
 BOOST_PP_CAT(BOOST_PP_WHILE_, d)(pred,
+        op, state). 

+    

+    
 Previously, it was possible to concatenate d directly to BOOST_PP_WHILE
+      (without the trailing underscore).  This is no longer supported. 

+    
See Also

+    
+    
Requirements

+    
+    
Sample Code

+    

+      
#include <boost/preprocessor/arithmetic/add.hpp>
 #include <boost/preprocessor/arithmetic/dec.hpp>
 #include <boost/preprocessor/array/elem.hpp>
 #include <boost/preprocessor/array/size.hpp>
@@ -114,16 +102,14 @@
 
 ACCUMULATE_D(1, ARRAY)// expands to 10
 

-	

-	

-		© Copyright Housemarque Oy 2002
-		
© Copyright Paul Mensonides 2002
-	

-	

-		
Distributed under the Boost Software License, Version 1.0. (See
-		accompanying file LICENSE_1_0.txt or
-		copy at www.boost.org/LICENSE_1_0.txt)

-	

-
+    

+    
 © Copyright Housemarque Oy 2002 

+      © Copyright Paul Mensonides 2002 

+    

+      
Distributed under the Boost Software License, Version 1.0. (See
+          accompanying file LICENSE_1_0.txt
+          or copy at www.boost.org/LICENSE_1_0.txt)

+    

+