Fixed inspect report problems: tabs and lack of copyright notices, and a few other small html file errors.

doc/ref/list_to_array_d.html

@@ -30,5 +30,13 @@
     <h4> Requirements </h4>
     <div> <b>Header:</b> &nbsp;<a href="../headers/list/to_array.html">&lt;boost/preprocessor/list/to_array.hpp&gt;</a>
     </div>
+    <hr size="1">
+    <div style="margin-left: 0px;"> <i></i><i>© Copyright Edward Diener 2011</i>
+    </div>
+    <div style="margin-left: 0px;">
+      <p><small>Distributed under the Boost Software License, Version 1.0. (See
+          accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
+          or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
+    </div>
   </body>
 </html>

doc/ref/list_to_seq_r.html

@@ -28,5 +28,12 @@
     <h4> Requirements </h4>
     <div> <b>Header:</b> &nbsp;<a href="../headers/list/to_seq.html">&lt;boost/preprocessor/list/to_seq.hpp&gt;</a>
     </div>
+    <hr size="1">
+    <div style="margin-left: 0px;"> <i>© Copyright Edward Diener 2011</i> </div>
+    <div style="margin-left: 0px;">
+      <p><small>Distributed under the Boost Software License, Version 1.0. (See
+          accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
+          or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
+    </div>
   </body>
 </html>

doc/ref/tuple_elem.html

@@ -49,7 +49,7 @@ or<br>
 			<b>Header:</b> &nbsp;<a href="../headers/tuple/elem.html">&lt;boost/preprocessor/tuple/elem.hpp&gt;</a>
 		</div>
 	<h4>Sample Code</h4>
-<div><pre>#include &lt;<a href="../headers/tuple/elem.html">boost/preprocessor/tuple/elem.hpp</a>&gt;<br><br>#define TUPLE (a, b, c, d)<br><br><a href="tuple_elem.html">BOOST_PP_TUPLE_ELEM</a>(4, 0, TUPLE) // expands to a<br><a href="tuple_elem.html">BOOST_PP_TUPLE_ELEM</a>(4, 3, TUPLE) // expands to d<br><br>// or for the variadic version <a href="../topics/variadic_macros.html#VNotation" target="_self"><sup>(v)</sup></a><br><br><a href="tuple_elem.html">BOOST_PP_TUPLE_ELEM</a>(0, TUPLE) // expands to a in the variadic version<br><a href="file:///C:/Programming/VersionControl/sandbox/variadics/libs/preprocessor/doc/ref/tuple_elem.html">BOOST_PP_TUPLE_ELEM</a>(3, TUPLE) // expands to d in the variadic version<br></pre></div>
+<div><pre>#include &lt;<a href="../headers/tuple/elem.html">boost/preprocessor/tuple/elem.hpp</a>&gt;<br><br>#define TUPLE (a, b, c, d)<br><br><a href="tuple_elem.html">BOOST_PP_TUPLE_ELEM</a>(4, 0, TUPLE) // expands to a<br><a href="tuple_elem.html">BOOST_PP_TUPLE_ELEM</a>(4, 3, TUPLE) // expands to d<br><br>// or for the variadic version <a href="../topics/variadic_macros.html#VNotation" target="_self"><sup>(v)</sup></a><br><br><a href="tuple_elem.html">BOOST_PP_TUPLE_ELEM</a>(0, TUPLE) // expands to a in the variadic version<br><a href="tuple_elem.html">BOOST_PP_TUPLE_ELEM</a>(3, TUPLE) // expands to d in the variadic version<br></pre></div>
 	<hr size="1">
 	<div style="margin-left: 0px;">
 		<i><EFBFBD> Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>

include/boost/preprocessor/array/detail/get_data.hpp

@@ -23,33 +23,33 @@
 # define BOOST_PP_ARRAY_DETAIL_GET_DATA_NONE(size, data)
 
 # if BOOST_PP_VARIADICS && !(BOOST_PP_VARIADICS_MSVC && _MSC_VER <= 1400)
-# 	 if BOOST_PP_VARIADICS_MSVC
+#    if BOOST_PP_VARIADICS_MSVC
-# 		define BOOST_PP_ARRAY_DETAIL_GET_DATA_ANY_VC_DEFAULT(size, data) BOOST_PP_TUPLE_REM(size) data
+#       define BOOST_PP_ARRAY_DETAIL_GET_DATA_ANY_VC_DEFAULT(size, data) BOOST_PP_TUPLE_REM(size) data
-# 		define BOOST_PP_ARRAY_DETAIL_GET_DATA_ANY_VC_CAT(size, data) BOOST_PP_TUPLE_REM_CAT(size) data
+#       define BOOST_PP_ARRAY_DETAIL_GET_DATA_ANY_VC_CAT(size, data) BOOST_PP_TUPLE_REM_CAT(size) data
-# 		define BOOST_PP_ARRAY_DETAIL_GET_DATA_ANY(size, data) \
+#       define BOOST_PP_ARRAY_DETAIL_GET_DATA_ANY(size, data) \
-			BOOST_PP_IIF \
+            BOOST_PP_IIF \
-				( \
+                ( \
-				BOOST_PP_IS_1(size), \
+                BOOST_PP_IS_1(size), \
-				BOOST_PP_ARRAY_DETAIL_GET_DATA_ANY_VC_CAT, \
+                BOOST_PP_ARRAY_DETAIL_GET_DATA_ANY_VC_CAT, \
-				BOOST_PP_ARRAY_DETAIL_GET_DATA_ANY_VC_DEFAULT \
+                BOOST_PP_ARRAY_DETAIL_GET_DATA_ANY_VC_DEFAULT \
-				) \
+                ) \
-			(size,data) \
+            (size,data) \
 /**/
 #    else
-# 		define BOOST_PP_ARRAY_DETAIL_GET_DATA_ANY(size, data) BOOST_PP_TUPLE_REM(size) data
+#       define BOOST_PP_ARRAY_DETAIL_GET_DATA_ANY(size, data) BOOST_PP_TUPLE_REM(size) data
 #    endif
 # else
-# 	 define BOOST_PP_ARRAY_DETAIL_GET_DATA_ANY(size, data) BOOST_PP_TUPLE_REM(size) data
+#    define BOOST_PP_ARRAY_DETAIL_GET_DATA_ANY(size, data) BOOST_PP_TUPLE_REM(size) data
 # endif
 
 # define BOOST_PP_ARRAY_DETAIL_GET_DATA(size, data) \
-	BOOST_PP_IF \
+    BOOST_PP_IF \
-		( \
+        ( \
-		size, \
+        size, \
-		BOOST_PP_ARRAY_DETAIL_GET_DATA_ANY, \
+        BOOST_PP_ARRAY_DETAIL_GET_DATA_ANY, \
-		BOOST_PP_ARRAY_DETAIL_GET_DATA_NONE \
+        BOOST_PP_ARRAY_DETAIL_GET_DATA_NONE \
-		) \
+        ) \
-	(size,data) \
+    (size,data) \
 /**/
 #
 # endif /* BOOST_PREPROCESSOR_ARRAY_DETAIL_GET_DATA_HPP */

include/boost/preprocessor/array/to_list.hpp

@@ -22,13 +22,13 @@
 # /* BOOST_PP_ARRAY_TO_LIST */
 #
 #    define BOOST_PP_ARRAY_TO_LIST(array) \
-		BOOST_PP_IF \
+        BOOST_PP_IF \
-			( \
+            ( \
-			BOOST_PP_ARRAY_SIZE(array), \
+            BOOST_PP_ARRAY_SIZE(array), \
-			BOOST_PP_ARRAY_TO_LIST_DO, \
+            BOOST_PP_ARRAY_TO_LIST_DO, \
-			BOOST_PP_ARRAY_TO_LIST_EMPTY \
+            BOOST_PP_ARRAY_TO_LIST_EMPTY \
-			) \
+            ) \
-		(array) \
+        (array) \
 /**/
 #
 #    define BOOST_PP_ARRAY_TO_LIST_EMPTY(array) BOOST_PP_NIL

include/boost/preprocessor/array/to_seq.hpp

@@ -22,13 +22,13 @@
 # /* BOOST_PP_ARRAY_TO_SEQ */
 #
 #    define BOOST_PP_ARRAY_TO_SEQ(array) \
-		BOOST_PP_IF \
+        BOOST_PP_IF \
-			( \
+            ( \
-			BOOST_PP_ARRAY_SIZE(array), \
+            BOOST_PP_ARRAY_SIZE(array), \
-			BOOST_PP_ARRAY_TO_SEQ_DO, \
+            BOOST_PP_ARRAY_TO_SEQ_DO, \
-			BOOST_PP_ARRAY_TO_SEQ_EMPTY \
+            BOOST_PP_ARRAY_TO_SEQ_EMPTY \
-			) \
+            ) \
-		(array) \
+        (array) \
 /**/
 #    define BOOST_PP_ARRAY_TO_SEQ_EMPTY(array)
 #

include/boost/preprocessor/array/to_tuple.hpp

@@ -20,13 +20,13 @@
 # /* BOOST_PP_ARRAY_TO_TUPLE */
 #
 #    define BOOST_PP_ARRAY_TO_TUPLE(array) \
-		BOOST_PP_IF \
+        BOOST_PP_IF \
-			( \
+            ( \
-			BOOST_PP_ARRAY_SIZE(array), \
+            BOOST_PP_ARRAY_SIZE(array), \
-			BOOST_PP_ARRAY_DATA, \
+            BOOST_PP_ARRAY_DATA, \
-			BOOST_PP_ARRAY_TO_TUPLE_EMPTY \
+            BOOST_PP_ARRAY_TO_TUPLE_EMPTY \
-			) \
+            ) \
-		(array) \
+        (array) \
 /**/
 #    define BOOST_PP_ARRAY_TO_TUPLE_EMPTY(array)
 #

include/boost/preprocessor/facilities/detail/is_empty.hpp

@@ -31,8 +31,8 @@
 #if BOOST_PP_VARIADICS_MSVC && _MSC_VER <= 1400
 
 #define BOOST_PP_DETAIL_IS_EMPTY_PROCESS(param) \
-	BOOST_PP_IS_BEGIN_PARENS \
+    BOOST_PP_IS_BEGIN_PARENS \
-    	( \
+        ( \
         BOOST_PP_DETAIL_IS_EMPTY_NON_FUNCTION_C param () \
         ) \
 /**/
@@ -40,7 +40,7 @@
 #else
 
 #define BOOST_PP_DETAIL_IS_EMPTY_PROCESS(...) \
-	BOOST_PP_IS_BEGIN_PARENS \
+    BOOST_PP_IS_BEGIN_PARENS \
         ( \
         BOOST_PP_DETAIL_IS_EMPTY_NON_FUNCTION_C __VA_ARGS__ () \
         ) \

include/boost/preprocessor/list/to_array.hpp

@@ -28,13 +28,13 @@
 #
 # if BOOST_PP_VARIADICS && BOOST_PP_VARIADICS_MSVC && (_MSC_VER <= 1400)
 # define BOOST_PP_LIST_TO_ARRAY(list) \
-	BOOST_PP_IIF \
+    BOOST_PP_IIF \
-		( \
+        ( \
-		BOOST_PP_LIST_IS_NIL(list), \
+        BOOST_PP_LIST_IS_NIL(list), \
-		BOOST_PP_LIST_TO_ARRAY_VC8ORLESS_EMPTY, \
+        BOOST_PP_LIST_TO_ARRAY_VC8ORLESS_EMPTY, \
-		BOOST_PP_LIST_TO_ARRAY_VC8ORLESS_DO \
+        BOOST_PP_LIST_TO_ARRAY_VC8ORLESS_DO \
-		) \
+        ) \
-	(list) \
+    (list) \
 /**/
 # define BOOST_PP_LIST_TO_ARRAY_VC8ORLESS_EMPTY(list) (0,())
 # define BOOST_PP_LIST_TO_ARRAY_VC8ORLESS_DO(list) BOOST_PP_LIST_TO_ARRAY_I(BOOST_PP_WHILE, list)
@@ -46,7 +46,7 @@
 #    define BOOST_PP_LIST_TO_ARRAY_I(w, list) \
         BOOST_PP_LIST_TO_ARRAY_II(((BOOST_PP_TUPLE_REM_CTOR( \
             3, \
-	        w(BOOST_PP_LIST_TO_ARRAY_P, BOOST_PP_LIST_TO_ARRAY_O, (list, 1, (~))) \
+            w(BOOST_PP_LIST_TO_ARRAY_P, BOOST_PP_LIST_TO_ARRAY_O, (list, 1, (~))) \
         )))) \
         /**/
 #    define BOOST_PP_LIST_TO_ARRAY_II(p) BOOST_PP_LIST_TO_ARRAY_II_B(p)
@@ -56,7 +56,7 @@
 #    define BOOST_PP_LIST_TO_ARRAY_I(w, list) \
         BOOST_PP_LIST_TO_ARRAY_II(BOOST_PP_TUPLE_REM_CTOR( \
             3, \
-	        w(BOOST_PP_LIST_TO_ARRAY_P, BOOST_PP_LIST_TO_ARRAY_O, (list, 1, (~))) \
+            w(BOOST_PP_LIST_TO_ARRAY_P, BOOST_PP_LIST_TO_ARRAY_O, (list, 1, (~))) \
         )) \
         /**/
 #    define BOOST_PP_LIST_TO_ARRAY_II(im) BOOST_PP_LIST_TO_ARRAY_III(im)
@@ -138,13 +138,13 @@
 #
 # if BOOST_PP_VARIADICS && BOOST_PP_VARIADICS_MSVC && (_MSC_VER <= 1400)
 # define BOOST_PP_LIST_TO_ARRAY_D(d, list) \
-	BOOST_PP_IIF \
+    BOOST_PP_IIF \
-		( \
+        ( \
-		BOOST_PP_LIST_IS_NIL(list), \
+        BOOST_PP_LIST_IS_NIL(list), \
-		BOOST_PP_LIST_TO_ARRAY_D_VC8ORLESS_EMPTY, \
+        BOOST_PP_LIST_TO_ARRAY_D_VC8ORLESS_EMPTY, \
-		BOOST_PP_LIST_TO_ARRAY_D_VC8ORLESS_DO \
+        BOOST_PP_LIST_TO_ARRAY_D_VC8ORLESS_DO \
-		) \
+        ) \
-	(d, list) \
+    (d, list) \
 /**/
 # define BOOST_PP_LIST_TO_ARRAY_D_VC8ORLESS_EMPTY(d, list) (0,())
 # define BOOST_PP_LIST_TO_ARRAY_D_VC8ORLESS_DO(d, list) BOOST_PP_LIST_TO_ARRAY_I(BOOST_PP_WHILE_ ## d, list)

include/boost/preprocessor/list/to_tuple.hpp

@@ -21,13 +21,13 @@
 # /* BOOST_PP_LIST_TO_TUPLE */
 #
 # define BOOST_PP_LIST_TO_TUPLE(list) \
-	BOOST_PP_IIF \
+    BOOST_PP_IIF \
-		( \
+        ( \
-		BOOST_PP_LIST_IS_NIL(list), \
+        BOOST_PP_LIST_IS_NIL(list), \
-		BOOST_PP_LIST_TO_TUPLE_EMPTY, \
+        BOOST_PP_LIST_TO_TUPLE_EMPTY, \
-		BOOST_PP_LIST_TO_TUPLE_DO \
+        BOOST_PP_LIST_TO_TUPLE_DO \
-		) \
+        ) \
-	(list) \
+    (list) \
 /**/
 # define BOOST_PP_LIST_TO_TUPLE_EMPTY(list)
 #
@@ -41,13 +41,13 @@
 # /* BOOST_PP_LIST_TO_TUPLE_R */
 #
 # define BOOST_PP_LIST_TO_TUPLE_R(r, list) \
-	BOOST_PP_IIF \
+    BOOST_PP_IIF \
-		( \
+        ( \
-		BOOST_PP_LIST_IS_NIL(list), \
+        BOOST_PP_LIST_IS_NIL(list), \
-		BOOST_PP_LIST_TO_TUPLE_R_EMPTY, \
+        BOOST_PP_LIST_TO_TUPLE_R_EMPTY, \
-		BOOST_PP_LIST_TO_TUPLE_R_DO \
+        BOOST_PP_LIST_TO_TUPLE_R_DO \
-		) \
+        ) \
-	(r, list) \
+    (r, list) \
 /**/
 # define BOOST_PP_LIST_TO_TUPLE_R_EMPTY(r,list)
 #

include/boost/preprocessor/repetition/for.hpp

@@ -52,13 +52,13 @@
 
 # define BOOST_PP_FOR_257_ERROR() BOOST_PP_ERROR(0x0002)
 # define BOOST_PP_FOR_257(s, p, o, m) \
-	BOOST_PP_IIF \
+    BOOST_PP_IIF \
-		( \
+        ( \
-		BOOST_PP_FOR_257_PR(s,p), \
+        BOOST_PP_FOR_257_PR(s,p), \
-		BOOST_PP_FOR_257_ERROR, \
+        BOOST_PP_FOR_257_ERROR, \
-		BOOST_PP_EMPTY \
+        BOOST_PP_EMPTY \
-		) \
+        ) \
-	() \
+    () \
 /**/
 // # define BOOST_PP_FOR_257(s, p, o, m) BOOST_PP_ERROR(0x0002)
 #

include/boost/preprocessor/seq/detail/binary_transform.hpp

@@ -30,13 +30,13 @@
 # endif
 # if BOOST_PP_VARIADICS
 #    if BOOST_PP_VARIADICS_MSVC
-#		define BOOST_PP_SEQ_BINARY_TRANSFORM_REM(data) data
+#       define BOOST_PP_SEQ_BINARY_TRANSFORM_REM(data) data
 #       define BOOST_PP_SEQ_BINARY_TRANSFORM_A(...) (BOOST_PP_SEQ_BINARY_TRANSFORM_REM, __VA_ARGS__)() BOOST_PP_SEQ_BINARY_TRANSFORM_B
 #       define BOOST_PP_SEQ_BINARY_TRANSFORM_B(...) (BOOST_PP_SEQ_BINARY_TRANSFORM_REM, __VA_ARGS__)() BOOST_PP_SEQ_BINARY_TRANSFORM_A
-#	 else
+#    else
 #       define BOOST_PP_SEQ_BINARY_TRANSFORM_A(...) (BOOST_PP_REM, __VA_ARGS__)() BOOST_PP_SEQ_BINARY_TRANSFORM_B
 #       define BOOST_PP_SEQ_BINARY_TRANSFORM_B(...) (BOOST_PP_REM, __VA_ARGS__)() BOOST_PP_SEQ_BINARY_TRANSFORM_A
-#	 endif
+#    endif
 # else
 #    define BOOST_PP_SEQ_BINARY_TRANSFORM_A(e) (BOOST_PP_REM, e)() BOOST_PP_SEQ_BINARY_TRANSFORM_B
 #    define BOOST_PP_SEQ_BINARY_TRANSFORM_B(e) (BOOST_PP_REM, e)() BOOST_PP_SEQ_BINARY_TRANSFORM_A

include/boost/preprocessor/seq/detail/is_empty.hpp

@@ -21,29 +21,29 @@
 /* An empty seq is one that is just BOOST_PP_SEQ_NIL */
 #
 # define BOOST_PP_SEQ_DETAIL_IS_EMPTY(seq) \
-	BOOST_PP_COMPL \
+    BOOST_PP_COMPL \
-		( \
+        ( \
-		BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq) \
+        BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq) \
-		) \
+        ) \
 /**/
 #
 # define BOOST_PP_SEQ_DETAIL_IS_EMPTY_SIZE(size) \
-	BOOST_PP_COMPL \
+    BOOST_PP_COMPL \
-		( \
+        ( \
-		BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY_SIZE(size) \
+        BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY_SIZE(size) \
-		) \
+        ) \
 /**/
 #
 # define BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq) \
-	BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY_SIZE(BOOST_PP_SEQ_DETAIL_EMPTY_SIZE(seq)) \
+    BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY_SIZE(BOOST_PP_SEQ_DETAIL_EMPTY_SIZE(seq)) \
 /**/
 #
 # define BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY_SIZE(size) \
-	BOOST_PP_BOOL(size) \
+    BOOST_PP_BOOL(size) \
 /**/
 #
 # define BOOST_PP_SEQ_DETAIL_EMPTY_SIZE(seq) \
-	BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq (nil))) \
+    BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq (nil))) \
 /**/
 #
 # endif

