Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r75058 - in sandbox/local: boost/detail/preprocessor/keyword/facility boost/local boost/local/aux_ boost/local/aux_/function_macros boost/local/aux_/function_macros/code_ boost/utility libs/local/doc/html libs/local/doc/html/boost/local/function libs/local/doc/html/boost_local libs/local/doc/qbk libs/local/example
From: lorcaminiti_at_[hidden]
Date: 2011-10-18 21:36:28

Next message: steven_at_[hidden]: "[Boost-commit] svn:boost r75059 - trunk/tools/boostbook/xsl"
Previous message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r75057 - in sandbox/conversion/boost/conversion: . type_traits"

Author: lcaminiti
Date: 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
New Revision: 75058
URL: http://svn.boost.org/trac/boost/changeset/75058

Log:
Final doc updates.
Text files modified:
   sandbox/local/boost/detail/preprocessor/keyword/facility/is.hpp | 2
   sandbox/local/boost/local/aux_/config.hpp | 4
   sandbox/local/boost/local/aux_/function_macros/code_/functor.hpp | 4
   sandbox/local/boost/local/aux_/function_macros/name.hpp | 30 ++++++------
   sandbox/local/boost/local/config.hpp | 10 ++--
   sandbox/local/boost/local/function.hpp | 10 ++--
   sandbox/local/boost/utility/identity.hpp | 31 +++++++++++-
   sandbox/local/libs/local/doc/html/BOOST_IDENTITY_TYPE.html | 7 ++
   sandbox/local/libs/local/doc/html/BOOST_IDENTITY_VALUE.html | 5 +
   sandbox/local/libs/local/doc/html/BOOST_LOCAL_BLOCK.html | 2
   sandbox/local/libs/local/doc/html/BOOST_LOCAL_BLOCK_END.html | 2
   sandbox/local/libs/local/doc/html/BOOST_LOCAL_BLOCK_TPL.html | 2
   sandbox/local/libs/local/doc/html/BOOST_LOCAL_CONFIG_COMPLIANT.html | 10 ++--
   sandbox/local/libs/local/doc/html/BOOST_LOCAL_CONFIG_FUNCTION_ARITY_MAX.html | 2
   sandbox/local/libs/local/doc/html/BOOST_LOCAL_CONFIG_OVERLOAD_MAX.html | 2
   sandbox/local/libs/local/doc/html/BOOST_LOCAL_CONFIG_THIS_PARAM_NAME.html | 2
   sandbox/local/libs/local/doc/html/BOOST_LOCAL_EXIT.html | 2
   sandbox/local/libs/local/doc/html/BOOST_LOCAL_EXIT_END.html | 2
   sandbox/local/libs/local/doc/html/BOOST_LOCAL_EXIT_TPL.html | 2
   sandbox/local/libs/local/doc/html/BOOST_LOCAL_FUNCTION_NAME.html | 4
   sandbox/local/libs/local/doc/html/BOOST_LOCAL_FUNCTION_PARAMS.html | 2
   sandbox/local/libs/local/doc/html/BOOST_LOCAL_FUNCTION_PARAMS_TPL.html | 2
   sandbox/local/libs/local/doc/html/BOOST_LOCAL_TYPEOF.html | 2
   sandbox/local/libs/local/doc/html/boost/local/function/overload.html | 22 ++++----
   sandbox/local/libs/local/doc/html/boost_local/Acknowledgments.html | 8 +-
   sandbox/local/libs/local/doc/html/boost_local/Advanced_Topics.html | 42 ++++++++++-------
   sandbox/local/libs/local/doc/html/boost_local/Alternatives.html | 7 +-
   sandbox/local/libs/local/doc/html/boost_local/Getting_Started.html | 6 +-
   sandbox/local/libs/local/doc/html/boost_local/Implementation.html | 37 +++++++--------
   sandbox/local/libs/local/doc/html/boost_local/Tutorial.html | 96 +++++++++++++++++++++------------------
   sandbox/local/libs/local/doc/html/index.html | 27 ++++++-----
   sandbox/local/libs/local/doc/html/reference.html | 2
   sandbox/local/libs/local/doc/qbk/acknowledgements.qbk | 6 +-
   sandbox/local/libs/local/doc/qbk/advanced_topics.qbk | 4 +
   sandbox/local/libs/local/doc/qbk/alternatives.qbk | 3
   sandbox/local/libs/local/doc/qbk/getting_started.qbk | 2
   sandbox/local/libs/local/doc/qbk/implementation.qbk | 16 +++---
   sandbox/local/libs/local/doc/qbk/introduction.qbk | 8 +-
   sandbox/local/libs/local/doc/qbk/local.qbk | 2
   sandbox/local/libs/local/doc/qbk/tutorial.qbk | 11 ++--
   sandbox/local/libs/local/example/add_function_inline.cpp | 4
   sandbox/local/libs/local/example/add_function_inline_va.cpp | 4
   sandbox/local/libs/local/example/add_using_0x_lambda.cpp | 2
   sandbox/local/libs/local/example/expensive_copy_0x_lambda.cpp | 4
   sandbox/local/libs/local/example/expensive_copy_boost_local.cpp | 2
   sandbox/local/libs/local/example/expensive_copy_boost_local_va.cpp | 2
   sandbox/local/libs/local/example/profile_0x_lambda.cpp | 2
   sandbox/local/libs/local/example/tparam_trick.cpp | 2
   48 files changed, 255 insertions(+), 207 deletions(-)

Modified: sandbox/local/boost/detail/preprocessor/keyword/facility/is.hpp
==============================================================================
--- sandbox/local/boost/detail/preprocessor/keyword/facility/is.hpp (original)
+++ sandbox/local/boost/detail/preprocessor/keyword/facility/is.hpp 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -27,7 +27,7 @@
#define BOOST_DETAIL_PP_KEYWORD_FACILITY_IS_FRONT(tokens, checking_prefix) \
     BOOST_PP_IIF(BOOST_PP_IS_UNARY(tokens), \
         /* on MSVC this check works even if tokens already unary but on */ \
- /* ISO C++ (including GCC) this check on non-unary tokens gives */ \
+ /* C++03 (including GCC) this check on non-unary tokens gives */ \
         /* a concatenation error -- so return false is tokens is not unary */ \
         0 BOOST_PP_TUPLE_EAT(2) \
     , \

Modified: sandbox/local/boost/local/aux_/config.hpp
==============================================================================
--- sandbox/local/boost/local/aux_/config.hpp (original)
+++ sandbox/local/boost/local/aux_/config.hpp 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -10,8 +10,8 @@
#include "../config.hpp"

// If it is possible to pass local types (classes, etc) as
-// template parameters. This is not possible in ISO C++ but it
-// is possible in C++03 extensions (MSVC, GCC 4.5.x, etc).
+// template parameters. This is not possible in pure C++03 but it
+// is possible in some C++03 extensions (MSVC, GCC 4.5.x, etc).
#if !defined(BOOST_LOCAL_CONFIG_COMPLIANT)
# if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 4)) && defined(__GXX_EXPERIMENTAL_CXX0X__)
// From GCC 4.5.x when -std=c++0x specified.

Modified: sandbox/local/boost/local/aux_/function_macros/code_/functor.hpp
==============================================================================
--- sandbox/local/boost/local/aux_/function_macros/code_/functor.hpp (original)
+++ sandbox/local/boost/local/aux_/function_macros/code_/functor.hpp 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -313,7 +313,7 @@
 /* or using a casted object local variable here to call body */ \
 /* directly from here without passing via `operator()`) */ \
 /* compliance: passing local class type to `static_cast` is fully */ \
- /* ISO C++ compliant because `static_cast` is not a template (even */ \
+ /* C++03 compliant because `static_cast` is not a template (even */ \
 /* if its syntax resembles a function template call) in fact even */ \
 /* in C is legal to cast to a local struct (using C-style casting) */ \
 return static_cast< BOOST_LOCAL_AUX_SYMBOL_FUNCTOR_CLASS_NAME(id)* >( \
@@ -482,7 +482,7 @@
 , has_bind_this, id, typename_keyword ) \
 ) \
 /* compliance: trick to pass this local class as a template param */ \
- /* on ISO C++ without non C++03 extension */ \
+ /* on pure C++03 without non C++03 extension */ \
 /* performance: this trick introduced _one_ indirect function call */ \
 /* via a function pointer that cannot be inlined by the complier */ \
 /* thus increasing run-time (also another trick using a base */ \

Modified: sandbox/local/boost/local/aux_/function_macros/name.hpp
==============================================================================
--- sandbox/local/boost/local/aux_/function_macros/name.hpp (original)
+++ sandbox/local/boost/local/aux_/function_macros/name.hpp 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -58,7 +58,7 @@
                 local_function_name = functor; \
             } \
         ) \
- /* local functor can be passed as tparam only on C++0x (faster) */ \
+ /* local functor can be passed as tparam only on C++11 (faster) */ \
     } local_functor_name(BOOST_LOCAL_AUX_SYMBOL_ARGS_VARIABLE_NAME.value); \
     /* non-local functor can always be passed as tparam (but slower) */ \
     BOOST_TYPEOF(local_functor_name. \
@@ -88,19 +88,19 @@
     BOOST_LOCAL_AUX_FUNCTION_NAME_END_LOCAL_FUNCTOR_(__LINE__, \
             local_function_name, \
             /* local function is not recursive (because recursion and its */ \
- /* initialization cannot be inlined even on C++0x, */ \
- /* so this allows optimization at least on C++0x) */ \
+ /* initialization cannot be inlined even on C++11, */ \
+ /* so this allows optimization at least on C++11) */ \
             0 /* not recursive */ , \
             /* local functor */ \
             BOOST_LOCAL_AUX_FUNCTION_NAME_FUNCTOR_(local_function_name), \
             /* local function declared as non-local functor -- but it can */ \
- /* be inlined only by C++0x and it cannot be recursive */ \
+ /* be inlined only by C++11 and it cannot be recursive */ \
             local_function_name)

// This is faster on some compilers but not all (e.g., it is faster on GCC
// because its optimization inlines it but not on MSVC). However, it cannot be
-// passed as a template parameter on non C++0x compilers.
-// Passed at tparam: Only on C++0x. Inlineable: Yes. Recursive: No.
+// passed as a template parameter on non C++11 compilers.
+// Passed at tparam: Only on C++11. Inlineable: Yes. Recursive: No.
#define BOOST_LOCAL_AUX_FUNCTION_NAME_INLINE_(local_function_name) \
     BOOST_LOCAL_AUX_FUNCTION_NAME_END_LOCAL_FUNCTOR_(__LINE__, \
             local_function_name, \
@@ -108,13 +108,13 @@
             /* and its initialization cannot be inlined)*/ \
             0 /* not recursive */ , \
             /* inlined local function declared as local functor (maybe */ \
- /* inlined even by non C++0x -- but it can be passed as */ \
- /* template parameter only on C++0x */ \
+ /* inlined even by non C++11 -- but it can be passed as */ \
+ /* template parameter only on C++11 */ \
             local_function_name, \
             /* non-local functor */ \
             BOOST_LOCAL_AUX_FUNCTION_NAME_FUNCTOR_(local_function_name))

-// This is slower on all compilers (C++0x and non) because recursion and its
+// This is slower on all compilers (C++11 and non) because recursion and its
// initialization can never be inlined.
// Passed at tparam: Yes. Inlineable: No. Recursive: Yes.
#define BOOST_LOCAL_AUX_FUNCTION_NAME_RECURSIVE_(local_function_name) \
@@ -125,22 +125,22 @@
             /* local functor */ \
             BOOST_LOCAL_AUX_FUNCTION_NAME_FUNCTOR_(local_function_name), \
             /* local function declared as non-local functor -- but it can */ \
- /* be inlined only by C++0x */ \
+ /* be inlined only by C++11 */ \
             local_function_name)

// Inlined local functions are specified by `..._NAME(inline name)`.
// They have more chances to be inlined for faster run-times by some compilers
-// (for example by GCC but not by MSVC). C++0x compilers can always inline
+// (for example by GCC but not by MSVC). C++11 compilers can always inline
// local functions even if they are not explicitly specified inline.
#define BOOST_LOCAL_AUX_FUNCTION_NAME_PARSE_INLINE_(qualified_name) \
     BOOST_PP_IIF(BOOST_PP_BITOR( \
             BOOST_LOCAL_AUX_CONFIG_LOCAL_TYPES_AS_TPARAMS_01, \
             BOOST_DETAIL_PP_KEYWORD_IS_INLINE_FRONT(qualified_name)), \
- /* on C++0x always use inlining because compilers might optimize */ \
+ /* on C++11 always use inlining because compilers might optimize */ \
         /* it to be faster and it can also be passed as tparam */ \
         BOOST_LOCAL_AUX_FUNCTION_NAME_INLINE_ \
     , \
- /* on non C++0x don't use liniling unless explicitly specified by */ \
+ /* on non C++11 don't use liniling unless explicitly specified by */ \
         /* programmers `inline name` the inlined local function cannot be */ \
         /* passed as tparam */ \
         BOOST_LOCAL_AUX_FUNCTION_NAME_ \
@@ -170,10 +170,10 @@
     )(qualified_name)

