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

script_core 0.0.5 → 0.0.6

Files changed (1076) hide show

data/ext/enterprise_script_service/msgpack/external/boost/predef/doc/html/predef/to_do.html DELETED Viewed

@@ -1,42 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>To Do</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
-<link rel="home" href="../index.html" title="Predef 1.4.1">
-<link rel="up" href="../index.html" title="Predef 1.4.1">
-<link rel="prev" href="history.html" title="History">
-<link rel="next" href="acknoledgements.html" title="Acknoledgements">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<div class="spirit-nav">
-<a accesskey="p" href="history.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="acknoledgements.html"><img src="../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="predef.to_do"></a><a class="link" href="to_do.html" title="To Do">To Do</a>
-</h2></div></div></div>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-          Improve reference documentation.
-        </li>
-<li class="listitem">
-          Provide BOOST_WORKAROUND style macros for public use.
-        </li>
-</ul></div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2005, 2008-2016 Rene Rivera<br>Copyright &#169; 2015 Charly Chevalier<br>Copyright &#169; 2015 Joel Falcou<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
-      </p>
-</div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="history.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="acknoledgements.html"><img src="../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

data/ext/enterprise_script_service/msgpack/external/boost/predef/doc/html/predef/using_the_predefs.html DELETED Viewed

@@ -1,233 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Using the predefs</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
-<link rel="home" href="../index.html" title="Predef 1.4.1">
-<link rel="up" href="../index.html" title="Predef 1.4.1">
-<link rel="prev" href="introduction.html" title="Introduction">
-<link rel="next" href="adding_new_predefs.html" title="Adding new predefs">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<div class="spirit-nav">
-<a accesskey="p" href="introduction.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="adding_new_predefs.html"><img src="../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="predef.using_the_predefs"></a><a class="link" href="using_the_predefs.html" title="Using the predefs">Using the predefs</a>
-</h2></div></div></div>
-<p>
-      To use the automatically defined predefs one needs to only include the single
-      top-level header:
-    </p>
-<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">predef</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span>
-</pre>
-<p>
-      This defines <span class="bold"><strong>all</strong></span> the version macros known
-      to the library. For each macro it will be defined to either a <span class="emphasis"><em>zero</em></span>
-      valued expression for when the particular item is not detected, and to a <span class="emphasis"><em>positive</em></span>
-      value if it is detected. The predef macros fall onto five categories each with
-      macros of a particular prefix:
-    </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-          <code class="computeroutput"><span class="identifier">BOOST_ARCH_</span></code>for system/CPU
-          architecture one is compiling for.
-        </li>
-<li class="listitem">
-          <code class="computeroutput"><span class="identifier">BOOST_COMP_</span></code> for the compiler
-          one is using.
-        </li>
-<li class="listitem">
-          <code class="computeroutput"><span class="identifier">BOOST_LANG_</span></code> for language
-          standards one is compiling against.
-        </li>
-<li class="listitem">
-          <code class="computeroutput"><span class="identifier">BOOST_LIB_C_</span></code> and <code class="computeroutput"><span class="identifier">BOOST_LIB_STD_</span></code> for the C and C++ standard
-          library in use.
-        </li>
-<li class="listitem">
-          <code class="computeroutput"><span class="identifier">BOOST_OS_</span></code> for the operating
-          system we are compiling to.
-        </li>
-<li class="listitem">
-          <code class="computeroutput"><span class="identifier">BOOST_PLAT_</span></code> for platforms
-          on top of operating system or compilers.
-        </li>
-<li class="listitem">
-          <code class="computeroutput"><span class="identifier">BOOST_ENDIAN_</span></code> for endianness
-          of the os and architecture combination.
-        </li>
-<li class="listitem">
-          <code class="computeroutput"><span class="identifier">BOOST_HW_</span></code> for hardware
-          specific features.
-        </li>
-<li class="listitem">
-          <code class="computeroutput"><span class="identifier">BOOST_HW_SIMD</span></code> for SIMD
-          (Single Instruction Multiple Data) detection.
-        </li>
-</ul></div>
-<div class="note"><table border="0" summary="Note">
-<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../images/note.png"></td>
-<th align="left">Note</th>
-</tr>
-<tr><td align="left" valign="top"><p>
-        The detected definitions are for the configuration one is targeting during
-        the compile. In particular in a cross-compile this means the target system,
-        and not the host system.
-      </p></td></tr>
-</table></div>
-<p>
-      One uses the individual definitions to compare against specific versions by
-      comparing against the <code class="computeroutput"><span class="identifier">BOOST_VERSION_NUMBER</span></code>
-      macro. For example, to make a choice based on the version of the GCC C++ compiler
-      one would:
-    </p>
-<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">predef</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span>
-<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
-<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
-<span class="special">{</span>
-  <span class="keyword">if</span> <span class="special">(</span><span class="identifier">BOOST_COMP_GNUC</span> <span class="special">&gt;=</span> <span class="identifier">BOOST_VERSION_NUMBER</span><span class="special">(</span><span class="number">4</span><span class="special">,</span><span class="number">0</span><span class="special">,</span><span class="number">0</span><span class="special">))</span>
-    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"GCC compiler is at least version 4.0.0"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
-  <span class="keyword">else</span>
-    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"GCC compiler is at older than version 4.0.0, or not a GCC compiler"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
-  <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
-<span class="special">}</span>
-</pre>
-<p>
-      As you might notice above the <code class="computeroutput"><span class="keyword">else</span></code>
-      clause also covers the case where the particular compiler is not detected.
-      But one can make the test also test for the detection. All predef definitions
-      are defined as a zero (0) expression when not detected. Hence one could use
-      the detection with a natural single condition. For example:
-    </p>
-<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">predef</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span>
-<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
-<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
-<span class="special">{</span>
-  <span class="keyword">if</span> <span class="special">(</span><span class="identifier">BOOST_COMP_GNUC</span><span class="special">)</span>
-    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"This is GNU GCC!"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
-  <span class="keyword">else</span>
-    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Not GNU GCC."</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
-  <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
-<span class="special">}</span>
-</pre>
-<p>
-      And since the predef's are preprocessor definitions the same is possible from
-      the preprocessor:
-    </p>
-<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">predef</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span>
-<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
-<span class="preprocessor">#if</span> <span class="identifier">BOOST_COMP_GNUC</span>
-  <span class="preprocessor">#if</span> <span class="identifier">BOOST_COMP_GNUC</span> <span class="special">&gt;=</span> <span class="identifier">BOOST_VERSION_NUMBER</span><span class="special">(</span><span class="number">4</span><span class="special">,</span><span class="number">0</span><span class="special">,</span><span class="number">0</span><span class="special">)</span>
-    <span class="keyword">const</span> <span class="keyword">char</span> <span class="special">*</span> <span class="identifier">the_compiler</span> <span class="special">=</span> <span class="string">"GNU GCC, of at least version 4."</span>
-  <span class="preprocessor">#else</span>
-    <span class="keyword">const</span> <span class="keyword">char</span> <span class="special">*</span> <span class="identifier">the_compiler</span> <span class="special">=</span> <span class="string">"GNU GCC, less than version 4."</span>
-  <span class="preprocessor">#endif</span>
-<span class="preprocessor">#else</span>
-  <span class="keyword">const</span> <span class="keyword">char</span> <span class="special">*</span> <span class="identifier">the_compiler</span> <span class="special">=</span> <span class="string">"Not GNU GCC."</span>
-<span class="preprocessor">#endif</span>
-<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
-<span class="special">{</span>
-  <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">the_compiler</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
-  <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
-<span class="special">}</span>
-</pre>
-<p>
-      In addition, for each version macro defined there is an <code class="computeroutput"><span class="special">*</span><span class="identifier">_AVAILABLE</span></code> macro defined only when the particular
-      aspect is detected. I.e. a definition equivalent to:
-    </p>
-<pre class="programlisting"><span class="preprocessor">#if</span> <span class="identifier">BOOST_PREDEF_ABC</span>
-  <span class="preprocessor">#define</span> <span class="identifier">BOOST_PREDEF_ABC_AVAILABLE</span>
-<span class="preprocessor">#endif</span>
-</pre>
-<p>
-      Also for each aspect there is a macro defined with a descriptive name of what
-      the detection is.
-    </p>
-<h4>
-<a name="predef.using_the_predefs.h0"></a>
-      <span class="phrase"><a name="predef.using_the_predefs.the_emulated_macros"></a></span><a class="link" href="using_the_predefs.html#predef.using_the_predefs.the_emulated_macros">The
-      <code class="computeroutput"><span class="special">*</span><span class="identifier">_EMULATED</span></code>
-      macros</a>
-    </h4>
-<p>
-      Predef definitions are guaranteed to be uniquely detected within one category.
-      But there are contexts under which multiple underlying detections are possible.
-      The well known example of this is detection of GCC and MSVC compilers which
-      are commonly emulated by other compilers by defining the same base macros.
-      To account for this detection headers are allowed to define <code class="computeroutput"><span class="special">*</span><span class="identifier">_EMULATED</span></code> predefs when this situation is
-      detected. The emulated predefs will be set to the version number of the detection
-      instead of the regular predef macro for that detection. For example MSVC will
-      set <code class="computeroutput"><span class="identifier">BOOST_COMP_MSVC_EMULATED</span></code>
-      but not set <code class="computeroutput"><span class="identifier">BOOST_COM_MSVC</span></code>,
-      and it will also set <code class="computeroutput"><span class="identifier">BOOST_COMP_MSVC_AVAILABLE</span></code>.
-    </p>
-<h4>
-<a name="predef.using_the_predefs.h1"></a>
-      <span class="phrase"><a name="predef.using_the_predefs.using_the_boost_version_number_m"></a></span><a class="link" href="using_the_predefs.html#predef.using_the_predefs.using_the_boost_version_number_m">Using the
-      <code class="computeroutput"><span class="identifier">BOOST_VERSION_NUMBER</span></code> macro</a>
-    </h4>
-<p>
-      All the predefs are defined to be a use of the <code class="computeroutput"><span class="identifier">BOOST_VERSION_NUMBER</span></code>
-      macro. The macro takes individual major, minor, and patch value expressions:
-    </p>
-<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">BOOST_VERSION_NUMBER</span><span class="special">(</span> <span class="identifier">major</span><span class="special">,</span> <span class="identifier">minor</span><span class="special">,</span> <span class="identifier">patch</span> <span class="special">)</span> <span class="special">...</span>
-</pre>
-<p>
-      The arguments are:
-    </p>
-<div class="orderedlist"><ol class="orderedlist" type="1">
-<li class="listitem">
-          Major version number, as a constant value expression in the range [0,99].
-        </li>
-<li class="listitem">
-          Minor version number, as a constant value expression in the range [0,99].
-        </li>
-<li class="listitem">
-          Patch-level version number, as a constant value expression in the range
-          [0,99999].
-        </li>
-</ol></div>
-<p>
-      The ranges for each are "enforced" by the use of a modulo ("%"),
-      i.e. truncation, as opposed to a clamp. And hence this means that the limits
-      are enforced only enough to keep from having out-of-range problems. But not
-      enough to prevent other kinds of problems. Like exceeding the range and getting
-      false detections, or non-detections. It is up to the individual predefs to
-      ensure correct usage beyond the range guarantee.
-    </p>
-<p>
-      The values for the arguments can be any preprocessor valid constant value expression.
-      Only constant value arithmetic is used in the definition of the <code class="computeroutput"><span class="identifier">BOOST_VERSION_NUMBER</span></code> macro and in any of
-      the other predef macros. This means that any allowed base is possible, i.e.
-      binary, octal, decimal, and hexadecimal. For example:
-    </p>
-<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">MY_APPLICATION_VERSION_NUMBER</span> <span class="identifier">BOOST_VERSION_NUMBER</span><span class="special">(</span><span class="number">2</span><span class="special">,</span><span class="number">0xA</span><span class="special">,</span><span class="number">015</span><span class="special">)</span>
-</pre>
-<p>
-      Is equivalent to:
-    </p>
-<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">MY_APPLICATION_VERSION_NUMBER</span> <span class="identifier">BOOST_VERSION_NUMBER</span><span class="special">(</span><span class="number">2</span><span class="special">,</span><span class="number">10</span><span class="special">,</span><span class="number">13</span><span class="special">)</span>
-</pre>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2005, 2008-2016 Rene Rivera<br>Copyright &#169; 2015 Charly Chevalier<br>Copyright &#169; 2015 Joel Falcou<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
-      </p>
-</div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="introduction.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="adding_new_predefs.html"><img src="../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