include/boost/preprocessor/seq/for_each.hpp

@@ -36,13 +36,13 @@
 #    define BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_EMPTY(macro, data, seq)
 #
 #    define BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK(macro, data, seq) \
-		BOOST_PP_IIF \
+        BOOST_PP_IIF \
-			( \
+            ( \
-			BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq), \
+            BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq), \
-			BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_EXEC, \
+            BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_EXEC, \
-			BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_EMPTY \
+            BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_EMPTY \
-			) \
+            ) \
-		(macro, data, seq) \
+        (macro, data, seq) \
 /**/
 #
 # define BOOST_PP_SEQ_FOR_EACH_P(r, x) BOOST_PP_TUPLE_ELEM(4, 3, x)
@@ -54,21 +54,21 @@
 # endif
 #
 # define BOOST_PP_SEQ_FOR_EACH_O_I(macro, data, seq, sz) \
-	BOOST_PP_SEQ_FOR_EACH_O_I_DEC(macro, data, seq, BOOST_PP_DEC(sz)) \
+    BOOST_PP_SEQ_FOR_EACH_O_I_DEC(macro, data, seq, BOOST_PP_DEC(sz)) \
 /**/
 # define BOOST_PP_SEQ_FOR_EACH_O_I_DEC(macro, data, seq, sz) \