// Recursive local function are specified by `..._NAME(recursive name)`.
-// They can never be inlined for faster run-time (not even by C++0x compilers).
+// They can never be inlined for faster run-time (not even by C++11 compilers).
#define BOOST_LOCAL_AUX_FUNCTION_NAME_PARSE_RECURSIVE_(qualified_name) \
     BOOST_PP_IIF(BOOST_LOCAL_AUX_FUNCTION_NAME_IS_RECURSIVE_(qualified_name), \
- /* recursion can never be inlined (not even on C++0x) */ \
+ /* recursion can never be inlined (not even on C++11) */ \
         BOOST_LOCAL_AUX_FUNCTION_NAME_RECURSIVE_ \
     , \
         BOOST_LOCAL_AUX_FUNCTION_NAME_PARSE_INLINE_ \

Modified: sandbox/local/boost/local/config.hpp
==============================================================================
--- sandbox/local/boost/local/config.hpp (original)
+++ sandbox/local/boost/local/config.hpp 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -13,7 +13,7 @@
#define BOOST_LOCAL_CONFIG_HPP_

/**
- * @brief Force to use ISO C++ standard features only.
+ * @brief Force to use only pure C++03 standard features.
 *
 * If programmers leave this configuration macro undefined, its default
 * value is to be left not defined.
@@ -33,14 +33,14 @@
 * (and this configuration macro can be defined to disable them).
 * Variadic macros, are supported by most recent compilers (like MSVC and
 * GCC), they were first introduced by the C99 standard, they are part of the
- * C++0x standard, but they are not part of the official ISO C++ standard.
+ * C++11 standard, but they are not part of the C++03 standard.
 * Empty macro parameters are also supported by the C99 standards and they are
- * part of the C++0x standard, but they are not supported by all modern
+ * part of the C++11 standard, but they are not supported by all modern
 * compilers (for example, they are not supported by MSVC).
 *
 * Furthermore, if this macro is defined then the library will not take advantage of
 * compilers that allow to pass local types as template parameters (e.g., MSVC
- * and C++0x compilers) in order to generate code that has more chances to be
+ * and C++11 compilers) in order to generate code that has more chances to be
 * optimized by the compiler for faster run-times (i.e., inlining the local
 * function calls, see the @RefSect2{Advanced_Topics, Advanced Topics}
 * section).
@@ -48,7 +48,7 @@
 * @Note This library internally uses Boost.Typeof to automatically deduce
 * the bound variable types. The macro symbol <a href='http://www.boost.org/doc/libs/1_46_1/doc/html/typeof/refe.html#typeof.compl'><c>BOOST_TYPEOF_COMPLIANT</c></a>
 * needs to be defined separately from this configuration macro if programmers
- * do not want to use non ISO C++ standard support for type deduction
+ * do not want to use non C++03 standard support for type deduction
 * operations.
 *
 * @See @RefSect{Tutorial} section, @RefSect2{Advanced_Topics, Advanced Topics}

Modified: sandbox/local/boost/local/function.hpp
==============================================================================
--- sandbox/local/boost/local/function.hpp (original)
+++ sandbox/local/boost/local/function.hpp 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -185,12 +185,12 @@
 * This increases the chances that the compiler will be able to inline the
 * local function calls (thus reducing their run-time).
 * However, inlined local functions cannot be passed as template parameters or
- * assigned to other functors like <c>boost::function</c> (that is true on ISO
- * C++ compilers, see @RefMacro{BOOST_LOCAL_CONFIG_COMPLIANT}, but inlined
- * local functions can instead be passed as template parameters on C++0x
+ * assigned to other functors like <c>boost::function</c> (that is true on
+ * C++03 compilers, see @RefMacro{BOOST_LOCAL_CONFIG_COMPLIANT}, but inlined
+ * local functions can instead be passed as template parameters on C++11
 * compilers).
- * On C++0x compilers, there is no need to declare a local function lined
- * because this library will automatically use C++0x specific features to
+ * On C++11 compilers, there is no need to declare a local function lined
+ * because this library will automatically use C++11 specific features to
 * inline the local function while always allowing to pass it as a template
 * parameter.
 *

Modified: sandbox/local/boost/utility/identity.hpp
==============================================================================
--- sandbox/local/boost/utility/identity.hpp (original)
+++ sandbox/local/boost/utility/identity.hpp 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -11,7 +11,7 @@
 * @Note The only way (at least as far as the authors know) to pass an
 * arbitrary number of commas within macro parameters without explicitly
 * indicating the number of commas (and without using variadic macros which
- * are not part of the ISO C++ standard) is to wrap the expression within round
+ * are not part of the C++03 standard) is to wrap the expression within round
 * parenthesis that are not replaced by macro expansion and then to remove the
 * extra parenthesis at compile-time (for type expressions) or at run-time
 * (for value expressions).
@@ -53,6 +53,16 @@
 * contains a comma not wrapped by round parenthesis so it will be interpreted
 * as two separate macro parameters by the preprocessor).
 *
+ * In many cases it might be possible to use alternatives to this macro that
+ * will make the code more readable.
+ * For example, it might be possible to use define a new type
+ * <c>typedef std::map<int, duble> map_type</c> prior to the macro and then
+ * pass the newly defined type <c>map_type</c> which contains no comma as the
+ * macro parameter.
+ *
+ * This macro must be prefixed by <c>typename</c> when used within a
+ * type-dependant context (for example, within a template).
+ *
 * On some compilers (like GCC), using this macro on abstract types (classes
 * with one or more pure virtual functions) generate a compile-time error.
 * This can be worked around by manipulating the type adding and removing a
@@ -71,10 +81,19 @@
 * }
 * @EndParams
 *
- * @Note This macro works on ISO C++ compilers (it does not require variadic
+ * @Note This macro works on C++03 compilers (it does not require variadic
 * macros). It expands to code equivalent to
 * <c>boost::function_traits<void parenthesized_type>::arg1_type</c>.
 *
+ * @Warning The compiler will not be able to automatically deduce any template
+ * parameter type part of the type expression specified by this macro.
+ * For example, if this macro is used to wrap the type <c>std::map<T, V></c>
+ * where <c>T</c> and <c>V</c> are template parameters, the compiler will not
+ * be able to automatically deduce <c>T</c> and <c>V</c> which will have to be
+ * explicitly specified when invoking the template expression.
+ * (This is never a concern for local functions because they cannot be
+ * templates.)
+ *
 * @See @RefSect2{Advanced_Topics, Advanced Topics} section.
 */
#define BOOST_IDENTITY_TYPE(parenthesized_type) \
@@ -98,6 +117,12 @@
 * parenthesis so it will be interpreted as two separate macro parameters by
 * the preprocessor).
 *
+ * In many cases it might be possible to use alternatives to this macro that
+ * will make the code more readable.
+ * For example, if the expression type is know (and contains no commas) the
+ * type constructor can be used to wrap the expression command within
+ * parenthesis <c>size_type(key_sizeof<int, double>::value)</c>.
+ *
 * @Params
 * @Param{parenthesize_value,
 * The value expression to be passed as macro parameter wrapped by a single
@@ -106,7 +131,7 @@
 * }
 * @EndParams
 *