data/ext/enterprise_script_service/msgpack/external/boost/predef/doc/predef.qbk DELETED Viewed

@@ -1,735 +0,0 @@
-[article Predef
-    [quickbook 1.7]
-    [version 1.4.1]
-    [authors [Rivera, Rene]]
-    [copyright 2005, 2008-2016 Rene Rivera]
-    [copyright 2015 Charly Chevalier]
-    [copyright 2015 Joel Falcou]
-    [purpose Identification and specification of predefined macros.]
-    [license
-        Distributed under the Boost Software License, Version 1.0.
-        (See accompanying file LICENSE_1_0.txt or copy at
-        [@http://www.boost.org/LICENSE_1_0.txt])
-    ]
-    [source-mode c++]
-]
-[section Introduction]
-This library defines a set of compiler, architecture, operating system,
-library, and other version numbers from the information it can gather of
-C, C++, Objective C, and Objective C++ predefined macros or those defined
-in generally available headers. The idea for this library grew out of a
-proposal to extend the Boost Config library to provide more, and consistent,
-information than the feature definitions it supports. What follows is
-an edited version of that brief proposal.
-[heading Proposal]
-The idea is to define a set of macros to identify compilers and
-consistently represent their version. This includes:
-* A unique BOOST_VERSION_NUMBER(major,minor,patch) macro to specify version
-  numbers (unfortunately, the name BOOST_VERSION is already taken to designate
-  the version number of boost itself).
-* A compiler identification macro, suitable for use in `#if`/`#elif` directives,
-  for each of the supported compilers. All macros would be defined, regardless
-  of the compiler. The one macro corresponding to the compiler being used would
-  be defined, in terms of BOOST_VERSION_NUMBER, to carry the exact compiler
-  version. All other macros would expand to an expression evaluating to false
-  (for instance, the token 0) to indicate that the corresponding compiler is not
-  present.
-* "Null values" could be set, for all macros, in
-  boost/config/select_compiler.hpp; then, for each compiler the corresponding
-  identification macro would be #undef and re-#defined in the corresponding
-  boost/compiler/(cc).hpp; however in the context of the Boost.Config
-  infrastructure using a "prefix" header (to be introduced) or
-  boost/config/suffix.hpp is a better solution.
-[heading Current Library]
-The current Predef library is now, both an independent library, and expanded
-in scope. It includes detection and definition of architectures, compilers,
-languages, libraries, operating systems, and endianness. The key benefits are:
-* Version numbers that are always defined so that one doesn't have to guard
-  with `#ifdef`.
-* Guard macros that can be used for `#ifdef` checks.
-* All possible definitions are included with the single `#include <boost/predef.h>`
-  so that it's friendly to precompiled header usage.
-* Specific definitions can be included, ex. `#include <boost/predef/os/windows.h>`
-  for single checks.
-* Predefs can be directly used in both preprocessor and compiler expressions
-  for comparison to other similarly defined values.
-* The headers are usable from multiple languages, that support the C preprocessor.
-  In particular C++, C, Objective C, and Objective C++.
-[heading Design choices]
-An important design choice concerns how to represent compiler versions by means
-of a single integer number suitable for use in preprocessing directives. Let's
-do some calculation. The "basic" signed type for preprocessing
-constant-expressions is long in C90 (and C++, as of 2006) and intmax_t in C99.
-The type long shall at least be able to represent the number [^+2 147 483 647].
-This means the most significant digit can only be 0, 1 or 2; and if we want all
-decimal digits to be able to vary between 0 and 9, the largest range we can
-consider is [^\[0, 999 999 999\]]. Distributing evenly, this means 3 decimal
-digits for each version number part.
-So we can:
-# use an uneven distribution or
-# use more bits (a larger type) or
-# use 3/3/3 and have the particular compiler/platform/stdlib deal with setting
-  the numbers within the 3-digit range.
-It appears relatively safe to go for the first option and set it at 2/2/5. That
-covers CodeWarrior and others, which are up to and past 10 for the major number.
-Some compilers use the build number in lieu of the patch one; five digits
-(which is already reached by VC++ 8) seems a reasonable limit even in this case.
-[note A 2/2/6 scheme would allow for bigger patch/build numbers at the cost,
-for instance, of limiting the major version number to 20 (or, with further
-constraints, to 21).]
-It might reassure the reader that this decision is actually encoded in one place
-in the code; the definition of `BOOST_VERSION_NUMBER`.
-[heading Future work]
-Even though the basics of this library are done, there is much work that can be
-done:
-* Right now we limit the detection of libraries to known built-in predefined
-  macros, and to guaranteed to exist system and library headers. It might be
-  interesting to add something like auto-configuration predefs. This way we can
-  add definitions for user specific libraries and features.
-* Along with the above, it might be good to add some user control as to which
-  headers are included with the top-level header. Although in the current
-  form of the library this is less of an issue as one can include the
-  specific headers one needs.
-* Additionally, even if there is no auto-configure style option.. It would be
-  good to add optionally included headers so that user can get consistent
-  version number definitions for libraries they use.
-* Having a consistent set of version number definitions opens the door to
-  improving the user level syntax of libraries that do checks against version
-  numbers. Specifically Boost Config's `BOOST_WORKAROUND` macro would benefit
-  from a more readable syntax. As would the `BOOST_TESTED_AT` detail macro.
-* And obviously there's lots of work to do in reformulating the existing
-  Boost libraries to use the Predef library once it's accepted.
-* And there's the continuing work of adding definitions for present and
-  future compilers, platforms, architectures, languages, and libraries.
-[endsect] [/Introduction]
-[section Using the predefs]
-To use the automatically defined predefs one needs to only include the
-single top-level header:
-``
-  #include <boost/predef.h>
-``
-This defines [*all] the version macros known to the library. For each
-macro it will be defined to either a /zero/ valued expression for when
-the particular item is not detected, and to a /positive/ value if it
-is detected. The predef macros fall onto five categories each with
-macros of a particular prefix:
-* `BOOST_ARCH_`for system/CPU architecture one is compiling for.
-* `BOOST_COMP_` for the compiler one is using.
-* `BOOST_LANG_` for language standards one is compiling against.
-* `BOOST_LIB_C_` and `BOOST_LIB_STD_` for the C and C++ standard library
-  in use.
-* `BOOST_OS_` for the operating system we are compiling to.
-* `BOOST_PLAT_` for platforms on top of operating system or compilers.
-* `BOOST_ENDIAN_` for endianness of the os and architecture combination.
-* `BOOST_HW_` for hardware specific features.
-* `BOOST_HW_SIMD` for SIMD (Single Instruction Multiple Data) detection.
-[note The detected definitions are for the configuration one is targeting
-during the compile. In particular in a cross-compile this means the target
-system, and not the host system.]
-One uses the individual definitions to compare against specific versions
-by comparing against the `BOOST_VERSION_NUMBER` macro. For example, to make
-a choice based on the version of the GCC C++ compiler one would:
-``
-  #include <boost/predef.h>
-  #include <iostream>
-  int main()
-  {
-    if (BOOST_COMP_GNUC >= BOOST_VERSION_NUMBER(4,0,0))
-      std::cout << "GCC compiler is at least version 4.0.0" << std::endl;
-    else
-      std::cout << "GCC compiler is at older than version 4.0.0, or not a GCC compiler" << std::endl;
-    return 0;
-  }
-``
-As you might notice above the `else` clause also covers the case where
-the particular compiler is not detected. But one can make the test
-also test for the detection. All predef definitions are defined
-as a zero (0) expression when not detected. Hence one could use the
-detection with a natural single condition. For example:
-``
-  #include <boost/predef.h>
-  #include <iostream>
-  int main()
-  {
-    if (BOOST_COMP_GNUC)
-      std::cout << "This is GNU GCC!" << std::endl;
-    else
-      std::cout << "Not GNU GCC." << std::endl;
-    return 0;
-  }
-``
-And since the predef's are preprocessor definitions the same is possible
-from the preprocessor:
-``
-  #include <boost/predef.h>
-  #include <iostream>
-  #if BOOST_COMP_GNUC
-    #if BOOST_COMP_GNUC >= BOOST_VERSION_NUMBER(4,0,0)
-      const char * the_compiler = "GNU GCC, of at least version 4."
-    #else
-      const char * the_compiler = "GNU GCC, less than version 4."
-    #endif
-  #else
-    const char * the_compiler = "Not GNU GCC."
-  #endif
-  int main()
-  {
-    std::cout << the_compiler << std::endl;
-    return 0;
-  }
-``
-In addition, for each version macro defined there is an
-`*_AVAILABLE` macro defined only when the particular aspect is
-detected. I.e. a definition equivalent to:
-``
-  #if BOOST_PREDEF_ABC
-    #define BOOST_PREDEF_ABC_AVAILABLE
-  #endif
-``
-Also for each aspect there is a macro defined with a descriptive
-name of what the detection is.
-[heading The `*_EMULATED` macros]
-Predef definitions are guaranteed to be uniquely detected within one category.
-But there are contexts under which multiple underlying detections are possible.
-The well known example of this is detection of GCC and MSVC compilers which are
-commonly emulated by other compilers by defining the same base macros. To
-account for this detection headers are allowed to define `*_EMULATED` predefs
-when this situation is detected. The emulated predefs will be set to the
-version number of the detection instead of the regular predef macro for that
-detection. For example MSVC will set `BOOST_COMP_MSVC_EMULATED` but not set `BOOST_COM_MSVC`, and it will also set `BOOST_COMP_MSVC_AVAILABLE`.
-[heading Using the `BOOST_VERSION_NUMBER` macro]
-All the predefs are defined to be a use of the `BOOST_VERSION_NUMBER` macro.
-The macro takes individual major, minor, and patch value expressions:
-``
-  #define BOOST_VERSION_NUMBER( major, minor, patch ) ...
-``
-The arguments are:
-# Major version number, as a constant value expression in the range [0,99].
-# Minor version number, as a constant value expression in the range [0,99].
-# Patch-level version number, as a constant value expression in the
-  range [0,99999].
-The ranges for each are "enforced" by the use of a modulo ("%"), i.e. truncation,
-as opposed to a clamp. And hence this means that the limits are enforced only
-enough to keep from having out-of-range problems. But not enough to prevent
-other kinds of problems. Like exceeding the range and getting false detections,
-or non-detections. It is up to the individual predefs to ensure correct
-usage beyond the range guarantee.
-The values for the arguments can be any preprocessor valid constant value expression.
-Only constant value arithmetic is used in the definition of the `BOOST_VERSION_NUMBER`
-macro and in any of the other predef macros. This means that any allowed base is
-possible, i.e. binary, octal, decimal, and hexadecimal. For example:
-``
-  #define MY_APPLICATION_VERSION_NUMBER BOOST_VERSION_NUMBER(2,0xA,015)
-``
-Is equivalent to:
-``
-  #define MY_APPLICATION_VERSION_NUMBER BOOST_VERSION_NUMBER(2,10,13)
-``
-[endsect]
-[section Adding new predefs]
-We know that a library like this one will be an eternal work-in-progress. And
-as such we expect, and look forward to, others contributing corrections and
-additions to the predefs. With that in mind we need to keep a consistent way
-of defining the new predefs. Hence all current, and future, predefs follow
-the same structure and requirements.
-[heading Requirements of the header]
-All predefs need to follow a set of requirements:
-* The headers must use the Boost Software License.
-* The predef must, by default, be defined as `BOOST_VERSION_NUMBER_NOT_AVAILABLE`.
-* The predef must be redefined to a non-zero value once detected.
-* The predef must, by default, be defined to `BOOST_VERSION_NUMBER_AVAILABLE`
-  when the predef is detected.
-* If possible, the predef will be defined as the version number detected.
-* The predef must define `*_AVAILABLE` macros as needed.
-* The predef must define a symbolic constant string name macro.
-* The predef must declare itself, after being defined, for the testing
-  system.
-* The predef must guarantee that it is the only one defined as detected
-  per category.
-* But a predef can define `*_EMULATED` macros to indicate that it was
-  previously detected by another header and is being "emulated" by the
-  system. Note that the `*_AVAILABLE` macros must still be defined in this
-  situation.
-And there are some extra guidelines that predef headers should follow:
-* The detection should avoid including extra headers that might otherwise
-  not be included by default.
-* If the detection must include a header, prefer guarding it within the
-  detection if possible.
-* If the detection must include headers unconditionally, and has a choice
-  of headers to include, prefer the ones with the least impact. I.e.
-  include the one with the minimal set of definitions and other
-  dependencies.
-[heading Structure of the header]
-For general consistency it's suggested that new predef headers follow the
-structure below, as current predef headers do. First we have the copyright
-and license statement, followed by the include guard:
-``
-/*
-Copyright Jane Doe YYYY
-Distributed under the Boost Software License, Version 1.0.
-(See accompanying file LICENSE_1_0.txt or copy at
-http://www.boost.org/LICENSE_1_0.txt)
-*/
-#ifndef BOOST_PREDEF_category_tag_H
-#define BOOST_PREDEF_category_tag_H
-``
-If the detection depends on the detection of another predef you should
-include those headers here.
-``
-#include <boost/predef/CATEGORY_TAG/DEPENDENCY.h>
-``
-Depending on how you are defining the predef you will at minimum have
-to include the `version_number.h` header. But you might also want to
-include the `make.h` header for the version number decomposing utility
-macros:
-``
-#include <boost/predef/version_number.h>
-#include <boost/predef/make.h>
-``
-The Predef library uses Quickbook for documentation and for the
-individual predefs to appear in the reference section we add in-code
-documentation followed by the zero-value default definition of the
-predef macro. We strongly recommend this particular placement of the
-documentation and default definition because some development
-environments automatically interpret this and provide in-line help
-for the macro. In particular this works for the popular Eclipse IDE:
-``
-/*`
-[heading `BOOST_category_tag`]
-Documentation about what is detected.
-*/
-#define BOOST_category_tag BOOST_VERSION_NUMBER_NOT_AVAILABLE
-``
-Next is the detection and definition of the particular predef. The
-structure for this is to do a single overall check (`condition_a`) and
-place further version detection inside this. The first action inside
-the overall check is to "`#undef BOOST_category_tag`" which undefines
-the zero-value default. The rest is up to the you how to do the checks
-for defining the version. But at minimum it must
-"`#define BOOST_category_tag BOOST_VERSION_NUMBER_AVAILABLE`" as the fallback
-to minimally indicate that the predef was detected:
-``
-#if (condition_a)
-#   undef BOOST_category_tag
-#   if (condition_b)
-#        define BOOST_category_tag BOOST_VERSION_NUMBER(major,minor,patch)
-#    else
-#        define BOOST_category_tag BOOST_VERSION_NUMBER_AVAILABLE
-#    endif
-#endif
-``
-We also need to provide the `*_AVAILABLE` versions of the predef.
-``
-#if BOOST_category_tag
-#   define BOOST_category_tag_AVAILABLE
-#endif
-``
-And for convenience we also want to provide a `*_NAME` macro:
-``
-#define BOOST_catagory_tag_NAME "Name"
-``
-The testing of the predef macros is automated to generate checks for all
-the defined predefs, whether detected or not. To do this we need to
-declare the predef to the test system. This declaration is empty for
-regular use. And during the test programs they expand out specially
-to create informational output:
-``
-#include <boost/predef/detail/test.h>
-BOOST_PREDEF_DECLARE_TEST(BOOST_category_tag,BOOST_category_tag_NAME)
-``
-And, of course, we last need to close out the include guard:
-``
-#endif
-``
-[heading Adding exclusive predefs]
-For headers of predefs that need to be mutually exclusive in the detection
-we need to add checks and definitions to detect when the predef is
-detected by multiple headers.
-Internally compiler, operating system, and platforms define
-`BOOST_PREDEF_DETAIL_COMP_DETECTED`, `BOOST_PREDEF_DEFAIL_OS_DETECTED`, and
-`BOOST_PREDEF_DETAIL_PLAT_DETECTED` respectively when the predef is first
-detected. This is used to guard against multiple definition of the detection
-in later included headers. In those cases the detection would instead be
-written as:
-``
-#if !BOOST_PREDEF_DETAIL_category_DETECTED && (condition_a)
-#   undef BOOST_category_tag
-#   if (condition_b)
-#        define BOOST_category_tag BOOST_VERSION_NUMBER(major,minor,patch)
-#    else
-#        define BOOST_category_tag BOOST_VERSION_NUMBER(0,0,1)
-#    endif
-#endif
-``
-And we also include a header that defines the `*_DETECTED` macro when we have
-the detection:
-``
-#if BOOST_category_tag
-#   define BOOST_category_tag_AVAILABLE
-#   include <boost/predef/detail/CATEGORY_detected.h>
-#endif
-``
-Everything else about the header is the same as the basic detection header.
-[heading Adding an exclusive but emulated predef]
-Because compilers are frequently emulated by other compilers we both want
-to have exclusive detection of the compiler and also provide information
-that we detected the emulation of the compiler. To accomplish this we define
-a local `*_DETECTION` macro for the compiler detection. And conditionally
-define either the base compiler predef `BOOST_COMP_compiler` or the alternate
-`BOOST_COMP_compiler_EMULATED` predef.
-The initial detection would look like:
-``
-#if (condition_a)
-#   if (condition_b)
-#        define BOOST_COMP_tag_DETECTION BOOST_VERSION_NUMBER(major,minor,patch)
-#    else
-#        define BOOST_COMP_tag_DETECTION BOOST_VERSION_NUMBER_AVAILABLE
-#    endif
-#endif
-``
-And then we can conditionally define the base or emulated predefs:
-``
-#ifdef BOOST_COMP_tag_DETECTION
-#   if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
-#       define BOOST_COMP_tag_EMULATED BOOST_COMP_tag_DETECTION
-#   else
-#       undef BOOST_COMP_tag
-#       define BOOST_COMP_tag BOOST_COMP_tag_DETECTION
-#   endif
-#   define BOOST_category_tag_AVAILABLE
-#   include <boost/predef/detail/comp_detected.h>
-#endif
-``
-[heading Using utility pattern macros]
-By including:
-``
-#include <boost/predef/make.h>
-``
-One will get a set of utility macros to decompose common version
-macros as defined by compilers. For example the EDG compiler
-uses a simple 3-digit version macro (M,N,P). It can be decomposed
-and defined as:
-``
-#define BOOST_CCOMP_EDG BOOST_PREDEF_MAKE_N_N_N(__EDG_VERSION__)
-``
-The decomposition macros are split into three types: decimal
-decomposition, hexadecimal decomposition, and date decomposition.
-They follow the format of using "N" for decimal, "F" for hexadecimal,
-and "Y", "M", "D" for dates.
-[endsect]
-[def __predef_symbol__ Symbol]
-[def __predef_version__ Version]
-[def __predef_detection__ *detection*]
-[section Reference]
-[section `BOOST_ARCH` architecture macros]
-[include ../include/boost/predef/architecture/*.h]
-[include ../include/boost/predef/architecture/x86/*.h]
-[endsect]
-[section `BOOST_COMP` compiler macros]
-[include ../include/boost/predef/compiler/*.h]
-[endsect]
-[section `BOOST_LANG` language standards macros]
-[include ../include/boost/predef/language/*.h]
-[endsect]
-[section `BOOST_LIB` library macros]
-[include ../include/boost/predef/library/c/*.h]
-[include ../include/boost/predef/library/std/*.h]
-[endsect]
-[section `BOOST_OS` operating system macros]
-[include ../include/boost/predef/os/*.h]
-[include ../include/boost/predef/os/bsd/*.h]
-[endsect]
-[section `BOOST_PLAT` platform macros]
-[include ../include/boost/predef/platform/*.h]
-[endsect]
-[section `BOOST_HW` hardware macros]
-[include ../include/boost/predef/hardware/*.h]
-[endsect]
-[section Other macros]
-[include ../include/boost/predef/other/*.h]
-[endsect]
-[section Version definition macros]
-[include ../include/boost/predef/version_number.h]
-[include ../include/boost/predef/make.h]
-[endsect]
-[endsect]
-[section Check Utilities]
-The `predef_check` utility provides a facility for building a
-program that will check a given set of expressions against
-the definitions it detected when it was built.
-[heading [^predef_check] programs]
-Even though there is only one `predef_check` program, there
-are variations for each of the languages that are detected
-by Predef to match the convention for sources files. For all
-of them one invokes with a list of expression arguments. The
-expressions are evaluated within the context of the particular
-[^predef_check] program and if they all are true zero (0) is returned.
-Otherwise the index of the first false expression is returned.
-The expression syntax is simple:
-[teletype]
-``
-predef-definition [ relational-operator version-value ]
-``
-[c++]
-[~predef-definition] can be any of the Predef definitions. For
-example `BOOST_COMP_GCC`.
-[~relational-operator] can be any of: [^>], [^<], [^>=], [^<=],
-[^==] and [^!=].
-[~version-number] can be a full or partial version triplet value.
-If it's a partial version triple it is completed with zeros. That
-is [^x.y] is equivalent to [^x.y.0] and [^x] is equivalent to
-[^x.0.0].
-The [~relations-operator] and [~version-number] can be ommited. In
-which case it is equivalent to:
-[teletype]
-``
-predef-definition > 0.0.0
-``
-[c++]
-[heading Using with Boost.Build]
-You can use the [^predef_check] programs directly from Boost Build
-to configure target requirements. This is useful for controlling
-what gets built as part of your project based on the detailed
-version information available in Predef. The basic use is simple:
-[teletype]
-``
-import path-to-predef-src/tools/check/predef
-    : check require
-    : predef-check predef-require ;
-exe my_windows_program : windows_source.cpp
-    : [ predef-require "BOOST_OS_WINDOWS" ] ;
-``
-[c++]
-That simple use case will skip building the [^my_windows_program]
-unless one is building for Windows. Like the direct [^predef_check]
-you can pass mutiple expressions using relational comparisons.
-For example:
-[teletype]
-``
-import path-to-predef-src/tools/check/predef
-    : check require
-    : predef-check predef-require ;
-lib my_special_lib : source.cpp
-    : [ predef-require "BOOST_OS_WINDOWS != 0" "BOOST_OS_VMS != 0"] ;
-``
-[c++]
-And in that case the [^my_special_lib] is built only when the OS is
-not Windows or VMS. The [^requires] rule is a special case of the
-[^check] rule. And is defined in terms of it:
-[teletype]
-``
-rule require ( expressions + : language ? )
-{
-    return [ check $(expressions) : $(language) : : <build>no ] ;
-}
-``
-[c++]
-The expression can also use explicit "and", "or" logical operators
-to for more complex checks:
-[teletype]
-``
-import path-to-predef-src/tools/check/predef
-    : check require
-    : predef-check predef-require ;
-lib my_special_lib : source.cpp
-    : [ predef-require "BOOST_OS_WINDOWS" or "BOOST_OS_VMS"] ;
-``
-[c++]
-You can use the [^check] rule for more control and to implement
-something other than control of what gets built. The definition
-for the [^check] rule is:
-[teletype]
-``
-rule check ( expressions + : language ? : true-properties * : false-properties * )
-``
-[c++]
-When invoked as a reuirement of a Boost Build target this rule
-will add the [^true-properties] to the target if all the [^expressions]
-evaluate to true. Otherwise the [^false-properties] get added as
-requirements. For example you could use it to enable or disable
-features in your programs:
-[teletype]
-``
-import path-to-predef-src/tools/check/predef
-    : check require
-    : predef-check predef-require ;
-exe my_special_exe : source.cpp
-    : [ predef-check "BOOST_OS_WINDOWS == 0"
-        : : <define>ENABLE_WMF=0
-        : <define>ENABLE_WMF=1 ] ;
-``
-[c++]
-For both [^check] and [^require] the [^language] argument controls
-which variant of the [^predef_check] program is used to check the
-expressions. It defaults to "c++", but can be any of: "c", "cpp",
-"objc", and "objcpp".
-[endsect]
-[include history.qbk]
-[include todo.qbk]
-[section Acknoledgements]
-The comprehensiveness of this library would not be
-possible without the existence of the indispensable
-resource that is the
-[@http://sourceforge.net/p/predef/ Pre-defined C/C++ Compiler Macros]
-Project. It was, and continues to be, the primary source
-of the definitions that make up this library. Thanks
-to Bjorn Reese and all the volunteers that make that
-resource possible.
-This library would be an incoherent mess if it weren't for
-Boost community that provided invaluable feedback for the
-eight years that it took to polish into a useable form.
-In particular I would like to thank: Mathias Gaunard,
-Robert Stewart, Joël Lamotte, Lars Viklund, Nathan Ridge,
-Artyom Beilis, Joshua Boyce, Gottlob Frege, Thomas Heller,
-Edward Diener, Dave Abrahams, Iain Denniston, Dan Price,
-Ioannis Papadopoulos, and Robert Ramey. And thanks to
-Joel Falcou for managing the review of this library.
-[endsect]