-	( \
+    ( \
-	macro, \
+    macro, \
-	data, \
+    data, \
-	BOOST_PP_IF \
+    BOOST_PP_IF \
-		( \
+        ( \
-		sz, \
+        sz, \
-		BOOST_PP_SEQ_FOR_EACH_O_I_TAIL, \
+        BOOST_PP_SEQ_FOR_EACH_O_I_TAIL, \
-		BOOST_PP_SEQ_FOR_EACH_O_I_NIL \
+        BOOST_PP_SEQ_FOR_EACH_O_I_NIL \
-		) \
+        ) \
-	(seq), \
+    (seq), \
-	sz \
+    sz \
-	) \
+    ) \
 /**/
 # define BOOST_PP_SEQ_FOR_EACH_O_I_TAIL(seq) BOOST_PP_SEQ_TAIL(seq)
 # define BOOST_PP_SEQ_FOR_EACH_O_I_NIL(seq) BOOST_PP_NIL
@@ -95,13 +95,13 @@
 #    define BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_EMPTY_R(r, macro, data, seq)
 #
 #    define BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_R(r, macro, data, seq) \
-		BOOST_PP_IIF \
+        BOOST_PP_IIF \
-			( \
+            ( \
-			BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq), \
+            BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq), \
-			BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_EXEC_R, \
+            BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_EXEC_R, \
-			BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_EMPTY_R \
+            BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_EMPTY_R \
-			) \
+            ) \
-		(r, macro, data, seq) \
+        (r, macro, data, seq) \
 /**/
 #
 # endif