- * @Note This macro works on ISO C++ compilers (it does not require variadic
+ * @Note This macro works on C++03 compilers (it does not require variadic
 * macros). This macro expands to code equivalent to
 * <c>boost::aux::identity_value parenthesized_value</c> where:
 * @code

Modified: sandbox/local/libs/local/doc/html/BOOST_IDENTITY_TYPE.html
==============================================================================
--- sandbox/local/libs/local/doc/html/BOOST_IDENTITY_TYPE.html (original)
+++ sandbox/local/libs/local/doc/html/BOOST_IDENTITY_TYPE.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -33,9 +33,11 @@

BOOST_IDENTITY_TYPE(parenthesized_type)</pre></div>
<div class="refsect1">
-<a name="id926852"></a><h2>Description</h2>
+<a name="id926914"></a><h2>Description</h2>
This macro expands to an expression that can be passed as a single macro parameter even if it contains commas and that evaluates to the specified type at compile-time (see the <a class="link" href="boost_local/Advanced_Topics.html" title="Advanced Topics"> Advanced Topics</a> section).
For example <code class="computeroutput">BOOST_IDENTITY_TYPE((std::map<int, double>))</code> can be passed as a single macro parameter when instead <code class="computeroutput">std::map<int, double></code> cannot (because <code class="computeroutput">std::map<int, double></code> contains a comma not wrapped by round parenthesis so it will be interpreted as two separate macro parameters by the preprocessor).
+In many cases it might be possible to use alternatives to this macro that will make the code more readable. For example, it might be possible to use define a new type <code class="computeroutput">typedef std::map<int, duble> map_type</code> prior to the macro and then pass the newly defined type <code class="computeroutput">map_type</code> which contains no comma as the macro parameter.
+This macro must be prefixed by <code class="computeroutput">typename</code> when used within a type-dependant context (for example, within a template).
On some compilers (like GCC), using this macro on abstract types (classes with one or more pure virtual functions) generate a compile-time error. This can be worked around by manipulating the type adding and removing a reference to it: 
<pre class="programlisting"> boost::remove_reference< BOOST_IDENTITY_TYPE((boost::add_reference<
my_abstract_type< int, double >
@@ -54,7 +56,8 @@
</table></div>


-Note: This macro works on ISO C++ compilers (it does not require variadic macros). It expands to code equivalent to <code class="computeroutput">boost::function_traits<void parenthesized_type>::arg1_type</code>.
+Note: This macro works on C++03 compilers (it does not require variadic macros). It expands to code equivalent to <code class="computeroutput">boost::function_traits<void parenthesized_type>::arg1_type</code>.
+Warning: The compiler will not be able to automatically deduce any template parameter type part of the type expression specified by this macro. For example, if this macro is used to wrap the type <code class="computeroutput">std::map<T, V></code> where <code class="computeroutput">T</code> and <code class="computeroutput">V</code> are template parameters, the compiler will not be able to automatically deduce <code class="computeroutput">T</code> and <code class="computeroutput">V</code> which will have to be explicitly specified when invoking the template expression. (This is never a concern for local functions because they cannot be templates.)
See: <a class="link" href="boost_local/Advanced_Topics.html" title="Advanced Topics"> Advanced Topics</a> section. 
</div>
</div>

Modified: sandbox/local/libs/local/doc/html/BOOST_IDENTITY_VALUE.html
==============================================================================
--- sandbox/local/libs/local/doc/html/BOOST_IDENTITY_VALUE.html (original)
+++ sandbox/local/libs/local/doc/html/BOOST_IDENTITY_VALUE.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -33,9 +33,10 @@

BOOST_IDENTITY_VALUE(parenthesized_value)</pre></div>
<div class="refsect1">
-<a name="id927167"></a><h2>Description</h2>
+<a name="id927307"></a><h2>Description</h2>
This macro expands to an expression that can be passed as a single macro parameter even if it contains commas and that evaluates to the specified value at run-time (see the <a class="link" href="boost_local/Advanced_Topics.html" title="Advanced Topics"> Advanced Topics</a> section).
For example <code class="computeroutput">BOOST_IDENTITY_VALUE((key_sizeof<int, double>::value))</code> can be passed as a single macro parameter when instead <code class="computeroutput">key_sizeof<int, double>::value</code> cannot (because <code class="computeroutput">key_sizeof<int, double>::value</code> contains a comma not wrapped by round parenthesis so it will be interpreted as two separate macro parameters by the preprocessor).
+In many cases it might be possible to use alternatives to this macro that will make the code more readable. For example, if the expression type is know (and contains no commas) the type constructor can be used to wrap the expression command within parenthesis <code class="computeroutput">size_type(key_sizeof<int, double>::value)</code>.
Parameters: 
<div class="informaltable"><table class="table">
<colgroup>
@@ -49,7 +50,7 @@
</table></div>


-Note: This macro works on ISO C++ compilers (it does not require variadic macros). This macro expands to code equivalent to <code class="computeroutput">boost::aux::identity_value parenthesized_value</code> where: 
+Note: This macro works on C++03 compilers (it does not require variadic macros). This macro expands to code equivalent to <code class="computeroutput">boost::aux::identity_value parenthesized_value</code> where: 
<pre class="programlisting"> namespace boost { namespace aux {

template<typename T>

Modified: sandbox/local/libs/local/doc/html/BOOST_LOCAL_BLOCK.html
==============================================================================
--- sandbox/local/libs/local/doc/html/BOOST_LOCAL_BLOCK.html (original)
+++ sandbox/local/libs/local/doc/html/BOOST_LOCAL_BLOCK.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -33,7 +33,7 @@

BOOST_LOCAL_BLOCK(bindings)</pre></div>
<div class="refsect1">
-<a name="id921058"></a><h2>Description</h2>
+<a name="id921124"></a><h2>Description</h2>
This macro must be used within a declarative context, it must be followed by the local block body code and then by the <code class="computeroutput"><a class="link" href="BOOST_LOCAL_BLOCK_END.html" title="Macro BOOST_LOCAL_BLOCK_END">BOOST_LOCAL_BLOCK_END</a></code> macro (see the <a class="link" href="boost_local/Tutorial.html" title="Tutorial">Tutorial</a> section): 
<pre class="programlisting"> { // Some declarative context.
...

Modified: sandbox/local/libs/local/doc/html/BOOST_LOCAL_BLOCK_END.html
==============================================================================
--- sandbox/local/libs/local/doc/html/BOOST_LOCAL_BLOCK_END.html (original)
+++ sandbox/local/libs/local/doc/html/BOOST_LOCAL_BLOCK_END.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -33,7 +33,7 @@

BOOST_LOCAL_BLOCK_END</pre></div>
<div class="refsect1">
-<a name="id921913"></a><h2>Description</h2>
+<a name="id921978"></a><h2>Description</h2>
This macro must follow the local block body code <code class="computeroutput">{ ... }</code> as shown in the <code class="computeroutput"><a class="link" href="BOOST_LOCAL_BLOCK.html" title="Macro BOOST_LOCAL_BLOCK">BOOST_LOCAL_BLOCK</a></code> documentation.
Note: This macro cannot be used multiple times on the same line because it internally uses the line number <code class="computeroutput">__LINE__</code> to generate unique identifiers.
See: <code class="computeroutput"><a class="link" href="BOOST_LOCAL_BLOCK.html" title="Macro BOOST_LOCAL_BLOCK">BOOST_LOCAL_BLOCK</a></code>, <a class="link" href="boost_local/Tutorial.html" title="Tutorial">Tutorial</a> section.

Modified: sandbox/local/libs/local/doc/html/BOOST_LOCAL_BLOCK_TPL.html
==============================================================================
--- sandbox/local/libs/local/doc/html/BOOST_LOCAL_BLOCK_TPL.html (original)
+++ sandbox/local/libs/local/doc/html/BOOST_LOCAL_BLOCK_TPL.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -33,7 +33,7 @@

BOOST_LOCAL_BLOCK_TPL(bindings)</pre></div>
<div class="refsect1">
-<a name="id921839"></a><h2>Description</h2>
+<a name="id921904"></a><h2>Description</h2>
See: <code class="computeroutput"><a class="link" href="BOOST_LOCAL_BLOCK.html" title="Macro BOOST_LOCAL_BLOCK">BOOST_LOCAL_BLOCK</a></code>, <a class="link" href="boost_local/Tutorial.html" title="Tutorial">Tutorial</a> section. 
</div>
</div>

Modified: sandbox/local/libs/local/doc/html/BOOST_LOCAL_CONFIG_COMPLIANT.html
==============================================================================
--- sandbox/local/libs/local/doc/html/BOOST_LOCAL_CONFIG_COMPLIANT.html (original)
+++ sandbox/local/libs/local/doc/html/BOOST_LOCAL_CONFIG_COMPLIANT.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -26,19 +26,19 @@
<a name="BOOST_LOCAL_CONFIG_COMPLIANT"></a><div class="titlepage"></div>
<div class="refnamediv">
<h2>Macro BOOST_LOCAL_CONFIG_COMPLIANT</h2>
-BOOST_LOCAL_CONFIG_COMPLIANT — Force to use ISO C++ standard features only. 
+BOOST_LOCAL_CONFIG_COMPLIANT — Force to use only pure C++03 standard features. 
</div>
<h2 xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="refsynopsisdiv-title">Synopsis</h2>
<div xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="refsynopsisdiv"><pre class="synopsis">// In header: <<a class="link" href="reference.html#header.boost.local.config_hpp" title="Header <boost/local/config.hpp>">boost/local/config.hpp</a>>

BOOST_LOCAL_CONFIG_COMPLIANT</pre></div>
<div class="refsect1">
-<a name="id922085"></a><h2>Description</h2>
+<a name="id922151"></a><h2>Description</h2>
If programmers leave this configuration macro undefined, its default value is to be left not defined.
If this macro is defined, variadic macros and empty macro parameters are not used by this library. Using variadic macros and empty macro parameters allows this library to provide the variadic macro and empty macro syntaxes which some programmers might find more readable than the sequencing macro syntax (see the <a class="link" href="boost_local/Tutorial.html" title="Tutorial">Tutorial</a> section, <code class="computeroutput"><a class="link" href="BOOST_LOCAL_FUNCTION_PARAMS.html" title="Macro BOOST_LOCAL_FUNCTION_PARAMS">BOOST_LOCAL_FUNCTION_PARAMS</a></code>, <code class="computeroutput"><a class="link" href="BOOST_LOCAL_BLOCK.html" title="Macro BOOST_LOCAL_BLOCK">BOOST_LOCAL_BLOCK</a></code>, and <code class="computeroutput"><a class="link" href="BOOST_LOCAL_EXIT.html" title="Macro BOOST_LOCAL_EXIT">BOOST_LOCAL_EXIT</a></code>). If this configuration macro is defined then only the s
equencing macro syntax is allowed (regardless of whether the compiler supports variadic and empty macros or not).
-Warning: The variadic and empty macro syntaxes are not supported by all C++ compilers so they should be used with care to avoid portability issues (and this configuration macro can be defined to disable them). Variadic macros, are supported by most recent compilers (like MSVC and GCC), they were first introduced by the C99 standard, they are part of the C++0x standard, but they are not part of the official ISO C++ standard. Empty macro parameters are also supported by the C99 standards and they are part of the C++0x standard, but they are not supported by all modern compilers (for example, they are not supported by MSVC).
-Furthermore, if this macro is defined then the library will not take advantage of compilers that allow to pass local types as template parameters (e.g., MSVC and C++0x compilers) in order to generate code that has more chances to be optimized by the compiler for faster run-times (i.e., inlining the local function calls, see the <a class="link" href="boost_local/Advanced_Topics.html" title="Advanced Topics"> Advanced Topics</a> section).
-Note: This library internally uses Boost.Typeof to automatically deduce the bound variable types. The macro symbol BOOST_TYPEOF_COMPLIANT needs to be defined separately from this configuration macro if programmers do not want to use non ISO C++ standard support for type deduction operations.
+Warning: The variadic and empty macro syntaxes are not supported by all C++ compilers so they should be used with care to avoid portability issues (and this configuration macro can be defined to disable them). Variadic macros, are supported by most recent compilers (like MSVC and GCC), they were first introduced by the C99 standard, they are part of the C++11 standard, but they are not part of the C++03 standard. Empty macro parameters are also supported by the C99 standards and they are part of the C++11 standard, but they are not supported by all modern compilers (for example, they are not supported by MSVC).
+Furthermore, if this macro is defined then the library will not take advantage of compilers that allow to pass local types as template parameters (e.g., MSVC and C++11 compilers) in order to generate code that has more chances to be optimized by the compiler for faster run-times (i.e., inlining the local function calls, see the <a class="link" href="boost_local/Advanced_Topics.html" title="Advanced Topics"> Advanced Topics</a> section).
+Note: This library internally uses Boost.Typeof to automatically deduce the bound variable types. The macro symbol BOOST_TYPEOF_COMPLIANT needs to be defined separately from this configuration macro if programmers do not want to use non C++03 standard support for type deduction operations.
See: <a class="link" href="boost_local/Tutorial.html" title="Tutorial">Tutorial</a> section, <a class="link" href="boost_local/Advanced_Topics.html" title="Advanced Topics"> Advanced Topics</a> section, <a class="link" href="boost_local/Getting_Started.html" title="Getting Started"> Getting Started</a> section. 
</div>
</div>

Modified: sandbox/local/libs/local/doc/html/BOOST_LOCAL_CONFIG_FUNCTION_ARITY_MAX.html
==============================================================================
--- sandbox/local/libs/local/doc/html/BOOST_LOCAL_CONFIG_FUNCTION_ARITY_MAX.html (original)
+++ sandbox/local/libs/local/doc/html/BOOST_LOCAL_CONFIG_FUNCTION_ARITY_MAX.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -33,7 +33,7 @@

BOOST_LOCAL_CONFIG_FUNCTION_ARITY_MAX</pre></div>
<div class="refsect1">
-<a name="id922291"></a><h2>Description</h2>
+<a name="id922356"></a><h2>Description</h2>
If programmers leave this configuration macro undefined, its default value is <code class="computeroutput">5</code>.
This only applies to the number of local function parameters and not to the number of bound variables in scope (the limit on the number of bound variables is instead the maximum size allowed for a Boost.Preprocessor sequence).
Warning: Increasing this number will increase compilation time.

Modified: sandbox/local/libs/local/doc/html/BOOST_LOCAL_CONFIG_OVERLOAD_MAX.html
==============================================================================
--- sandbox/local/libs/local/doc/html/BOOST_LOCAL_CONFIG_OVERLOAD_MAX.html (original)
+++ sandbox/local/libs/local/doc/html/BOOST_LOCAL_CONFIG_OVERLOAD_MAX.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -33,7 +33,7 @@

BOOST_LOCAL_CONFIG_OVERLOAD_MAX</pre></div>
<div class="refsect1">
-<a name="id922399"></a><h2>Description</h2>
+<a name="id922464"></a><h2>Description</h2>
If programmers leave this configuration macro undefined, its default value is <code class="computeroutput">6</code>.
This number must be greater or equal than 2 (because at least two function types are needed to define an overloaded call operator) otherwise the library will generate a compile-time error.
Warning: Increasing this number will increase compilation time when the header file <code class="computeroutput">"boost/local/function/overload.hpp"</code> is included.

Modified: sandbox/local/libs/local/doc/html/BOOST_LOCAL_CONFIG_THIS_PARAM_NAME.html
==============================================================================
--- sandbox/local/libs/local/doc/html/BOOST_LOCAL_CONFIG_THIS_PARAM_NAME.html (original)
+++ sandbox/local/libs/local/doc/html/BOOST_LOCAL_CONFIG_THIS_PARAM_NAME.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -33,7 +33,7 @@

BOOST_LOCAL_CONFIG_THIS_PARAM_NAME</pre></div>
<div class="refsect1">
-<a name="id922512"></a><h2>Description</h2>
+<a name="id922577"></a><h2>Description</h2>
If programmers leave this configuration macro undefined, the default symbol used is <code class="computeroutput">this_</code> (this default symbol follows Boost's conventions to postfix with an underscore symbols that refer to C++ keywords -- the <code class="computeroutput">this</code> keyword in this case).
Warning: Programmers should not define this macro unless it is absolutely necessary (e.g., to avoid name clashes with another library which cannot be changed). Changing the symbol <code class="computeroutput">this_</code> effectively changes the public API of this library.
See: <a class="link" href="boost_local/Tutorial.html" title="Tutorial">Tutorial</a> section, <a class="link" href="boost_local/Getting_Started.html" title="Getting Started"> Getting Started</a> section.

Modified: sandbox/local/libs/local/doc/html/BOOST_LOCAL_EXIT.html
==============================================================================
--- sandbox/local/libs/local/doc/html/BOOST_LOCAL_EXIT.html (original)
+++ sandbox/local/libs/local/doc/html/BOOST_LOCAL_EXIT.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -33,7 +33,7 @@

BOOST_LOCAL_EXIT(binding_list)</pre></div>
<div class="refsect1">
-<a name="id922670"></a><h2>Description</h2>
+<a name="id922735"></a><h2>Description</h2>
This macro must be used within a declarative context, it must be followed by the local exit body code and then by the <code class="computeroutput"><a class="link" href="BOOST_LOCAL_EXIT_END.html" title="Macro BOOST_LOCAL_EXIT_END">BOOST_LOCAL_EXIT_END</a></code> macro (see the <a class="link" href="boost_local/Tutorial.html" title="Tutorial">Tutorial</a> section): 
<pre class="programlisting"> { // Some declarative context.
...

Modified: sandbox/local/libs/local/doc/html/BOOST_LOCAL_EXIT_END.html
==============================================================================
--- sandbox/local/libs/local/doc/html/BOOST_LOCAL_EXIT_END.html (original)
+++ sandbox/local/libs/local/doc/html/BOOST_LOCAL_EXIT_END.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -33,7 +33,7 @@

BOOST_LOCAL_EXIT_END</pre></div>
<div class="refsect1">
-<a name="id923527"></a><h2>Description</h2>
+<a name="id923592"></a><h2>Description</h2>
This macro must follow the local exit body code <code class="computeroutput">{ ... }</code> as shown in the <code class="computeroutput"><a class="link" href="BOOST_LOCAL_EXIT.html" title="Macro BOOST_LOCAL_EXIT">BOOST_LOCAL_EXIT</a></code> documentation.
Note: This macro cannot be used multiple times on the same line because it internally uses the line number <code class="computeroutput">__LINE__</code> to generate unique identifiers.
See: <code class="computeroutput"><a class="link" href="BOOST_LOCAL_EXIT.html" title="Macro BOOST_LOCAL_EXIT">BOOST_LOCAL_EXIT</a></code>, <a class="link" href="boost_local/Tutorial.html" title="Tutorial">Tutorial</a> section.

Modified: sandbox/local/libs/local/doc/html/BOOST_LOCAL_EXIT_TPL.html
==============================================================================
--- sandbox/local/libs/local/doc/html/BOOST_LOCAL_EXIT_TPL.html (original)
+++ sandbox/local/libs/local/doc/html/BOOST_LOCAL_EXIT_TPL.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -33,7 +33,7 @@

BOOST_LOCAL_EXIT_TPL(binding_list)</pre></div>
<div class="refsect1">
-<a name="id923453"></a><h2>Description</h2>
+<a name="id923518"></a><h2>Description</h2>
See: <code class="computeroutput"><a class="link" href="BOOST_LOCAL_EXIT.html" title="Macro BOOST_LOCAL_EXIT">BOOST_LOCAL_EXIT</a></code>, <a class="link" href="boost_local/Tutorial.html" title="Tutorial">Tutorial</a> section. 
</div>
</div>

Modified: sandbox/local/libs/local/doc/html/BOOST_LOCAL_FUNCTION_NAME.html
==============================================================================
--- sandbox/local/libs/local/doc/html/BOOST_LOCAL_FUNCTION_NAME.html (original)
+++ sandbox/local/libs/local/doc/html/BOOST_LOCAL_FUNCTION_NAME.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -33,12 +33,12 @@

BOOST_LOCAL_FUNCTION_NAME(name)</pre></div>
<div class="refsect1">
-<a name="id924786"></a><h2>Description</h2>
+<a name="id924850"></a><h2>Description</h2>
This macro must follow the local function body code block <code class="computeroutput">{ ... }</code> as shown in the <code class="computeroutput"><a class="link" href="BOOST_LOCAL_FUNCTION_PARAMS.html" title="Macro BOOST_LOCAL_FUNCTION_PARAMS">BOOST_LOCAL_FUNCTION_PARAMS</a></code> documentation.
The local function name can be prefixed by the "keyword" <code class="computeroutput">inline</code> (see the <a class="link" href="boost_local/Advanced_Topics.html" title="Advanced Topics"> Advanced Topics</a> section): 
<pre class="programlisting"> ... BOOST_LOCAL_FUNCTION_NAME(inline name)
</pre>
- This increases the chances that the compiler will be able to inline the local function calls (thus reducing their run-time). However, inlined local functions cannot be passed as template parameters or assigned to other functors like <code class="computeroutput">boost::function</code> (that is true on ISO C++ compilers, see <code class="computeroutput"><a class="link" href="BOOST_LOCAL_CONFIG_COMPLIANT.html" title="Macro BOOST_LOCAL_CONFIG_COMPLIANT">BOOST_LOCAL_CONFIG_COMPLIANT</a></code>, but inlined local functions can instead be passed as template parameters on C++0x compilers). On C++0x compilers, there is no need to declare a local function lined because this library will automatically use C++0x specific features to inline the local function while always allowing to pass it as a template parameter.
+ This increases the chances that the compiler will be able to inline the local function calls (thus reducing their run-time). However, inlined local functions cannot be passed as template parameters or assigned to other functors like <code class="computeroutput">boost::function</code> (that is true on C++03 compilers, see <code class="computeroutput"><a class="link" href="BOOST_LOCAL_CONFIG_COMPLIANT.html" title="Macro BOOST_LOCAL_CONFIG_COMPLIANT">BOOST_LOCAL_CONFIG_COMPLIANT</a></code>, but inlined local functions can instead be passed as template parameters on C++11 compilers). On C++11 compilers, there is no need to declare a local function lined because this library will automatically use C++11 specific features to inline the local function while always allowing to pass it as a template parameter.
The local function name can also be prefixed by the "keyword" <code class="computeroutput">recursive</code> (see the <a class="link" href="boost_local/Advanced_Topics.html" title="Advanced Topics"> Advanced Topics</a> section): 
<pre class="programlisting"> ... BOOST_LOCAL_FUNCTION_NAME(recursive name)
</pre>

Modified: sandbox/local/libs/local/doc/html/BOOST_LOCAL_FUNCTION_PARAMS.html
==============================================================================
--- sandbox/local/libs/local/doc/html/BOOST_LOCAL_FUNCTION_PARAMS.html (original)
+++ sandbox/local/libs/local/doc/html/BOOST_LOCAL_FUNCTION_PARAMS.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -33,7 +33,7 @@

BOOST_LOCAL_FUNCTION_PARAMS(parameters)</pre></div>
<div class="refsect1">
-<a name="id923694"></a><h2>Description</h2>
+<a name="id923758"></a><h2>Description</h2>
This macro must be used within a declarative context, it must follow the local function result type, it must be followed by the local function body code and then by the <code class="computeroutput"><a class="link" href="BOOST_LOCAL_FUNCTION_NAME.html" title="Macro BOOST_LOCAL_FUNCTION_NAME">BOOST_LOCAL_FUNCTION_NAME</a></code> macro (see the <a class="link" href="boost_local/Tutorial.html" title="Tutorial">Tutorial</a> and <a class="link" href="boost_local/Advanced_Topics.html" title="Advanced Topics"> Advanced Topics</a> sections): 
<pre class="programlisting"> { // Some declarative context.
...

Modified: sandbox/local/libs/local/doc/html/BOOST_LOCAL_FUNCTION_PARAMS_TPL.html
==============================================================================
--- sandbox/local/libs/local/doc/html/BOOST_LOCAL_FUNCTION_PARAMS_TPL.html (original)
+++ sandbox/local/libs/local/doc/html/BOOST_LOCAL_FUNCTION_PARAMS_TPL.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -33,7 +33,7 @@

BOOST_LOCAL_FUNCTION_PARAMS_TPL(parameters)</pre></div>
<div class="refsect1">
-<a name="id924711"></a><h2>Description</h2>
+<a name="id924775"></a><h2>Description</h2>
See: <code class="computeroutput"><a class="link" href="BOOST_LOCAL_FUNCTION_PARAMS.html" title="Macro BOOST_LOCAL_FUNCTION_PARAMS">BOOST_LOCAL_FUNCTION_PARAMS</a></code>, <a class="link" href="boost_local/Tutorial.html" title="Tutorial">Tutorial</a> section. 
</div>
</div>

Modified: sandbox/local/libs/local/doc/html/BOOST_LOCAL_TYPEOF.html
==============================================================================
--- sandbox/local/libs/local/doc/html/BOOST_LOCAL_TYPEOF.html (original)
+++ sandbox/local/libs/local/doc/html/BOOST_LOCAL_TYPEOF.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -33,7 +33,7 @@

BOOST_LOCAL_TYPEOF(bound_variable_name)</pre></div>
<div class="refsect1">
-<a name="id926531"></a><h2>Description</h2>
+<a name="id926592"></a><h2>Description</h2>
The type is fully qualified in that it contains the extra constant and reference qualifiers when they are specified for binding by constant and by reference. For example, if a variable named <code class="computeroutput">t</code> of type <code class="computeroutput">T</code> is: 
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">Bound by value using <code class="computeroutput">bind t</code> then <code class="computeroutput">BOOST_LOCAL_TYPEOF(t)</code> is <code class="computeroutput">T</code>. </li>

Modified: sandbox/local/libs/local/doc/html/boost/local/function/overload.html
==============================================================================
--- sandbox/local/libs/local/doc/html/boost/local/function/overload.html (original)
+++ sandbox/local/libs/local/doc/html/boost/local/function/overload.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -35,37 +35,37 @@
class <a class="link" href="overload.html" title="Class template overload">overload</a> {
public:
 // <a class="link" href="overload.html#boost.local.function.overloadconstruct-copy-destruct">construct/copy/destruct</a>
- <a class="link" href="overload.html#id435998-bb">overload</a>(const boost::function< F0 > &, const boost::function< F1 > &, ...);
+ <a class="link" href="overload.html#id436141-bb">overload</a>(const boost::function< F0 > &, const boost::function< F1 > &, ...);

- // <a class="link" href="overload.html#id435919-bb">public member functions</a>
- result_type< F0 > <a class="link" href="overload.html#id435923-bb">operator()</a>(arg0_type< F0 >, arg1_type< F0 >, ...) const;
- result_type< F1 > <a class="link" href="overload.html#id435960-bb">operator()</a>(arg0_type< F1 >, arg1_type< F1 >, ...) const;
+ // <a class="link" href="overload.html#id436062-bb">public member functions</a>
+ result_type< F0 > <a class="link" href="overload.html#id436066-bb">operator()</a>(arg0_type< F0 >, arg1_type< F0 >, ...) const;
+ result_type< F1 > <a class="link" href="overload.html#id436104-bb">operator()</a>(arg0_type< F1 >, arg1_type< F1 >, ...) const;
};</pre></div>
<div class="refsect1">
-<a name="id925827"></a><h2>Description</h2>
+<a name="id925889"></a><h2>Description</h2>
This functor aggregates together calls to functions of all the specified function types <code class="computeroutput">F0</code>, <code class="computeroutput">F1</code>, etc. Each function type must be specified following the Boost.Function preferred syntax: 
<pre class="programlisting"> ResultType (ArgumentType0, ArgumgnetType1, ...)
</pre>
The maximum number of overloaded function types is specified by the <code class="computeroutput"><a class="link" href="../../../BOOST_LOCAL_CONFIG_OVERLOAD_MAX.html" title="Macro BOOST_LOCAL_CONFIG_OVERLOAD_MAX">BOOST_LOCAL_CONFIG_OVERLOAD_MAX</a></code> configuration macro. The maximum number of function parameters for each of the specified function type is specified by the <code class="computeroutput"><a class="link" href="../../../BOOST_LOCAL_CONFIG_OVERLOAD_MAX.html" title="Macro BOOST_LOCAL_CONFIG_OVERLOAD_MAX">BOOST_LOCAL_CONFIG_OVERLOAD_MAX</a></code> configuration macro.
See: <a class="link" href="../../../boost_local/Advanced_Topics.html" title="Advanced Topics"> Advanced Topics</a> section, <code class="computeroutput"><a class="link" href="../../../BOOST_LOCAL_CONFIG_OVERLOAD_MAX.html" title="Macro BOOST_LOCAL_CONFIG_OVERLOAD_MAX">BOOST_LOCAL_CONFIG_OVERLOAD_MAX</a></code>, <code class="computeroutput"><a class="link" href="../../../BOOST_LOCAL_CONFIG_OVERLOAD_MAX.html" title="Macro BOOST_LOCAL_CONFIG_OVERLOAD_MAX">BOOST_LOCAL_CONFIG_OVERLOAD_MAX</a></code>, Boost.Function. 
<div class="refsect2">
-<a name="id925970"></a><h3>
+<a name="id926033"></a><h3>
<a name="boost.local.function.overloadconstruct-copy-destruct"></a><code class="computeroutput">overload</code>
 public
 construct/copy/destruct</h3>
<div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
-<pre class="literallayout"><a name="id435998-bb"></a>overload(const boost::function< F0 > &, const boost::function< F1 > &, ...);</pre>Construct the overloading functor. Any functor that can be converted to a <code class="computeroutput">boost::function</code> funcotr can be specified (local functions, functio
n pointers, other functors, etc). 
+<pre class="literallayout"><a name="id436141-bb"></a>overload(const boost::function< F0 > &, const boost::function< F1 > &, ...);</pre>Construct the overloading functor. Any functor that can be converted to a <code class="computeroutput">boost::function</code> funcotr can be specified (local functions, functio
n pointers, other functors, etc). 
</li></ol></div>
</div>
<div class="refsect2">
-<a name="id926146"></a><h3>
-<a name="id435919-bb"></a><code class="computeroutput">overload</code> public member functions</h3>
+<a name="id926208"></a><h3>
+<a name="id436062-bb"></a><code class="computeroutput">overload</code> public member functions</h3>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem">
-<pre class="literallayout">result_type< F0 > <a name="id435923-bb"></a>operator()(arg0_type< F0 >, arg1_type< F0 >, ...) const;</pre>Call operator matching the signature of the function type specified as first. This will in turn invoke the call operator of the first functor that was passed to the constructor. 
+<pre class="literallayout">result_type< F0 > <a name="id436066-bb"></a>operator()(arg0_type< F0 >, arg1_type< F0 >, ...) const;</pre>Call operator matching the signature of the function type specified as first. This will in turn invoke the call operator of the first functor that was passed to the constructor. 
</li>
<li class="listitem">
-<pre class="literallayout">result_type< F1 > <a name="id435960-bb"></a>operator()(arg0_type< F1 >, arg1_type< F1 >, ...) const;</pre>Call operator matching the signature of the function type specified as second. This will in turn invoke the call operator of the second functor that was passed to the constructor. 
+<pre class="literallayout">result_type< F1 > <a name="id436104-bb"></a>operator()(arg0_type< F1 >, arg1_type< F1 >, ...) const;</pre>Call operator matching the signature of the function type specified as second. This will in turn invoke the call operator of the second functor that was passed to the constructor. 
</li>
</ol></div>
</div>

Modified: sandbox/local/libs/local/doc/html/boost_local/Acknowledgments.html
==============================================================================
--- sandbox/local/libs/local/doc/html/boost_local/Acknowledgments.html (original)
+++ sandbox/local/libs/local/doc/html/boost_local/Acknowledgments.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -51,8 +51,8 @@

 Thanks to Pierre Morcello for suggesting to use <code class="computeroutput">return;</code> to exit local blocks (in the context of a
 discussion about a possible Boost.Breakable
- library). Thanks to Pierre also for sharing some code that already experimented
- with implementing local functions using Boost.ScopeExit
+ library). Thanks to Pierre also for sharing some code that experimented with
+ implementing local functions using Boost.ScopeExit
 binding (even if this library was not developed using such a code).
 

@@ -62,14 +62,14 @@

 Thanks to Jeffrey Lee Hellrung for suggesting the use of the "keyword"
 <code class="computeroutput">bind</code> to bind variables in scope
- and for suggesting to use <code class="computeroutput">bind(type)</code>
+ and for suggesting to use <code class="literal">bind(type)</code>
 to optionally specify the bound variable type (instead of using Boost.Typeof).
 Thanks to Vicente Botet for suggesting to provide <code class="computeroutput"><a class="link" href="../BOOST_LOCAL_TYPEOF.html" title="Macro BOOST_LOCAL_TYPEOF">BOOST_LOCAL_TYPEOF</a></code>
 to access the bound variable type.
 

 Thanks to Mathias Gaunard for suggesting to implement <code class="computeroutput"><a class="link" href="../boost/local/function/overload.html" title="Class template overload">boost::local::function::overload</a></code>
- and for providing an early version of it.
+ and for providing an early version of its code.
 

 Thanks to Steven Watanabe, Vicente Botet, Michael Caisse, Yechezkel Mett, Joel

Modified: sandbox/local/libs/local/doc/html/boost_local/Advanced_Topics.html
==============================================================================
--- sandbox/local/libs/local/doc/html/boost_local/Advanced_Topics.html (original)
+++ sandbox/local/libs/local/doc/html/boost_local/Advanced_Topics.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -86,7 +86,7 @@

 In addition, local function parameter types cannot start with non-alphanumeric
 symbols (alphanumeric symbols are <code class="computeroutput">A-Z</code>, <code class="computeroutput">a-z</code>,
- and <code class="computeroutput">0-9</code>). [<a name="id882590" href="#ftn.id882590" class="footnote">19</a>] The library will generate (cryptic) preprocessor errors if a
+ and <code class="computeroutput">0-9</code>). [<a name="id882775" href="#ftn.id882775" class="footnote">19</a>] The library will generate (cryptic) preprocessor errors if a
 parameter type starts with a non-alphanumeric symbol.
 

@@ -227,7 +227,7 @@
<li class="listitem">
 Parenthesis to wrap the type expression (and therefore any commas <code class="computeroutput">,</code> that it contains) passed as parameter
 to the <code class="computeroutput"><a class="link" href="../BOOST_IDENTITY_TYPE.html" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
- macro. [<a name="id884041" href="#ftn.id884041" class="footnote">20</a>]
+ macro. [<a name="id884226" href="#ftn.id884226" class="footnote">20</a>]
 </li>
</ol></div>
<div class="note"><table border="0" summary="Note">
@@ -1370,7 +1370,7 @@
 to their equivalent implementation that uses local functors (see the <a class="link" href="Alternatives.html" title="Appendix: Alternatives">Alternatives</a> section). However,
 inlined local functions have the limitation that they cannot be assigned
 to other functors (like <code class="computeroutput">boost::function</code>)
- and they cannot be passed as template parameters. [<a name="id904734" href="#ftn.id904734" class="footnote">21</a>] On C++11
+ and they cannot be passed as template parameters. [<a name="id904920" href="#ftn.id904920" class="footnote">21</a>] On C++11
 compilers, <code class="computeroutput">inline</code> has no effect
 because this library will automatically generate code that uses C++11
 specific features to inline the local function calls whenever possible even
@@ -1439,11 +1439,11 @@
 std::vector<double> v(1000000);
 std::fill(v.begin(), v.end(), 1.0);

- // On some ISO C++ compilers (e.g., GCC 4.3.4) inlined local functions are
+ // On some C++03 compilers (e.g., GCC 4.3.4) inlined local functions are
 // more likely to be optimized for faster run-times. However, inlined local
 // functions cannot be passed at template parameters (i.e., `std::for_each`
 // cannot be used here).
- // On C++0x compilers (e.g., MSVC 8.0 or GCC 4.5.1) linining has no effect
+ // On C++11 compilers (e.g., MSVC 8.0 or GCC 4.5.1) linining has no effect
 // because the local function can always be optimized even if not
 // explicitly specified inline and inlined local functions can always be
 // passed as template parameters.
@@ -1479,11 +1479,11 @@
 std::vector<double> v(1000000);
 std::fill(v.begin(), v.end(), 1.0);

- // On some ISO C++ compilers (e.g., GCC 4.3.4) inlined local functions are
+ // On some C++03 compilers (e.g., GCC 4.3.4) inlined local functions are
 // more likely to be optimized for faster run-times. However, inlined local
 // functions cannot be passed at template parameters (i.e., `std::for_each`
 // cannot be used here).
- // On C++0x compilers (e.g., MSVC 8.0 and GCC 4.5.1) linining has no effect
+ // On C++11 compilers (e.g., MSVC 8.0 and GCC 4.5.1) linining has no effect
 // because the local function can always be optimized even if not
 // explicitly specified inline and inlined local functions can always be
 // passed as template parameters.
@@ -1635,6 +1635,7 @@

 Compilers have not been observed to be able to inline recursive local function
 calls (not even when the recursive local function is also declared inlined).
+ [<a name="id909349" href="#ftn.id909349" class="footnote">22</a>]
 
</div>
<div class="section">
@@ -1817,7 +1818,7 @@
 functor can be constructed from any function type that can be converted to
 a <code class="computeroutput">boost::function</code>
 type (i.e., local functions but also function pointers and other function
- objects). [<a name="id913840" href="#ftn.id913840" class="footnote">22</a>] The <code class="computeroutput"><a class="link" href="../boost/local/function/overload.html" title="Class template overload">boost::local::function::overload</a></code>
+ objects). [<a name="id913906" href="#ftn.id913906" class="footnote">23</a>] The <code class="computeroutput"><a class="link" href="../boost/local/function/overload.html" title="Class template overload">boost::local::function::overload</a></code>
 functor provides overloaded call operators <code class="computeroutput">operator()</code> that match the signatures of all the specified
 function types.
 
@@ -2099,7 +2100,7 @@

 Local function parameters support the storage classifiers as usual in C++03.
 The <code class="computeroutput">auto</code> storage classifier
- is specified as: [<a name="id918474" href="#ftn.id918474" class="footnote">23</a>]
+ is specified as: [<a name="id918540" href="#ftn.id918540" class="footnote">24</a>]
 
<pre class="programlisting">auto parameter-type parameter-name
</pre>
@@ -2332,7 +2333,7 @@
<td>
 
 This is not supported because local functions are not member functions.
- [<a name="id919784" href="#ftn.id919784" class="footnote">a</a>]
+ [<a name="id919849" href="#ftn.id919849" class="footnote">a</a>]
 
 </td>
</tr>
@@ -2431,7 +2432,7 @@
 </td>
</tr>
</tbody>
-<tbody class="footnotes"><tr><td colspan="3"><div class="footnote">[<a id="ftn.id919784" href="#id919784" class="para">a</a>] 
+<tbody class="footnotes"><tr><td colspan="3"><div class="footnote">[<a id="ftn.id919849" href="#id919849" class="para">a</a>] 
 Rationale. It would be possible
 to make a local function class inherit from another local function
 class. However, this "inheritance" feature is not implemented
@@ -2447,7 +2448,7 @@
 </h6>

 Local functions cannot be operators. Naming a local function <code class="computeroutput">operator...</code>
- will generate a compile-time error. [<a name="id920131" href="#ftn.id920131" class="footnote">24</a>]
+ will generate a compile-time error. [<a name="id920197" href="#ftn.id920197" class="footnote">25</a>]
 

 For example, the following code will not
@@ -2499,21 +2500,21 @@
</div>
<div class="footnotes">
 <hr width="100" align="left">
-<div class="footnote">[<a id="ftn.id882590" href="#id882590" class="para">19</a>] 
+<div class="footnote">[<a id="ftn.id882775" href="#id882775" class="para">19</a>] 
 Rationale. This limitation derives from
 the fact that <code class="computeroutput"><a class="link" href="../BOOST_LOCAL_FUNCTION_PARAMS.html" title="Macro BOOST_LOCAL_FUNCTION_PARAMS">BOOST_LOCAL_FUNCTION_PARAMS</a></code>
 uses preprocessor token concatenation to inspect the parameter type token
 to see if the token is a parameter or a bound variable. The C++ preprocessor
 does not allow to concatenate non-alphanumeric tokens.
 </div>
-<div class="footnote">[<a id="ftn.id884041" href="#id884041" class="para">20</a>] 
+<div class="footnote">[<a id="ftn.id884226" href="#id884226" class="para">20</a>] 
 Rationale. Using variadic macros,
 this extra set of parenthesis could be eliminated requiring only the
 parenthesis to invoke the <code class="computeroutput"><a class="link" href="../BOOST_IDENTITY_TYPE.html" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
 macro. However, this feature is currently not implemented and the double
 parenthesis are always needed when invoking this macro.
 </div>
-<div class="footnote">[<a id="ftn.id904734" href="#id904734" class="para">21</a>] 
+<div class="footnote">[<a id="ftn.id904920" href="#id904920" class="para">21</a>] 
 Rationale. This library uses an indirect
 function call via a function pointer in order to pass the local function
 as a template parameter (see the <a class="link" href="Implementation.html" title="Appendix: Implementation">Implementation</a>
@@ -2529,7 +2530,12 @@
 be inlined on C++11
 compilers (even when the local function is not declared inlined).
 </div>
-<div class="footnote">[<a id="ftn.id913840" href="#id913840" class="para">22</a>] 
+<div class="footnote">[<a id="ftn.id909349" href="#id909349" class="para">22</a>] 
+ Ratinale. Local functions are not declared
+ recursive by default because recursion seems to always prevent the possibility
+ for inlining optimization.
+ </div>
+<div class="footnote">[<a id="ftn.id913906" href="#id913906" class="para">23</a>] 
 The <code class="computeroutput"><a class="link" href="../boost/local/function/overload.html" title="Class template overload">boost::local::function::overload</a></code>
 functor can aggregate any functor and it is not at all specific to local
 functions. Therefore, it might be preferable to move <code class="computeroutput"><a class="link" href="../boost/local/function/overload.html" title="Class template overload">boost::local::function::overload</a></code>
@@ -2537,7 +2543,7 @@
 to Boost.Function
 and to rename it as <code class="computeroutput">boost::function::overload</code>.
 </div>
-<div class="footnote">[<a id="ftn.id918474" href="#id918474" class="para">23</a>] 
+<div class="footnote">[<a id="ftn.id918540" href="#id918540" class="para">24</a>] 
 The <code class="computeroutput">auto</code> storage classifier
 is part of the C++03
 standard and therefore supported by this library. However, the meaning
@@ -2547,7 +2553,7 @@
 classifier with the usual care in order to avoid writing C++03
 code that might not work on C++11.
 </div>
-<div class="footnote">[<a id="ftn.id920131" href="#id920131" class="para">24</a>] 
+<div class="footnote">[<a id="ftn.id920197" href="#id920197" class="para">25</a>] 
 Rationale. This is the because a local
 function name must be a valid local variable name (the local variable to
 hold the local functor) and operators cannot be used as local variable

Modified: sandbox/local/libs/local/doc/html/boost_local/Alternatives.html
==============================================================================
--- sandbox/local/libs/local/doc/html/boost_local/Alternatives.html (original)
+++ sandbox/local/libs/local/doc/html/boost_local/Alternatives.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -1115,9 +1115,10 @@
<a name="boost_local.Alternatives.local_blocks"></a><a class="link" href="Alternatives.html#boost_local.Alternatives.local_blocks" title="Local Blocks">Local Blocks</a>
</h3></div></div></div>

- The authors know of no other library or C++ language feature that supports
- local blocks (i.e., with the ability to bind by constant value or constant
- reference).
+ The authors know of no other library or C++ standard feature that fully supports
+ local blocks. For example, even using <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11
+ lambda</a> functions does not allow binding by constant reference and
+ non-constant value.

</div>
<div class="section">

Modified: sandbox/local/libs/local/doc/html/boost_local/Getting_Started.html
==============================================================================
--- sandbox/local/libs/local/doc/html/boost_local/Getting_Started.html (original)
+++ sandbox/local/libs/local/doc/html/boost_local/Getting_Started.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -124,7 +124,7 @@
</pre>

 The followings are part of the library private API, they are not documented,
- and they should not be directly used by programmers: [<a name="id866234" href="#ftn.id866234" class="footnote">2</a>]
+ and they should not be directly used by programmers: [<a name="id866387" href="#ftn.id866387" class="footnote">2</a>]
 
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
@@ -132,7 +132,7 @@
 directory (these header files should not be directly included by programmers).
 </li>
<li class="listitem">
- Any symbol prefixed by <code class="computeroutput">BOOST_LOCAL_AUX_...</code>.
+ Any symbol prefixed by <code class="computeroutput">BOOST_LOCAL_AUX_...</code> (regardless of its namespace).
 </li>
<li class="listitem">
 Any symbol within the <code class="computeroutput">boost::local::aux</code>
@@ -162,7 +162,7 @@
</div>
<div class="footnotes">
 <hr width="100" align="left">
-<div class="footnote">[<a id="ftn.id866234" href="#id866234" class="para">2</a>] 
+<div class="footnote">[<a id="ftn.id866387" href="#id866387" class="para">2</a>] 
 Rationale. This library concatenates symbols
 specified by the programmers (e.g., the local function name) with other
 symbols (e.g., special prefixes or preprocessor line numbers) to make internal

Modified: sandbox/local/libs/local/doc/html/boost_local/Implementation.html
==============================================================================
--- sandbox/local/libs/local/doc/html/boost_local/Implementation.html (original)
+++ sandbox/local/libs/local/doc/html/boost_local/Implementation.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -35,14 +35,13 @@
<dt>Local Functions</dt>
</dl></div>

- This section lists source code that should provide a general idea on how this
- library is implemented.
+ This section gives an overview of the key programming techniques used to implement
+ this library.
 

 The code listed here can be used by curious readers and library maintainers
 as a reference in trying to understand this library source files at <code class="computeroutput">"boost/local/..."</code>. There is absolutely
- no guarantee that the library implementation uses the exact the code listed
- here.
+ no guarantee that the library implementation uses the exact code listed here.
 
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
@@ -69,9 +68,9 @@
 type casting).
 </li>
<li class="listitem">
- The virtual functor trick uses a non-local base
- class for the local functor class. The correct overridden implementation
- of the virtual <code class="computeroutput">operator()</code> is called via polymorphism.
+ The virtual functor trick derives the local functor
+ class from a non-local base class. The correct overridden implementation
+ of the virtual <code class="computeroutput">operator()</code> is then called via polymorphism.
 </li>
</ol></div>

@@ -134,7 +133,7 @@
 std::vector<double> v(10);
 std::fill(v.begin(), v.end(), 1.0);

-// std::for_each(v.begin(), v.end(), add_local); // Error but OK on C++0x.
+// std::for_each(v.begin(), v.end(), add_local); // Error but OK on C++11.
 std::for_each(v.begin(), v.end(), add_casting); // OK.
 std::for_each(v.begin(), v.end(), add_virtual); // OK.

@@ -156,10 +155,10 @@
 Therefore, on compilers that accept local types as template parameters (MSVC,
 <a href="http://www.open-std.org/JTC1/SC22/WG21/" target="_top">C++11</a>, etc,
 see [N2657]),
- this library generates code that passes the local class type directly as
- template parameter without using neither one of these two tricks in order
- to take full advantage of compiler optimizations that inline the local function
- calls.
+ this library automatically generates code that passes the local class type
+ directly as template parameter without using neither one of these two tricks
+ in order to take full advantage of compiler optimizations that inline the
+ local function calls.
 
</div>
<div class="section">
@@ -207,9 +206,8 @@
<a name="boost_local.Implementation.local_blocks"></a><a class="link" href="Implementation.html#boost_local.Implementation.local_blocks" title="Local Blocks">Local Blocks</a>
</h3></div></div></div>

- The expansion of the local block macros for the main local block example
- presented in the <a class="link" href="Tutorial.html" title="Tutorial">Tutorial</a> section
- generates code equivalent to the following:
+ The local block macros presented in the example of the <a class="link" href="Tutorial.html" title="Tutorial">Tutorial</a>
+ section expand to code equivalent to the following:
 


@@ -249,9 +247,8 @@
<a name="boost_local.Implementation.local_exits"></a><a class="link" href="Implementation.html#boost_local.Implementation.local_exits" title="Local Exits">Local Exits</a>
</h3></div></div></div>

- The expansion of the local exit macros for the main local exit example presented
- in the <a class="link" href="Tutorial.html" title="Tutorial">Tutorial</a> section generates
- code equivalent to the following:
+ The local exit macros presented in the example of the <a class="link" href="Tutorial.html" title="Tutorial">Tutorial</a>
+ section expand to code equivalent to the following:
 


@@ -294,9 +291,9 @@
<a name="boost_local.Implementation.local_functions"></a><a class="link" href="Implementation.html#boost_local.Implementation.local_functions" title="Local Functions">Local Functions</a>
</h3></div></div></div>

- The expansion of the local function macros of the <code class="computeroutput">factorial</code>
+ The local function macros of the <code class="computeroutput">factorial</code>
 example presented in the <a class="link" href="Advanced_Topics.html" title="Advanced Topics">Advanced
- Topics</a> section generates code equivalent to the following:
+ Topics</a> section expand to code equivalent to the following:

Modified: sandbox/local/libs/local/doc/html/boost_local/Tutorial.html
==============================================================================
--- sandbox/local/libs/local/doc/html/boost_local/Tutorial.html (original)
+++ sandbox/local/libs/local/doc/html/boost_local/Tutorial.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -30,7 +30,7 @@
<dt>Local Functions</dt>
<dt>Empty Parameters</dt>
<dt>Default Parameters</dt>
-<dt>Binding</dt>
+<dt>Variable Binding</dt>
<dt>Local Blocks</dt>
<dt>Local Exits</dt>
<dt>Templates</dt>
@@ -116,12 +116,12 @@
 ... }</code>
 using the usual C++ syntax. The body is specified outside any of the macros
 so eventual compiler error messages and related line numbers retain their
- usual meaning and format. [<a name="id866948" href="#ftn.id866948" class="footnote">3</a>]
+ usual meaning and format. [<a name="id867096" href="#ftn.id867096" class="footnote">3</a>]
 

 The macro <code class="computeroutput"><a class="link" href="../BOOST_LOCAL_FUNCTION_NAME.html" title="Macro BOOST_LOCAL_FUNCTION_NAME">BOOST_LOCAL_FUNCTION_NAME</a></code>
 is used to end the local function definition and to specify the local function
- name. [<a name="id866984" href="#ftn.id866984" class="footnote">4</a>]
+ name. [<a name="id867132" href="#ftn.id867132" class="footnote">4</a>]
 

 For example, let's program a local function named <code class="computeroutput">add</code>
@@ -383,7 +383,7 @@
 This library also allows to specify default values for the local function
 parameters. However, the usual C++ syntax for default parameters that uses
 the assignment symbol <code class="computeroutput">=</code> cannot
- be used. [<a name="id869144" href="#ftn.id869144" class="footnote">5</a>] The keyword <code class="computeroutput">default</code>
+ be used. [<a name="id869292" href="#ftn.id869292" class="footnote">5</a>] The keyword <code class="computeroutput">default</code>
 is used instead:
 
<div class="informaltable"><table class="table">
@@ -487,7 +487,7 @@

 Programmers can define a <code class="computeroutput">WITH_DEFAULT</code>
 macro similar to the following if they think it improves readability over
- the syntax above: [<a name="id870135" href="#ftn.id870135" class="footnote">6</a>]
+ the syntax above: [<a name="id870283" href="#ftn.id870283" class="footnote">6</a>]
 
<div class="informaltable"><table class="table">
<colgroup>
@@ -555,14 +555,14 @@
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_local.Tutorial.Binding"></a><a class="link" href="Tutorial.html#boost_local.Tutorial.Binding" title="Binding">Binding</a>
+<a name="boost_local.Tutorial.Binding"></a><a class="link" href="Tutorial.html#boost_local.Tutorial.Binding" title="Variable Binding">Variable Binding</a>
</h3></div></div></div>

 Variables in scope (local variables, enclosing function parameters, member
 variables, the object <code class="computeroutput">this</code>,
 etc) can be bound to a local function declaration. The types of bound variables
 are automatically deduced by this library using Boost.Typeof.
- [<a name="id870944" href="#ftn.id870944" class="footnote">7</a>]
+ [<a name="id871105" href="#ftn.id871105" class="footnote">7</a>]
 
<div class="important"><table border="0" summary="Important">
<tr>
@@ -579,7 +579,7 @@
</table></div>

 This library introduces the new "keyword" <code class="computeroutput">bind</code>
- [<a name="id871026" href="#ftn.id871026" class="footnote">8</a>] which is used in place of the parameter type to specify the name
+ [<a name="id871197" href="#ftn.id871197" class="footnote">8</a>] which is used in place of the parameter type to specify the name
 of a variable in scope to bind. The variable can be bound by value:
 
<pre class="programlisting">bind variable-name // Bind by value.
@@ -604,7 +604,7 @@

 Note that when <code class="computeroutput">const</code> is used,
 it must always precede <code class="computeroutput">bind</code>.
- [<a name="id871253" href="#ftn.id871253" class="footnote">9</a>]
+ [<a name="id871425" href="#ftn.id871425" class="footnote">9</a>]
 

 If a variable is bound by value, then a copy of the variable value is taken
@@ -618,7 +618,8 @@
 

 The type of a bound variable is automatically deduced and it is the exact
- same type used to declare such a variable in the enclosing scope.
+ same type used to declare such a variable in the enclosing scope with the
+ following notes:
 
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
@@ -631,7 +632,7 @@
 forced using <code class="computeroutput">const bind
 ...</code>. (Note that binding by constant
 reference is not supported by <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11
- lambda</a> functions but it is supported by this library.) [<a name="id871440" href="#ftn.id871440" class="footnote">10</a>]
+ lambda</a> functions but it is supported by this library.) [<a name="id871612" href="#ftn.id871612" class="footnote">10</a>]
 </li>
<li class="listitem">
 If a bound variable was declared as a reference in the enclosing scope,
@@ -639,7 +640,7 @@
 using <code class="computeroutput">bind&
 ...</code> or <code class="computeroutput">const
 bind&
- ...</code>. [<a name="id871559" href="#ftn.id871559" class="footnote">11</a>]
+ ...</code>. [<a name="id871732" href="#ftn.id871732" class="footnote">11</a>]
 </li>
</ul></div>

@@ -731,10 +732,11 @@
 </h6>

 It is also possible to bind the object <code class="computeroutput">this</code>
- when it is in scope (e.g., from an enclosing member function). This is done
- by using <code class="computeroutput">this</code> as the name of
- the variable to bind in the local function declaration and by using the special
- symbol <code class="computeroutput">this_</code> [<a name="id872736" href="#ftn.id872736" class="footnote">12</a>] (instead of <code class="computeroutput">this</code>)
+ when it is in scope (e.g., from an enclosing non-static member function).
+ This is done by using <code class="computeroutput">this</code> as
+ the name of the variable to bind in the local function declaration and by
+ using the special symbol <code class="computeroutput">this_</code>
+ [<a name="id872911" href="#ftn.id872911" class="footnote">12</a>] (instead of <code class="computeroutput">this</code>)
 to access the object within the local function body.
 

@@ -745,7 +747,7 @@
</pre>

 In this case the local function will be able to modify the object when the
- enclosing scope is not a constant member, or it will not be able to modify
+ enclosing scope is not a constant member and it will not be able to modify
 the object when the enclosing scope is a constant member. Otherwise, the
 object <code class="computeroutput">this</code> can be bound by
 constant value:
@@ -777,12 +779,12 @@

 When the object <code class="computeroutput">this</code> is bound
 to a local function, the local function body must use the special symbol
- <code class="computeroutput">this_</code> (instead of <code class="computeroutput">this</code>) to access the bound object. [<a name="id873066" href="#ftn.id873066" class="footnote">13</a>]
+ <code class="computeroutput">this_</code> (instead of <code class="computeroutput">this</code>) to access the bound object. [<a name="id873247" href="#ftn.id873247" class="footnote">13</a>]
 

 Unfortunately, mistakenly using <code class="computeroutput">this</code>
 within the local function body instead of <code class="computeroutput">this_</code>
- will not necessarily generate a compile-time error. [<a name="id873167" href="#ftn.id873167" class="footnote">14</a>] Programmers are responsible to make sure that <code class="computeroutput">this</code> is never used within a local function
+ will not necessarily generate a compile-time error. [<a name="id873347" href="#ftn.id873347" class="footnote">14</a>] Programmers are responsible to make sure that <code class="computeroutput">this</code> is never used within a local function
 body which should only use the special symbol <code class="computeroutput">this_</code>.
 
</td></tr>
@@ -923,9 +925,10 @@
</tr></tbody>
</table></div>

- The special name <code class="computeroutput">this_</code> used
- to replace the bound object name <code class="computeroutput">this</code>
- is controlled at compile-time by the configuration macro <code class="computeroutput"><a class="link" href="../BOOST_LOCAL_CONFIG_THIS_PARAM_NAME.html" title="Macro BOOST_LOCAL_CONFIG_THIS_PARAM_NAME">BOOST_LOCAL_CONFIG_THIS_PARAM_NAME</a></code>.
+ (The special symbol <code class="computeroutput">this_</code>
+ to be used to refer to the object <code class="computeroutput">this</code>
+ from within the local function can be changed at compile-time using the configuration
+ macro <code class="computeroutput"><a class="link" href="../BOOST_LOCAL_CONFIG_THIS_PARAM_NAME.html" title="Macro BOOST_LOCAL_CONFIG_THIS_PARAM_NAME">BOOST_LOCAL_CONFIG_THIS_PARAM_NAME</a></code>.)
 
</div>
<div class="section">
@@ -960,7 +963,7 @@
 Parameters</a>), or they can list the variables to bind using the "keyword"
 <code class="computeroutput">bind</code> in place of the parameter
 type, using <code class="computeroutput">const bind</code>
- for constant binding, prefixing the bound variable name with <code class="computeroutput">&</code> to bind by reference, and using <code class="computeroutput">this</code> to bind the object in scope (see <a class="link" href="Tutorial.html#boost_local.Tutorial.Binding" title="Binding">Binding</a>).
+ for constant binding, prefixing the bound variable name with <code class="computeroutput">&</code> to bind by reference, and using <code class="computeroutput">this</code> to bind the object in scope (see <a class="link" href="Tutorial.html#boost_local.Tutorial.Binding" title="Variable Binding">Variable Binding</a>).
 
<div class="important"><table border="0" summary="Important">
<tr>
@@ -970,7 +973,7 @@
<tr><td align="left" valign="top">
 A <code class="computeroutput">return;</code>
 instruction from within a local block jumps to the end of the local block
- body and it does not return the enclosing function. [<a name="id876588" href="#ftn.id876588" class="footnote">15</a>]
+ body and it does not return the enclosing function. [<a name="id876768" href="#ftn.id876768" class="footnote">15</a>]
 </td></tr>
</table></div>

@@ -1083,7 +1086,7 @@
</tr>
<tr><td align="left" valign="top">
 The execution of the local exit body code is guaranteed only if the program
- does not terminate because of an uncaught exception. [<a name="id877834" href="#ftn.id877834" class="footnote">16</a>]
+ does not terminate because of an uncaught exception. [<a name="id878014" href="#ftn.id878014" class="footnote">16</a>]
 </td></tr>
</table></div>

@@ -1095,7 +1098,7 @@
 Parameters</a>), or they can list the variables to bind using the "keyword"
 <code class="computeroutput">bind</code> in place of the parameter
 type, using <code class="computeroutput">const bind</code>
- for constant binding, prefixing the bound variable name with <code class="computeroutput">&</code> to bind by reference, and using <code class="computeroutput">this</code> to bind the object in scope (see <a class="link" href="Tutorial.html#boost_local.Tutorial.Binding" title="Binding">Binding</a>).
+ for constant binding, prefixing the bound variable name with <code class="computeroutput">&</code> to bind by reference, and using <code class="computeroutput">this</code> to bind the object in scope (see <a class="link" href="Tutorial.html#boost_local.Tutorial.Binding" title="Variable Binding">Variable Binding</a>).
 
<div class="important"><table border="0" summary="Important">
<tr>
@@ -1189,7 +1192,7 @@
 Local exits are very similar to the scope exits provided
 by Boost.ScopeExit
 with the addition that they also support constant binding and binding of
- the object <code class="computeroutput">this</code>. [<a name="id879124" href="#ftn.id879124" class="footnote">17</a>] Local exits can be used to emulate the <a href="http://d.digitalmars.com" target="_top">D
+ the object <code class="computeroutput">this</code>. [<a name="id879309" href="#ftn.id879309" class="footnote">17</a>] Local exits can be used to emulate the <a href="http://d.digitalmars.com" target="_top">D
 Programming Language</a> scope guards (see the
 <a class="link" href="Examples.html#boost_local.Examples.Emulating_Ds_Scope_Guards" title="Emulating D's Scope Guards">Emulating
 D's Scope Guards</a> example).
@@ -1203,7 +1206,7 @@
 When local functions, local blocks, and local exits are programmed within
 templates, they need to be declared using the following special macros ending
 with the <code class="computeroutput">TPL</code> postfix (see
- the Reference section): [<a name="id879438" href="#ftn.id879438" class="footnote">18</a>]
+ the Reference section): [<a name="id879623" href="#ftn.id879623" class="footnote">18</a>]
 
<pre class="programlisting"><code class="computeroutput"><a class="link" href="../BOOST_LOCAL_FUNCTION_PARAMS_TPL.html" title="Macro BOOST_LOCAL_FUNCTION_PARAMS_TPL">BOOST_LOCAL_FUNCTION_PARAMS_TPL</a></code>(parameters)
<code class="computeroutput"><a class="link" href="../BOOST_LOCAL_BLOCK_TPL.html" title="Macro BOOST_LOCAL_BLOCK_TPL">BOOST_LOCAL_BLOCK_TPL</a></code>(bindings)
@@ -1339,20 +1342,20 @@
</div>
<div class="footnotes">
 <hr width="100" align="left">
-<div class="footnote">[<a id="ftn.id866948" href="#id866948" class="para">3</a>] 
+<div class="footnote">[<a id="ftn.id867096" href="#id867096" class="para">3</a>] 
 Rationale. If the local function body
 were instead passed as a macro parameter, it would be expanded on a single
 line of code (because macros always expand as a single line of code). Therefore,
 eventual compiler error line numbers would all report the same value and
 would no longer be useful to pinpoint the error.
 </div>
-<div class="footnote">[<a id="ftn.id866984" href="#id866984" class="para">4</a>] 
+<div class="footnote">[<a id="ftn.id867132" href="#id867132" class="para">4</a>] 
 Rationale. The local function name must
 be passed to the macro <code class="computeroutput"><a class="link" href="../BOOST_LOCAL_FUNCTION_NAME.html" title="Macro BOOST_LOCAL_FUNCTION_NAME">BOOST_LOCAL_FUNCTION_NAME</a></code>
 ending the function definition so this macro can declare a local variable
 with the local function name to hold the local function object.
 </div>
-<div class="footnote">[<a id="ftn.id869144" href="#id869144" class="para">5</a>] 
+<div class="footnote">[<a id="ftn.id869292" href="#id869292" class="para">5</a>] 
 Rationale. The assignment symbol <code class="computeroutput">=</code> cannot be used to specify default parameter
 values because default values are not part of the parameter type so they
 cannot be handled using template metaprogamming. Default parameter values
@@ -1365,12 +1368,15 @@
 symbol cannot be detected by preprocessor metaprogramming because it cannot
 be concatenated by the preprocessor).
 </div>
-<div class="footnote">[<a id="ftn.id870135" href="#id870135" class="para">6</a>] 
+<div class="footnote">[<a id="ftn.id870283" href="#id870283" class="para">6</a>] 
 The authors do not personally find the use of the <code class="computeroutput">WITH_DEFAULT</code>
 macro more readable and they prefer to use the <code class="computeroutput">default</code>
- "keyword" directly.
+ "keyword" directly. Furthermore, <code class="computeroutput">WITH_DEFAULT</code>
+ need to be defined differently for the sequencing and variadic macro syntax
+ so it can only be defined by programmers based on the syntax they decide
+ to use.
 </div>
-<div class="footnote">[<a id="ftn.id870944" href="#id870944" class="para">7</a>] 
+<div class="footnote">[<a id="ftn.id871105" href="#id871105" class="para">7</a>] 
 Rationale. By binding a variable in scope,
 the local function declaration is specifying that such a variable should
 be accessible within the local function body regardless of its type. Semantically,
@@ -1383,7 +1389,7 @@
 For example, this is useful for maintenance because if a bound variable
 type is changed, the local function declaration does not have to change.
 </div>
-<div class="footnote">[<a id="ftn.id871026" href="#id871026" class="para">8</a>] 
+<div class="footnote">[<a id="ftn.id871197" href="#id871197" class="para">8</a>] 
 Obviously, the token <code class="computeroutput">bind</code>
 is not a keyword of the C++ language. This library parses the token <code class="computeroutput">bind</code> during macro expansion using preprocessor
 metaprogramming (see the <a class="link" href="Implementation.html" title="Appendix: Implementation">Implementation</a>
@@ -1392,7 +1398,7 @@
 level within the syntax defined by the macros of this library -- thus it
 is referred to as a "keyword" only within quotes.
 </div>
-<div class="footnote">[<a id="ftn.id871253" href="#id871253" class="para">9</a>] 
+<div class="footnote">[<a id="ftn.id871425" href="#id871425" class="para">9</a>] 
 Rationale. The library macros could have
 been implemented to accept both syntaxes <code class="computeroutput">const
 bind ...</code>
@@ -1403,7 +1409,7 @@
 bind ...</code>)
 is supported.
 </div>
-<div class="footnote">[<a id="ftn.id871440" href="#id871440" class="para">10</a>] 
+<div class="footnote">[<a id="ftn.id871612" href="#id871612" class="para">10</a>] 
 An historical note: Constant binding of variables in scope was the
 main use case that originally motivated the authors in developing this
 library. The authors needed to locally create a chuck of code to assert
@@ -1418,7 +1424,7 @@
 correctly generates an error because the bound variable is of <code class="computeroutput">const</code> type within the local function
 body.
 </div>
-<div class="footnote">[<a id="ftn.id871559" href="#id871559" class="para">11</a>] 
+<div class="footnote">[<a id="ftn.id871732" href="#id871732" class="para">11</a>] 
 Rationale. Variables originally declared
 as references are bound by value unless <code class="computeroutput">[const] bind&</code>
 is used so that references can be bound by both value <code class="computeroutput">[const] bind</code>
@@ -1431,13 +1437,13 @@
 even if <code class="computeroutput">bind[&]</code>
 is used instead of <code class="computeroutput">const bind[&]</code>.
 </div>
-<div class="footnote">[<a id="ftn.id872736" href="#id872736" class="para">12</a>] 
+<div class="footnote">[<a id="ftn.id872911" href="#id872911" class="para">12</a>] 
 Rationale. The special name <code class="computeroutput">this_</code> was chosen following <a href="http://boost.2283326.n4.nabble.com/local-this-or-this-td3423912.html" target="_top">Boost
 practises</a> which postfix with an underscore identifiers that are
 named after keywords (the C++ keyword <code class="computeroutput">this</code>
 in this case).
 </div>
-<div class="footnote">[<a id="ftn.id873066" href="#id873066" class="para">13</a>] 
+<div class="footnote">[<a id="ftn.id873247" href="#id873247" class="para">13</a>] 
 Rationale. This limitation comes from
 the fact that <code class="computeroutput">this</code> is a
 reserved C++ keyword so it cannot be used as the name of the internal
@@ -1451,7 +1457,7 @@
 behaviour of <code class="computeroutput">static_cast</code></a>
 (which might not work on all platforms at the cost of portability).
 </div>
-<div class="footnote">[<a id="ftn.id873167" href="#id873167" class="para">14</a>] 
+<div class="footnote">[<a id="ftn.id873347" href="#id873347" class="para">14</a>] 
 Rationale. The local function body cannot
 be a static member function of the local functor object in order to support
 recursion (because the local function name is specified by the <code class="computeroutput"><a class="link" href="../BOOST_LOCAL_FUNCTION_NAME.html" title="Macro BOOST_LOCAL_FUNCTION_NAME">BOOST_LOCAL_FUNCTION_NAME</a></code>
@@ -1464,7 +1470,7 @@
 Therefore, from within the local function body the variable <code class="computeroutput">this</code> is visible but it refers to the local
 functor and not to the bound object.
 </div>
-<div class="footnote">[<a id="ftn.id876588" href="#id876588" class="para">15</a>] 
+<div class="footnote">[<a id="ftn.id876768" href="#id876768" class="para">15</a>] 
 Rationale. Programmers might expect
 <code class="computeroutput">return;</code>
 to exit the enclosing function instead of the local block (or local exit),
@@ -1482,7 +1488,7 @@
 <code class="computeroutput">BOOST_LOCAL_RETURN;</code>)
 to exit local blocks (and local exits).
 </div>
-<div class="footnote">[<a id="ftn.id877834" href="#id877834" class="para">16</a>] 
+<div class="footnote">[<a id="ftn.id878014" href="#id878014" class="para">16</a>] 
 Rationale. This library (as well as
 <a href="http://www.boost.org/doc/libs/release/libs/scope_exit/doc/html/index.html" target="_top">Boost.ScopeExit</a>)
 uses the destructor of a local variable to automatically execute the
@@ -1493,7 +1499,7 @@
 scope exit code even if the main program terminates because of an uncaught
 exception.)
 </div>
