[Boost-commit] svn:boost r74466 - trunk/boost/proto

Subject: [Boost-commit] svn:boost r74466 - trunk/boost/proto
From: eric_at_[hidden]
Date: 2011-09-19 11:24:19

Author: eric_niebler
Date: 2011-09-19 11:24:18 EDT (Mon, 19 Sep 2011)
New Revision: 74466
URL: http://svn.boost.org/trac/boost/changeset/74466

Log:
remove trailing spaces
Text files modified: 
   trunk/boost/proto/repeat.hpp |    78 ++++++++++++++++++++--------------------
   1 files changed, 39 insertions(+), 39 deletions(-)

Modified: trunk/boost/proto/repeat.hpp
==============================================================================
--- trunk/boost/proto/repeat.hpp	(original)
+++ trunk/boost/proto/repeat.hpp	2011-09-19 11:24:18 EDT (Mon, 19 Sep 2011)
@@ -90,7 +90,7 @@
 /// \brief Repeatedly invoke the specified macro.
 ///
 /// BOOST_PROTO_REPEAT_FROM_TO() is used generate the kind of repetitive code that is typical
-/// of DSELs built with Proto. BOOST_PROTO_REPEAT_FROM_TO(FROM, TO, MACRO)  is equivalent to: 
+/// of DSELs built with Proto. BOOST_PROTO_REPEAT_FROM_TO(FROM, TO, MACRO)  is equivalent to:
 ///
 /// \code
 /// MACRO(FROM, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a)
@@ -105,21 +105,21 @@
 
 // Generate BOOST_PROTO_MAX_ARITY-1 overloads of the
 // following construct() function template.
-#define M0(N, typename_A, A_const_ref, A_const_ref_a, ref_a)      \ 
-template<typename T, typename_A(N)>                               \ 
-typename proto::result_of::make_expr<                             \ 
-    proto::tag::function                                          \ 
-  , construct_helper<T>                                           \ 
-  , A_const_ref(N)                                                \ 
->::type const                                                     \ 
-construct(A_const_ref_a(N))                                       \ 
-{                                                                 \ 
-    return proto::make_expr<                                      \ 
-        proto::tag::function                                      \ 
-    >(                                                            \ 
-        construct_helper<T>()                                     \ 
-      , ref_a(N)                                                  \ 
-    );                                                            \ 
+#define M0(N, typename_A, A_const_ref, A_const_ref_a, ref_a)      \
+template<typename T, typename_A(N)>                               \
+typename proto::result_of::make_expr<                             \
+    proto::tag::function                                          \
+  , construct_helper<T>                                           \
+  , A_const_ref(N)                                                \
+>::type const                                                     \
+construct(A_const_ref_a(N))                                       \
+{                                                                 \
+    return proto::make_expr<                                      \
+        proto::tag::function                                      \
+    >(                                                            \
+        construct_helper<T>()                                     \
+      , ref_a(N)                                                  \
+    );                                                            \
 }
 BOOST_PROTO_REPEAT_FROM_TO(1, BOOST_PROTO_MAX_ARITY, M0)
 #undef M0
@@ -127,7 +127,7 @@
 \endcode
 **/
 /// The above invocation of BOOST_PROTO_REPEAT_FROM_TO()  will generate
-/// the following code: 
+/// the following code:
 ///
 /// \code
 /// template<typename T, typename A0>
@@ -145,7 +145,7 @@
 ///       , boost::ref(a0)
 ///     );
 /// }
-/// 
+///
 /// template<typename T, typename A0, typename A1>
 /// typename proto::result_of::make_expr<
 ///     proto::tag::function
@@ -163,7 +163,7 @@
 ///       , boost::ref(a1)
 ///     );
 /// }
-/// 
+///
 /// // ... and so on, up to BOOST_PROTO_MAX_ARITY-1 arguments ...
 /// \endcode
 #define BOOST_PROTO_REPEAT_FROM_TO(FROM, TO, MACRO)\
@@ -186,7 +186,7 @@
 /// \brief Repeatedly invoke the specified macro.
 ///
 /// BOOST_PROTO_REPEAT() is used generate the kind of repetitive code that is typical
-/// of DSELs built with Proto. BOOST_PROTO_REPEAT(MACRO)  is equivalent to: 
+/// of DSELs built with Proto. BOOST_PROTO_REPEAT(MACRO)  is equivalent to:
 ///
 /// \code
 /// MACRO(1, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a)
@@ -215,22 +215,22 @@
 
 // Generate BOOST_PROTO_MAX_ARITY-1 overloads of the
 // following construct() function template.
-#define BOOST_PROTO_LOCAL_MACRO(N, typename_A, A_const_ref,       \ 
-  A_const_ref_a, ref_a)                                           \ 
-template<typename T, typename_A(N)>                               \ 
-typename proto::result_of::make_expr<                             \ 
-    proto::tag::function                                          \ 
-  , construct_helper<T>                                           \ 
-  , A_const_ref(N)                                                \ 
->::type const                                                     \ 
-construct(A_const_ref_a(N))                                       \ 
-{                                                                 \ 
-    return proto::make_expr<                                      \ 
-        proto::tag::function                                      \ 
-    >(                                                            \ 
-        construct_helper<T>()                                     \ 
-      , ref_a(N)                                                  \ 
-    );                                                            \ 
+#define BOOST_PROTO_LOCAL_MACRO(N, typename_A, A_const_ref,       \
+  A_const_ref_a, ref_a)                                           \
+template<typename T, typename_A(N)>                               \
+typename proto::result_of::make_expr<                             \
+    proto::tag::function                                          \
+  , construct_helper<T>                                           \
+  , A_const_ref(N)                                                \
+>::type const                                                     \
+construct(A_const_ref_a(N))                                       \
+{                                                                 \
+    return proto::make_expr<                                      \
+        proto::tag::function                                      \
+    >(                                                            \
+        construct_helper<T>()                                     \
+      , ref_a(N)                                                  \
+    );                                                            \
 }
 #define BOOST_PROTO_LOCAL_LIMITS (1, BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY))
 #include BOOST_PROTO_LOCAL_ITERATE()
@@ -238,7 +238,7 @@
 \endcode
 **/
 /// The above inclusion of BOOST_PROTO_LOCAL_ITERATE() will generate
-/// the following code: 
+/// the following code:
 ///
 /// \code
 /// template<typename T, typename A0>
@@ -256,7 +256,7 @@
 ///       , boost::ref(a0)
 ///     );
 /// }
-/// 
+///
 /// template<typename T, typename A0, typename A1>
 /// typename proto::result_of::make_expr<
 ///     proto::tag::function
@@ -274,7 +274,7 @@
 ///       , boost::ref(a1)
 ///     );
 /// }
-/// 
+///
 /// // ... and so on, up to BOOST_PROTO_MAX_ARITY-1 arguments ...
 /// \endcode
 ///