include/boost/preprocessor/seq/for_each_i.hpp

@@ -37,13 +37,13 @@
 #    define BOOST_PP_SEQ_FOR_EACH_I_DETAIL_CHECK_EMPTY(macro, data, seq)
 #
 #    define BOOST_PP_SEQ_FOR_EACH_I_DETAIL_CHECK(macro, data, seq) \
-		BOOST_PP_IIF \
+        BOOST_PP_IIF \
-			( \
+            ( \
-			BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq), \
+            BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq), \
-			BOOST_PP_SEQ_FOR_EACH_I_DETAIL_CHECK_EXEC, \
+            BOOST_PP_SEQ_FOR_EACH_I_DETAIL_CHECK_EXEC, \
-			BOOST_PP_SEQ_FOR_EACH_I_DETAIL_CHECK_EMPTY \
+            BOOST_PP_SEQ_FOR_EACH_I_DETAIL_CHECK_EMPTY \
-			) \
+            ) \
-		(macro, data, seq) \
+        (macro, data, seq) \
 /**/
 #
 # define BOOST_PP_SEQ_FOR_EACH_I_P(r, x) BOOST_PP_TUPLE_ELEM(5, 4, x)
@@ -55,22 +55,22 @@
 # endif
 #
 # define BOOST_PP_SEQ_FOR_EACH_I_O_I(macro, data, seq, i, sz) \
-	BOOST_PP_SEQ_FOR_EACH_I_O_I_DEC(macro, data, seq, i, BOOST_PP_DEC(sz)) \
+    BOOST_PP_SEQ_FOR_EACH_I_O_I_DEC(macro, data, seq, i, BOOST_PP_DEC(sz)) \
 /**/
 # define BOOST_PP_SEQ_FOR_EACH_I_O_I_DEC(macro, data, seq, i, sz) \
-	( \
+    ( \
-	macro, \
+    macro, \
-	data, \
+    data, \
-	BOOST_PP_IF \
+    BOOST_PP_IF \
-		( \
+        ( \
-		sz, \
+        sz, \
-		BOOST_PP_SEQ_FOR_EACH_I_O_I_TAIL, \
+        BOOST_PP_SEQ_FOR_EACH_I_O_I_TAIL, \
-		BOOST_PP_SEQ_FOR_EACH_I_O_I_NIL \
+        BOOST_PP_SEQ_FOR_EACH_I_O_I_NIL \
-		) \
+        ) \
-	(seq), \
+    (seq), \
-	BOOST_PP_INC(i), \
+    BOOST_PP_INC(i), \
-	sz \
+    sz \
-	) \
+    ) \
 /**/
 # define BOOST_PP_SEQ_FOR_EACH_I_O_I_TAIL(seq) BOOST_PP_SEQ_TAIL(seq)
 # define BOOST_PP_SEQ_FOR_EACH_I_O_I_NIL(seq) BOOST_PP_NIL
@@ -97,13 +97,13 @@
 #    define BOOST_PP_SEQ_FOR_EACH_I_R_DETAIL_CHECK_EMPTY(r, macro, data, seq)
 #
 #    define BOOST_PP_SEQ_FOR_EACH_I_R_DETAIL_CHECK(r, macro, data, seq) \
-		BOOST_PP_IIF \
+        BOOST_PP_IIF \
-			( \
+            ( \
-			BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq), \
+            BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq), \
-			BOOST_PP_SEQ_FOR_EACH_I_R_DETAIL_CHECK_EXEC, \
+            BOOST_PP_SEQ_FOR_EACH_I_R_DETAIL_CHECK_EXEC, \
-			BOOST_PP_SEQ_FOR_EACH_I_R_DETAIL_CHECK_EMPTY \
+            BOOST_PP_SEQ_FOR_EACH_I_R_DETAIL_CHECK_EMPTY \
-			) \
+            ) \
-		(r, macro, data, seq) \
+        (r, macro, data, seq) \
 /**/
 #
 # endif

include/boost/preprocessor/seq/replace.hpp

@@ -33,13 +33,13 @@
 #    define BOOST_PP_SEQ_REPLACE_DETAIL_REST_EMPTY(seq, i)
 #    define BOOST_PP_SEQ_REPLACE_DETAIL_REST_VALID(seq, i) BOOST_PP_SEQ_REST_N(BOOST_PP_INC(i), seq)
 #    define BOOST_PP_SEQ_REPLACE_DETAIL_REST(seq, i) \
-		BOOST_PP_IIF \
+        BOOST_PP_IIF \
-			( \
+            ( \
-			BOOST_PP_EQUAL(i,BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq))), \
+            BOOST_PP_EQUAL(i,BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq))), \
-			BOOST_PP_SEQ_REPLACE_DETAIL_REST_EMPTY, \
+            BOOST_PP_SEQ_REPLACE_DETAIL_REST_EMPTY, \
-			BOOST_PP_SEQ_REPLACE_DETAIL_REST_VALID \
+            BOOST_PP_SEQ_REPLACE_DETAIL_REST_VALID \
-			) \
+            ) \
-		(seq, i) \
+        (seq, i) \
 /**/
 #
 # endif

include/boost/preprocessor/seq/rest_n.hpp

@@ -32,15 +32,15 @@
 # endif
 #
 #    define BOOST_PP_SEQ_REST_N_DETAIL_EXEC(n, seq, size) \
-		BOOST_PP_EXPR_IIF \
+        BOOST_PP_EXPR_IIF \
-			( \
+            ( \
-			BOOST_PP_BITAND \
+            BOOST_PP_BITAND \
-				( \
+                ( \
-				BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY_SIZE(size), \
+                BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY_SIZE(size), \
-				BOOST_PP_NOT_EQUAL(n,size) \
+                BOOST_PP_NOT_EQUAL(n,size) \
-				), \
+                ), \
-			BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_SEQ_SPLIT(BOOST_PP_INC(n), BOOST_PP_IDENTITY( (nil) seq )))() \
+            BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_SEQ_SPLIT(BOOST_PP_INC(n), BOOST_PP_IDENTITY( (nil) seq )))() \
-			) \
+            ) \
 /**/
 #
 # endif

include/boost/preprocessor/tuple/detail/is_single_return.hpp

@@ -20,9 +20,9 @@
 # include <boost/preprocessor/control/iif.hpp>
 # include <boost/preprocessor/facilities/is_1.hpp>
 # include <boost/preprocessor/tuple/size.hpp>
-# define BOOST_PP_TUPLE_IS_SINGLE_RETURN(sr,nsr,tuple)	\
+# define BOOST_PP_TUPLE_IS_SINGLE_RETURN(sr,nsr,tuple)  \
-	BOOST_PP_IIF(BOOST_PP_IS_1(BOOST_PP_TUPLE_SIZE(tuple)),sr,nsr) \
+    BOOST_PP_IIF(BOOST_PP_IS_1(BOOST_PP_TUPLE_SIZE(tuple)),sr,nsr) \
-	/**/
+    /**/
 # endif /* BOOST_PP_VARIADICS && BOOST_PP_VARIADICS_MSVC */
 #
 # endif /* BOOST_PREPROCESSOR_TUPLE_DETAIL_IS_SINGLE_RETURN_HPP */

include/boost/preprocessor/tuple/elem.hpp

@@ -33,12 +33,12 @@
   else use BOOST_PP_REM. This fixes a VC++ problem with an empty tuple and BOOST_PP_TUPLE_ELEM
   functionality. See tuple_elem_bug_test.cxx.
 */
-#    	 define BOOST_PP_TUPLE_ELEM_O_2(n, tuple) \
+#        define BOOST_PP_TUPLE_ELEM_O_2(n, tuple) \
-			BOOST_PP_VARIADIC_ELEM(n, BOOST_PP_EXPAND(BOOST_PP_TUPLE_IS_SINGLE_RETURN(BOOST_PP_REM_CAT,BOOST_PP_REM,tuple) tuple)) \
+            BOOST_PP_VARIADIC_ELEM(n, BOOST_PP_EXPAND(BOOST_PP_TUPLE_IS_SINGLE_RETURN(BOOST_PP_REM_CAT,BOOST_PP_REM,tuple) tuple)) \
-			/**/
+            /**/
 #    else
 #        define BOOST_PP_TUPLE_ELEM(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_ELEM_O_, __VA_ARGS__)(__VA_ARGS__)
-#    	 define BOOST_PP_TUPLE_ELEM_O_2(n, tuple) BOOST_PP_VARIADIC_ELEM(n, BOOST_PP_REM tuple)
+#        define BOOST_PP_TUPLE_ELEM_O_2(n, tuple) BOOST_PP_VARIADIC_ELEM(n, BOOST_PP_REM tuple)
 #    endif
 #    define BOOST_PP_TUPLE_ELEM_O_3(size, n, tuple) BOOST_PP_TUPLE_ELEM_O_2(n, tuple)
 # else

include/boost/preprocessor/tuple/insert.hpp

@@ -23,13 +23,13 @@
 # /* BOOST_PP_TUPLE_INSERT */
 #
 # define BOOST_PP_TUPLE_INSERT(tuple, i, elem) \
-	BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_INSERT(BOOST_PP_TUPLE_TO_ARRAY(tuple), i, elem)) \
+    BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_INSERT(BOOST_PP_TUPLE_TO_ARRAY(tuple), i, elem)) \
 /**/
 #
 # /* BOOST_PP_TUPLE_INSERT_D */
 #
 # define BOOST_PP_TUPLE_INSERT_D(d, tuple, i, elem) \
-	BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_INSERT_D(d, BOOST_PP_TUPLE_TO_ARRAY(tuple), i, elem)) \
+    BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_INSERT_D(d, BOOST_PP_TUPLE_TO_ARRAY(tuple), i, elem)) \
 /**/
 #
 # endif // BOOST_PP_VARIADICS

include/boost/preprocessor/tuple/pop_back.hpp

@@ -26,17 +26,17 @@
 # /* BOOST_PP_TUPLE_POP_BACK */
 #
 # define BOOST_PP_TUPLE_POP_BACK(tuple) \
-	BOOST_PP_IIF \
+    BOOST_PP_IIF \
-		( \
+        ( \
-		BOOST_PP_GREATER(BOOST_PP_TUPLE_SIZE(tuple),1), \
+        BOOST_PP_GREATER(BOOST_PP_TUPLE_SIZE(tuple),1), \
-		BOOST_PP_TUPLE_POP_BACK_EXEC, \
+        BOOST_PP_TUPLE_POP_BACK_EXEC, \
-		BOOST_PP_TUPLE_POP_BACK_RETURN \
+        BOOST_PP_TUPLE_POP_BACK_RETURN \
-		) \
+        ) \
-	(tuple) \
+    (tuple) \
 /**/
 #
 # define BOOST_PP_TUPLE_POP_BACK_EXEC(tuple) \
-	BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_BACK(BOOST_PP_TUPLE_TO_ARRAY(tuple))) \
+    BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_BACK(BOOST_PP_TUPLE_TO_ARRAY(tuple))) \
 /**/
 #
 # define BOOST_PP_TUPLE_POP_BACK_RETURN(tuple) tuple
@@ -44,17 +44,17 @@
 # /* BOOST_PP_TUPLE_POP_BACK_Z */
 #
 # define BOOST_PP_TUPLE_POP_BACK_Z(z, tuple) \
-	BOOST_PP_IIF \
+    BOOST_PP_IIF \
-		( \
+        ( \
-		BOOST_PP_GREATER(BOOST_PP_TUPLE_SIZE(tuple),1), \
+        BOOST_PP_GREATER(BOOST_PP_TUPLE_SIZE(tuple),1), \
-		BOOST_PP_TUPLE_POP_BACK_Z_EXEC, \
+        BOOST_PP_TUPLE_POP_BACK_Z_EXEC, \
-		BOOST_PP_TUPLE_POP_BACK_Z_RETURN \
+        BOOST_PP_TUPLE_POP_BACK_Z_RETURN \
-		) \
+        ) \
-	(z, tuple) \
+    (z, tuple) \
 /**/
 #
 # define BOOST_PP_TUPLE_POP_BACK_Z_EXEC(z, tuple) \
-	BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_BACK_Z(z, BOOST_PP_TUPLE_TO_ARRAY(tuple))) \
+    BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_BACK_Z(z, BOOST_PP_TUPLE_TO_ARRAY(tuple))) \
 /**/
 #
 # define BOOST_PP_TUPLE_POP_BACK_Z_RETURN(z, tuple) tuple

include/boost/preprocessor/tuple/pop_front.hpp

@@ -27,17 +27,17 @@
 # /* BOOST_PP_TUPLE_POP_FRONT */
 #
 # define BOOST_PP_TUPLE_POP_FRONT(tuple) \
-	BOOST_PP_IIF \
+    BOOST_PP_IIF \
-		( \
+        ( \
-		BOOST_PP_GREATER(BOOST_PP_TUPLE_SIZE(tuple),1), \
+        BOOST_PP_GREATER(BOOST_PP_TUPLE_SIZE(tuple),1), \
-		BOOST_PP_TUPLE_POP_FRONT_EXEC, \
+        BOOST_PP_TUPLE_POP_FRONT_EXEC, \
-		BOOST_PP_TUPLE_POP_FRONT_RETURN \
+        BOOST_PP_TUPLE_POP_FRONT_RETURN \
-		) \
+        ) \
-	(tuple) \
+    (tuple) \
 /**/
 #
 # define BOOST_PP_TUPLE_POP_FRONT_EXEC(tuple) \
-	BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_FRONT(BOOST_PP_TUPLE_TO_ARRAY(tuple))) \
+    BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_FRONT(BOOST_PP_TUPLE_TO_ARRAY(tuple))) \
 /**/
 #
 # define BOOST_PP_TUPLE_POP_FRONT_RETURN(tuple) tuple
@@ -45,17 +45,17 @@
 # /* BOOST_PP_TUPLE_POP_FRONT_Z */
 #
 # define BOOST_PP_TUPLE_POP_FRONT_Z(z, tuple) \
-	BOOST_PP_IIF \
+    BOOST_PP_IIF \
-		( \
+        ( \
-		BOOST_PP_GREATER(BOOST_PP_TUPLE_SIZE(tuple),1), \
+        BOOST_PP_GREATER(BOOST_PP_TUPLE_SIZE(tuple),1), \
-		BOOST_PP_TUPLE_POP_FRONT_Z_EXEC, \
+        BOOST_PP_TUPLE_POP_FRONT_Z_EXEC, \
-		BOOST_PP_TUPLE_POP_FRONT_Z_RETURN \
+        BOOST_PP_TUPLE_POP_FRONT_Z_RETURN \
-		) \
+        ) \
-	(z, tuple) \
+    (z, tuple) \
 /**/
 #
 # define BOOST_PP_TUPLE_POP_FRONT_Z_EXEC(z, tuple) \