-<div class="footnote">[<a id="ftn.id879124" href="#id879124" class="para">17</a>] 
+<div class="footnote">[<a id="ftn.id879309" href="#id879309" class="para">17</a>] 
 Rationale. This library could be merged
 together with Boost.ScopeExit
 into a new library named Boost.Scope (from the meaning of the word "scope"
@@ -1522,7 +1528,7 @@
 name of "<a href="http://gcc.gnu.org/onlinedocs/gcc/Nested-Functions.html" target="_top">nested
 functions</a>" (GCC compiler extension).
 </div>
-<div class="footnote">[<a id="ftn.id879438" href="#id879438" class="para">18</a>] 
+<div class="footnote">[<a id="ftn.id879623" href="#id879623" class="para">18</a>] 
 Rationale. Within templates, this library
 needs to use <code class="computeroutput">typename</code> to explicitly
 indicate that some expressions evaluate to a type. Because C++ does not

Modified: sandbox/local/libs/local/doc/html/index.html
==============================================================================
--- sandbox/local/libs/local/doc/html/index.html (original)
+++ sandbox/local/libs/local/doc/html/index.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -27,7 +27,7 @@
</h3></div></div></div>
<div>Copyright © 2009-2011 Lorenzo Caminiti</div>
<div><div class="legalnotice">
-<a name="id808762"></a>
+<a name="id863704"></a>
 Use, modification, and distribution is subject to the Boost Software License,
 Version 1.0 (see accompanying file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
 
@@ -80,15 +80,18 @@
 format).
 </li>
<li class="listitem">
- Local functions can be passed as template parameters (e.g., they can be
- conveniently passed to STL algorithms, this is in contrast to functors
- implemented using local classes see [N2657]
+ Local functions can be passed as template parameters so they can be conveniently
+ passed to STL algorithms, etc (this is a strength with respect to C++03
+ functors implemented using local classes, see [N2657]
 and the <a class="link" href="boost_local/Alternatives.html" title="Appendix: Alternatives">Alternatives</a> section).
 </li>
<li class="listitem">
 However, local functions must be defined within a declarative context (e.g.,
 at a point in the code where local variables can be declared) thus they
- cannot be defined within an expression.
+ cannot be defined within expressions (this is a weakness with respect to
+ <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11
+ lambda</a> functions, see the <a class="link" href="boost_local/Alternatives.html" title="Appendix: Alternatives">Alternatives</a>
+ section).
 </li>
</ul></div>

@@ -112,7 +115,7 @@
 for a comparison between this library, <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11
 lambda</a> functions, Boost.Lambda,
 <a href="http://www.boost.org/doc/libs/release/libs/spirit/phoenix/index.html" target="_top">Boost.Phoenix</a>,
- and other C++ libraries offering similar features.
+ and other C++ libraries offering related features.
 
<a name="boost_local.Introduction.two_syntaxes"></a><h6>
<a name="boost_local.Introduction.two_syntaxes-heading"></a>
@@ -126,9 +129,9 @@
<li class="listitem">
 The sequencing macro syntax is fully compliant with
 the C++03
- standard and supported on all C++ compilers. This syntax requires to wrap
- the local function parameters and bound variables between round parenthesis
- <code class="computeroutput">()</code>.
+ standard and supported on all C++ compliant compilers. This syntax requires
+ to wrap the local function parameters and bound variables between round
+ parenthesis <code class="computeroutput">()</code>.
 </li>
<li class="listitem">
 The variadic macro synstax is available only on C++
@@ -350,7 +353,7 @@
 by reference, by constant value, and by constant reference. In addition,
 the object <code class="computeroutput">this</code> can be bound
 (eventually by constant value but never by reference or constant reference
- [<a name="id865452" href="#ftn.id865452" class="footnote">1</a>] ) from within a non-static member function (see the <a class="link" href="boost_local/Tutorial.html" title="Tutorial">Tutorial</a>
+ [<a name="id865608" href="#ftn.id865608" class="footnote">1</a>] ) from within a non-static member function (see the <a class="link" href="boost_local/Tutorial.html" title="Tutorial">Tutorial</a>
 section). For example, the variable <code class="computeroutput">factor</code>
 is bound by constant value so it cannot be mistakenly modified by the local
 function body. The variable <code class="computeroutput">sum</code>
@@ -426,13 +429,13 @@
</div>
<div class="footnotes">
 <hr width="100" align="left">
-<div class="footnote">[<a id="ftn.id865452" href="#id865452" class="para">1</a>] 
+<div class="footnote">[<a id="ftn.id865608" href="#id865608" class="para">1</a>] 
 C++ does not allow to obtain a reference to the pointer <code class="computeroutput">this</code>.
 </div>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left">Last revised: October 04, 2011 at 16:21:48 GMT</td>
+<td align="left">Last revised: October 18, 2011 at 20:36:32 GMT</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>

Modified: sandbox/local/libs/local/doc/html/reference.html
==============================================================================
--- sandbox/local/libs/local/doc/html/reference.html (original)
+++ sandbox/local/libs/local/doc/html/reference.html 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -99,7 +99,7 @@
<div class="titlepage"><div><div><h3 class="title">
<a name="header.boost.utility.identity_hpp"></a>Header <boost/utility/identity.hpp></h3></div></div></div>
Identity macros are used to pass expressions with commas (not already wrapped within round parenthesis) as macros parameters. 
-Note: The only way (at least as far as the authors know) to pass an arbitrary number of commas within macro parameters without explicitly indicating the number of commas (and without using variadic macros which are not part of the ISO C++ standard) is to wrap the expression within round parenthesis that are not replaced by macro expansion and then to remove the extra parenthesis at compile-time (for type expressions) or at run-time (for value expressions). This is what these macros do. 
+Note: The only way (at least as far as the authors know) to pass an arbitrary number of commas within macro parameters without explicitly indicating the number of commas (and without using variadic macros which are not part of the C++03 standard) is to wrap the expression within round parenthesis that are not replaced by macro expansion and then to remove the extra parenthesis at compile-time (for type expressions) or at run-time (for value expressions). This is what these macros do. 
<pre class="synopsis">

<a class="link" href="BOOST_IDENTITY_TYPE.html" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a>(parenthesized_type)

Modified: sandbox/local/libs/local/doc/qbk/acknowledgements.qbk
==============================================================================
--- sandbox/local/libs/local/doc/qbk/acknowledgements.qbk (original)
+++ sandbox/local/libs/local/doc/qbk/acknowledgements.qbk 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -16,14 +16,14 @@
Thanks to David Abrahams, Vicente Botet, et al. for suggesting to provide the [@http://lists.boost.org/Archives/boost/2011/02/176712.php variadic macro syntax] on compilers that support variadic macros.

Thanks to Pierre Morcello for suggesting to use `return;` to exit local blocks (in the context of a discussion about a possible [@http://lists.boost.org/Archives/boost/2009/09/156012.php Boost.Breakable] library).
-Thanks to Pierre also for sharing some code that already experimented with implementing local functions using __Boost_ScopeExit__ binding (even if this library was not developed using such a code).
+Thanks to Pierre also for sharing some code that experimented with implementing local functions using __Boost_ScopeExit__ binding (even if this library was not developed using such a code).

Thanks to John Bytheway for checking the authors' virtual functor technique that originally allowed this library to pass local functions as template parameters.

-Thanks to Jeffrey Lee Hellrung for suggesting the use of the "keyword" `bind` to bind variables in scope and for suggesting to use `bind(type)` to optionally specify the bound variable type (instead of using __Boost_Typeof__).
+Thanks to Jeffrey Lee Hellrung for suggesting the use of the "keyword" `bind` to bind variables in scope and for suggesting to use [^bind(/type/)] to optionally specify the bound variable type (instead of using __Boost_Typeof__).
Thanks to Vicente Botet for suggesting to provide `__BOOST_LOCAL_TYPEOF__` to access the bound variable type.

-Thanks to Mathias Gaunard for suggesting to implement `__boost__local__function__overload__` and for providing an early version of it.
+Thanks to Mathias Gaunard for suggesting to implement `__boost__local__function__overload__` and for providing an early version of its code.

Thanks to Steven Watanabe, Vicente Botet, Michael Caisse, Yechezkel Mett, Joel de Guzman, Thomas Heller, et al. for helping with the __Alternatives__ section and with the profiling of the different alternatives.

Modified: sandbox/local/libs/local/doc/qbk/advanced_topics.qbk
==============================================================================
--- sandbox/local/libs/local/doc/qbk/advanced_topics.qbk (original)
+++ sandbox/local/libs/local/doc/qbk/advanced_topics.qbk 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -327,6 +327,10 @@
]

Compilers have not been observed to be able to inline recursive local function calls (not even when the recursive local function is also declared inlined).
+[footnote
+[*Ratinale.]
+Local functions are not declared recursive by default because recursion seems to always prevent the possibility for inlining optimization.
+]

[endsect]

Modified: sandbox/local/libs/local/doc/qbk/alternatives.qbk
==============================================================================
--- sandbox/local/libs/local/doc/qbk/alternatives.qbk (original)
+++ sandbox/local/libs/local/doc/qbk/alternatives.qbk 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -238,7 +238,8 @@

[section Local Blocks]

-The authors know of no other library or C++ language feature that supports local blocks (i.e., with the ability to bind by constant value or constant reference).
+The authors know of no other library or C++ standard feature that fully supports local blocks.
+For example, even using __CPP0x_lambda__ functions does not allow binding by constant reference and non-constant value.

[endsect]

Modified: sandbox/local/libs/local/doc/qbk/getting_started.qbk
==============================================================================
--- sandbox/local/libs/local/doc/qbk/getting_started.qbk (original)
+++ sandbox/local/libs/local/doc/qbk/getting_started.qbk 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -60,7 +60,7 @@
]

* Any symbol defined by files within the `"boost/local/aux_/"` directory (these header files should not be directly included by programmers).
-* Any symbol prefixed by `BOOST_LOCAL_AUX_...`.
+* Any symbol prefixed by `BOOST_LOCAL_AUX_...` (regardless of its namespace).
* Any symbol within the `boost::local::aux` namespace.
* Any symbol prefixed by `boost_local_aux...` (regardless of its namespace).

Modified: sandbox/local/libs/local/doc/qbk/implementation.qbk
==============================================================================
--- sandbox/local/libs/local/doc/qbk/implementation.qbk (original)
+++ sandbox/local/libs/local/doc/qbk/implementation.qbk 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -6,10 +6,10 @@

[section:Implementation Appendix: Implementation]

-This section lists source code that should provide a general idea on how this library is implemented.
+This section gives an overview of the key programming techniques used to implement this library.

The code listed here can be used by curious readers and library maintainers as a reference in trying to understand this library source files at `"boost/local/..."`.
-There is absolutely no guarantee that the library implementation uses the exact the code listed here.
+There is absolutely no guarantee that the library implementation uses the exact code listed here.

[section Local Classes as Template Parameters]

@@ -20,14 +20,14 @@
# The /casting functor trick/ uses a non-local functor that calls a static member function of the local class via a function pointer.
The static member function then calls the correct local function body after type casting the object from a `void*` pointer (local classes can be used for type casting).

-# The /virtual functor trick/ uses a non-local base class for the local functor class.
-The correct overridden implementation of the virtual `operator()` is called via polymorphism.
+# The /virtual functor trick/ derives the local functor class from a non-local base class.
+The correct overridden implementation of the virtual `operator()` is then called via polymorphism.

[tparam_trick_cpp]

The casting functor trick measured slightly better run-time performances than the virtual functor trick so the current implementation of this library uses the casting functor trick (probably because in addition to the indirect function call, the virtual functor trick also requires accessing the [@http://en.wikipedia.org/wiki/Virtual_method_table virtual function table]).
However, both tricks do not allow for compiler optimizations that inline the local function calls because they rely on one indirect function call (via either a function pointer or a virtual function respectively) that has been observed to be resolved only at run-time by all analyzed compilers.
-Therefore, on compilers that accept local types as template parameters (MSVC, __CPP11__, etc, see __N2657__), this library generates code that passes the local class type directly as template parameter without using neither one of these two tricks in order to take full advantage of compiler optimizations that inline the local function calls.
+Therefore, on compilers that accept local types as template parameters (MSVC, __CPP11__, etc, see __N2657__), this library automatically generates code that passes the local class type directly as template parameter without using neither one of these two tricks in order to take full advantage of compiler optimizations that inline the local function calls.

[endsect]

@@ -43,7 +43,7 @@

[section Local Blocks]

-The expansion of the local block macros for the main local block example presented in the __Tutorial__ section generates code equivalent to the following:
+The local block macros presented in the example of the __Tutorial__ section expand to code equivalent to the following:

[add_block_impl_cpp]

@@ -51,7 +51,7 @@

[section Local Exits]

-The expansion of the local exit macros for the main local exit example presented in the __Tutorial__ section generates code equivalent to the following:
+The local exit macros presented in the example of the __Tutorial__ section expand to code equivalent to the following:

[add_exit_impl_cpp]

@@ -59,7 +59,7 @@

[section Local Functions]

-The expansion of the local function macros of the `factorial` example presented in the __Advanced_Topics__ section generates code equivalent to the following:
+The local function macros of the `factorial` example presented in the __Advanced_Topics__ section expand to code equivalent to the following:

[factorial_impl_cpp]

Modified: sandbox/local/libs/local/doc/qbk/introduction.qbk
==============================================================================
--- sandbox/local/libs/local/doc/qbk/introduction.qbk (original)
+++ sandbox/local/libs/local/doc/qbk/introduction.qbk 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -14,8 +14,8 @@
* Local functions can access, or better [@http://en.wikipedia.org/wiki/Name_binding /bind/], any of the variables from the enclosing scope.
Furthermore, local functions defined within a member function can bind the enclosing object `this`.
* The local function body is programmed using the usual C++ statement syntax (as a consequence, compiler error messages retain their usual meaning and format).
-* Local functions can be passed as template parameters (e.g., they can be conveniently passed to STL algorithms, this is in contrast to functors implemented using local classes see __N2657__ and the __Alternatives__ section).
-* However, local functions must be defined within a declarative context (e.g., at a point in the code where local variables can be declared) thus they cannot be defined within an expression.
+* Local functions can be passed as template parameters so they can be conveniently passed to STL algorithms, etc (this is a strength with respect to __CPP03__ functors implemented using local classes, see __N2657__ and the __Alternatives__ section).
+* However, local functions must be defined within a declarative context (e.g., at a point in the code where local variables can be declared) thus they cannot be defined within expressions (this is a weakness with respect to __CPP0x_lambda__ functions, see the __Alternatives__ section).

In addition to local functions, this library also supports the following features:

@@ -23,14 +23,14 @@
Local blocks allow programmers to bind variables as constants (/constant binding/) to prevent local chunks of code from modifying selected variables.
* /Local exits/ which define blocks of code that are executed when the enclosing scope is exited (again with support for binding variables in scope including the object `this`).

-See the __Alternatives__ section for a comparison between this library, __CPP0x_lambda__ functions, __Boost_Lambda__, __Boost_Phoenix__, and other C++ libraries offering similar features.
+See the __Alternatives__ section for a comparison between this library, __CPP0x_lambda__ functions, __Boost_Lambda__, __Boost_Phoenix__, and other C++ libraries offering related features.

[h5 Two Syntaxes]

This library uses macros to declare the local functions, local blocks, and local exits.
These macros support two different syntaxes:

-* The /sequencing macro syntax/ is fully compliant with the __CPP03__ standard and supported on all C++ compilers.
+* The /sequencing macro syntax/ is fully compliant with the __CPP03__ standard and supported on all C++ compliant compilers.
This syntax requires to wrap the local function parameters and bound variables between round parenthesis `()`.
* The /variadic macro synstax/ is available only on C++ compilers that support [@http://en.wikipedia.org/wiki/Variadic_macro variadic macros] (variadic macros were first introduced by the __C99__ standard and they are now supported by essentially all modern C++ compilers including GCC and MSVC).
This syntax allows to use commas `,` to separate macro parameters therefore resembling the usual C++ syntax for function parameter declaration.

Modified: sandbox/local/libs/local/doc/qbk/local.qbk
==============================================================================
--- sandbox/local/libs/local/doc/qbk/local.qbk (original)
+++ sandbox/local/libs/local/doc/qbk/local.qbk 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -52,7 +52,7 @@
[def __Getting_Started__ [link boost_local.Getting_Started Getting Started]]
[def __Tutorial__ [link boost_local.Tutorial Tutorial]]
[def __Tutorial_Empty_Parameters__ [link boost_local.Tutorial.Empty_Parameters Empty Parameters]]
-[def __Tutorial_Binding__ [link boost_local.Tutorial.Binding Binding]]
+[def __Tutorial_Binding__ [link boost_local.Tutorial.Binding Variable Binding]]
[def __Advanced_Topics__ [link boost_local.Advanced_Topics Advanced Topics]]
[def __Reference__ [@reference.html Reference]]
[def __Examples__ [link boost_local.Examples Examples]]

Modified: sandbox/local/libs/local/doc/qbk/tutorial.qbk
==============================================================================
--- sandbox/local/libs/local/doc/qbk/tutorial.qbk (original)
+++ sandbox/local/libs/local/doc/qbk/tutorial.qbk 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -137,6 +137,7 @@
Programmers can define a `WITH_DEFAULT` macro similar to the following if they think it improves readability over the syntax above:
[footnote
The authors do not personally find the use of the `WITH_DEFAULT` macro more readable and they prefer to use the `default` "keyword" directly.
+Furthermore, `WITH_DEFAULT` need to be defined differently for the sequencing and variadic macro syntax so it can only be defined by programmers based on the syntax they decide to use.
]

[table
@@ -146,7 +147,7 @@

[endsect]

-[section:Binding Binding]
+[section:Binding Variable Binding]

Variables in scope (local variables, enclosing function parameters, member variables, the object `this`, etc) can be bound to a local function declaration.
The types of bound variables are automatically deduced by this library using __Boost_Typeof__.
@@ -196,7 +197,7 @@
If a variable is bound by reference instead, the variable will refer to the value it has at the point of the local function call.
Furthermore, it is the programmers' responsibility to ensure that variables bound by reference survive the declaration scope of the local function otherwise the bound references will be invalid causing run-time errors (in other words, the usual care in using C++ references must be taken for variables bound by reference).

-The type of a bound variable is automatically deduced and it is the exact same type used to declare such a variable in the enclosing scope.
+The type of a bound variable is automatically deduced and it is the exact same type used to declare such a variable in the enclosing scope with the following notes:

* If a bound variable was declared constant in the enclosing scope, it will be always bound by constant value or constant reference even if `bind ...` is used instead of `const bind ...` .
However, if a bound variable was not declared constant in the enclosing scope then it will not be bound as constant unless constant binding is forced using `const bind ...`. (Note that binding by constant reference is not supported by __CPP0x_lambda__ functions but it is supported by this library.)
@@ -225,7 +226,7 @@

[h5 Binding the Object `this`]

-It is also possible to bind the object `this` when it is in scope (e.g., from an enclosing member function).
+It is also possible to bind the object `this` when it is in scope (e.g., from an enclosing non-static member function).
This is done by using `this` as the name of the variable to bind in the local function declaration and by using the special symbol `this_`
[footnote
*Rationale.*
@@ -237,7 +238,7 @@

bind this // Bind the object `this` by value.

-In this case the local function will be able to modify the object when the enclosing scope is not a constant member, or it will not be able to modify the object when the enclosing scope is a constant member.
+In this case the local function will be able to modify the object when the enclosing scope is not a constant member and it will not be able to modify the object when the enclosing scope is a constant member.
Otherwise, the object `this` can be bound by constant value:

const bind this // Bind the object `this` by constant value.
@@ -271,7 +272,7 @@
[ [ [add_this_va_cpp] ] [ [add_this_cpp] ] ]
]

-The special name `this_` used to replace the bound object name `this` is controlled at compile-time by the configuration macro `__BOOST_LOCAL_CONFIG_THIS_PARAM_NAME__`.
+(The special symbol `this_` to be used to refer to the object `this` from within the local function can be changed at compile-time using the configuration macro `__BOOST_LOCAL_CONFIG_THIS_PARAM_NAME__`.)

[endsect]

Modified: sandbox/local/libs/local/example/add_function_inline.cpp
==============================================================================
--- sandbox/local/libs/local/example/add_function_inline.cpp (original)
+++ sandbox/local/libs/local/example/add_function_inline.cpp 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -22,11 +22,11 @@
 std::vector<double> v(1000000);
 std::fill(v.begin(), v.end(), 1.0);

- // On some ISO C++ compilers (e.g., GCC 4.3.4) inlined local functions are
+ // On some C++03 compilers (e.g., GCC 4.3.4) inlined local functions are
 // more likely to be optimized for faster run-times. However, inlined local
 // functions cannot be passed at template parameters (i.e., `std::for_each`
 // cannot be used here).
- // On C++0x compilers (e.g., MSVC 8.0 and GCC 4.5.1) linining has no effect
+ // On C++11 compilers (e.g., MSVC 8.0 and GCC 4.5.1) linining has no effect
 // because the local function can always be optimized even if not
 // explicitly specified inline and inlined local functions can always be
 // passed as template parameters.

Modified: sandbox/local/libs/local/example/add_function_inline_va.cpp
==============================================================================
--- sandbox/local/libs/local/example/add_function_inline_va.cpp (original)
+++ sandbox/local/libs/local/example/add_function_inline_va.cpp 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -31,11 +31,11 @@
 std::vector<double> v(1000000);
 std::fill(v.begin(), v.end(), 1.0);

- // On some ISO C++ compilers (e.g., GCC 4.3.4) inlined local functions are
+ // On some C++03 compilers (e.g., GCC 4.3.4) inlined local functions are
 // more likely to be optimized for faster run-times. However, inlined local
 // functions cannot be passed at template parameters (i.e., `std::for_each`
 // cannot be used here).
- // On C++0x compilers (e.g., MSVC 8.0 or GCC 4.5.1) linining has no effect
+ // On C++11 compilers (e.g., MSVC 8.0 or GCC 4.5.1) linining has no effect
 // because the local function can always be optimized even if not
 // explicitly specified inline and inlined local functions can always be
 // passed as template parameters.

Modified: sandbox/local/libs/local/example/add_using_0x_lambda.cpp
==============================================================================
--- sandbox/local/libs/local/example/add_using_0x_lambda.cpp (original)
+++ sandbox/local/libs/local/example/add_using_0x_lambda.cpp 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -8,7 +8,7 @@
#ifdef BOOST_NO_LAMBDAS
#include <iostream>
int main() {
- std::cerr << "Error: This program requires C++0x lambdas" << std::endl;
+ std::cerr << "Error: This program requires C++11 lambdas" << std::endl;
return 0;
}
#else

Modified: sandbox/local/libs/local/example/expensive_copy_0x_lambda.cpp
==============================================================================
--- sandbox/local/libs/local/example/expensive_copy_0x_lambda.cpp (original)
+++ sandbox/local/libs/local/example/expensive_copy_0x_lambda.cpp 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -8,7 +8,7 @@
#ifdef BOOST_NO_LAMBDAS
#include <iostream>
int main() {
- std::cerr << "Error: This program requires C++0x lambdas" << std::endl;
+ std::cerr << "Error: This program requires C++11 lambdas" << std::endl;
 return 0;
}
#else
@@ -20,7 +20,7 @@
 int i;
 x_t(int _i): i(_i) {}
 x_t(x_t const& o): i(o.i) { // Some time consuming copy.
- for (unsigned long i = 0; i < 10000000000; ++i);
+ for (unsigned i = 0; i < 10000; ++i) std::cout << '.';
 }
};

Modified: sandbox/local/libs/local/example/expensive_copy_boost_local.cpp
==============================================================================
--- sandbox/local/libs/local/example/expensive_copy_boost_local.cpp (original)
+++ sandbox/local/libs/local/example/expensive_copy_boost_local.cpp 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -12,7 +12,7 @@
 int i;
 x_t(int _i): i(_i) {}
 x_t(x_t const& o): i(o.i) { // Some time consuming copy.
- for (unsigned long i = 0; i < 10000000000; ++i);
+ for (unsigned i = 0; i < 10000; ++i) std::cout << '.';
 }
};

Modified: sandbox/local/libs/local/example/expensive_copy_boost_local_va.cpp
==============================================================================
--- sandbox/local/libs/local/example/expensive_copy_boost_local_va.cpp (original)
+++ sandbox/local/libs/local/example/expensive_copy_boost_local_va.cpp 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -21,7 +21,7 @@
 int i;
 x_t(int _i): i(_i) {}
 x_t(x_t const& o): i(o.i) { // Some time consuming copy.
- for (unsigned long i = 0; i < 10000000000; ++i);
+ for (unsigned i = 0; i < 10000; ++i) std::cout << '.';
 }
};

Modified: sandbox/local/libs/local/example/profile_0x_lambda.cpp
==============================================================================
--- sandbox/local/libs/local/example/profile_0x_lambda.cpp (original)
+++ sandbox/local/libs/local/example/profile_0x_lambda.cpp 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -8,7 +8,7 @@
#ifdef BOOST_NO_LAMBDAS
#include <iostream>
int main() {
- std::cerr << "Error: This program requires C++0x lambdas" << std::endl;
+ std::cerr << "Error: This program requires C++11 lambdas" << std::endl;
return 0;
}
#else

Modified: sandbox/local/libs/local/example/tparam_trick.cpp
==============================================================================
--- sandbox/local/libs/local/example/tparam_trick.cpp (original)
+++ sandbox/local/libs/local/example/tparam_trick.cpp 2011-10-18 21:36:23 EDT (Tue, 18 Oct 2011)
@@ -64,7 +64,7 @@
 std::vector<double> v(10);
 std::fill(v.begin(), v.end(), 1.0);

-// std::for_each(v.begin(), v.end(), add_local); // Error but OK on C++0x.
+// std::for_each(v.begin(), v.end(), add_local); // Error but OK on C++11.
 std::for_each(v.begin(), v.end(), add_casting); // OK.
 std::for_each(v.begin(), v.end(), add_virtual); // OK.

Next message: steven_at_[hidden]: "[Boost-commit] svn:boost r75059 - trunk/tools/boostbook/xsl"
Previous message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r75057 - in sandbox/conversion/boost/conversion: . type_traits"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk