RubyGems - script_core - Versions diffs - 0.1.1 → 0.2.4 - Mend

script_core 0.1.1 → 0.2.4

Files changed (1479) hide show

data/ext/enterprise_script_service/msgpack/external/boost/preprocessor/doc/topics/reentrancy.html DELETED

@@ -1,298 +0,0 @@
-<html>
-	<head>
-		<title>reentrancy.html</title>
-		<link rel="stylesheet" type="text/css" href="../styles.css">
-	</head>
-	<body>
-		<h4>
-			Reentrancy
-		</h4>
-		<div>
-			Macro expansion in the preprocessor is entirely functional.&nbsp; Therefore,
-			there is no iteration.&nbsp; Unfortunately, the preprocessor also disallows
-			recursion.&nbsp; This means that the library must fake iteration or recursion
-			by defining sets of macros that are implemented similarly.&nbsp;
-		</div>
-		<div>
-			To illustrate, here is a simple concatenation macro:
-		</div>
-		<div class="code">
-			<pre>
-#define CONCAT(a, b) CONCAT_D(a, b)
-#define CONCAT_D(a, b) a ## b
-CONCAT(a, CONCAT(b, c)) // abc
-</pre>
-		</div>
-		<div>
-			This is fine for a simple case like the above, but what happens in a scenario
-			like the following:
-		</div>
-		<div class="code">
-			<pre>
-#define AB(x, y) CONCAT(x, y)
-CONCAT(A, B(p, q)) // CONCAT(p, q)
-</pre>
-		</div>
-		<div>
-			Because there is no recursion, the example above expands to <code>CONCAT(p, q)</code>
-			rather than <code>pq</code>.
-		</div>
-		<div>
-			There are only two ways to "fix" the above.&nbsp; First, it can be documented
-			that <code>AB</code> uses <code>CONCAT</code> and disallow usage similar to the
-			above.&nbsp; Second, multiple concatenation macros can be provided....
-		</div>
-		<div class="code">
-			<pre>
-#define CONCAT_1(a, b) CONCAT_1_D(a, b)
-#define CONCAT_1_D(a, b) a ## b
-#define CONCAT_2(a, b) CONCAT_2_D(a, b)
-#define CONCAT_2_D(a, b) a ## b
-#define AB(x, y) CONCAT_2(x, y)
-CONCAT_1(A, B(p, q)) // pq
-</pre>
-		</div>
-		<div>
-			This solves the problem.&nbsp; However, it is now necessary to know that <code>AB</code>
-			uses, not only <i>a</i> concatenation macro, but <code>CONCAT_2</code> specifically.
-		</div>
-		<div>
-			A better solution is to abstract <i>which</i> concatenation macro is used....
-		</div>
-		<div class="code">
-			<pre>
-#define AB(c, x, y) CONCAT_ ## c(x, y)
-CONCAT_1(A, B(2, p, q)) // pq
-</pre>
-		</div>
-		<div>
-			This is an example of <i>generic reentrance</i>, in this case, into a fictional
-			set of concatenation macros.&nbsp; The <code>c</code> parameter represents the
-			"state" of the concatenation construct, and as long as the user keeps track of
-			this state, <code>AB</code> can be used inside of a concatenation macro.
-		</div>
-		<div>
-			The library has the same choices.&nbsp; It either has to disallow a construct
-			being inside itself or provide multiple, equivalent definitions of a construct
-			and provide a uniform way to <i>reenter</i> that construct.&nbsp; There are
-			several contructs that <i>require</i> recursion (such as <b>BOOST_PP_WHILE</b>).&nbsp;
-			Consequently, the library chooses to provide several sets of macros with
-			mechanisms to reenter the set at a macro that has not already been used.
-		</div>
-		<div>
-			In particular, the library must provide reentrance for <b>BOOST_PP_FOR</b>, <b>BOOST_PP_REPEAT</b>,
-			and <b>BOOST_PP_WHILE</b>.&nbsp; There are two mechanisms that are used to
-			accomplish this:&nbsp; state parameters (like the above concatenation example)
-			and <i>automatic recursion</i>.
-		</div>
-		<h4>
-			State Parameters
-		</h4>
-		<div>
-			Each of the above constructs (<b>BOOST_PP_FOR</b>, <b>BOOST_PP_REPEAT</b>, and <b>BOOST_PP_WHILE</b>)
-			has an associated state.&nbsp; This state provides the means to reenter the
-			respective construct.
-		</div>
-		<div>
-			Several user-defined macros are passed to each of these constructs (for use as
-			predicates, operations, etc.).&nbsp; Every time a user-defined macro is
-			invoked, it is passed the current state of the construct that invoked it so
-			that the macro can reenter the respective set if necessary.
-		</div>
-		<div>
-			These states are used in one of two ways--either by concatenating to or passing
-			to another macro.
-		</div>
-		<div>
-			There are three types of macros that use these state parameters.&nbsp; First,
-			the set itself which is reentered through concatenation.&nbsp; Second,
-			corresponding sets that act like they are a part of the the primary set.&nbsp;
-			These are also reentered through concatenation.&nbsp; And third, macros that
-			internally use the first or second type of macro.&nbsp; These macros take the
-			state as an additional argument.
-		</div>
-		<div>
-			The state of <b>BOOST_PP_WHILE</b> is symbolized by the letter <i>D</i>.&nbsp;
-			Two user-defined macros are passed to <b>BOOST_PP_WHILE</b>--a predicate and an
-			operation.&nbsp; When <b>BOOST_PP_WHILE</b> expands these macros, it passes
-			along its state so that these macros can reenter the <b>BOOST_PP_WHILE</b> set.&nbsp;
-		</div>
-		<div>
-			Consider the following multiplication implementation that illustrates this
-			technique:
-		</div>
-		<div class="code">
-			<pre>
-// The addition interface macro.
-// The _D signifies that it reenters
-// BOOST_PP_WHILE with concatenation.
-#define ADD_D(d, x, y) \
-   BOOST_PP_TUPLE_ELEM( \
-      2, 0, \
-      BOOST_PP_WHILE_ ## d(ADD_P, ADD_O, (x, y)) \
-   ) \
-   /**/
-// The predicate that is passed to BOOST_PP_WHILE.
-// It returns "true" until "y" becomes zero.
-#define ADD_P(d, xy) BOOST_PP_TUPLE_ELEM(2, 1, xy)
-// The operation that is passed to BOOST_PP_WHILE.
-// It increments "x" and decrements "y" which will
-// eventually cause "y" to equal zero and therefore
-// cause the predicate to return "false."
-#define ADD_O(d, xy) \
-   ( \
-      BOOST_PP_INC( \
-         BOOST_PP_TUPLE_ELEM(2, 0, xy) \
-      ), \
-      BOOST_PP_DEC( \
-         BOOST_PP_TUPLE_ELEM(2, 1, xy) \
-      ) \
-   ) \
-   /**/
-// The multiplication interface macro.
-#define MUL(x, y) \
-   BOOST_PP_TUPLE_ELEM( \
-      3, 0, \
-      BOOST_PP_WHILE(MUL_P, MUL_O, (0, x, y)) \
-   ) \
-   /**/
-// The predicate that is passed to BOOST_PP_WHILE.
-// It returns "true" until "y" becomes zero.
-#define MUL_P(d, rxy) BOOST_PP_TUPLE_ELEM(3, 2, rxy)
-// The operation that is passed to BOOST_PP_WHILE.
-// It adds "x" to "r" and decrements "y" which will
-// eventually cause "y" to equal zero and therefore
-// cause the predicate to return "false."
-#define MUL_O(d, rxy) \
-   ( \
-      ADD_D( \
-         d, /* pass the state on to ADD_D */ \
-         BOOST_PP_TUPLE_ELEM(3, 0, rxy), \
-         BOOST_PP_TUPLE_ELEM(3, 1, rxy) \
-      ), \
-      BOOST_PP_TUPLE_ELEM(3, 1, rxy), \
-      BOOST_PP_DEC( \
-         BOOST_PP_TUPLE_ELEM(3, 2, rxy) \
-      ) \
-   ) \
-   /**/
-MUL(3, 2) // expands to 6
-</pre>
-		</div>
-		<div>
-			There are a couple things to note in the above implementation.&nbsp; First,
-			note how <code>ADD_D</code> reenters <b>BOOST_PP_WHILE</b> using the <i>d</i> state
-			parameter.&nbsp; Second, note how <code>MUL</code>'s operation, which is
-			expanded by <b>BOOST_PP_WHILE</b>, passes the state on to <code>ADD_D</code>.&nbsp;
-			This illustrates state reentrance by both argument and concatenation.
-		</div>
-		<div>
-			For every macro in the library that uses <b>BOOST_PP_WHILE</b>, there is a
-			state reentrant variant.&nbsp; If that variant uses an argument rather than
-			concatenation, it is suffixed by <code>_D</code> to symbolize its method of
-			reentrance.&nbsp; Examples or this include the library's own <b>BOOST_PP_ADD_D</b>
-			and <b>BOOST_PP_MUL_D</b>.&nbsp; If the variant uses concatenation, it is
-			suffixed by an underscore.&nbsp; It is completed by concatenation of the
-			state.&nbsp; This includes <b>BOOST_PP_WHILE</b> itself with <b>BOOST_PP_WHILE_</b>
-			## <i>d</i> and, for example, <b>BOOST_PP_LIST_FOLD_LEFT</b> with <b>BOOST_PP_LIST_FOLD_LEFT_</b>
-			## <i>d</i>.
-		</div>
-		<div>
-			The same set of conventions are used for <b>BOOST_PP_FOR</b> and <b>BOOST_PP_REPEAT</b>,
-			but with the letters <i>R</i> and <i>Z</i>, respectively, to symbolize their
-			states.
-		</div>
-		<div>
-			Also note that the above <code>MUL</code> implementation, though not
-			immediately obvious, is using <i>all three</i> types of reentrance.&nbsp; Not
-			only is it using both types of <i>state</i> reentrance, it is also using <i>automatic
-				recursion</i>....
-		</div>
-		<h4>
-			Automatic Recursion
-		</h4>
-		<div>
-			Automatic recursion is a technique that vastly simplifies the use of reentrant
-			constructs.&nbsp; It is used by simply <i>not</i> using any state parameters at
-			all.
-		</div>
-		<div>
-			The <code>MUL</code> example above uses automatic recursion when it uses <b>BOOST_PP_WHILE</b>
-			by itself.&nbsp; In other words, <code>MUL</code> can <i>still</i> be used
-			inside <b>BOOST_PP_WHILE</b> even though it doesn't reenter <b>BOOST_PP_WHILE</b>
-			by concatenating the state to <b>BOOST_PP_WHILE_</b>.
-		</div>
-		<div>
-			To accomplish this, the library uses a "trick."&nbsp; Despite what it looks
-			like, the macro <b>BOOST_PP_WHILE</b> does not take three arguments.&nbsp; In
-			fact, it takes no arguments at all.&nbsp; Instead, the <b>BOOST_PP_WHILE</b> macro
-			expands <i>to</i> a macro that takes three arguments.&nbsp; It simply detects
-			what the next available <b>BOOST_PP_WHILE_</b> ## <i>d</i> macro is and returns
-			it.&nbsp; This detection process is somewhat involved, so I won't go into <i>how</i>
-			it works here, but suffice to say it <i>does</i> work.
-		</div>
-		<div>
-			Using automatic recursion to reenter various sets of macros is obviously much
-			simpler.&nbsp; It completely hides the underlying implementation details.&nbsp;
-			So, if it is so much easier to use, why do the state parameters still
-			exist?&nbsp; The reason is simple as well.&nbsp; When state parameters are
-			used, the state is <i>known</i> at all times.&nbsp; This is not the case when
-			automatic recursion is used.&nbsp; The automatic recursion mechanism has to <i>deduce</i>
-			the state at each point that it is used.&nbsp; This implies a cost in macro
-			complexity that in some situations--notably at deep macro depths--will slow
-			some preprocessors to a crawl.
-		</div>
-		<h4>
-			Conclusion
-		</h4>
-		<div>
-			It is really a tradeoff whether to use state parameters or automatic recursion
-			for reentrancy.&nbsp; The strengths of automatic recursion are ease of use and
-			implementation encapsulation.&nbsp; These come at a performance cost on some
-			preprocessors in some situations.&nbsp; The primary strength of state
-			parameters, on the other hand, is efficiency.&nbsp; Use of the state parameters
-			is the only way to achieve <i>maximum</i> efficiency.&nbsp; This efficiency
-			comes at the cost of both code complexity and exposition of implementation.
-		</div>
-		<h4>
-			See Also
-		</h4>
-		<ul>
-			<li><a href="../ref/for.html">BOOST_PP_FOR</a></li>
-			<li><a href="../ref/repeat.html">BOOST_PP_REPEAT</a></li>
-			<li><a href="../ref/while.html">BOOST_PP_WHILE</a></li>
-		</ul>
-		<div class="sig">
-			- Paul Mensonides
-		</div>
-	<hr size="1">
-	<div style="margin-left: 0px;">
-		<i>� Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
-		</br><i>� Copyright Paul Mensonides 2002</i>
-	</div>
-	<div style="margin-left: 0px;">
-		<p><small>Distributed under the Boost Software License, Version 1.0. (See
-		accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
-		copy at <a href=
-		"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
-	</div>
-	</body>
-</html>

data/ext/enterprise_script_service/msgpack/external/boost/preprocessor/doc/topics/techniques.html DELETED

@@ -1,350 +0,0 @@
-<html>
-<head>
-	<title>techniques.html</title>
-	<link rel="stylesheet" type="text/css" href="../styles.css">
-	<style>
-		u { font-weight:  normal; text-decoration:  none; }
-	</style>
-</head>
-<body>
-<h4>Techniques</h4>
-<div>
-	The preprocessor metaprogramming techniques are presented in example format.
-</div>
-<h4>Example<u> - Use a local macro to avoid small scale repetition.</u></h4>
-<div class="code"><pre>
-#define BOOST_PP_DEF(op) /* ..................................... */ \
-   template&lt;class T, int n&gt;                                          \
-   vec&lt;T, n&gt; operator op ## =(vec&lt;T, n&gt; lhs, const vec&lt;T, n&gt;& rhs) { \
-      for (int i = 0; i &lt; n; ++i) {                                  \
-         lhs(i) op ## = rhs(i);                                      \
-      }                                                              \
-   }                                                                 \
-   /**/
-BOOST_PP_DEF(+)
-BOOST_PP_DEF(-)
-BOOST_PP_DEF(*)
-BOOST_PP_DEF(/)
-#undef BOOST_PP_DEF
-</pre></div>
-<div>
-	<b>Tip:</b>&nbsp; It is usually okay to use a standard macro name like <code>BOOST_PP_DEF</code> for this kind of code
-	because the macro is both defined and undefined in the immediate site of its use.
-</div>
-<div>
-	<b>Tip:</b>&nbsp; It is easier to verify proper use of the line continuation operator when they are aligned.
-</div>
-<div>
-	<b>Notes:</b>&nbsp; You can extend this example by defining more and different kinds of operators.&nbsp;
-	Before doing so, consider using the <i>algebraic categories</i> technique introduced in <a href="../bibliography.html#barton">[Barton]</a>
-	or a <i>layered architecture</i> (see for instance <a href="../bibliography.html#czarnecki">[Czarnecki]</a>).&nbsp;
-	However, at some point you must type the operator tokens <code>*</code>, <code>/</code>, <code>+</code>, <code>-</code>, etc.,
-	because it is impossible to generate them using templates.&nbsp;
-	The resulting <i>categorical repetition</i> of tokens can be eliminated by using preprocessor metaprogramming.
-</div>
-<h4>Example<u> - Use BOOST_PP_EMPTY as an unused parameter in local macro instantiations.</u></h4>
-<div class="code"><pre>
-#define BOOST_PP_DEF(cv) /* ... */ \
-   template&lt;class base&gt;            \
-   cv() typename implement_subscript_using_begin_subscript&lt;base&gt;::value_type& \
-   implement_subscript_using_begin_subscript&lt;base&gt;::operator[](index_type i) cv() { \
-      return base::begin()[i];     \
-   }                               \
-   /**/
-   BOOST_PP_DEF(BOOST_PP_EMPTY)
-   BOOST_PP_DEF(BOOST_PP_IDENTITY(const))
-</pre></div>
-<div>
-	<b>How:</b>&nbsp; BOOST_PP_EMPTY() expands to nothing and can be used as an unused parameter.
-</div>
-<div>
-	<b>Note:</b>&nbsp; BOOST_PP_EMPTY with the () never gets expanded.&nbsp;
-	The () is necessary to invoke a function-like macro.
-</div>
-<div>
-	<b>Caveat:</b>&nbsp; You cannot safely use concatenation while using BOOST_PP_EMPTY().
-</div>
-<div>
-	<b>Tip:</b>&nbsp; Occasionally, one or two lines are considerably longer than the rest.&nbsp;
-	It can often save some work to <i>not</i> align all the line continuation operators without making the code too unreadable.
-</div>
-<div>
-	<b>Tip:</b>&nbsp; Use syntax highlighting on preprocessor metaprogramming macro identifiers such as:
-	<ul>
-		<li>BOOST_PP_DEF</li>
-		<li>BOOST_PP_EMPTY</li>
-		<li>BOOST_PP_REPEAT</li>
-		<li>...</li>
-	</ul>
-	It can greatly improve readability.
-</div>
-<h4>Example<u> - Use BOOST_PP_CAT instead of ## when necessary.</u></h4>
-<div class="code"><pre>
-#define STATIC_ASSERT(expr) \
-   enum { BOOST_PP_CAT(static_check_, __LINE__) = (expr) ? 1 : -1 }; \
-   typedef char \
-      BOOST_PP_CAT(static_assert_, __LINE__)[BOOST_PP_CAT(static_check_, __LINE__)] \
-   /**/
-// ...
-STATIC_ASSERT(sizeof(int) &lt;= sizeof(long));
-</pre></div>
-<div>
-	<b>Why:</b>&nbsp; Macro expansion proceeds recursively in "layers."&nbsp;
-	Token pasting prevents the preprocessor from performing macro expansion,
-	therefore it is often necessary to delay token concatenation.
-</div>
-<h4>Example<u> - Use BOOST_PP_STRINGIZE instead of # whenever necessary.</u></h4>
-<div class="code"><pre>
-#define NOTE(str) \
-   message(__FILE__ "(" BOOST_PP_STRINGIZE(__LINE__) ") : " str) \
-   /**/
-// ...
-#pragma NOTE("TBD!")
-</pre></div>
-<div>
-	<b>Why:</b>&nbsp; Macro expansion proceeds recursively in "layers."&nbsp;
-	Stringization prevents the preprocessor from performing macro expansion, therefore it is often necessary to delay stringization.
-</div>
-<h4>Example<u> - Use BOOST_PP_ENUM_PARAMS (and its variants) or BOOST_PP_REPEAT and BOOST_PP_COMMA_IF to avoid <i>O</i>(<i>n</i>) repetition on lists in general.</u></h4>
-<div class="code"><pre>
-struct make_type_list_end;
-template&lt;
-   BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
-      MAKE_TYPE_LIST_MAX_LENGTH,
-      class T,
-      make_type_list_end
-   )
-&gt;
-struct make_type_list {
-   private:
-      enum { end = is_same&lt;T0, make_type_list_end&gt;::value };
-   public:
-      typedef typename type_if&lt;
-         end, type_cons_empty,
-         type_cons&lt;
-            T0,
-            typename type_inner_if&lt;
-               end, type_identity&lt;end&gt;,
-               make_type_list&lt;
-                  BOOST_PP_ENUM_SHIFTED_PARAMS(
-                     MAKE_TYPE_LIST_MAX_LENGTH,
-                     T
-                  )
-               &gt;
-            &gt;::type
-         &gt;
-      &gt;::type type;
-};
-</pre></div>
-<div>
-	<b>How:</b>&nbsp; BOOST_PP_REPEAT uses simulated recursion (pseudo code):
-</div>
-<div><pre>
-#define BOOST_PP_REPEAT(n, m, p) BOOST_PP_REPEAT ## n(m, p)
-#define BOOST_PP_REPEAT0(m, p)
-#define BOOST_PP_REPEAT1(m, p) m(0, p)
-#define BOOST_PP_REPEAT2(m, p) m(0, p) m(1, p)
-#define BOOST_PP_REPEAT3(m, p) BOOST_PP_REPEAT2(m, p) m(2, p)
-#define BOOST_PP_REPEAT4(m, p) BOOST_PP_REPEAT3(m, p) m(3, p)
-// ...
-</pre></div>
-<div>
-	<i>Note:&nbsp; This is no longer how BOOST_PP_REPEAT is implemented, so the code above is illustrative only!&nbsp;</i>
-</div>
-<div>
-	BOOST_PP_ENUM_PARAMS and its variations use BOOST_PP_REPEAT.&nbsp;
-	BOOST_PP_COMMA_IF(I) expands to a comma if I != 0.&nbsp;
-	BOOST_PP_INC(I) essentially expands to "I+1," and BOOST_PP_DEC(I) essentially expands to "I-1.".
-</div>
-<h4>Example<u> - Use a <i>conditional macro definition</i> to enable user configuration of code repetition based on need rather than some "reasonable" upper limit.</u></h4>
-<div class="code"><pre>
-#ifndef MAKE_TYPE_LIST_MAX_LENGTH
-#define MAKE_TYPE_LIST_MAX_LENGTH 8
-#endif
-</pre></div>
-<div>
-	Now the user can configure the <code>make_type_list</code> primitive without modifying library code.
-</div>
-<h4>Example<u> - Use BOOST_PP_REPEAT and a <i>token look-up function</i> to eliminate categorical repetition.</u></h4>
-<div class="code"><pre>
-// CAVEAT:  My compiler is not standard on arithmetic types.
-#define ARITHMETIC_TYPE(I) ARITHMETIC_TYPE ## I
-#define ARITHMETIC_TYPE0    bool
-#define ARITHMETIC_TYPE1    char
-#define ARITHMETIC_TYPE2    signed char
-#define ARITHMETIC_TYPE3    unsigned char
-#define ARITHMETIC_TYPE4    short
-#define ARITHMETIC_TYPE5    unsigned short
-#define ARITHMETIC_TYPE6    int
-#define ARITHMETIC_TYPE7    unsigned int
-#define ARITHMETIC_TYPE8    long
-#define ARITHMETIC_TYPE9    unsigned long
-#define ARITHMETIC_TYPE10   float
-#define ARITHMETIC_TYPE11   double
-#define ARITHMETIC_TYPE12   long double
-#define ARITHMETIC_TYPE_CNT 13
-// ...
-#define BOOST_PP_DEF(z, I, _) /* ... */ \
-   catch (ARITHMETIC_TYPE(I) t) {       \
-      report_typeid(t);                 \
-      report_value(t);                  \
-   }                                    \
-   /**/
-BOOST_PP_REPEAT(ARITHMETIC_TYPE_CNT, BOOST_PP_DEF, _)
-#undef BOOST_PP_DEF
-</pre></div>
-<div>
-	<b>Note:</b>&nbsp; The repetition of the above example can be eliminated using template metaprogramming <a href="../bibliography.html#czarnecki">[Czarnecki]</a> as well.&nbsp;
-	However categorical repetition of operator tokens cannot be completely eliminated by using template metaprogramming.
-</div>
-<h4>Example<u> - Use BOOST_PP_REPEAT to avoid <i>O</i>(<i>n</i>*<i>n</i>) repetition.</u></h4>
-<div class="code"><pre>
-#ifndef MAX_VEC_ARG_CNT
-#define MAX_VEC_ARG_CNT 8
-#endif
-// ...
-#define ARG_FUN(z, i, _) BOOST_PP_COMMA_IF(i) T a ## i
-#define ASSIGN_FUN(z, i, ) (*this)[i] = a ## i;
-#define DEF_VEC_CTOR_FUN(z, i, _) /* ... */ \
-   vec(BOOST_PP_REPEAT(i, ARG_FUN, _)) { \
-      BOOST_PP_REPEAT(i, ASSIGN_FUN, _)  \
-   }                                     \
-   /**/
-BOOST_PP_REPEAT(BOOST_PP_INC(MAX_VEC_ARG_CNT), DEF_VEC_CTOR_FUN, _)
-#undef ARG_FUN
-#undef ASSIGN_FUN
-#undef DEF_VEC_CTOR_FUN
-// ...
-</pre></div>
-<div>
-	<b>How:</b>&nbsp; BOOST_PP_REPEAT is implemented is a special way to enable <i>automatic recursion</i>.
-</div>
-<h4>Example<u> - Use BOOST_PP_IF to implement special case for the first element.</u></h4>
-<div class="code"><pre>
-#define COMMA_IF(c) \
-   BOOST_PP_IF(c, BOOST_PP_COMMA, BOOST_PP_EMPTY)() \
-   /**/
-BOOST_PP_IF(0, true, false) == false;
-BOOST_PP_IF(1, true, false) == true;
-</pre></div>
-<div>
-	BOOST_PP_IF enables convenient generation of lists using BOOST_PP_REPEAT.
-</div>
-<div>
-	<b>Note:</b>&nbsp; <i>THEN</i> and <i>ELSE</i> don't have to be macros.&nbsp;
-	However, if at least one of them is a function-like macro, and you want it be expanded conditionally,
-	you have to make the other parameter a function-like macro too.&nbsp;
-	This can often be done using BOOST_PP_IDENTITY.&nbsp;
-	Consider the following example (by Aleksey Gurtovoy):
-</div>
-<div><pre>
-#define NUMBERED_EXPRESSION(i, x) /* ... */ \
-   BOOST_PP_IF(                             \
-      i,                                    \
-      BOOST_PP_IDENTITY(x ## i)             \
-      BOOST_PP_EMPTY                        \
-   )()                                      \
-   /**/
-</pre></div>
-<div>
-	<b>Note:</b>&nbsp; Like in the above implementation of COMMA_IF, the result of BOOST_PP_IF is often invoked and not the <i>THEN</i> and <i>ELSE</i> parameters.&nbsp;
-	If the parameters were invoked, the code would not expand correctly, because the BOOST_PP_EMPTY parameter would get expanded
-	to nothing before the <b>BOOST_PP_IF</b> would be properly expanded.
-</div>
-<div>
-	<b>How:</b>&nbsp; BOOST_PP_IF is defined for the entire repeat range (psuedo code):
-</div>
-<div><pre>
-#define BOOST_PP_IF(c, THEN, ELSE) BOOST_PP_IF ## c(THEN, ELSE)
-#define BOOST_PP_IF0(THEN, ELSE) ELSE
-#define BOOST_PP_IF1(THEN, ELSE) THEN
-#define BOOST_PP_IF1(THEN, ELSE) THEN
-// ...
-</pre></div>
-<h4>Example:<u>&nbsp; Use arithmetic, logical, and comparison operations when necessary.</u></h4>
-<div class="code"><pre>
-#define SPECIAL_NUMBERED_LIST(n, i, elem, special) \
-   BOOST_PP_ASSERT_MSG(                     \
-      BOOST_PP_LESS(i, n),                  \
-      bad params for SPECIAL_NUMBERED_LIST! \
-   )                                        \
-   BOOST_PP_ENUM_PARAMS(i, elem)            \
-   BOOST_PP_COMMA_IF(i) special             \
-   BOOST_PP_REPEAT(                         \
-      BOOST_PP_SUB(BOOST_PP_DEC(n), i),     \
-      SPECIAL_NUMBERED_LIST_HELPER,         \
-      (elem, i)                             \
-   )                                        \
-   /**/
-#define SPECIAL_NUMBERED_LIST_HELPER(z, i, elem_base) \
-   ,                                          \
-   BOOST_PP_CAT(                              \
-      BOOST_PP_TUPLE_ELEM(2, 0, elem_base),   \
-      BOOST_PP_ADD(                           \
-         i,                                   \
-         BOOST_PP_TUPLE_ELEM(2, 1, elem_base) \
-      )                                       \
-   )                                          \
-   /**/
-SPECIAL_NUMBERED_LIST(3, 0, E, S)
-SPECIAL_NUMBERED_LIST(3, 1, E, S)
-SPECIAL_NUMBERED_LIST(3, 2, E, S)
-SPECIAL_NUMBERED_LIST(3, 3, E, S)
-</pre></div>
-<hr size="1">
-<div style="margin-left: 0px;">
-	<i>� Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
-</div>
-<div style="margin-left: 0px;">
-Permission to copy, use, modify, sell and distribute this document is granted provided this copyright notice appears in all copies.&nbsp;
-This document is provided "as is" without express or implied warranty and with no claim as to its suitability for any purpose.
-</div>
-	<hr size="1">
-	<div style="margin-left: 0px;">
-		<i>� Copyright <a href="http://www.housemarque.com" target="_top">Housemarque Oy</a> 2002</i>
-		</br><i>� Copyright Paul Mensonides 2002</i>
-	</div>
-	<div style="margin-left: 0px;">
-		<p><small>Distributed under the Boost Software License, Version 1.0. (See
-		accompanying file <a href="../../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
-		copy at <a href=
-		"http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</small></p>
-	</div>
-</body>
-</html>