-	BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_FRONT_Z(z, BOOST_PP_TUPLE_TO_ARRAY(tuple))) \
+    BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_FRONT_Z(z, BOOST_PP_TUPLE_TO_ARRAY(tuple))) \
 /**/
 #
 # define BOOST_PP_TUPLE_POP_FRONT_Z_RETURN(z, tuple) tuple

include/boost/preprocessor/tuple/push_back.hpp

@@ -23,7 +23,7 @@
 # /* BOOST_PP_TUPLE_PUSH_BACK */
 #
 # define BOOST_PP_TUPLE_PUSH_BACK(tuple, elem) \
-	BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_PUSH_BACK(BOOST_PP_TUPLE_TO_ARRAY(tuple), elem)) \
+    BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_PUSH_BACK(BOOST_PP_TUPLE_TO_ARRAY(tuple), elem)) \
 /**/
 #
 # endif // BOOST_PP_VARIADICS

include/boost/preprocessor/tuple/push_front.hpp

@@ -24,7 +24,7 @@
 # /* BOOST_PP_TUPLE_PUSH_FRONT */
 #
 # define BOOST_PP_TUPLE_PUSH_FRONT(tuple, elem) \
-	BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_PUSH_FRONT(BOOST_PP_TUPLE_TO_ARRAY(tuple), elem)) \
+    BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_PUSH_FRONT(BOOST_PP_TUPLE_TO_ARRAY(tuple), elem)) \
 /**/
 #
 # endif // BOOST_PP_VARIADICS

include/boost/preprocessor/tuple/rem.hpp

@@ -22,10 +22,10 @@
 # /* BOOST_PP_REM */
 #
 # if BOOST_PP_VARIADICS
-# 	 if BOOST_PP_VARIADICS_MSVC
+#    if BOOST_PP_VARIADICS_MSVC
-		/* To be used internally when __VA_ARGS__ could be empty ( or is a single element ) */
+        /* To be used internally when __VA_ARGS__ could be empty ( or is a single element ) */
-#    	define BOOST_PP_REM_CAT(...) BOOST_PP_CAT(__VA_ARGS__,)
+#       define BOOST_PP_REM_CAT(...) BOOST_PP_CAT(__VA_ARGS__,)
-# 	 endif
+#    endif
 #    define BOOST_PP_REM(...) __VA_ARGS__
 # else
 #    define BOOST_PP_REM(x) x
@@ -37,10 +37,10 @@
   VC++8.0 cannot handle the variadic version of BOOST_PP_TUPLE_REM(size)
 */
 # if BOOST_PP_VARIADICS && !(BOOST_PP_VARIADICS_MSVC && _MSC_VER <= 1400)
-# 	 if BOOST_PP_VARIADICS_MSVC
+#    if BOOST_PP_VARIADICS_MSVC
-		/* To be used internally when the size could be 0 ( or 1 ) */
+        /* To be used internally when the size could be 0 ( or 1 ) */
-#    	define BOOST_PP_TUPLE_REM_CAT(size) BOOST_PP_REM_CAT
+#       define BOOST_PP_TUPLE_REM_CAT(size) BOOST_PP_REM_CAT
-# 	 endif
+#    endif
 #    define BOOST_PP_TUPLE_REM(size) BOOST_PP_REM
 # else
 #    if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC()
@@ -124,10 +124,10 @@
 #        define BOOST_PP_TUPLE_REM_CTOR(...) BOOST_PP_TUPLE_REM_CTOR_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_REM_CTOR_O_, __VA_ARGS__), (__VA_ARGS__))
 #        define BOOST_PP_TUPLE_REM_CTOR_I(m, args) BOOST_PP_TUPLE_REM_CTOR_II(m, args)
 #        define BOOST_PP_TUPLE_REM_CTOR_II(m, args) BOOST_PP_CAT(m ## args,)
-#    	 define BOOST_PP_TUPLE_REM_CTOR_O_1(tuple) BOOST_PP_EXPAND(BOOST_PP_TUPLE_IS_SINGLE_RETURN(BOOST_PP_REM_CAT,BOOST_PP_REM,tuple) tuple)
+#        define BOOST_PP_TUPLE_REM_CTOR_O_1(tuple) BOOST_PP_EXPAND(BOOST_PP_TUPLE_IS_SINGLE_RETURN(BOOST_PP_REM_CAT,BOOST_PP_REM,tuple) tuple)
 #    else
 #        define BOOST_PP_TUPLE_REM_CTOR(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_REM_CTOR_O_, __VA_ARGS__)(__VA_ARGS__)
-#    	 define BOOST_PP_TUPLE_REM_CTOR_O_1(tuple) BOOST_PP_REM tuple
+#        define BOOST_PP_TUPLE_REM_CTOR_O_1(tuple) BOOST_PP_REM tuple
 #    endif
 #    define BOOST_PP_TUPLE_REM_CTOR_O_2(size, tuple) BOOST_PP_TUPLE_REM_CTOR_O_1(tuple)
 # else

include/boost/preprocessor/tuple/remove.hpp

@@ -26,17 +26,17 @@
 # /* BOOST_PP_TUPLE_REMOVE */
 #
 # define BOOST_PP_TUPLE_REMOVE(tuple, i) \
-	BOOST_PP_IIF \
+    BOOST_PP_IIF \
-		( \
+        ( \
-		BOOST_PP_GREATER(BOOST_PP_TUPLE_SIZE(tuple),1), \
+        BOOST_PP_GREATER(BOOST_PP_TUPLE_SIZE(tuple),1), \
-		BOOST_PP_TUPLE_REMOVE_EXEC, \
+        BOOST_PP_TUPLE_REMOVE_EXEC, \
-		BOOST_PP_TUPLE_REMOVE_RETURN \
+        BOOST_PP_TUPLE_REMOVE_RETURN \
-		) \
+        ) \
-	(tuple, i) \
+    (tuple, i) \
 /**/
 #
 # define BOOST_PP_TUPLE_REMOVE_EXEC(tuple, i) \
-	BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_REMOVE(BOOST_PP_TUPLE_TO_ARRAY(tuple), i)) \
+    BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_REMOVE(BOOST_PP_TUPLE_TO_ARRAY(tuple), i)) \
 /**/
 #
 # define BOOST_PP_TUPLE_REMOVE_RETURN(tuple, i) tuple
@@ -44,17 +44,17 @@
 # /* BOOST_PP_TUPLE_REMOVE_D */
 #
 # define BOOST_PP_TUPLE_REMOVE_D(d, tuple, i) \
-	BOOST_PP_IIF \
+    BOOST_PP_IIF \
-		( \
+        ( \
-		BOOST_PP_GREATER_D(d, BOOST_PP_TUPLE_SIZE(tuple), 1), \
+        BOOST_PP_GREATER_D(d, BOOST_PP_TUPLE_SIZE(tuple), 1), \
-		BOOST_PP_TUPLE_REMOVE_D_EXEC, \
+        BOOST_PP_TUPLE_REMOVE_D_EXEC, \
-		BOOST_PP_TUPLE_REMOVE_D_RETURN \
+        BOOST_PP_TUPLE_REMOVE_D_RETURN \
-		) \
+        ) \
-	(d, tuple, i) \
+    (d, tuple, i) \
 /**/
 #
 # define BOOST_PP_TUPLE_REMOVE_D_EXEC(d, tuple, i) \
