RubyGems - script_core - Versions diffs - 0.0.6 → 0.1.0 - Mend

script_core 0.0.6 → 0.1.0

Files changed (2211) hide show

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

@@ -0,0 +1,298 @@
+<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 ADDED

@@ -0,0 +1,350 @@
+<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>