-	BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_REMOVE_D(d, BOOST_PP_TUPLE_TO_ARRAY(tuple), i)) \
+    BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_REMOVE_D(d, BOOST_PP_TUPLE_TO_ARRAY(tuple), i)) \
 /**/
 #
 # define BOOST_PP_TUPLE_REMOVE_D_RETURN(d, tuple, i) tuple

include/boost/preprocessor/tuple/replace.hpp

@@ -23,13 +23,13 @@
 # /* BOOST_PP_TUPLE_REPLACE */
 #
 # define BOOST_PP_TUPLE_REPLACE(tuple, i, elem) \
-	BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_REPLACE(BOOST_PP_TUPLE_TO_ARRAY(tuple), i, elem)) \
+    BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_REPLACE(BOOST_PP_TUPLE_TO_ARRAY(tuple), i, elem)) \
 /**/
 #
 # /* BOOST_PP_TUPLE_REPLACE_D */
 #
 # define BOOST_PP_TUPLE_REPLACE_D(d, tuple, i, elem) \
-	BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_REPLACE_D(d, BOOST_PP_TUPLE_TO_ARRAY(tuple), i, elem)) \
+    BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_REPLACE_D(d, BOOST_PP_TUPLE_TO_ARRAY(tuple), i, elem)) \
 /**/
 #
 # endif // BOOST_PP_VARIADICS

include/boost/preprocessor/tuple/reverse.hpp

@@ -28,10 +28,10 @@
 #        define BOOST_PP_TUPLE_REVERSE(...) BOOST_PP_TUPLE_REVERSE_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_REVERSE_O_, __VA_ARGS__), (__VA_ARGS__))
 #        define BOOST_PP_TUPLE_REVERSE_I(m, args) BOOST_PP_TUPLE_REVERSE_II(m, args)
 #        define BOOST_PP_TUPLE_REVERSE_II(m, args) BOOST_PP_CAT(m ## args,)
-#    	 define BOOST_PP_TUPLE_REVERSE_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_REVERSE_, BOOST_PP_TUPLE_SIZE(tuple)) tuple
+#        define BOOST_PP_TUPLE_REVERSE_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_REVERSE_, BOOST_PP_TUPLE_SIZE(tuple)) tuple
 #    else
 #        define BOOST_PP_TUPLE_REVERSE(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_REVERSE_O_, __VA_ARGS__)(__VA_ARGS__)
-#    	 define BOOST_PP_TUPLE_REVERSE_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_REVERSE_, BOOST_PP_VARIADIC_SIZE tuple) tuple
+#        define BOOST_PP_TUPLE_REVERSE_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_REVERSE_, BOOST_PP_VARIADIC_SIZE tuple) tuple
 #    endif
 #    define BOOST_PP_TUPLE_REVERSE_O_2(size, tuple) BOOST_PP_TUPLE_REVERSE_O_1(tuple)
 # else

include/boost/preprocessor/tuple/to_list.hpp

@@ -28,10 +28,10 @@
 #        define BOOST_PP_TUPLE_TO_LIST(...) BOOST_PP_TUPLE_TO_LIST_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_TO_LIST_O_, __VA_ARGS__), (__VA_ARGS__))
 #        define BOOST_PP_TUPLE_TO_LIST_I(m, args) BOOST_PP_TUPLE_TO_LIST_II(m, args)
 #        define BOOST_PP_TUPLE_TO_LIST_II(m, args) BOOST_PP_CAT(m ## args,)
-#    	 define BOOST_PP_TUPLE_TO_LIST_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_LIST_, BOOST_PP_TUPLE_SIZE(tuple)) tuple
+#        define BOOST_PP_TUPLE_TO_LIST_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_LIST_, BOOST_PP_TUPLE_SIZE(tuple)) tuple
 #    else
 #        define BOOST_PP_TUPLE_TO_LIST(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_TO_LIST_O_, __VA_ARGS__)(__VA_ARGS__)
-#    	 define BOOST_PP_TUPLE_TO_LIST_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_LIST_, BOOST_PP_VARIADIC_SIZE tuple) tuple
+#        define BOOST_PP_TUPLE_TO_LIST_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_LIST_, BOOST_PP_VARIADIC_SIZE tuple) tuple
 #    endif
 #    define BOOST_PP_TUPLE_TO_LIST_O_2(size, tuple) BOOST_PP_TUPLE_TO_LIST_O_1(tuple)
 # else

include/boost/preprocessor/tuple/to_seq.hpp

@@ -26,10 +26,10 @@
 #        define BOOST_PP_TUPLE_TO_SEQ(...) BOOST_PP_TUPLE_TO_SEQ_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_TO_SEQ_O_, __VA_ARGS__), (__VA_ARGS__))
 #        define BOOST_PP_TUPLE_TO_SEQ_I(m, args) BOOST_PP_TUPLE_TO_SEQ_II(m, args)
 #        define BOOST_PP_TUPLE_TO_SEQ_II(m, args) BOOST_PP_CAT(m ## args,)
-#    	 define BOOST_PP_TUPLE_TO_SEQ_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_SEQ_, BOOST_PP_TUPLE_SIZE(tuple)) tuple
+#        define BOOST_PP_TUPLE_TO_SEQ_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_SEQ_, BOOST_PP_TUPLE_SIZE(tuple)) tuple
 #    else
 #        define BOOST_PP_TUPLE_TO_SEQ(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_TO_SEQ_O_, __VA_ARGS__)(__VA_ARGS__)
-#    	 define BOOST_PP_TUPLE_TO_SEQ_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_SEQ_, BOOST_PP_VARIADIC_SIZE tuple) tuple
+#        define BOOST_PP_TUPLE_TO_SEQ_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_SEQ_, BOOST_PP_VARIADIC_SIZE tuple) tuple
 #    endif
 #    define BOOST_PP_TUPLE_TO_SEQ_O_2(size, tuple) BOOST_PP_TUPLE_TO_SEQ_O_1(tuple)
 # else

include/boost/preprocessor/variadic/detail/is_single_return.hpp

@@ -20,9 +20,9 @@
 # include <boost/preprocessor/control/iif.hpp>
 # include <boost/preprocessor/facilities/is_1.hpp>
 # include <boost/preprocessor/variadic/size.hpp>
-# define BOOST_PP_VARIADIC_IS_SINGLE_RETURN(sr,nsr,...)	\
+# define BOOST_PP_VARIADIC_IS_SINGLE_RETURN(sr,nsr,...) \
-	BOOST_PP_IIF(BOOST_PP_IS_1(BOOST_PP_VARIADIC_SIZE(__VA_ARGS__)),sr,nsr) \
+    BOOST_PP_IIF(BOOST_PP_IS_1(BOOST_PP_VARIADIC_SIZE(__VA_ARGS__)),sr,nsr) \
-	/**/
+    /**/
 # endif /* BOOST_PP_VARIADICS && BOOST_PP_VARIADICS_MSVC */
 #
 # endif /* BOOST_PREPROCESSOR_VARIADIC_DETAIL_IS_SINGLE_RETURN_HPP */

test/config_info.cpp

@@ -1,3 +1,14 @@
+# /* **************************************************************************
+#  *                                                                          *
+#  *     (C) Copyright Edward Diener 2014.
+#  *     Distributed under the Boost Software License, Version 1.0. (See
+#  *     accompanying file LICENSE_1_0.txt or copy at
+#  *     http://www.boost.org/LICENSE_1_0.txt)
+#  *                                                                          *
+#  ************************************************************************** */
+#
+# /* See http://www.boost.org for most recent version. */
+#
 #include <iostream>
 #include <iomanip>
 #include <string.h>

test/seq.cxx

@@ -35,46 +35,46 @@
 # define SEQ (4)(1)(5)(2)
 
 # define SEQ_100 \
-	(1)(2)(3)(4)(5)(6)(7)(8)(9) \
+    (1)(2)(3)(4)(5)(6)(7)(8)(9) \
-	(10)(11)(12)(13)(14)(15)(16)(17)(18)(19) \
+    (10)(11)(12)(13)(14)(15)(16)(17)(18)(19) \
-	(20)(21)(22)(23)(24)(25)(26)(27)(28)(29) \
+    (20)(21)(22)(23)(24)(25)(26)(27)(28)(29) \
-	(30)(31)(32)(33)(34)(35)(36)(37)(38)(39) \
+    (30)(31)(32)(33)(34)(35)(36)(37)(38)(39) \
-	(40)(41)(42)(43)(44)(45)(46)(47)(48)(49) \
+    (40)(41)(42)(43)(44)(45)(46)(47)(48)(49) \
-	(50)(51)(52)(53)(54)(55)(56)(57)(58)(59) \
+    (50)(51)(52)(53)(54)(55)(56)(57)(58)(59) \
-	(60)(61)(62)(63)(64)(65)(66)(67)(68)(69) \
+    (60)(61)(62)(63)(64)(65)(66)(67)(68)(69) \
-	(70)(71)(72)(73)(74)(75)(76)(77)(78)(79) \
+    (70)(71)(72)(73)(74)(75)(76)(77)(78)(79) \
-	(80)(81)(82)(83)(84)(85)(86)(87)(88)(89) \
+    (80)(81)(82)(83)(84)(85)(86)(87)(88)(89) \
-	(90)(91)(92)(93)(94)(95)(96)(97)(98)(99) \
+    (90)(91)(92)(93)(94)(95)(96)(97)(98)(99) \
-	(100)
+    (100)
-	
+    
 # define SEQ_255 \
-	(1)(2)(3)(4)(5)(6)(7)(8)(9) \
+    (1)(2)(3)(4)(5)(6)(7)(8)(9) \
-	(10)(11)(12)(13)(14)(15)(16)(17)(18)(19) \
+    (10)(11)(12)(13)(14)(15)(16)(17)(18)(19) \
-	(20)(21)(22)(23)(24)(25)(26)(27)(28)(29) \
+    (20)(21)(22)(23)(24)(25)(26)(27)(28)(29) \
-	(30)(31)(32)(33)(34)(35)(36)(37)(38)(39) \
+    (30)(31)(32)(33)(34)(35)(36)(37)(38)(39) \
-	(40)(41)(42)(43)(44)(45)(46)(47)(48)(49) \
+    (40)(41)(42)(43)(44)(45)(46)(47)(48)(49) \
-	(50)(51)(52)(53)(54)(55)(56)(57)(58)(59) \
+    (50)(51)(52)(53)(54)(55)(56)(57)(58)(59) \
-	(60)(61)(62)(63)(64)(65)(66)(67)(68)(69) \
+    (60)(61)(62)(63)(64)(65)(66)(67)(68)(69) \
-	(70)(71)(72)(73)(74)(75)(76)(77)(78)(79) \
+    (70)(71)(72)(73)(74)(75)(76)(77)(78)(79) \
-	(80)(81)(82)(83)(84)(85)(86)(87)(88)(89) \
+    (80)(81)(82)(83)(84)(85)(86)(87)(88)(89) \
-	(90)(91)(92)(93)(94)(95)(96)(97)(98)(99) \
+    (90)(91)(92)(93)(94)(95)(96)(97)(98)(99) \
-	(100)(101)(102)(103)(104)(105)(106)(107)(108)(109) \
+    (100)(101)(102)(103)(104)(105)(106)(107)(108)(109) \
-	(110)(111)(112)(113)(114)(115)(116)(117)(118)(119) \
+    (110)(111)(112)(113)(114)(115)(116)(117)(118)(119) \
-	(120)(121)(122)(123)(124)(125)(126)(127)(128)(129) \
+    (120)(121)(122)(123)(124)(125)(126)(127)(128)(129) \
-	(130)(131)(132)(133)(134)(135)(136)(137)(138)(139) \
+    (130)(131)(132)(133)(134)(135)(136)(137)(138)(139) \
-	(140)(141)(142)(143)(144)(145)(146)(147)(148)(149) \
+    (140)(141)(142)(143)(144)(145)(146)(147)(148)(149) \
-	(150)(151)(152)(153)(154)(155)(156)(157)(158)(159) \
+    (150)(151)(152)(153)(154)(155)(156)(157)(158)(159) \
-	(160)(161)(162)(163)(164)(165)(166)(167)(168)(169) \
+    (160)(161)(162)(163)(164)(165)(166)(167)(168)(169) \
-	(170)(171)(172)(173)(174)(175)(176)(177)(178)(179) \
+    (170)(171)(172)(173)(174)(175)(176)(177)(178)(179) \
-	(180)(181)(182)(183)(184)(185)(186)(187)(188)(189) \
+    (180)(181)(182)(183)(184)(185)(186)(187)(188)(189) \
-	(190)(191)(192)(193)(194)(195)(196)(197)(198)(199) \
+    (190)(191)(192)(193)(194)(195)(196)(197)(198)(199) \
-	(200)(201)(202)(203)(204)(205)(206)(207)(208)(209) \
+    (200)(201)(202)(203)(204)(205)(206)(207)(208)(209) \
-	(210)(211)(212)(213)(214)(215)(216)(217)(218)(219) \
+    (210)(211)(212)(213)(214)(215)(216)(217)(218)(219) \
-	(220)(221)(222)(223)(224)(225)(226)(227)(228)(229) \
+    (220)(221)(222)(223)(224)(225)(226)(227)(228)(229) \
-	(230)(231)(232)(233)(234)(235)(236)(237)(238)(239) \
+    (230)(231)(232)(233)(234)(235)(236)(237)(238)(239) \
-	(240)(241)(242)(243)(244)(245)(246)(247)(248)(249) \
+    (240)(241)(242)(243)(244)(245)(246)(247)(248)(249) \
-	(250)(251)(252)(253)(254)(255)
+    (250)(251)(252)(253)(254)(255)
-	
+    
 # define SEQ_256 SEQ_255(256)
 
 # define SEQVAR (4,5,8,3,61)(1,0)(5,22,43)(2)(17,45,33)

test/tuple_elem_bug_test.cxx

@@ -17,21 +17,21 @@
 #define TN_GEN_ONE(p) (1)
 #define TN_GEN_ZERO(p) (0)
 #define TN_TEST_ONE_MORE(parameter,ens) \
-		BOOST_PP_IF \
+        BOOST_PP_IF \
-			( \
+            ( \
-			BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(1,0,ens),0), \
+            BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(1,0,ens),0), \
-			TN_GEN_ONE, \
+            TN_GEN_ONE, \
-			TN_GEN_ZERO \
+            TN_GEN_ZERO \
-			) \
+            ) \
-		(parameter) \
+        (parameter) \
 /**/
 #define TN_TEST_ONE(parameter,ens) \
-	BOOST_PP_TUPLE_ELEM \
+    BOOST_PP_TUPLE_ELEM \
-		( \
+        ( \
-		1, \
+        1, \
-		0, \
+        0, \
-		TN_TEST_ONE_MORE(parameter,ens) \
+        TN_TEST_ONE_MORE(parameter,ens) \
-		) \
+        ) \
 /**/
 
 BEGIN TN_TEST_ONE(A,(1)) == 1 END