Removing unecessary files

[SVN r26375]
Removed part of the Boost files from the SPIRIT_MINIBOOST branch.
2004-12-01 02:44:55 +00:00 · 2004-11-30 07:52:25 +00:00 · 2004-11-29 15:59:10 +00:00 · 2004-11-29 07:29:20 +00:00
27 changed files with 487 additions and 3275 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,25 +0,0 @@
-#----------------------------------------------------------------------------
-# This file was automatically generated from the original CMakeLists.txt file
-# Add a variable to hold the headers for the library
-set (lib_headers
-    integer.hpp
-    integer_fwd.hpp
-    integer_traits.hpp
-    integer
-)
-
-# Add a library target to the build system
-boost_library_project(
-  integer
-  #  SRCDIRS 
-  TESTDIRS  test
-  HEADERS ${lib_headers}
-  #  DOCDIRS 
-  DESCRIPTION  "The organization of boost integer headers and classes is designed to take advantage of <stdint.h> types from the 1999 C standard without resorting to undefined behavior in terms of the 1998 C++ standard. The header <boost/cstdint.hpp> makes the standard integer types safely available in namespace boost without placing any names in namespace std."
-  MODULARIZED 
-  AUTHORS  "Beman Dawes <bdawes -at- acm.org>"
-           "Daryle Walker <darylew -at- hotmail.com>"
-  #  MAINTAINERS 
-)
-
-
--- a/cstdint.htm
+++ b/cstdint.htm
@ -2,7 +2,7 @@

 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
+<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
 <meta name="ProgId" content="FrontPage.Editor.Document">
 <title>Header boost/cstdint.hpp</title>
 </head>
@ -18,7 +18,7 @@ writing portable code that requires certain integer widths.  All typedef's are i
 header &lt;stdint.h&gt;.&nbsp; The 64-bit types required by the C standard are not
 required in the boost header, and may not be supplied in all implementations,
 because <code>long long</code> is not [yet] included in the C++ standard.</p>
-<p>See <a href="test/cstdint_test.cpp">cstdint_test.cpp</a> for a test program.</p>
+<p>See <a href="cstdint_test.cpp">cstdint_test.cpp</a> for a test program.</p>
 <h2>Exact-width integer types</h2>
 <p>The typedef <code>int#_t</code>, with # replaced by the width, designates a
 signed integer type of exactly # bits; <code>int8_t</code> denotes an 8-bit
@ -69,13 +69,10 @@ representing any value of any signed integer type.</p>
 capable of representing any value of any unsigned integer type.</p>
 <p>These types are required.</p>
 <hr>
-<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->06 Nov 2007<!--webbot bot="Timestamp" endspan i-checksum="15272" -->
+<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->19 Aug 2001<!--webbot bot="Timestamp" endspan i-checksum="14767" -->
 </p>
-<p><EFBFBD> Copyright Beman Dawes 2000</p>
-
-<p>Distributed under the Boost Software License, Version 1.0. See
-<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
+<p>&nbsp;</p>

 </body>

-</html>
+</html>
--- a/test/cstdint_test.cpp
+++ b/test/cstdint_test.cpp
@ -113,24 +113,10 @@ void integral_constant_type_check(T1, T2)
   assert(sizeof(T1) == sizeof(T2));
   assert(t1 == t2);
 #endif
-#if defined(BOOST_HAS_STDINT_H)
-   // native headers are permitted to promote small
-   // unsigned types to type int:
-   if(sizeof(T1) >= sizeof(int))
-   {
-      if(t1 > 0)
-        assert(t2 > 0);
-      else
-        assert(!(t2 > 0));
-   }
-   else if(t1 < 0)
-      assert(!(t2 > 0));
-#else
   if(t1 > 0)
     assert(t2 > 0);
   else
     assert(!(t2 > 0));
-#endif
 }


--- a/doc/integer_mask.html
+++ b/doc/integer_mask.html
@ -8,11 +8,7 @@
 <h1><img src="../../../boost.png" alt="boost.png (6897 bytes)"
 align="middle" width="277" height="86">Integer Bit Mask Templates</h1>

-<p>The class templates in <cite><a
-href="../../../boost/integer/integer_mask.hpp">&lt;boost/integer/integer_mask.hpp&gt;</a></cite>
-provide bit masks for a certain bit position or a contiguous-bit pack of a
-certain size.  The types of the masking constants come from the <a
-href="../integer.htm">integer type selection templates</a> header.</p>
+<p>The class templates in <cite><a href="../../../boost/integer/integer_mask.hpp">&lt;boost/integer/integer_mask.hpp&gt;</a></cite> provide bit masks for a certain bit position or a contiguous-bit pack of a certain size.  The types of the masking constants come from the <a href="../integer.htm">integer type selection templates</a> header.</p>

 <h2><a name="contents">Contents</a></h2>

@ -21,7 +17,6 @@ href="../integer.htm">integer type selection templates</a> header.</p>
 	<li><a href="#synopsis">Synopsis</a></li>
 	<li><a href="#single">Single Bit-Mask Class Template</a></li>
 	<li><a href="#group">Group Bit-Mask Class Template</a></li>
-	<li><a href="#mpl">MPL-Compatible Variants</a></li>
 	<li><a href="#example">Example</a></li>
 	<li><a href="#demo">Demonstration Program</a></li>
 	<li><a href="#rationale">Rationale</a></li>
@ -31,68 +26,39 @@ href="../integer.htm">integer type selection templates</a> header.</p>
 <h2><a name="synopsis">Synopsis</a></h2>

 <blockquote><pre>
-#include &lt;<a href="../../../boost/integer_fwd.hpp">boost/integer_fwd.hpp</a>&gt;  <i>// forwarding header</i>
-#include &lt;<a href="../../../boost/integer.hpp">boost/integer.hpp</a>&gt;      <i>// for boost::int_fast_t</i>
-#include &lt;cstddef&gt;                <i>// for std::size_t</i>
+#include &lt;cstddef&gt;  <i>// for std::size_t</i>

 namespace boost
 {

-// MPL-compatible
-template &lt; int Offset &gt;
-struct integer_hi_mask
-{
-    static  bool const  is_specialized = <em>implementation_supplied</em>;
-    static  int const   bit_offset = Offset;
-
-    typedef <em>implementation_supplied</em>  type;
-    typedef <em>implementation_supplied</em>  value_type;
-    static  value_type const  value = <em>implementation_supplied</em>;
-    // There are other (optional) operations....
-};
-
-template &lt; int Length &gt;
-struct integer_lo_mask
-{
-    static  bool const  is_specialized = <em>implementation_supplied</em>;
-    static  int const   bit_count = Length;
-
-    typedef <em>implementation_supplied</em>  type;
-    typedef <em>implementation_supplied</em>  value_type;
-    static  value_type const  value = <em>implementation_supplied</em>;
-    // There are other (optional) operations....
-};
-
-// single
 template &lt; std::size_t Bit &gt;
-class high_bit_mask_t
+struct high_bit_mask_t
 {
-public:
-    typedef typename integer_hi_mask&lt;Bit&gt;::value_type  least;
-    typedef int_fast_t&lt;least&gt;::fast                     fast;
+    typedef <em>implementation_supplied</em>  least;
+    typedef <em>implementation_supplied</em>   fast;

-    static const least  high_bit = integer_hi_mask&lt;Bit&gt;::value;
-    static const fast   high_bit_fast = high_bit;
+    static const least  high_bit = <em>implementation_defined</em>;
+    static const fast   high_bit_fast = <em>implementation_defined</em>;

    static const std::size_t  bit_position = Bit;

 };

-// group
 template &lt; std::size_t Bits &gt;
-class low_bits_mask_t
+struct low_bits_mask_t
 {
-public:
-    typedef typename integer_lo_mask&lt;Bits&gt;::value_type  least;
-    typedef int_fast_t&lt;least&gt;::fast                      fast;
+    typedef <em>implementation_supplied</em>  least;
+    typedef <em>implementation_supplied</em>   fast;

-    static const least  sig_bits = integer_lo_mask&lt;Bits&gt;::value;
-    static const fast   sig_bits_fast = sig_bits;
+    static const least  sig_bits = <em>implementation_defined</em>;
+    static const fast   sig_bits_fast = <em>implementation_defined</em>;

    static const std::size_t  bit_count = Bits;

 };

+// Specializations for low_bits_mask_t exist for certain bit counts.
+
 }  // namespace boost
 </pre></blockquote>

@ -183,149 +149,16 @@ describes the members of an instantiation of
 	</tr>
 </table>

-<h2><a name="mpl">MPL-Compatible Variants</a></h2>
-
-<p>The single and group bit-mask class templates have several drawbacks:</p>
-
-<ul>
-	<li>You must know the valid bit-lengths in advance.</li>
-	<li>Using an inappropriate parameter value results in a compiler
-	    diagnostic.</li>
-	<li>The type names used are inconsistent with other transformations in
-	    Boost, like in <a href="../../mpl/">MPL</a>.</li>
-	<li>The above two facts make use of the regular bit-mask class templates
-	    incompatible with template meta-programming techniques.</li>
-</ul>
-
-<p>The <code>integer_hi_mask</code> and <code>integer_lo_mask</code> class
-templates provide MPL-compatible alternatives.  These alternatives have the
-form:</p>
-
-<blockquote><pre>
-template&lt; int <var>Size</var> &gt;
-struct <var>name</var>
-{
-    static  bool const  is_specialized = <em>implementation_supplied</em>;
-    static  int const   <var>switch_id</var> = <var>Size</var>;
-
-    typedef <em>implementation_supplied</em>  type;
-    typedef <em>implementation_supplied</em>  value_type;
-    static  value_type const  value = <em>implementation_supplied</em>;
-    // with other operations...
-};
-</pre></blockquote>
-
-<p>Only some of the members are always present.  The presence of other members
-and operations is flagged by the (always-present) <code>is_specialized</code>.</p>
-
-<table border="2" cellpadding="5" align="center">
-	<caption>Permanent Members of the MPL-Compatible Masking Class Template
-	         Types</caption>
-	<tr>
-		<th>Class Template Member</th>
-		<th>Meaning</th>
-	</tr>
-	<tr>
-		<td><code>is_specialized</code></td>
-		<td>Flag indicating when a particular template class instantiation is a
-		    valid meta-function (<code>true</code>) or not (<code>false</code>).</td>
-	</tr>
-	<tr>
-		<td><code><var>switch_id</var></code> (Actual name is template-specific.)</td>
-		<td>The value of the main control parameter, accessible even if the
-			template class instantiation is aliased.</td>
-	</tr>
-</table>
-
-<p>The optional members are based from inheriting from a <a
-href="../../mpl/doc/refmanual/integral-constant.html">MPL-style Integral
-Constant</a> type, but only if <code>is_specialized</code> is <code>true</code>.</p>
-
-<table border="2" cellpadding="5" align="center">
-	<caption>Optional Members of the MPL-Compatible Masking Types</caption>
-	<tr>
-		<th>Class Template Member</th>
-		<th>Meaning</th>
-	</tr>
-	<tr>
-		<td><code>value</code></td>
-		<td>The actual bit mask.</td>
-	</tr>
-	<tr>
-		<td><code>value_type</code></td>
-		<td>The type of the bit mask value.</td>
-	</tr>
-	<tr>
-		<td><code>type</code></td>
-		<td>The Integral Constant</a> implementation type, which should be
-			<code><a href="../../mpl/doc/refmanual/integral-c.html">boost::mpl::
-			integral_c</a>&lt; <var>value_type</var>, <var>value</var>
-			&gt;</code>.</td>
-	</tr>
-</table>
-
-<p>The Integral Constant prototype also adds the following operations:</p>
-
-<table border="2" cellpadding="5" align="center">
-	<caption>Optional Operations of the MPL-Compatible Masking Types</caption>
-	<tr>
-		<th>Operation (with <var>n</var> as a masking type)</th>
-		<th>Meaning</th>
-	</tr>
-	<tr>
-		<td><code>boost::mpl::next&lt; n &gt;::type</code></td>
-		<td><code>boost::mpl::next&lt; n::type &gt;::type</code>, i.e.
-			<code>boost::mpl::integral_c&lt; n::value_type, n::value + 1
-			&gt;</code>.</td>
-	</tr>
-	<tr>
-		<td><code>boost::mpl::prior&lt; n &gt;::type</code></td>
-		<td><code>boost::mpl::prior&lt; n::type &gt;::type</code>, i.e.
-			<code>boost::mpl::integral_c&lt; n::value_type, n::value - 1
-			&gt;</code>.</td>
-	</tr>
-	<tr>
-		<td><code>n::value_type const  c = n();</code></td>
-		<td><var>c</var> is set to <code>n::value</code>.</td>
-	</tr>
-</table>
-
-<p>The specifics for each masking class template are:</p>
-
-<table border="2" cellpadding="5" align="center">
-	<caption>Criteria for the MPL-Compatible Masking Types<br>
-	         (Everything besides the parameter ID is in name-space
-	         <code>boost</code> except where indicated.)</caption>
-	<tr>
-		<th>Class Template</th>
-		<th>Parameter Member ID</th>
-		<th>Classic Equivalent</th>
-		<th>Value Type</th>
-		<th>Value</th>
-		<th>Valid Range</th>
-	</tr>
-	<tr>
-		<td><code>integer_hi_mask</code></td>
-		<td><code>bit_offset</code></td>
-		<td><code>high_bit_mask_t</code></td>
-		<td><code>sized_integral &lt; bit_offset + 1, unsigned &gt;</code></td>
-		<td>2<sup><code>bit_offset</code></sup></td>
-		<td><code>0 &lt;= bit_offset &lt; std::numeric_limits&lt; uintmax_t &gt;::digits</code></td>
-	</tr>
-	<tr>
-		<td><code>integer_lo_mask</code></td>
-		<td><code>bit_count</code></td>
-		<td><code>low_bits_mask_t</code></td>
-		<td><code>sized_integral &lt; bit_count, unsigned &gt;</code></td>
-		<td>2<sup><code>bit_offset</code></sup> - 1</td>
-		<td><code>0 &lt;= bit_count &lt;= std::numeric_limits&lt; uintmax_t &gt;::digits</code></td>
-	</tr>
-</table>
+<p><strong>Implementation Note</strong><br>
+When <code>Bits</code> is the exact size of a built-in unsigned type,
+the implementation has to change to prevent undefined behavior. 
+Therefore, there are specializations of <code>low_bits_mask_t</code> at
+those bit counts.</p>

 <h2><a name="example">Example</a></h2>

 <blockquote><pre>
-#include &lt;<a href="../../../boost/integer/integer_mask.hpp">boost/integer/integer_mask.hpp</a>&gt;
+#include &lt;boost/integer/integer_mask.hpp&gt;

 //...

@ -363,15 +196,16 @@ contaimination of values by the higher, unused bits.</p>
 <h2><a name="credits">Credits</a></h2>

 <p>The author of the Boost bit mask class templates is <a
-href="http://www.boost.org/people/daryle_walker.html">Daryle Walker</a>.</p>
+href="../../../people/daryle_walker.html">Daryle Walker</a>.</p>

 <hr>

-<p>Revised July 29, 2008</p>
+<p>Revised September 23, 2001</p>

-<p>&copy; Copyright Daryle Walker 2001.  Use, modification, and distribution are
-subject to the Boost Software License, Version 1.0.  (See accompanying file <a
-href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
-href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
+<p>&copy; Copyright Daryle Walker 2001.  Permission to copy, use,
+modify, sell and distribute this document is granted provided this
+copyright notice appears in all copies.  This document is provided
+&quot;as is&quot; without express or implied warranty, and with no claim
+as to its suitability for any purpose.</p>
 </body>
 </html>
--- a/doc/static_log2.html
+++ b/doc/static_log2.html
@ -186,7 +186,7 @@ code (and update old code as soon as possible).


 <p>The original version of the Boost binary logarithm class template was
-written by <a href="http://www.boost.org/people/daryle_walker.html">Daryle Walker</a>
+written by <a href="../../../people/daryle_walker.html">Daryle Walker</a>
 and then enhanced by Giovanni Bajo with support for compilers without
 partial template specialization. The current version was suggested,
 together with a reference implementation, by Vesa Karvonen. Gennaro Prota
--- a/doc/static_min_max.html
+++ b/doc/static_min_max.html
@ -106,15 +106,16 @@ class template.</p>
 <h2><a name="credits">Credits</a></h2>

 <p>The author of the Boost compile-time extrema class templates is <a
-href="http://www.boost.org/people/daryle_walker.html">Daryle Walker</a>.</p>
+href="../../../people/daryle_walker.html">Daryle Walker</a>.</p>

 <hr>

 <p>Revised October 12, 2001</p>

-<p>&copy; Copyright Daryle Walker 2001.  Use, modification, and distribution are
-subject to the Boost Software License, Version 1.0.  (See accompanying file <a
-href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
-href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
+<p>&copy; Copyright Daryle Walker 2001.  Permission to copy, use,
+modify, sell and distribute this document is granted provided this
+copyright notice appears in all copies.  This document is provided
+&quot;as is&quot; without express or implied warranty, and with no claim
+as to its suitability for any purpose.</p>
 </body>
 </html>
--- a/include/boost/cstdint.hpp
+++ b/include/boost/cstdint.hpp
@ -1,446 +0,0 @@
-//  boost cstdint.hpp header file  ------------------------------------------//
-
-//  (C) Copyright Beman Dawes 1999. 
-//  (C) Copyright Jens Mauer 2001  
-//  (C) Copyright John Maddock 2001 
-//  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)
-
-//  See http://www.boost.org/libs/integer for documentation.
-
-//  Revision History
-//   31 Oct 01  use BOOST_HAS_LONG_LONG to check for "long long" (Jens M.)
-//   16 Apr 01  check LONGLONG_MAX when looking for "long long" (Jens Maurer)
-//   23 Jan 01  prefer "long" over "int" for int32_t and intmax_t (Jens Maurer)
-//   12 Nov 00  Merged <boost/stdint.h> (Jens Maurer)
-//   23 Sep 00  Added INTXX_C macro support (John Maddock).
-//   22 Sep 00  Better 64-bit support (John Maddock)
-//   29 Jun 00  Reimplement to avoid including stdint.h within namespace boost
-//    8 Aug 99  Initial version (Beman Dawes)
-
-
-#ifndef BOOST_CSTDINT_HPP
-#define BOOST_CSTDINT_HPP
-
-#include <boost/config.hpp>
-
-
-#ifdef BOOST_HAS_STDINT_H
-
-// The following #include is an implementation artifact; not part of interface.
-# ifdef __hpux
-// HP-UX has a vaguely nice <stdint.h> in a non-standard location
-#   include <inttypes.h>
-#   ifdef __STDC_32_MODE__
-      // this is triggered with GCC, because it defines __cplusplus < 199707L
-#     define BOOST_NO_INT64_T
-#   endif 
-# elif defined(__FreeBSD__) || defined(__IBMCPP__) || defined(_AIX)
-#   include <inttypes.h>
-# else
-#   include <stdint.h>
-
-// There is a bug in Cygwin two _C macros
-#   if defined(__STDC_CONSTANT_MACROS) && defined(__CYGWIN__)
-#     undef INTMAX_C
-#     undef UINTMAX_C
-#     define INTMAX_C(c) c##LL
-#     define UINTMAX_C(c) c##ULL
-#   endif
-
-# endif
-
-#ifdef __QNX__
-
-// QNX (Dinkumware stdlib) defines these as non-standard names.
-// Reflect to the standard names.
-
-typedef ::intleast8_t int_least8_t;
-typedef ::intfast8_t int_fast8_t;
-typedef ::uintleast8_t uint_least8_t;
-typedef ::uintfast8_t uint_fast8_t;
-
-typedef ::intleast16_t int_least16_t;
-typedef ::intfast16_t int_fast16_t;
-typedef ::uintleast16_t uint_least16_t;
-typedef ::uintfast16_t uint_fast16_t;
-
-typedef ::intleast32_t int_least32_t;
-typedef ::intfast32_t int_fast32_t;
-typedef ::uintleast32_t uint_least32_t;
-typedef ::uintfast32_t uint_fast32_t;
-
-# ifndef BOOST_NO_INT64_T
-
-typedef ::intleast64_t int_least64_t;
-typedef ::intfast64_t int_fast64_t;
-typedef ::uintleast64_t uint_least64_t;
-typedef ::uintfast64_t uint_fast64_t;
-
-# endif
-
-#endif
-
-namespace boost
-{
-
-  using ::int8_t;             
-  using ::int_least8_t;       
-  using ::int_fast8_t;        
-  using ::uint8_t;            
-  using ::uint_least8_t;      
-  using ::uint_fast8_t;       
-                     
-  using ::int16_t;            
-  using ::int_least16_t;      
-  using ::int_fast16_t;       
-  using ::uint16_t;           
-  using ::uint_least16_t;     
-  using ::uint_fast16_t;      
-                     
-  using ::int32_t;            
-  using ::int_least32_t;      
-  using ::int_fast32_t;       
-  using ::uint32_t;           
-  using ::uint_least32_t;     
-  using ::uint_fast32_t;      
-                     
-# ifndef BOOST_NO_INT64_T
-
-  using ::int64_t;            
-  using ::int_least64_t;      
-  using ::int_fast64_t;       
-  using ::uint64_t;           
-  using ::uint_least64_t;     
-  using ::uint_fast64_t;      
-                     
-# endif
-
-  using ::intmax_t;      
-  using ::uintmax_t;     
-
-} // namespace boost
-
-#elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__)
-// FreeBSD and Tru64 have an <inttypes.h> that contains much of what we need.
-# include <inttypes.h>
-
-namespace boost {
-
-  using ::int8_t;             
-  typedef int8_t int_least8_t;       
-  typedef int8_t int_fast8_t;        
-  using ::uint8_t;            
-  typedef uint8_t uint_least8_t;      
-  typedef uint8_t uint_fast8_t;       
-                     
-  using ::int16_t;            
-  typedef int16_t int_least16_t;      
-  typedef int16_t int_fast16_t;       
-  using ::uint16_t;           
-  typedef uint16_t uint_least16_t;     
-  typedef uint16_t uint_fast16_t;      
-                     
-  using ::int32_t;            
-  typedef int32_t int_least32_t;      
-  typedef int32_t int_fast32_t;       
-  using ::uint32_t;           
-  typedef uint32_t uint_least32_t;     
-  typedef uint32_t uint_fast32_t;      
-         
-# ifndef BOOST_NO_INT64_T          
-
-  using ::int64_t;            
-  typedef int64_t int_least64_t;      
-  typedef int64_t int_fast64_t;       
-  using ::uint64_t;           
-  typedef uint64_t uint_least64_t;     
-  typedef uint64_t uint_fast64_t;      
-
-  typedef int64_t intmax_t;
-  typedef uint64_t uintmax_t;
-
-# else
-
-  typedef int32_t intmax_t;
-  typedef uint32_t uintmax_t;
-
-# endif
-
-} // namespace boost
-
-#else  // BOOST_HAS_STDINT_H
-
-# include <boost/limits.hpp> // implementation artifact; not part of interface
-# include <limits.h>         // needed for limits macros
-
-
-namespace boost
-{
-
-//  These are fairly safe guesses for some 16-bit, and most 32-bit and 64-bit
-//  platforms.  For other systems, they will have to be hand tailored.
-//
-//  Because the fast types are assumed to be the same as the undecorated types,
-//  it may be possible to hand tailor a more efficient implementation.  Such
-//  an optimization may be illusionary; on the Intel x86-family 386 on, for
-//  example, byte arithmetic and load/stores are as fast as "int" sized ones.
-
-//  8-bit types  ------------------------------------------------------------//
-
-# if UCHAR_MAX == 0xff
-     typedef signed char     int8_t;
-     typedef signed char     int_least8_t;
-     typedef signed char     int_fast8_t;
-     typedef unsigned char   uint8_t;
-     typedef unsigned char   uint_least8_t;
-     typedef unsigned char   uint_fast8_t;
-# else
-#    error defaults not correct; you must hand modify boost/cstdint.hpp
-# endif
-
-//  16-bit types  -----------------------------------------------------------//
-
-# if USHRT_MAX == 0xffff
-#  if defined(__crayx1)
-     // The Cray X1 has a 16-bit short, however it is not recommend
-     // for use in performance critical code.
-     typedef short           int16_t;
-     typedef short           int_least16_t;
-     typedef int             int_fast16_t;
-     typedef unsigned short  uint16_t;
-     typedef unsigned short  uint_least16_t;
-     typedef unsigned int    uint_fast16_t;
-#  else
-     typedef short           int16_t;
-     typedef short           int_least16_t;
-     typedef short           int_fast16_t;
-     typedef unsigned short  uint16_t;
-     typedef unsigned short  uint_least16_t;
-     typedef unsigned short  uint_fast16_t;
-#  endif
-# elif (USHRT_MAX == 0xffffffff) && defined(CRAY)
-     // no 16-bit types on Cray:
-     typedef short           int_least16_t;
-     typedef short           int_fast16_t;
-     typedef unsigned short  uint_least16_t;
-     typedef unsigned short  uint_fast16_t;
-# else
-#    error defaults not correct; you must hand modify boost/cstdint.hpp
-# endif
-
-//  32-bit types  -----------------------------------------------------------//
-
-# if ULONG_MAX == 0xffffffff
-     typedef long            int32_t;
-     typedef long            int_least32_t;
-     typedef long            int_fast32_t;
-     typedef unsigned long   uint32_t;
-     typedef unsigned long   uint_least32_t;
-     typedef unsigned long   uint_fast32_t;
-# elif UINT_MAX == 0xffffffff
-     typedef int             int32_t;
-     typedef int             int_least32_t;
-     typedef int             int_fast32_t;
-     typedef unsigned int    uint32_t;
-     typedef unsigned int    uint_least32_t;
-     typedef unsigned int    uint_fast32_t;
-# else
-#    error defaults not correct; you must hand modify boost/cstdint.hpp
-# endif
-
-//  64-bit types + intmax_t and uintmax_t  ----------------------------------//
-
-# if defined(BOOST_HAS_LONG_LONG) && \
-   !defined(BOOST_MSVC) && !defined(__BORLANDC__) && \
-   (!defined(__GLIBCPP__) || defined(_GLIBCPP_USE_LONG_LONG)) && \
-   (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
-#    if defined(__hpux)
-     // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions
-#    elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) || (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) || (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL)
-                                                                 // 2**64 - 1
-#    else
-#       error defaults not correct; you must hand modify boost/cstdint.hpp
-#    endif
-
-     typedef  ::boost::long_long_type            intmax_t;
-     typedef  ::boost::ulong_long_type   uintmax_t;
-     typedef  ::boost::long_long_type            int64_t;
-     typedef  ::boost::long_long_type            int_least64_t;
-     typedef  ::boost::long_long_type            int_fast64_t;
-     typedef  ::boost::ulong_long_type   uint64_t;
-     typedef  ::boost::ulong_long_type   uint_least64_t;
-     typedef  ::boost::ulong_long_type   uint_fast64_t;
-
-# elif ULONG_MAX != 0xffffffff
-
-#    if ULONG_MAX == 18446744073709551615 // 2**64 - 1
-     typedef long                 intmax_t;
-     typedef unsigned long        uintmax_t;
-     typedef long                 int64_t;
-     typedef long                 int_least64_t;
-     typedef long                 int_fast64_t;
-     typedef unsigned long        uint64_t;
-     typedef unsigned long        uint_least64_t;
-     typedef unsigned long        uint_fast64_t;
-#    else
-#       error defaults not correct; you must hand modify boost/cstdint.hpp
-#    endif
-# elif defined(__GNUC__) && defined(BOOST_HAS_LONG_LONG)
-     __extension__ typedef long long            intmax_t;
-     __extension__ typedef unsigned long long   uintmax_t;
-     __extension__ typedef long long            int64_t;
-     __extension__ typedef long long            int_least64_t;
-     __extension__ typedef long long            int_fast64_t;
-     __extension__ typedef unsigned long long   uint64_t;
-     __extension__ typedef unsigned long long   uint_least64_t;
-     __extension__ typedef unsigned long long   uint_fast64_t;
-# elif defined(BOOST_HAS_MS_INT64)
-     //
-     // we have Borland/Intel/Microsoft __int64:
-     //
-     typedef __int64             intmax_t;
-     typedef unsigned __int64    uintmax_t;
-     typedef __int64             int64_t;
-     typedef __int64             int_least64_t;
-     typedef __int64             int_fast64_t;
-     typedef unsigned __int64    uint64_t;
-     typedef unsigned __int64    uint_least64_t;
-     typedef unsigned __int64    uint_fast64_t;
-# else // assume no 64-bit integers
-#  define BOOST_NO_INT64_T
-     typedef int32_t              intmax_t;
-     typedef uint32_t             uintmax_t;
-# endif
-
-} // namespace boost
-
-
-#endif // BOOST_HAS_STDINT_H
-
-#endif // BOOST_CSTDINT_HPP
-
-
-/****************************************************
-
-Macro definition section:
-
-Define various INTXX_C macros only if
-__STDC_CONSTANT_MACROS is defined.
-
-Undefine the macros if __STDC_CONSTANT_MACROS is
-not defined and the macros are (cf <cassert>).
-
-Added 23rd September 2000 (John Maddock).
-Modified 11th September 2001 to be excluded when
-BOOST_HAS_STDINT_H is defined (John Maddock).
-
-******************************************************/
-
-#if defined(__STDC_CONSTANT_MACROS) && !defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && !defined(BOOST_HAS_STDINT_H)
-# define BOOST__STDC_CONSTANT_MACROS_DEFINED
-# if defined(BOOST_HAS_MS_INT64)
-//
-// Borland/Intel/Microsoft compilers have width specific suffixes:
-//
-#  define INT8_C(value)     value##i8
-#  define INT16_C(value)    value##i16
-#  define INT32_C(value)    value##i32
-#  define INT64_C(value)    value##i64
-#  ifdef __BORLANDC__
-    // Borland bug: appending ui8 makes the type a signed char
-#   define UINT8_C(value)    static_cast<unsigned char>(value##u)
-#  else
-#   define UINT8_C(value)    value##ui8
-#  endif
-#  define UINT16_C(value)   value##ui16
-#  define UINT32_C(value)   value##ui32
-#  define UINT64_C(value)   value##ui64
-#  define INTMAX_C(value)   value##i64
-#  define UINTMAX_C(value)  value##ui64
-
-# else
-//  do it the old fashioned way:
-
-//  8-bit types  ------------------------------------------------------------//
-
-#  if UCHAR_MAX == 0xff
-#   define INT8_C(value) static_cast<boost::int8_t>(value)
-#   define UINT8_C(value) static_cast<boost::uint8_t>(value##u)
-#  endif
-
-//  16-bit types  -----------------------------------------------------------//
-
-#  if USHRT_MAX == 0xffff
-#   define INT16_C(value) static_cast<boost::int16_t>(value)
-#   define UINT16_C(value) static_cast<boost::uint16_t>(value##u)
-#  endif
-
-//  32-bit types  -----------------------------------------------------------//
-
-#  if UINT_MAX == 0xffffffff
-#   define INT32_C(value) value
-#   define UINT32_C(value) value##u
-#  elif ULONG_MAX == 0xffffffff
-#   define INT32_C(value) value##L
-#   define UINT32_C(value) value##uL
-#  endif
-
-//  64-bit types + intmax_t and uintmax_t  ----------------------------------//
-
-#  if defined(BOOST_HAS_LONG_LONG) && \
-    (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
-
-#    if defined(__hpux)
-     // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions
-#    elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615U) ||  \
-        (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615U) ||  \
-        (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615U)
-
-#    else
-#       error defaults not correct; you must hand modify boost/cstdint.hpp
-#    endif
-#    define INT64_C(value) value##LL
-#    define UINT64_C(value) value##uLL
-#  elif ULONG_MAX != 0xffffffff
-
-#    if ULONG_MAX == 18446744073709551615 // 2**64 - 1
-#       define INT64_C(value) value##L
-#       define UINT64_C(value) value##uL
-#    else
-#       error defaults not correct; you must hand modify boost/cstdint.hpp
-#    endif
-#  endif
-
-#  ifdef BOOST_NO_INT64_T
-#   define INTMAX_C(value) INT32_C(value)
-#   define UINTMAX_C(value) UINT32_C(value)
-#  else
-#   define INTMAX_C(value) INT64_C(value)
-#   define UINTMAX_C(value) UINT64_C(value)
-#  endif
-
-# endif // Borland/Microsoft specific width suffixes
-
-
-#elif defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && !defined(__STDC_CONSTANT_MACROS) && !defined(BOOST_HAS_STDINT_H)
-//
-// undef all the macros:
-//
-# undef INT8_C
-# undef INT16_C
-# undef INT32_C
-# undef INT64_C
-# undef UINT8_C
-# undef UINT16_C
-# undef UINT32_C
-# undef UINT64_C
-# undef INTMAX_C
-# undef UINTMAX_C
-
-#endif // __STDC_CONSTANT_MACROS_DEFINED etc.
-
-
-
-
--- a/include/boost/detail/extended_integer.hpp
+++ b/include/boost/detail/extended_integer.hpp
@ -1,177 +0,0 @@
-// Boost detail/extended_integer.hpp header file  ----------------------------//
-
-// (C) Copyright Daryle Walker 2008.  Distributed under the Boost Software
-// License, Version 1.0.  (See the accompanying file LICENSE_1_0.txt or a copy
-// at <http://www.boost.org/LICENSE_1_0.txt>.)
-
-// Encapsulates the double-long and __int64 type families as a single family,
-// as they are mutually exclusive.
-
-/** \file
-    \brief  Common definition of extended integer types.
-
-    Instead of other Boost headers making separate \#defines for the double-long
-    and __int64 type families, since they're mutually exclusive, make a single
-    set of types and macros for the family that exists (if either).
- */
-
-#ifndef BOOST_DETAIL_EXTENDED_INTEGER_HPP
-#define BOOST_DETAIL_EXTENDED_INTEGER_HPP
-
-#include <boost/config.hpp>  // for BOOST_HAS_LONG_LONG and BOOST_HAS_MS_INT64
-
-#include <climits>  // for CHAR_BIT, etc.
-
-
-namespace boost
-{
-namespace detail
-{
-
-
-//  Extended integer type macro and alias definitions  -----------------------//
-
-// (Unsigned) long long family
-#ifdef BOOST_HAS_LONG_LONG
-
-// Existence
-#define BOOST_HAS_XINT  1
-
-// Extents
-#ifdef ULLONG_MAX
-#define BOOST_XINT_MAX    LLONG_MAX
-#define BOOST_XINT_MIN    LLONG_MIN
-#define BOOST_UXINT_MAX  ULLONG_MAX
-#elif defined(ULONG_LONG_MAX)
-#define BOOST_XINT_MAX    LONG_LONG_MAX
-#define BOOST_XINT_MIN    LONG_LONG_MIN
-#define BOOST_UXINT_MAX  ULONG_LONG_MAX
-#elif defined(ULONGLONG_MAX)
-#define BOOST_XINT_MAX    LONGLONG_MAX
-#define BOOST_XINT_MIN    LONGLONG_MIN
-#define BOOST_UXINT_MAX  ULONGLONG_MAX
-#elif defined(_LLONG_MAX) && defined(_C2)
-#define BOOST_XINT_MAX    _LLONG_MAX
-#define BOOST_XINT_MIN    (-_LLONG_MAX - _C2)
-#define BOOST_UXINT_MAX  _ULLONG_MAX
-#else  // guess
-// Sometimes we get the double-long types without the corresponding constants,
-// e.g. GCC in "-ansi" mode.  In this case, we'll just have to work out the
-// values ourselves.  (Here we assume a two's complement representation.)
-#define BOOST_XINT_MIN   (1LL << (sizeof(::boost::long_long_type) * CHAR_BIT - 1))
-#define BOOST_XINT_MAX   (~ BOOST_XINT_MIN)
-#define BOOST_UXINT_MAX  (~ 0uLL)
-#endif
-
-// Types
-typedef ::boost:: long_long_type   xint_t;
-typedef ::boost::ulong_long_type  uxint_t;
-
-// (Unsigned) __int64 family
-#elif defined(BOOST_HAS_MS_INT64)
-
-// Existence
-#define BOOST_HAS_XINT  1
-
-// Extents
-#ifdef _UI64_MAX
-#define BOOST_XINT_MAX    _I64_MAX
-#define BOOST_XINT_MIN    _I64_MIN
-#define BOOST_UXINT_MAX  _UI64_MAX
-#else  // guess
-// The types are exactly 2's-compl. 64-bit, so we'll enter the values directly.
-#define BOOST_XINT_MAX   0x7FFFFFFFFFFFFFFFi64
-#define BOOST_XINT_MIN   0x8000000000000000i64
-#define BOOST_UXINT_MAX  0xFFFFFFFFFFFFFFFFui64
-#endif
-
-// Types
-typedef          __int64   xint_t;
-typedef unsigned __int64  uxint_t;
-
-// Neither
-#else
-
-// Non-existence
-#define BOOST_HAS_XINT  0
-
-// Dummy extents
-#define BOOST_XINT_MAX    LONG_MAX
-#define BOOST_XINT_MIN    LONG_MIN
-#define BOOST_UXINT_MAX  ULONG_MAX
-
-// Dummy types
-typedef   signed long   xint_t;
-typedef unsigned long  uxint_t;
-
-#endif  // defined(BOOST_HAS_LONG_LONG)/defined(BOOST_HAS_MS_INT64)/else
-
-/** \def  BOOST_HAS_XINT
-
-    \brief  Flag for extended integer types.
-
-    Indicates the presence of one of the two common extended integer type
-    families, either (<code>unsigned</code>) <code>long long</code> or
-    (<code>unsigned</code>) <code>__int64</code>.  \c BOOST_HAS_XINT is \c 1 if
-    either type family is defined, and \c 0 if neither is.
- */
-
-/** \def  BOOST_XINT_MAX
-
-    \brief  Maximum value for the signed extended integer type.
-
-    \pre  \c BOOST_HAS_XINT is \c \#defined to be \c 1.
-
-    Macro constant representing the largest value the signed extended integer
-    type supports.  Its composition may be another macro, an expression, or a
-    literal.  Defaulted to \c LONG_MAX if \c BOOST_HAS_XINT is zero.
- */
-/** \def  BOOST_XINT_MIN
-
-    \brief  Minimum value for the signed extended integer type.
-
-    \pre  \c BOOST_HAS_XINT is \c \#defined to be \c 1.
-
-    Macro constant representing the smallest value the signed extended integer
-    type supports.  Its composition may be another macro, an expression, or a
-    literal.  Defaulted to \c LONG_MIN if \c BOOST_HAS_XINT is zero.
- */
-/** \def  BOOST_UXINT_MAX
-
-    \brief  Maximum value for the unsigned extended integer type.
-
-    \pre  \c BOOST_HAS_XINT is \c \#defined to be \c 1.
-
-    Macro constant representing the largest value the unsigned extended integer
-    type supports.  Its composition may be another macro, an expression, or a
-    literal.  Defaulted to \c ULONG_MAX if \c BOOST_HAS_XINT is zero.  (Use
-    \c 0u for the type's minimum value.)
- */
-
-/** \typedef  signed long  boost::detail::xint_t
-
-    \brief  Alias for the signed extended integer type.
-
-    \pre  \c BOOST_HAS_XINT is \c \#defined to be \c 1.
-
-    Alias representing the signed extended integer type, no matter which type
-    family it came from.  Defaulted to <code>signed long</code> if
-    \c BOOST_HAS_XINT is zero.
- */
-/** \typedef  unsigned long  ::boost::detail::uxint_t
-
-    \brief  Alias for the signed extended integer type.
-
-    \pre  \c BOOST_HAS_XINT is \c \#defined to be \c 1.
-
-    Alias representing the unsigned extended integer type, no matter which type
-    family it came from.  Defaulted to <code>unsigned long</code> if
-    \c BOOST_HAS_XINT is zero.
- */
-
-
-}  // namespace detail
-}  // namespace boost
-
-
-#endif  // BOOST_DETAIL_EXTENDED_INTEGER_HPP
--- a/include/boost/integer.hpp
+++ b/include/boost/integer.hpp
@ -1,382 +0,0 @@
-//  boost integer.hpp header file  -------------------------------------------//
-
-//  Copyright Beman Dawes and Daryle Walker 1999.  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)
-
-//  See http://www.boost.org/libs/integer for documentation.
-
-//  Revision History
-//   16 Jul 08  Added MPL-compatible variants of the minimum-size and value-
-//              based integer templates. (Daryle Walker)
-//   15 Jul 08  Added exact-integer templates; added MPL-compatible variant of
-//              processor-optimized integer template. (Daryle Walker)
-//   14 Jul 08  Added extended-integer support. (Daryle Walker)
-//   13 Jul 08  Redid implmentation. (Daryle Walker)
-//   22 Sep 01  Added value-based integer templates. (Daryle Walker)
-//   01 Apr 01  Modified to use new <boost/limits.hpp> header. (John Maddock)
-//   30 Jul 00  Add typename syntax fix (Jens Maurer)
-//   28 Aug 99  Initial version
-
-#ifndef BOOST_INTEGER_HPP
-#define BOOST_INTEGER_HPP
-
-#include <boost/integer_fwd.hpp>  // self include
-
-#include <boost/config.hpp>             // for BOOST_STATIC_CONSTANT, etc.
-#include <boost/cstdint.hpp>            // for boost::uintmax_t, intmax_t
-#include <boost/integer_traits.hpp>     // for boost::integer_traits
-#include <boost/limits.hpp>             // for std::numeric_limits
-#include <boost/utility/enable_if.hpp>  // for boost::enable_if_c
-
-#include <boost/detail/extended_integer.hpp>  // for BOOST_HAS_XINT, etc.
-
-#include <climits>  // for UCHAR_MAX, USHRT_MAX, UINT_MAX, ULONG_MAX, etc.
-
-namespace boost
-{
-
-  //  integer template mapping a type to its processor-optimized analog  -----//
-
-  //  Some types can be handled better by the processor than others.  This
-  //  template metafunction should map various built-in integral types to
-  //  the processor's perferred type for the given type's value range
-  template < typename BaseInt >
-  struct fast_integral
-  {
-      typedef BaseInt  type;
-  };
-
-  // Platform-specific specializations should go here.
-
-  //  fast integers from least integers
-  //  int_fast_t<> works correctly for unsigned too, in spite of the name.
-  template< typename LeastInt >
-  struct int_fast_t { typedef typename fast_integral<LeastInt>::type fast; };
-
-namespace detail
-{
-
-  //  Helper templates  ------------------------------------------------------//
-
-  //  convert integer category to type ; default is empty
-  template< int Rank, typename Signedness > struct  int_least_helper {};
-
-  //  specializatons: 1=(unsigned) __int64/long long, 2=(unsigned) long,
-  //     3=unsigned/int, 4=(unsigned) short, 5=(un)signed char
-  //  no specializations for 0: requests for a type > (unsigned) (long) long are
-  //     in error
-#if BOOST_HAS_XINT
-  template<> struct int_least_helper<1,   signed>  { typedef  xint_t least; };
-  template<> struct int_least_helper<1, unsigned>  { typedef uxint_t least; };
-#endif
-  template<> struct int_least_helper<2, signed> { typedef long least; };
-  template<> struct int_least_helper<2, unsigned>
-   { typedef unsigned long least; };
-  template<> struct int_least_helper<3, signed> { typedef int least; };
-  template<> struct int_least_helper<3, unsigned>
-   { typedef unsigned int least; };
-  template<> struct int_least_helper<4, signed> { typedef short least; };
-  template<> struct int_least_helper<4, unsigned>
-   { typedef unsigned short least; };
-  template<> struct int_least_helper<5, signed> { typedef signed char least; };
-  template<> struct int_least_helper<5, unsigned>
-   { typedef unsigned char least; };
-
-  //  category bounds
-  enum
-  {
-#if BOOST_HAS_XINT
-      lowest_integral_rank  = 1,
-#else
-      lowest_integral_rank  = 2,
-#endif
-      highest_integral_rank = 5
-  };
-
-  //  map a bit count to a category
-  template < int BitsIncludingSign >
-  struct int_rank_helper
-  {
-      BOOST_STATIC_CONSTANT( int, mantissa = BitsIncludingSign - 1 );
-#if BOOST_HAS_XINT
-      BOOST_STATIC_CONSTANT( int, extended_ = (mantissa <= std::numeric_limits<
-       xint_t >::digits) );
-#else
-      BOOST_STATIC_CONSTANT( int, extended_ = 1 );
-#endif
-      BOOST_STATIC_CONSTANT( int, rank = (BitsIncludingSign > 0) * (extended_ +
-       (mantissa <= std::numeric_limits< long >::digits) +
-       (mantissa <= std::numeric_limits< int >::digits) +
-       (mantissa <= std::numeric_limits< short >::digits) +
-       (mantissa <= std::numeric_limits< signed char >::digits)) );
-  };
-
-  template < int Bits >
-  struct uint_rank_helper
-  {
-#if BOOST_HAS_XINT
-      BOOST_STATIC_CONSTANT( int, extended_ = (Bits <= std::numeric_limits<
-       uxint_t >::digits) );
-#else
-      BOOST_STATIC_CONSTANT( int, extended_ = 1 );
-#endif
-      BOOST_STATIC_CONSTANT( int, rank = (Bits >= 0) * (extended_ +
-       (Bits <= std::numeric_limits< unsigned long >::digits) +
-       (Bits <= std::numeric_limits< unsigned int >::digits) +
-       (Bits <= std::numeric_limits< unsigned short >::digits) +
-       (Bits <= std::numeric_limits< unsigned char >::digits)) );
-  };
-
-  template < int BitsIncludingSign >
-  struct int_exact_rank_helper   { BOOST_STATIC_CONSTANT( int, rank = 0 ); };
-  template < int Bits >
-  struct uint_exact_rank_helper  { BOOST_STATIC_CONSTANT( int, rank = 0 ); };
-
-#define BOOST_PRIVATE_INT_EXACT_BUILDER(Type, Rank) \
-  template < > \
-  struct int_exact_rank_helper<std::numeric_limits< Type >::digits + 1> \
-  { BOOST_STATIC_CONSTANT( int, rank = Rank ); }
-#define BOOST_PRIVATE_UINT_EXACT_BUILDER(Type, Rank) \
-  template < > \
-  struct uint_exact_rank_helper<std::numeric_limits< Type >::digits> \
-  { BOOST_STATIC_CONSTANT( int, rank = Rank ); }
-
-#if BOOST_HAS_XINT && (BOOST_UXINT_MAX > ULONG_MAX)
-  BOOST_PRIVATE_INT_EXACT_BUILDER( xint_t, 1 );
-  BOOST_PRIVATE_UINT_EXACT_BUILDER( uxint_t, 1 );
-#endif
-#if ULONG_MAX > UINT_MAX
-  BOOST_PRIVATE_INT_EXACT_BUILDER( long, 2 );
-  BOOST_PRIVATE_UINT_EXACT_BUILDER( unsigned long, 2 );
-#endif
-#if UINT_MAX > USHRT_MAX
-  BOOST_PRIVATE_INT_EXACT_BUILDER( int, 3 );
-  BOOST_PRIVATE_UINT_EXACT_BUILDER( unsigned, 3 );
-#endif
-#if USHRT_MAX > UCHAR_MAX
-  BOOST_PRIVATE_INT_EXACT_BUILDER( short, 4 );
-  BOOST_PRIVATE_UINT_EXACT_BUILDER( unsigned short, 4 );
-#endif
-  BOOST_PRIVATE_INT_EXACT_BUILDER( signed char, 5 );
-  BOOST_PRIVATE_UINT_EXACT_BUILDER( unsigned char, 5 );
-
-#undef BOOST_PRIVATE_INT_EXACT_BUILDER
-#undef BOOST_PRIVATE_UINT_EXACT_BUILDER
-
-  //  map an extreme value to a category
-  template < intmax_t MaxValue >
-  struct int_max_rank_helper
-  {
-#if BOOST_HAS_XINT
-      BOOST_STATIC_CONSTANT( int, extended_ = (MaxValue <=
-       boost::integer_traits< xint_t >::const_max) );
-#else
-      BOOST_STATIC_CONSTANT( int, extended_ = 1 );
-#endif
-      BOOST_STATIC_CONSTANT( int, rank = (MaxValue > 0) * (extended_ +
-       (MaxValue <= boost::integer_traits< long >::const_max) +
-       (MaxValue <= boost::integer_traits< int >::const_max) +
-       (MaxValue <= boost::integer_traits< short >::const_max) +
-       (MaxValue <= boost::integer_traits< signed char >::const_max)) );
-  };
-
-  template < intmax_t MinValue >
-  struct int_min_rank_helper
-  {
-#if BOOST_HAS_XINT
-      BOOST_STATIC_CONSTANT( int, extended_ = (MinValue >=
-       boost::integer_traits< xint_t >::const_min) );
-#else
-      BOOST_STATIC_CONSTANT( int, extended_ = 1 );
-#endif
-      BOOST_STATIC_CONSTANT( int, rank = (MinValue < 0) * (extended_ +
-       (MinValue >= boost::integer_traits< long >::const_min) +
-       (MinValue >= boost::integer_traits< int >::const_min) +
-       (MinValue >= boost::integer_traits< short >::const_min) +
-       (MinValue >= boost::integer_traits< signed char >::const_min)) );
-  };
-
-  template < uintmax_t Value >
-  struct uint_max_rank_helper
-  {
-#if BOOST_HAS_XINT
-      BOOST_STATIC_CONSTANT( int, extended_ = (Value <= boost::integer_traits<
-       uxint_t >::const_max) );
-#else
-      BOOST_STATIC_CONSTANT( int, extended_ = 1 );
-#endif
-      BOOST_STATIC_CONSTANT( int, rank = extended_ +
-       (Value <= boost::integer_traits< unsigned long >::const_max) +
-       (Value <= boost::integer_traits< unsigned int >::const_max) +
-       (Value <= boost::integer_traits< unsigned short >::const_max) +
-       (Value <= boost::integer_traits< unsigned char >::const_max) );
-  };
-
-  //  convert rank to type, Boost.MPL-style
-  template < int Rank, typename Signedness, class Enable = void >
-  struct integral_rank_to_type
-  {
-      BOOST_STATIC_CONSTANT( bool, is_specialized = false );
-      // No "signed" nor "type" here
-  };
-
-  template < int Rank >
-  struct integral_rank_to_type< Rank, signed, typename
-   enable_if_c<(lowest_integral_rank <= Rank) && (Rank <=
-   highest_integral_rank)>::type >
-  {
-      BOOST_STATIC_CONSTANT( bool, is_specialized = true );
-      BOOST_STATIC_CONSTANT( bool, is_signed = true );
-      typedef typename int_least_helper< Rank, signed >::least  type;
-  };
-
-  template < int Rank >
-  struct integral_rank_to_type< Rank, unsigned, typename
-   enable_if_c<(lowest_integral_rank <= Rank) && (Rank <=
-   highest_integral_rank)>::type >
-  {
-      BOOST_STATIC_CONSTANT( bool, is_specialized = true );
-      BOOST_STATIC_CONSTANT( bool, is_signed = false );
-      typedef typename int_least_helper< Rank, unsigned >::least  type;
-  };
-
-} // namespace detail
-
-  //  MPL-compatible integer-mapping class templates  ------------------------//
-
-  //  minimum number of bits
-  template < int Bits, typename Signedness >
-  struct sized_integral
-  {
-      BOOST_STATIC_CONSTANT( bool, is_specialized = false );
-      BOOST_STATIC_CONSTANT( int, bit_count = Bits );
-  };
-
-  template < int BitsIncludingSign >
-  struct sized_integral< BitsIncludingSign, signed >
-      : detail::integral_rank_to_type<
-         detail::int_rank_helper<BitsIncludingSign>::rank, signed >
-  {
-      BOOST_STATIC_CONSTANT( int, bit_count = BitsIncludingSign );
-  };
-
-  template < int Bits >
-  struct sized_integral< Bits, unsigned >
-      : detail::integral_rank_to_type<
-         detail::uint_rank_helper<Bits>::rank, unsigned >
-  {
-      BOOST_STATIC_CONSTANT( int, bit_count = Bits );
-  };
-
-  //  exact number of bits
-  template < int Bits, typename Signedness >
-  struct exact_integral
-  {
-      BOOST_STATIC_CONSTANT( bool, is_specialized = false );
-      BOOST_STATIC_CONSTANT( int, bit_count = Bits );
-  };
-
-  template < int BitsIncludingSign >
-  struct exact_integral< BitsIncludingSign, signed >
-      : detail::integral_rank_to_type<
-         detail::int_exact_rank_helper<BitsIncludingSign>::rank, signed >
-  {
-      BOOST_STATIC_CONSTANT( int, bit_count = BitsIncludingSign );
-  };
-
-  template < int Bits >
-  struct exact_integral< Bits, unsigned >
-      : detail::integral_rank_to_type<
-         detail::uint_exact_rank_helper<Bits>::rank, unsigned >
-  {
-      BOOST_STATIC_CONSTANT( int, bit_count = Bits );
-  };
-
-  //  maximum supported (positive) value, signed
-  template < intmax_t MaxValue >
-  struct maximum_signed_integral
-      : detail::integral_rank_to_type<
-         detail::int_max_rank_helper<MaxValue>::rank, signed >
-  {
-      BOOST_STATIC_CONSTANT( intmax_t, bound = MaxValue );
-  };
-
-  //  minimum supported (negative) value
-  template < intmax_t MinValue >
-  struct minimum_signed_integral
-      : detail::integral_rank_to_type<
-         detail::int_min_rank_helper<MinValue>::rank, signed >
-  {
-      BOOST_STATIC_CONSTANT( intmax_t, bound = MinValue );
-  };
-
-  //  maximum supported (nonnegative) value, unsigned
-  template < uintmax_t Value >
-  struct maximum_unsigned_integral
-      : detail::integral_rank_to_type<
-         detail::uint_max_rank_helper<Value>::rank, unsigned >
-  {
-      BOOST_STATIC_CONSTANT( uintmax_t, bound = Value );
-  };
-
-  //  integer templates specifying number of bits  ---------------------------//
-
-  //  signed
-  template< int Bits >   // minimum bits (including sign) required
-  struct int_t 
-  {
-      typedef typename sized_integral<Bits, signed>::type  least;
-      typedef typename int_fast_t<least>::fast             fast;
-  };
-
-  template< int Bits >   // exact bits (including sign) desired
-  struct int_exact_t
-  {
-      typedef typename exact_integral<Bits, signed>::type  exact;
-  };
-
-  //  unsigned
-  template< int Bits >   // minimum bits required
-  struct uint_t 
-  {
-      typedef typename sized_integral<Bits, unsigned>::type  least;
-      typedef typename int_fast_t<least>::fast               fast;
-      // int_fast_t<> works correctly for unsigned too, in spite of the name.
-  };
-
-  template< int Bits >   // exact bits desired
-  struct uint_exact_t
-  {
-      typedef typename exact_integral<Bits, unsigned>::type  exact;
-  };
-
-  //  integer templates specifying extreme value  ----------------------------//
-
-  //  signed
-  template< intmax_t MaxValue >   // maximum value to require support
-  struct int_max_value_t 
-  {
-      typedef typename maximum_signed_integral<MaxValue>::type  least;
-      typedef typename int_fast_t<least>::fast                  fast;
-  };
-
-  template< intmax_t MinValue >   // minimum value to require support
-  struct int_min_value_t 
-  {
-      typedef typename minimum_signed_integral<MinValue>::type  least;
-      typedef typename int_fast_t<least>::fast                  fast;
-  };
-
-  //  unsigned
-  template< uintmax_t Value >   // maximum value to require support
-  struct uint_value_t 
-  {
-      typedef typename maximum_unsigned_integral<Value>::type  least;
-      typedef typename int_fast_t<least>::fast                 fast;
-  };
-
-
-} // namespace boost
-
-#endif  // BOOST_INTEGER_HPP
--- a/include/boost/integer/integer_mask.hpp
+++ b/include/boost/integer/integer_mask.hpp
@ -1,204 +0,0 @@
-//  Boost integer/integer_mask.hpp header file  ------------------------------//
-
-//  (C) Copyright Daryle Walker 2001.
-//  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)
-
-//  See http://www.boost.org for updates, documentation, and revision history. 
-
-#ifndef BOOST_INTEGER_INTEGER_MASK_HPP
-#define BOOST_INTEGER_INTEGER_MASK_HPP
-
-#include <boost/integer_fwd.hpp>  // self include
-
-#include <boost/config.hpp>             // for BOOST_STATIC_CONSTANT
-#include <boost/cstdint.hpp>            // for boost::uintmax_t
-#include <boost/integer.hpp>            // for boost::sized_integral
-#include <boost/limits.hpp>             // for std::numeric_limits
-#include <boost/mpl/and.hpp>            // for boost::mpl::and_
-#include <boost/mpl/bitwise.hpp>        // for boost::mpl::bitor_, shift_left
-#include <boost/mpl/bool.hpp>           // for boost::mpl::true_
-#include <boost/mpl/comparison.hpp>     // for boost::mpl::greater_equal, etc.
-#include <boost/mpl/empty_base.hpp>     // for boost::mpl::empty_base
-#include <boost/mpl/if.hpp>             // for boost::mpl::if_
-#include <boost/mpl/int.hpp>            // for boost::mpl::int_
-#include <boost/mpl/integral_c.hpp>     // for boost::integral_c
-#include <boost/mpl/next_prior.hpp>     // for boost::mpl::next, prior
-#include <boost/utility/enable_if.hpp>  // for boost::enable_if
-
-#include <cstddef>  // for std::size_t
-
-
-namespace boost
-{
-namespace detail
-{
-
-//  Helper templates  --------------------------------------------------------//
-
-template < int Bits >
-struct hi_integer_mask_builder1
-{
-    typedef boost::mpl::int_<Bits>  bit_count_type;
-
-    typedef typename boost::mpl::next<bit_count_type>::type
-      mask_length_type;
-    typedef boost::sized_integral<mask_length_type::value, unsigned>
-      mask_type;
-
-    typedef boost::mpl::integral_c<typename mask_type::type, 1>  one_type;
-    typedef boost::mpl::shift_left<one_type, bit_count_type>  result_type;
-};
-
-template < int Bits >
-struct hi_integer_mask_builder2
-{
-    typedef boost::mpl::int_<Bits>  bit_count_type;
-
-    typedef boost::mpl::greater_equal< bit_count_type, boost::mpl::int_<0> >
-      lo_bound_type;
-    typedef boost::mpl::less< bit_count_type,
-     boost::mpl::int_<std::numeric_limits<boost::uintmax_t>::digits> >
-      hi_bound_type;
-    typedef boost::mpl::and_<lo_bound_type, hi_bound_type>  count_valid_type;
-};
-
-template < int Bits, class Enable = void >
-struct hi_integer_mask_builder3
-{
-    BOOST_STATIC_CONSTANT( bool, is_specialized = false );
-};
-
-template < int Bits >
-struct hi_integer_mask_builder3< Bits, typename boost::enable_if<typename
- hi_integer_mask_builder2<Bits>::count_valid_type>::type >
-    : hi_integer_mask_builder1<Bits>::result_type
-{
-    BOOST_STATIC_CONSTANT( bool, is_specialized = true );
-};
-
-template < int Bits >
-struct lo_integer_mask_builder1
-{
-    typedef boost::mpl::int_<Bits>  bit_count_type;
-
-    typedef typename boost::mpl::prior<bit_count_type>::type
-      shift_length_type;
-    typedef boost::sized_integral<bit_count_type::value, unsigned>
-      mask_type;
-
-    typedef boost::mpl::integral_c<typename mask_type::type, 1>  one_type;
-    typedef boost::mpl::shift_left<one_type, shift_length_type>
-      high_bit_type;
-    typedef typename boost::mpl::prior<high_bit_type>::type  low_bits_type;
-    typedef boost::mpl::bitor_<high_bit_type, low_bits_type>  result_type;
-};
-
-template <  >
-struct lo_integer_mask_builder1< 0 >
-{
-    // Let's not deal with negative interim values....
-    typedef boost::mpl::integral_c<unsigned char, 0u>  result_type;
-};
-
-template < int Bits >
-struct lo_integer_mask_builder2
-{
-    typedef boost::mpl::int_<Bits>  bit_count_type;
-
-    typedef boost::mpl::greater_equal< bit_count_type, boost::mpl::int_<0> >
-      lo_bound_type;
-    typedef boost::mpl::less_equal< bit_count_type,
-     boost::mpl::int_<std::numeric_limits<boost::uintmax_t>::digits> >
-      hi_bound_type;
-    typedef boost::mpl::and_<lo_bound_type, hi_bound_type>  count_valid_type;
-};
-
-template <  >
-struct lo_integer_mask_builder2< 0 >
-{
-    typedef boost::mpl::true_  count_valid_type;
-};
-
-template < int Bits, class Enable = void >
-struct lo_integer_mask_builder3
-{
-    BOOST_STATIC_CONSTANT( bool, is_specialized = false );
-    // No MPL Integral Constant to inherit from
-};
-
-template < int Bits >
-struct lo_integer_mask_builder3< Bits, typename enable_if<typename
- lo_integer_mask_builder2<Bits>::count_valid_type>::type >
-    : lo_integer_mask_builder1<Bits>::result_type
-{
-    BOOST_STATIC_CONSTANT( bool, is_specialized = true );
-};
-
-} // namespace detail
-
-
-//  MPL-compatible integer mask class templates  -----------------------------//
-
-// Displaced single-bit mask, 1 << Offset, 0 <= Offset < BitLengthOf(uintmax_t)
-template < int Offset >
-struct integer_hi_mask
-    : detail::hi_integer_mask_builder3<Offset>
-{
-    BOOST_STATIC_CONSTANT( int, bit_offset = Offset );
-};
-
-// Lowest bit-group mask, 2**Length - 1, 0 <= Length <= BitLengthOf(uintmax_t)
-template < int Length >
-struct integer_lo_mask
-    : detail::lo_integer_mask_builder3<Length>
-{
-    BOOST_STATIC_CONSTANT( int, bit_count = Length );
-};
-
-
-//  Specified single-bit mask class declaration  -----------------------------//
-//  (Lowest bit starts counting at 0.)
-
-template < std::size_t Bit >
-class high_bit_mask_t
-{
-    typedef integer_hi_mask<Bit>  impl_type;
-
-public:
-    typedef typename impl_type::value_type   least;
-    typedef typename int_fast_t<least>::fast  fast;
-
-    BOOST_STATIC_CONSTANT( least, high_bit = impl_type::value );
-    BOOST_STATIC_CONSTANT( fast, high_bit_fast = impl_type::value );
-
-    BOOST_STATIC_CONSTANT( std::size_t, bit_position = impl_type::bit_offset );
-
-};  // boost::high_bit_mask_t
-
-
-//  Specified bit-block mask class declaration  ------------------------------//
-//  Makes masks for the lowest N bits
-
-template < std::size_t Bits >
-class low_bits_mask_t
-{
-    typedef integer_lo_mask<Bits>  impl_type;
-
-public:
-    typedef typename impl_type::value_type   least;
-    typedef typename int_fast_t<least>::fast  fast;
-
-    BOOST_STATIC_CONSTANT( least, sig_bits = impl_type::value );
-    BOOST_STATIC_CONSTANT( fast, sig_bits_fast = impl_type::value );
-
-    BOOST_STATIC_CONSTANT( std::size_t, bit_count = impl_type::bit_count );
-
-};  // boost::low_bits_mask_t
-
-
-}  // namespace boost
-
-
-#endif  // BOOST_INTEGER_INTEGER_MASK_HPP
--- a/include/boost/integer/static_log2.hpp
+++ b/include/boost/integer/static_log2.hpp
@ -1,132 +0,0 @@
-// -------------- Boost static_log2.hpp header file  ----------------------- //
-//
-//                 Copyright (C) 2001 Daryle Walker.
-//                 Copyright (C) 2003 Vesa Karvonen.
-//                 Copyright (C) 2003 Gennaro Prota.
-//
-//     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)
-//
-//         ---------------------------------------------------
-//       See http://www.boost.org/libs/integer for documentation.
-// ------------------------------------------------------------------------- //
-
-
-#ifndef BOOST_INTEGER_STATIC_LOG2_HPP
-#define BOOST_INTEGER_STATIC_LOG2_HPP
-
-#include "boost/config.hpp" // for BOOST_STATIC_CONSTANT
-
-namespace boost {
-
- namespace detail {
-
-     namespace static_log2_impl {
-
-     // choose_initial_n<>
-     //
-     // Recursively doubles its integer argument, until it
-     // becomes >= of the "width" (C99, 6.2.6.2p4) of
-     // static_log2_argument_type.
-     //
-     // Used to get the maximum power of two less then the width.
-     //
-     // Example: if on your platform argument_type has 48 value
-     //          bits it yields n=32.
-     //
-     // It's easy to prove that, starting from such a value
-     // of n, the core algorithm works correctly for any width
-     // of static_log2_argument_type and that recursion always
-     // terminates with x = 1 and n = 0 (see the algorithm's
-     // invariant).
-
-     typedef unsigned long argument_type;
-     typedef          int  result_type;
-
-
-     template <result_type n>
-     struct choose_initial_n {
-
-         enum { c = (argument_type(1) << n << n) != 0 };
-         BOOST_STATIC_CONSTANT(
-             result_type,
-             value = !c*n + choose_initial_n<2*c*n>::value
-         );
-
-     };
-
-     template <>
-     struct choose_initial_n<0> {
-         BOOST_STATIC_CONSTANT(result_type, value = 0);
-     };
-
-
-
-     // start computing from n_zero - must be a power of two
-     const result_type n_zero = 16;
-     const result_type initial_n = choose_initial_n<n_zero>::value;
-
-     // static_log2_impl<>
-     //
-     // * Invariant:
-     //                 2n
-     //  1 <= x && x < 2    at the start of each recursion
-     //                     (see also choose_initial_n<>)
-     //
-     // * Type requirements:
-     //
-     //   argument_type maybe any unsigned type with at least n_zero + 1
-     //   value bits. (Note: If larger types will be standardized -e.g.
-     //   unsigned long long- then the argument_type typedef can be
-     //   changed without affecting the rest of the code.)
-     //
-
-     template <argument_type x, result_type n = initial_n>
-     struct static_log2_impl {
-
-         enum { c = (x >> n) > 0 }; // x >= 2**n ?
-         BOOST_STATIC_CONSTANT(
-             result_type,
-             value = c*n + (static_log2_impl< (x>>c*n), n/2 >::value)
-         );
-
-     };
-
-     template <>
-     struct static_log2_impl<1, 0> {
-        BOOST_STATIC_CONSTANT(result_type, value = 0);
-     };
-
-     }
- } // detail
-
-
-
- // --------------------------------------
- // static_log2<x>
- // ----------------------------------------
-
- typedef detail::static_log2_impl::argument_type static_log2_argument_type;
- typedef detail::static_log2_impl::result_type   static_log2_result_type;
-
-
- template <static_log2_argument_type x>
- struct static_log2 {
-
-     BOOST_STATIC_CONSTANT(
-         static_log2_result_type,
-         value = detail::static_log2_impl::static_log2_impl<x>::value
-     );
-
- };
-
-
- template <>
- struct static_log2<0> { };
-
-}
-
-
-
-#endif // include guard
--- a/include/boost/integer/static_min_max.hpp
+++ b/include/boost/integer/static_min_max.hpp
@ -1,55 +0,0 @@
-//  Boost integer/static_min_max.hpp header file  ----------------------------//
-
-//  (C) Copyright Daryle Walker 2001.
-//  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)
-
-//  See http://www.boost.org for updates, documentation, and revision history. 
-
-#ifndef BOOST_INTEGER_STATIC_MIN_MAX_HPP
-#define BOOST_INTEGER_STATIC_MIN_MAX_HPP
-
-#include <boost/integer_fwd.hpp>  // self include
-
-#include <boost/config.hpp>  // for BOOST_STATIC_CONSTANT
-
-
-namespace boost
-{
-
-
-//  Compile-time extrema class declarations  ---------------------------------//
-//  Get the minimum or maximum of two values, signed or unsigned.
-
-template < long Value1, long Value2 >
-struct static_signed_min
-{
-    BOOST_STATIC_CONSTANT( long, value = (Value1 > Value2) ? Value2 : Value1 );
-};
-
-template < long Value1, long Value2 >
-struct static_signed_max
-{
-    BOOST_STATIC_CONSTANT( long, value = (Value1 < Value2) ? Value2 : Value1 );
-};
-
-template < unsigned long Value1, unsigned long Value2 >
-struct static_unsigned_min
-{
-    BOOST_STATIC_CONSTANT( unsigned long, value
-     = (Value1 > Value2) ? Value2 : Value1 );
-};
-
-template < unsigned long Value1, unsigned long Value2 >
-struct static_unsigned_max
-{
-    BOOST_STATIC_CONSTANT( unsigned long, value
-     = (Value1 < Value2) ? Value2 : Value1 );
-};
-
-
-}  // namespace boost
-
-
-#endif  // BOOST_INTEGER_STATIC_MIN_MAX_HPP
--- a/include/boost/integer_fwd.hpp
+++ b/include/boost/integer_fwd.hpp
@ -1,172 +0,0 @@
-//  Boost integer_fwd.hpp header file  ---------------------------------------//
-
-//  (C) Copyright Dave Abrahams and Daryle Walker 2001. 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)
-
-//  See http://www.boost.org/libs/integer for documentation.
-
-#ifndef BOOST_INTEGER_FWD_HPP
-#define BOOST_INTEGER_FWD_HPP
-
-#include <cstddef>  // for std::size_t
-
-#include <boost/config.hpp>   // for BOOST_NO_INTRINSIC_WCHAR_T, etc.
-#include <boost/cstdint.hpp>  // for boost::uintmax_t, intmax_t
-
-#include <boost/detail/extended_integer.hpp>  // for BOOST_HAS_XINT, etc.
-
-
-namespace boost
-{
-
-
-//  From <boost/cstdint.hpp>  ------------------------------------------------//
-
-// Only has typedefs or using statements, with #conditionals
-
-// ALERT: the forward declarations of items in <boost/integer.hpp> need items
-// from this header.  That means that <boost/cstdint.hpp> cannot #include this
-// forwarding header, to avoid infinite recursion!  One day, maybe
-// boost::uintmax_t and boost::intmax_t could be segregated into their own
-// header file (which can't #include this header), <boost/integer.hpp> will use
-// that header, and <boost/cstdint.hpp> could refer to <boost/integer.hpp>.
-
-
-//  From <boost/integer_traits.hpp>  -----------------------------------------//
-
-template < class T >
-    class integer_traits;
-
-template <  >
-    class integer_traits< bool >;
-
-template <  >
-    class integer_traits< char >;
-
-template <  >
-    class integer_traits< signed char >;
-
-template <  >
-    class integer_traits< unsigned char >;
-
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template <  >
-    class integer_traits< wchar_t >;
-#endif
-
-template <  >
-    class integer_traits< short >;
-
-template <  >
-    class integer_traits< unsigned short >;
-
-template <  >
-    class integer_traits< int >;
-
-template <  >
-    class integer_traits< unsigned int >;
-
-template <  >
-    class integer_traits< long >;
-
-template <  >
-    class integer_traits< unsigned long >;
-
-#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && BOOST_HAS_XINT
-template <  >
-    class integer_traits< ::boost::detail::xint_t >;
-
-template <  >
-    class integer_traits< ::boost::detail::uxint_t >;
-#endif
-
-
-//  From <boost/integer.hpp>  ------------------------------------------------//
-
-template < typename BaseInt >
-    struct fast_integral;
-
-template < typename LeastInt >
-    struct int_fast_t;
-
-template < int Bits, typename Signedness >
-    struct sized_integral;
-
-template < int Bits, typename Signedness >
-    struct exact_integral;
-
-template < intmax_t MaxValue >
-    struct maximum_signed_integral;
-
-template < intmax_t MinValue >
-    struct minimum_signed_integral;
-
-template < uintmax_t Value >
-    struct maximum_unsigned_integral;
-
-template< int Bits >
-    struct int_t;
-
-template< int Bits >
-    struct int_exact_t;
-
-template< int Bits >
-    struct uint_t;
-
-template< int Bits >
-    struct uint_exact_t;
-
-template< intmax_t MaxValue >
-    struct int_max_value_t;
-
-template< intmax_t MinValue >
-    struct int_min_value_t;
-
-template< uintmax_t Value >
-    struct uint_value_t;
-
-
-//  From <boost/integer/integer_mask.hpp>  -----------------------------------//
-
-template < int Offset >
-    struct integer_hi_mask;
-
-template < int Length >
-    struct integer_lo_mask;
-
-template < std::size_t Bit >
-    class high_bit_mask_t;
-
-template < std::size_t Bits >
-    class low_bits_mask_t;
-
-
-//  From <boost/integer/static_log2.hpp>  ------------------------------------//
-
-template < unsigned long Value >
-    struct static_log2;
-
-template <  >
-    struct static_log2< 0ul >;
-
-
-//  From <boost/integer/static_min_max.hpp>  ---------------------------------//
-
-template < long Value1, long Value2 >
-    struct static_signed_min;
-
-template < long Value1, long Value2 >
-    struct static_signed_max;
-
-template < unsigned long Value1, unsigned long Value2 >
-    struct static_unsigned_min;
-
-template < unsigned long Value1, unsigned long Value2 >
-    struct static_unsigned_max;
-
-
-}  // namespace boost
-
-
-#endif  // BOOST_INTEGER_FWD_HPP
--- a/include/boost/integer_traits.hpp
+++ b/include/boost/integer_traits.hpp
@ -1,179 +0,0 @@
-/* boost integer_traits.hpp header file
- *
- * Copyright Jens Maurer 2000
- * 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)
- *
- * $Id$
- *
- * Idea by Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers
- */
-
-//  See http://www.boost.org/libs/integer for documentation.
-
-
-#ifndef BOOST_INTEGER_TRAITS_HPP
-#define BOOST_INTEGER_TRAITS_HPP
-
-#include <boost/config.hpp>
-#include <boost/limits.hpp>
-
-// These are an implementation detail and not part of the interface
-#include <limits.h>
-// we need wchar.h for WCHAR_MAX/MIN but not all platforms provide it,
-// and some may have <wchar.h> but not <cwchar> ...
-#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) && (!defined(BOOST_NO_CWCHAR) || defined(sun) || defined(__sun) || defined(__QNX__))
-#include <wchar.h>
-#endif
-
-#include <boost/detail/extended_integer.hpp>  // for BOOST_HAS_XINT, etc.
-
-
-namespace boost {
-template<class T>
-class integer_traits : public std::numeric_limits<T>
-{
-public:
-  BOOST_STATIC_CONSTANT(bool, is_integral = false);
-};
-
-namespace detail {
-template<class T, T min_val, T max_val>
-class integer_traits_base
-{
-public:
-  BOOST_STATIC_CONSTANT(bool, is_integral = true);
-  BOOST_STATIC_CONSTANT(T, const_min = min_val);
-  BOOST_STATIC_CONSTANT(T, const_max = max_val);
-};
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-//  A definition is required even for integral static constants
-template<class T, T min_val, T max_val>
-const bool integer_traits_base<T, min_val, max_val>::is_integral;
-
-template<class T, T min_val, T max_val>
-const T integer_traits_base<T, min_val, max_val>::const_min;
-
-template<class T, T min_val, T max_val>
-const T integer_traits_base<T, min_val, max_val>::const_max;
-#endif
-
-} // namespace detail
-
-template<>
-class integer_traits<bool>
-  : public std::numeric_limits<bool>,
-    public detail::integer_traits_base<bool, false, true>
-{ };
-
-template<>
-class integer_traits<char>
-  : public std::numeric_limits<char>,
-    public detail::integer_traits_base<char, CHAR_MIN, CHAR_MAX>
-{ };
-
-template<>
-class integer_traits<signed char>
-  : public std::numeric_limits<signed char>,
-    public detail::integer_traits_base<signed char, SCHAR_MIN, SCHAR_MAX>
-{ };
-
-template<>
-class integer_traits<unsigned char>
-  : public std::numeric_limits<unsigned char>,
-    public detail::integer_traits_base<unsigned char, 0, UCHAR_MAX>
-{ };
-
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<>
-class integer_traits<wchar_t>
-  : public std::numeric_limits<wchar_t>,
-    // Don't trust WCHAR_MIN and WCHAR_MAX with Mac OS X's native
-    // library: they are wrong!
-#if defined(WCHAR_MIN) && defined(WCHAR_MAX) && !defined(__APPLE__)
-    public detail::integer_traits_base<wchar_t, WCHAR_MIN, WCHAR_MAX>
-#elif defined(__BORLANDC__) || defined(__CYGWIN__) || defined(__MINGW32__) || (defined(__BEOS__) && defined(__GNUC__))
-    // No WCHAR_MIN and WCHAR_MAX, whar_t is short and unsigned:
-    public detail::integer_traits_base<wchar_t, 0, 0xffff>
-#elif (defined(__sgi) && (!defined(__SGI_STL_PORT) || __SGI_STL_PORT < 0x400))\
-    || (defined __APPLE__)\
-    || (defined(__OpenBSD__) && defined(__GNUC__))\
-    || (defined(__NetBSD__) && defined(__GNUC__))\
-    || (defined(__FreeBSD__) && defined(__GNUC__))\
-    || (defined(__DragonFly__) && defined(__GNUC__))\
-    || (defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 3) && !defined(__SGI_STL_PORT))
-    // No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as int.
-    //  - SGI MIPSpro with native library
-    //  - gcc 3.x on HP-UX
-    //  - Mac OS X with native library
-    //  - gcc on FreeBSD, OpenBSD and NetBSD
-    public detail::integer_traits_base<wchar_t, INT_MIN, INT_MAX>
-#elif defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 2) && !defined(__SGI_STL_PORT)
-    // No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as unsigned int.
-    //  - gcc 2.95.x on HP-UX
-    // (also, std::numeric_limits<wchar_t> appears to return the wrong values).
-    public detail::integer_traits_base<wchar_t, 0, UINT_MAX>
-#else
-#error No WCHAR_MIN and WCHAR_MAX present, please adjust integer_traits<> for your compiler.
-#endif
-{ };
-#endif // BOOST_NO_INTRINSIC_WCHAR_T
-
-template<>
-class integer_traits<short>
-  : public std::numeric_limits<short>,
-    public detail::integer_traits_base<short, SHRT_MIN, SHRT_MAX>
-{ };
-
-template<>
-class integer_traits<unsigned short>
-  : public std::numeric_limits<unsigned short>,
-    public detail::integer_traits_base<unsigned short, 0, USHRT_MAX>
-{ };
-
-template<>
-class integer_traits<int>
-  : public std::numeric_limits<int>,
-    public detail::integer_traits_base<int, INT_MIN, INT_MAX>
-{ };
-
-template<>
-class integer_traits<unsigned int>
-  : public std::numeric_limits<unsigned int>,
-    public detail::integer_traits_base<unsigned int, 0, UINT_MAX>
-{ };
-
-template<>
-class integer_traits<long>
-  : public std::numeric_limits<long>,
-    public detail::integer_traits_base<long, LONG_MIN, LONG_MAX>
-{ };
-
-template<>
-class integer_traits<unsigned long>
-  : public std::numeric_limits<unsigned long>,
-    public detail::integer_traits_base<unsigned long, 0, ULONG_MAX>
-{ };
-
-#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && BOOST_HAS_XINT
-template<>
-class integer_traits< detail::xint_t >
-  : public std::numeric_limits< detail::xint_t >,
-    public detail::integer_traits_base< detail::xint_t, BOOST_XINT_MIN, BOOST_XINT_MAX >
-{ };
-
-template<>
-class integer_traits< detail::uxint_t >
-  : public std::numeric_limits< detail::uxint_t >,
-    public detail::integer_traits_base< detail::uxint_t, 0u, BOOST_UXINT_MAX >
-{ };
-#endif
-
-} // namespace boost
-
-#endif /* BOOST_INTEGER_TRAITS_HPP */
-
-
-
--- a/index.html
+++ b/index.html
@ -10,8 +10,8 @@
 		<td bgcolor="white"><img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86"></td>
 		<td><a href="../../index.htm"><font face="Arial" color="white"><big>Home</big></font></a></td>
 		<td><a href="../libraries.htm"><font face="Arial" color="white"><big>Libraries</big></font></a></td>
-		<td><a href="http://www.boost.org/people/people.htm"><font face="Arial" color="white"><big>People</big></font></a></td>
-		<td><a href="http://www.boost.org/more/faq.htm"><font face="Arial" color="white"><big>FAQ</big></font></a></td>
+		<td><a href="../../people/people.htm"><font face="Arial" color="white"><big>People</big></font></a></td>
+		<td><a href="../../more/faq.htm"><font face="Arial" color="white"><big>FAQ</big></font></a></td>
 		<td><a href="../../more/index.htm"><font face="Arial" color="white"><big>More</big></font></a></td>
 	</tr>
 </table>
@ -121,13 +121,8 @@ instead.</p>

 <hr>

-<p>Revised: <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %b %Y" startspan -->06 Nov 2007<!--webbot bot="Timestamp" endspan i-checksum="15272" -->
+<p>Revised: <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %b %Y" startspan -->03 Oct 2001<!--webbot bot="Timestamp" endspan i-checksum="14373" -->
 </p>

-<p><EFBFBD> Copyright Beman Dawes 2003</p>
-
-<p>Distributed under the Boost Software License, Version 1.0. See
-<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
-
 </body>
-</html>
+</html>
--- a/integer.htm
+++ b/integer.htm
@ -21,9 +21,8 @@ is particularly useful for solving generic programming problems.</p>
 <ul>
 	<li><a href="#contents">Contents</a></li>
 	<li><a href="#synopsis">Synopsis</a></li>
-	<li><a href="#easy">Processor-Optimized Types</a></li>
+	<li><a href="#easy">Easiest-to-Manipulate Types</a></li>
 	<li><a href="#sized">Sized Types</a></li>
-	<li><a href="#mpl">MPL-Compatible Variants</a></li>
 	<li><a href="#example">Example</a></li>
 	<li><a href="#demo">Demonstration Program</a></li>
 	<li><a href="#rationale">Rationale</a></li>
@ -33,145 +32,67 @@ is particularly useful for solving generic programming problems.</p>

 <h2><a name="synopsis">Synopsis</a></h2>

-<blockquote><pre>
-#include &lt;<a href="../../boost/integer_fwd.hpp">boost/integer_fwd.hpp</a>&gt;  // forwarding header
-#include &lt;<a href="cstdint.htm">boost/cstdint.hpp</a>&gt;      // for boost::uintmax_t, intmax_t
-
-namespace boost
+<blockquote><pre>namespace boost
 {
  //  fast integers from least integers
-  template&lt; typename BaseInt &gt;
-  struct fast_integral
-  {
-      typedef <em>implementation_supplied</em>  type;
-  };
-
  template&lt; typename LeastInt &gt;
  struct int_fast_t
  {
-      typedef typename fast_integral&lt;LeastInt&gt;::type  fast;
-  };
-
-  //  MPL-compatible
-  template&lt; int Bits, typename Signedness &gt;
-  struct sized_integral
-  {
-      static  bool const  is_specialized = <em>implementation_supplied</em>;
-      static  bool const  is_signed = <em>implementation_supplied</em>;
-      static  int const   bit_count = Bits;
-
-      typedef <em>implementation_supplied</em>  type;
-  };
-
-  template&lt; int Bits, typename Signedness &gt;
-  struct exact_integral
-  {
-      static  bool const  is_specialized = <em>implementation_supplied</em>;
-      static  bool const  is_signed = <em>implementation_supplied</em>;
-      static  int const   bit_count = Bits;
-
-      typedef <em>implementation_supplied</em>  type;
-  };
-
-  template&lt; intmax_t MaxValue &gt;
-  struct maximum_signed_integral
-  {
-      static  bool const      is_specialized = <em>implementation_supplied</em>;
-      static  bool const      is_signed = true;
-      static  intmax_t const  bound = MaxValue;
-
-      typedef <em>implementation_supplied</em>  type;
-  };
-
-  template&lt; intmax_t MinValue &gt;
-  struct minimum_signed_integral
-  {
-      static  bool const      is_specialized = <em>implementation_supplied</em>;
-      static  bool const      is_signed = true;
-      static  intmax_t const  bound = MinValue;
-
-      typedef <em>implementation_supplied</em>  type;
-  };
-
-  template&lt; uintmax_t Value &gt;
-  struct maximum_unsigned_integral
-  {
-      static  bool const       is_specialized = <em>implementation_supplied</em>;
-      static  bool const       is_signed = false;
-      static  uintmax_t const  bound = Value;
-
-      typedef <em>implementation_supplied</em>  type;
+      typedef <em>implementation_supplied</em>  fast;
  };

  //  signed
  template&lt; int Bits &gt;
  struct int_t 
  {
-      typedef typename sized_integral&lt;Bits, signed&gt;::type  least;
-      typedef int_fast_t&lt;least&gt;::fast                      fast;
-  };
-
-  template&lt; int Bits &gt;
-  struct int_exact_t
-  {
-      typedef typename exact_integral&lt;Bits, signed&gt;::type  exact;
+      typedef <em>implementation_supplied</em>  least;
+      typedef int_fast_t&lt;least&gt;::fast  fast;
  };

  //  unsigned
  template&lt; int Bits &gt;
  struct uint_t 
  {
-      typedef typename sized_integral&lt;Bits, unsigned&gt;::type  least;
-      typedef int_fast_t&lt;least&gt;::fast                        fast;
-  };
-
-  template&lt; int Bits &gt;
-  struct uint_exact_t
-  {
-      typedef typename exact_integral&lt;Bits, unsigned&gt;::type  exact;
+      typedef <em>implementation_supplied</em>  least;
+      typedef int_fast_t&lt;least&gt;::fast  fast;
  };

  //  signed
-  template&lt; intmax_t MaxValue &gt;
+  template&lt; long MaxValue &gt;
  struct int_max_value_t 
  {
-      typedef typename maximum_signed_integral&lt;MaxValue&gt;::type  least;
-      typedef int_fast_t&lt;least&gt;::fast                           fast;
+      typedef <em>implementation_supplied</em>  least;
+      typedef int_fast_t&lt;least&gt;::fast  fast;
  };

-  template&lt; intmax_t MinValue &gt;
+  template&lt; long MinValue &gt;
  struct int_min_value_t 
  {
-      typedef typename minimum_signed_integral&lt;MinValue&gt;::type  least;
-      typedef int_fast_t&lt;least&gt;::fast                           fast;
+      typedef <em>implementation_supplied</em>  least;
+      typedef int_fast_t&lt;least&gt;::fast  fast;
  };

  //  unsigned
-  template&lt; uintmax_t Value &gt;
+  template&lt; unsigned long Value &gt;
  struct uint_value_t 
  {
-      typedef typename maximum_unsigned_integral&lt;Value&gt;::type  least;
-      typedef int_fast_t&lt;least&gt;::fast                          fast;
+      typedef <em>implementation_supplied</em>  least;
+      typedef int_fast_t&lt;least&gt;::fast  fast;
  };
 } // namespace boost
 </pre></blockquote>

-<h2><a name="easy">Processor-Optimized Types</a></h2>
+<h2><a name="easy">Easiest-to-Manipulate Types</a></h2>

-<p>The <code>fast_integral</code> class template maps its input type to the
+<p>The <code>int_fast_t</code> class template maps its input type to the
 next-largest type that the processor can manipulate the easiest, or to
 itself if the input type is already an easy-to-manipulate type.  For
 instance, processing a bunch of <code>char</code> objects may go faster
 if they were converted to <code>int</code> objects before processing. 
-The input type, passed as the only template parameter, can be any built-in
-integral type besides <code>bool</code>.  The output type is given as the class
-member <code>type</code>.</p>
-
-<p>The <code>int_fast_t</code> class template is the classic meta-function for
-this operation.  Despite the name, it works for unsigned integral types just
-like it works for the signed integral types.  The output type is given as the
-class member <code>fast</code>, defined to be the same as the corresponding
-result from the <code>fast_integral</code> meta-function.</p>
+The input type, passed as the only template parameter, must be a
+built-in integral type, except <code>bool</code>.  Unsigned integral
+types can be used, as well as signed integral types, despite the name. 
+The output type is given as the class member <code>fast</code>.</p>

 <p><strong>Implementation Notes</strong><br>
 By default, the output type is identical to the input type.  Eventually,
@ -183,286 +104,72 @@ type.</p>

 <h2><a name="sized">Sized Types</a></h2>

-<p>The <code>int_t</code>, <code>int_exact_t</code>, <code>uint_t</code>,
-<code>uint_exact_t</code>, <code>int_max_value_t</code>,
-<code>int_min_value_t</code>, and <code>uint_value_t</code> class templates find
-the most appropriate built-in integral type for the given template parameter.
-This type is given by the class member <code>least</code> or <code>exact</code>.
-For the non-exact class templates, the easiest-to-manipulate version of that
-type is given by the class member <code>fast</code>.  The following table
-describes each template's criteria.</p>
+<p>The <code>int_t</code>, <code>uint_t</code>,
+<code>int_max_value_t</code>, <code>int_min_value_t</code>, and
+<code>uint_value_t</code> class templates find the most appropiate
+built-in integral type for the given template parameter.  This type is
+given by the class member <code>least</code>.  The easiest-to-manipulate
+version of that type is given by the class member <code>fast</code>. 
+The following table describes each template's criteria.</p>

-<table border="2" cellpadding="5">
+<table border="1" cellpadding="5">
 	<caption>Criteria for the Sized Type Class Templates</caption>
 	<tr>
-		<th>Class Template (all in name-space <code>boost</code>)</th>
+		<th>Class Template</th>
 		<th>Template Parameter Mapping</th>
 	</tr>
 	<tr>
-		<td><code>int_t</code></td>
+		<td><code>boost::int_t</code></td>
 		<td>The smallest built-in signed integral type with at least the
 			given number of bits, including the sign bit.  The parameter
-			<em>must</em> be a positive number.  A compile-time error results if
+			should be a positive number.  A compile-time error results if
 			the parameter is larger than the number of bits in a
-			<code>boost::intmax_t</code>.</td>
+			<code>long</code>.</td>
 	</tr>
 	<tr>
-		<td><code>int_exact_t</code></td>
-		<td>The smallest built-in signed integral type with exactly the
-			given number of bits, including the sign bit.  A compile-time error
-			results if no qualifying type exists.</td>
-	</tr>
-	<tr>
-		<td><code>uint_t</code></td>
+		<td><code>boost::uint_t</code></td>
 		<td>The smallest built-in unsigned integral type with at least
-			the given number of bits.  The parameter <em>must</em> be a
-			non-negative number.  A compile-time error results if the parameter
-			is larger than the number of bits in a
-			<code>boost::uintmax_t</code>.</td>
+			the given number of bits.  The parameter should be a positive
+			number.  A compile-time error results if the parameter is
+			larger than the number of bits in an <code>unsigned
+			long</code>.</td>
 	</tr>
 	<tr>
-		<td><code>uint_exact_t</code></td>
-		<td>The smallest built-in unsigned integral type with exactly the given
-			number of bits.  A compile-time error results if no qualifying type
-			exists.</td>
-	</tr>
-	<tr>
-		<td><code>int_max_value_t</code></td>
+		<td><code>boost::int_max_value_t</code></td>
 		<td>The smallest built-in signed integral type that supports the
-			given value as a maximum.  The parameter <em>must</em> be a
+			given value as a maximum.  The parameter should be a
 			positive number.</td>
 	</tr>
 	<tr>
-		<td><code>int_min_value_t</code></td>
+		<td><code>boost::int_min_value_t</code></td>
 		<td>The smallest built-in signed integral type that supports the
-			given value as a minimum.  The parameter <em>must</em> be a
+			given value as a minimum.  The parameter should be a
 			negative number.</td>
 	</tr>
 	<tr>
-		<td><code>uint_value_t</code></td>
+		<td><code>boost::uint_value_t</code></td>
 		<td>The smallest built-in unsigned integral type that supports
 			the given value as a maximum.  The parameter should be a
 			positive number.</td>
 	</tr>
 </table>

-<h2><a name="mpl">MPL-Compatible Variants</a></h2>
-
-<p>The bit-length sized-type class templates have several drawbacks:</p>
-
-<ul>
-	<li>You must know the valid bit-lengths in advance.</li>
-	<li>There is no way to inspect the parameter used after a size-type template
-	    class is aliased.</li>
-	<li>Using an inappropriate parameter value results in a compiler
-	    diagnostic.</li>
-	<li>The type names used are inconsistent with other transformations in
-	    Boost, like in <a href="../mpl/">MPL</a>.</li>
-	<li>The above two facts make use of the size-type class templates
-	    incompatible with template meta-programming techniques.</li>
-</ul>
-
-<p>The <code>sized_integral</code>, <code>exact_integral</code>,
-<code>maximum_signed_integral</code>, <code>minimum_signed_integral</code>, and
-<code>maximum_unsigned_integral</code> class templates provide MPL-compatible
-alternatives.  These alternatives generally have the form:</p>
-
-<blockquote><pre>
-template&lt; <var>SwitchType</var> <var>SwitchValue</var>, typename Signedness &gt;
-struct <var>name</var>
-{
-    static  bool const         is_specialized = <em>implementation_supplied</em>;
-    static  bool const         is_signed = <em>implementation_supplied</em>;
-    static  <var>SwitchType</var> const   <var>switch_id</var> = <var>SwitchValue</var>;
-
-    typedef <em>implementation_supplied</em>  type;
-};
-</pre></blockquote>
-
-<p>Each member, if present, is defined by:</p>
-
-<table border="2" cellpadding="5">
-	<caption>Members in MPL-Compatible Class Templates</caption>
-	<tr>
-		<th>Class Template Member</th>
-		<th>When Defined</th>
-		<th>Meaning</th>
-	</tr>
-	<tr>
-		<td><code>is_specialized</code></td>
-		<td>Always</td>
-		<td>Flag indicating when a particular template class instantiation is a
-		    valid meta-function (<code>true</code>) or not (<code>false</code>).</td>
-	</tr>
-	<tr>
-		<td><code>is_signed</code></td>
-		<td><code>is_specialized == true</code></td>
-		<td>Flag indicating whether the signed-variant (<code>true</code>) or
-		    the unsigned-variant (<code>false</code>) of the meta-function is
-		    used.  This is controlled by the <code>Signedness</code> template
-		    parameter:
-		    <table border="1" cellpadding="3" align="center">
-		    	<caption>Effect of <code>Signedness</code> Setting</caption>
-		    	<tr>
-		    		<th><code>Signedness</code> Type</th>
-		    		<th><code>is_signed</code></th>
-		    	</tr>
-		    	<tr>
-		    		<td><code>signed</code></td>
-		    		<td><code>true</code></td>
-		    	</tr>
-		    	<tr>
-		    		<td><code>unsigned</code></td>
-		    		<td><code>false</code></td>
-		    	</tr>
-		    	<tr>
-		    		<td>anything else</td>
-		    		<td><em>not defined</em></td>
-		    	</tr>
-		    </table>
-		    The type used is a programmer mnemonic; the compiler cannot prevent
-		    someone from using <code>int</code> or <code>signed int</code>
-		    instead of <code>signed</code>, or <code>unsigned int</code> instead
-		    of <code>unsigned</code>.</td>
-	</tr>
-	<tr>
-		<td><code><var>switch_id</var></code> (Actual name is template-specific.)</td>
-		<td>Always</td>
-		<td>The value of the main control parameter, accessible even if the
-			template class instantiation is aliased.</td>
-	</tr>
-	<tr>
-		<td><code>type</code></td>
-		<td><code>is_specialized == true</code></td>
-		<td>The meta-function's result.  It appears only if the input parameters
-			satisfy the template's requirements.  Its presence, or lack thereof,
-			enables &quot;Substitution Failure Is Not An Error&quot; (SFINAE)
-			techniques, instead of a hard compiler diagnostic.</td>
-	</tr>
-</table>
-
-<p>The exceptions are the extreme-value class templates
-(<code>maximum_signed_integral</code>, <code>minimum_signed_integral</code>, and
-<code>maximum_unsigned_integral</code>), which do not take a <var>Signedness</var>
-template parameter because the meta-functions already inherently have signedness.
-
-<p>The following table describes each template's criteria.  The classic signed
-and unsigned equivalents are the sized-type class templates that each
-MPL-compatible class template emulates.  (The setting of <var>Signedness</var>
-controls the appropriate emulation.)</p>
-
-<table border="2" cellpadding="5">
-	<caption>Criteria for the MPL-Compatible Class Templates</caption>
-	<tr>
-		<th rowspan="2">Class Template (all in name-space <code>boost</code>)</th>
-		<th rowspan="2">Parameter Type (in name-space <code>boost</code> as needed)</th>
-		<th rowspan="2">Parameter Member ID</th>
-		<th colspan="2">Classic Equivalent</th>
-		<th rowspan="2" colspan="2">Template Parameter Mapping (when <code>type</code> is defined)</th>
-	</tr>
-	<tr>
-		<th>Signed</th>
-		<th>Unsigned</th>
-	</tr>
-	<tr>
-		<td><code>sized_integral</code></td>
-		<td><code>int</code></td>
-		<td><code>bit_count</code></td>
-		<td><code>int_t</code></td>
-		<td><code>uint_t</code></td>
-		<td colspan="2">The smallest built-in integral type with at least
-			<code>bit_count</code> bits (including the sign bit when
-			<var>Signedness</var> is <code>signed</code>).  Not present if no
-			type qualifies.</td>
-	</tr>
-	<tr>
-		<td><code>exact_integral</code></td>
-		<td><code>int</code></td>
-		<td><code>bit_count</code></td>
-		<td><code>int_exact_t</code></td>
-		<td><code>uint_exact_t</code></td>
-		<td colspan="2">The smallest built-in integral type with exactly
-			<code>bit_count</code> bits (including the sign bit when
-			<var>Signedness</var> is <code>signed</code>).  Not present if no
-			type qualifies.</td>
-	</tr>
-	<tr>
-		<td><code>maximum_signed_integral</code></td>
-		<td><code>intmax_t</code></td>
-		<td><code>bound</code></td>
-		<td colspan="2"><code>int_max_value_t</code></td>
-		<td>The smallest built-in integral type that can perserve the value in
-			<code>bound</code>.  Not present if <code>bound</code> is non-positive.</td>
-		<td rowspan="3">It is possible for a <code>type</code> to be absent if
-			a platform supports really-extended integral types (beyond <code>long
-			long</code> or <code>__int64</code>), support for those types goes
-			into &lt;<a href="../../boost/cstdint.hpp">boost/cstdint.hpp</a>&gt;,
-			but said support hadn't yet been added to &lt;<a
-			href="../../boost/integer.hpp">boost/integer.hpp</a>&gt;</td>
-	</tr>
-	<tr>
-		<td><code>minimum_signed_integral</code></td>
-		<td><code>intmax_t</code></td>
-		<td><code>bound</code></td>
-		<td colspan="2"><code>int_min_value_t</code></td>
-		<td>The smallest built-in integral type that can perserve the value in
-			<code>bound</code>.  Not present if <code>bound</code> is non-negative.</td>
-	</tr>
-	<tr>
-		<td><code>maximum_unsigned_integral</code></td>
-		<td><code>uintmax_t</code></td>
-		<td><code>bound</code></td>
-		<td colspan="2"><code>uint_value_t</code></td>
-		<td>The smallest built-in integral type that can perserve the value in
-			<code>bound</code>.  Should always be present.</td>
-	</tr>
-</table>
-
 <h2><a name="example">Example</a></h2>

-<blockquote><pre>
-#include &lt;<a href="../../boost/integer.hpp">boost/integer.hpp</a>&gt;
-#include &lt;<a href="../../boost/mpl/int.hpp">boost/mpl/int.hpp</a>&gt;
-#include &lt;iostream&gt;
-#include &lt;ostream&gt;
-
-//...
-
-template &lt; int Bits &gt;
-bool
-fit_exactly( boost::mpl::int_&lt;Bits&gt; const &amp;x,
- typename boost::exact_integral&lt;Bits, signed&gt;::type *unused = 0 )
-{
-    return true;
-}
-
-template &lt; typename T &gt;
-bool
-fit_exactly( T const &amp;x )
-{
-    return false;
-}
+<blockquote><pre>#include &lt;boost/integer.hpp&gt;

 //...

 int main()
 {
-    typedef boost::mpl::int_&lt;24&gt;  twenty_four;
-
-    boost::int_t&lt;twenty_four::value&gt;::least my_var;
-
-    //...
-
-    std::cout &lt;&lt; &quot;my_var &quot; &lt;&lt; ( fit_exactly(twenty_four()) ? &quot;does&quot; :
-     &quot;does not&quot; ) &lt;&lt; &quot; fit its type exactly.&quot; &lt;&lt; std::endl;
-
+    boost::int_t&lt;24&gt;::least my_var;
    //...
 }
 </pre></blockquote>

 <h2><a name="demo">Demonstration Program</a></h2>

-<p>The program <a href="test/integer_test.cpp">integer_test.cpp</a> is a
+<p>The program <a href="integer_test.cpp">integer_test.cpp</a> is a
 simplistic demonstration of the results from instantiating various
 examples of the sized type class templates.</p>

@ -486,20 +193,21 @@ href="../../boost/cstdint.hpp">&lt;boost/cstdint.hpp&gt;</a></cite>.</p>
 <h2><a name="credits">Credits</a></h2>

 <p>The author of most of the Boost integer type choosing templates is <a
-href="http://www.boost.org/people/beman_dawes.html">Beman Dawes</a>.  He gives thanks
+href="../../people/beman_dawes.html">Beman Dawes</a>.  He gives thanks
 to Valentin Bonnard and
-<a href="http://www.boost.org/people/kevlin_henney.htm"> Kevlin Henney</a> for sharing
+<a href="../../people/kevlin_henney.htm"> Kevlin Henney</a> for sharing
 their designs for similar templates.  <a
-href="http://www.boost.org/people/daryle_walker.html">Daryle Walker</a> designed the
-exact and value-based sized templates, and the MPL-compatible templates.</p>
+href="../../people/daryle_walker.html">Daryle Walker</a> designed the
+value-based sized templates.</p>

 <hr>

-<p>Revised July 16, 2008</p>
+<p>Revised May 20, 2001</p>

-<p>&copy; Copyright Beman Dawes 1999.  Use, modification, and distribution are
-subject to the Boost Software License, Version 1.0.  (See accompanying file <a
-href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
-href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
+<p>&copy; Copyright Beman Dawes 1999.  Permission to copy, use, modify,
+sell and distribute this document is granted provided this copyright
+notice appears in all copies.  This document is provided &quot;as
+is&quot; without express or implied warranty, and with no claim as to
+its suitability for any purpose.</p>
 </body>
-</html>
+</html>
--- a/integer_test.cpp
+++ b/integer_test.cpp
@ -0,0 +1,253 @@
+//  boost integer.hpp test program  ------------------------------------------//
+
+//  Copyright Beman Dawes 1999.  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)
+
+
+//  See http://www.boost.org/libs/integer for documentation.
+
+//  Revision History
+//   04 Oct 01  Added tests for new templates; rewrote code (Daryle Walker)
+//   10 Mar 01  Boost Test Library now used for tests (Beman Dawes)
+//   31 Aug 99  Initial version
+
+#include <boost/test/minimal.hpp>  // for main, BOOST_TEST
+
+#include <boost/config.hpp>   // for BOOST_NO_USING_TEMPLATE
+#include <boost/cstdlib.hpp>  // for boost::exit_success
+#include <boost/integer.hpp>  // for boost::int_t, boost::uint_t
+
+#include <climits>   // for ULONG_MAX, LONG_MAX, LONG_MIN
+#include <iostream>  // for std::cout (std::endl indirectly)
+#include <typeinfo>  // for std::type_info
+
+
+// Control if the names of the types for each version
+// of the integer templates will be printed.
+#ifndef CONTROL_SHOW_TYPES
+#define CONTROL_SHOW_TYPES  0
+#endif
+
+
+// If specializations have not already been done, then we can confirm
+// the effects of the "fast" types by making a specialization.
+namespace boost
+{
+    template < >
+    struct int_fast_t< short >
+    {
+        typedef long  fast;
+    };
+}
+
+
+// Show the types of an integer template version
+#if CONTROL_SHOW_TYPES
+#define SHOW_TYPE(Template, Number, Type)  ::std::cout << "Type \"" \
+ #Template "<" #Number ">::" #Type "\" is \"" << typeid(Template <  \
+ Number > :: Type).name() << ".\"\n"
+#else
+#define SHOW_TYPE(Template, Number, Type)
+#endif
+
+#define SHOW_TYPES(Template, Type)  SHOW_TYPE(Template, 32, Type); \
+ SHOW_TYPE(Template, 31, Type); SHOW_TYPE(Template, 30, Type); \
+ SHOW_TYPE(Template, 29, Type); SHOW_TYPE(Template, 28, Type); \
+ SHOW_TYPE(Template, 27, Type); SHOW_TYPE(Template, 26, Type); \
+ SHOW_TYPE(Template, 25, Type); SHOW_TYPE(Template, 24, Type); \
+ SHOW_TYPE(Template, 23, Type); SHOW_TYPE(Template, 22, Type); \
+ SHOW_TYPE(Template, 21, Type); SHOW_TYPE(Template, 20, Type); \
+ SHOW_TYPE(Template, 19, Type); SHOW_TYPE(Template, 18, Type); \
+ SHOW_TYPE(Template, 17, Type); SHOW_TYPE(Template, 16, Type); \
+ SHOW_TYPE(Template, 15, Type); SHOW_TYPE(Template, 14, Type); \
+ SHOW_TYPE(Template, 13, Type); SHOW_TYPE(Template, 12, Type); \
+ SHOW_TYPE(Template, 11, Type); SHOW_TYPE(Template, 10, Type); \
+ SHOW_TYPE(Template, 9, Type); SHOW_TYPE(Template, 8, Type); \
+ SHOW_TYPE(Template, 7, Type); SHOW_TYPE(Template, 6, Type); \
+ SHOW_TYPE(Template, 5, Type); SHOW_TYPE(Template, 4, Type); \
+ SHOW_TYPE(Template, 3, Type); SHOW_TYPE(Template, 2, Type); \
+ SHOW_TYPE(Template, 1, Type); SHOW_TYPE(Template, 0, Type)
+
+#define SHOW_SHIFTED_TYPE(Template, Number, Type)  SHOW_TYPE(Template, (1UL << Number), Type)
+
+#define SHOW_SHIFTED_TYPES(Template, Type)  SHOW_SHIFTED_TYPE(Template, 30, Type); \
+ SHOW_SHIFTED_TYPE(Template, 29, Type); SHOW_SHIFTED_TYPE(Template, 28, Type); \
+ SHOW_SHIFTED_TYPE(Template, 27, Type); SHOW_SHIFTED_TYPE(Template, 26, Type); \
+ SHOW_SHIFTED_TYPE(Template, 25, Type); SHOW_SHIFTED_TYPE(Template, 24, Type); \
+ SHOW_SHIFTED_TYPE(Template, 23, Type); SHOW_SHIFTED_TYPE(Template, 22, Type); \
+ SHOW_SHIFTED_TYPE(Template, 21, Type); SHOW_SHIFTED_TYPE(Template, 20, Type); \
+ SHOW_SHIFTED_TYPE(Template, 19, Type); SHOW_SHIFTED_TYPE(Template, 18, Type); \
+ SHOW_SHIFTED_TYPE(Template, 17, Type); SHOW_SHIFTED_TYPE(Template, 16, Type); \
+ SHOW_SHIFTED_TYPE(Template, 15, Type); SHOW_SHIFTED_TYPE(Template, 14, Type); \
+ SHOW_SHIFTED_TYPE(Template, 13, Type); SHOW_SHIFTED_TYPE(Template, 12, Type); \
+ SHOW_SHIFTED_TYPE(Template, 11, Type); SHOW_SHIFTED_TYPE(Template, 10, Type); \
+ SHOW_SHIFTED_TYPE(Template, 9, Type); SHOW_SHIFTED_TYPE(Template, 8, Type); \
+ SHOW_SHIFTED_TYPE(Template, 7, Type); SHOW_SHIFTED_TYPE(Template, 6, Type); \
+ SHOW_SHIFTED_TYPE(Template, 5, Type); SHOW_SHIFTED_TYPE(Template, 4, Type); \
+ SHOW_SHIFTED_TYPE(Template, 3, Type); SHOW_SHIFTED_TYPE(Template, 2, Type); \
+ SHOW_SHIFTED_TYPE(Template, 1, Type); SHOW_SHIFTED_TYPE(Template, 0, Type)
+
+#define SHOW_POS_SHIFTED_TYPE(Template, Number, Type)  SHOW_TYPE(Template, +(1L << Number), Type)
+
+#define SHOW_POS_SHIFTED_TYPES(Template, Type)  SHOW_POS_SHIFTED_TYPE(Template, 30, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 29, Type); SHOW_POS_SHIFTED_TYPE(Template, 28, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 27, Type); SHOW_POS_SHIFTED_TYPE(Template, 26, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 25, Type); SHOW_POS_SHIFTED_TYPE(Template, 24, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 23, Type); SHOW_POS_SHIFTED_TYPE(Template, 22, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 21, Type); SHOW_POS_SHIFTED_TYPE(Template, 20, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 19, Type); SHOW_POS_SHIFTED_TYPE(Template, 18, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 17, Type); SHOW_POS_SHIFTED_TYPE(Template, 16, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 15, Type); SHOW_POS_SHIFTED_TYPE(Template, 14, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 13, Type); SHOW_POS_SHIFTED_TYPE(Template, 12, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 11, Type); SHOW_POS_SHIFTED_TYPE(Template, 10, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 9, Type); SHOW_POS_SHIFTED_TYPE(Template, 8, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 7, Type); SHOW_POS_SHIFTED_TYPE(Template, 6, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 5, Type); SHOW_POS_SHIFTED_TYPE(Template, 4, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 3, Type); SHOW_POS_SHIFTED_TYPE(Template, 2, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 1, Type); SHOW_POS_SHIFTED_TYPE(Template, 0, Type)
+
+#define SHOW_NEG_SHIFTED_TYPE(Template, Number, Type)  SHOW_TYPE(Template, -(1L << Number), Type)
+
+#define SHOW_NEG_SHIFTED_TYPES(Template, Type)  SHOW_NEG_SHIFTED_TYPE(Template, 30, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 29, Type); SHOW_NEG_SHIFTED_TYPE(Template, 28, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 27, Type); SHOW_NEG_SHIFTED_TYPE(Template, 26, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 25, Type); SHOW_NEG_SHIFTED_TYPE(Template, 24, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 23, Type); SHOW_NEG_SHIFTED_TYPE(Template, 22, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 21, Type); SHOW_NEG_SHIFTED_TYPE(Template, 20, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 19, Type); SHOW_NEG_SHIFTED_TYPE(Template, 18, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 17, Type); SHOW_NEG_SHIFTED_TYPE(Template, 16, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 15, Type); SHOW_NEG_SHIFTED_TYPE(Template, 14, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 13, Type); SHOW_NEG_SHIFTED_TYPE(Template, 12, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 11, Type); SHOW_NEG_SHIFTED_TYPE(Template, 10, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 9, Type); SHOW_NEG_SHIFTED_TYPE(Template, 8, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 7, Type); SHOW_NEG_SHIFTED_TYPE(Template, 6, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 5, Type); SHOW_NEG_SHIFTED_TYPE(Template, 4, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 3, Type); SHOW_NEG_SHIFTED_TYPE(Template, 2, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 1, Type); SHOW_NEG_SHIFTED_TYPE(Template, 0, Type)
+
+
+// Test if a constant can fit within a certain type
+#define PRIVATE_FIT_TEST(Template, Number, Type, Value)  BOOST_TEST( Template < Number > :: Type ( Value ) == Value )
+
+#define PRIVATE_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; PRIVATE_FIT_TEST(Template, 32, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 31, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 30, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 29, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 28, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 27, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 26, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 25, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 24, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 23, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 22, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 21, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 20, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 19, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 18, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 17, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 16, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 15, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 14, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 13, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 12, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 11, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 10, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 9, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 8, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 7, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 6, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 5, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 4, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 3, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 2, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 1, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 0, Type, v); } while ( false )
+
+#define PRIVATE_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_TEST( Template < (ULONG_MAX >> Number) > :: Type ( Value ) == Value )
+
+#define PRIVATE_SHIFTED_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
+
+#define PRIVATE_POS_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_TEST( Template < (LONG_MAX >> Number) > :: Type ( Value ) == Value )
+
+#define PRIVATE_POS_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
+
+#define PRIVATE_NEG_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_TEST( Template < (LONG_MIN >> Number) > :: Type ( Value ) == Value )
+
+#define PRIVATE_NEG_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
+
+
+// Test program
+int
+test_main
+(
+    int,
+    char*[]
+)
+{
+#ifndef BOOST_NO_USING_TEMPLATE
+    using boost::int_t;
+    using boost::uint_t;
+    using boost::int_max_value_t;
+    using boost::int_min_value_t;
+    using boost::uint_value_t;
+#else
+    using namespace boost;
+#endif
+
+    SHOW_TYPES( int_t, least );
+    SHOW_TYPES( int_t, fast );
+    SHOW_TYPES( uint_t, least );
+    SHOW_TYPES( uint_t, fast );
+    SHOW_POS_SHIFTED_TYPES( int_max_value_t, least );
+    SHOW_POS_SHIFTED_TYPES( int_max_value_t, fast );
+    SHOW_NEG_SHIFTED_TYPES( int_min_value_t, least );
+    SHOW_NEG_SHIFTED_TYPES( int_min_value_t, fast );
+    SHOW_SHIFTED_TYPES( uint_value_t, least );
+    SHOW_SHIFTED_TYPES( uint_value_t, fast );
+     
+    PRIVATE_FIT_TESTS( int_t, least, long, LONG_MAX );
+    PRIVATE_FIT_TESTS( int_t, fast, long, LONG_MAX );
+    PRIVATE_FIT_TESTS( uint_t, least, unsigned long, ULONG_MAX );
+    PRIVATE_FIT_TESTS( uint_t, fast, unsigned long, ULONG_MAX );
+    PRIVATE_POS_FIT_TESTS( int_max_value_t, least, long, LONG_MAX );
+    PRIVATE_POS_FIT_TESTS( int_max_value_t, fast, long, LONG_MAX );
+    PRIVATE_NEG_FIT_TESTS( int_min_value_t, least, long, LONG_MIN );
+    PRIVATE_NEG_FIT_TESTS( int_min_value_t, fast, long, LONG_MIN );
+    PRIVATE_SHIFTED_FIT_TESTS( uint_value_t, least, unsigned long, ULONG_MAX );
+    PRIVATE_SHIFTED_FIT_TESTS( uint_value_t, fast, unsigned long, ULONG_MAX );
+        
+    return boost::exit_success;
+}
--- a/integer_traits.html
+++ b/integer_traits.html
@ -77,7 +77,7 @@ Test Program</h2>

 <p>

-The program <code><a href="test/integer_traits_test.cpp">integer_traits_test.cpp</a></code>
+The program <code><a href="integer_traits_test.cpp">integer_traits_test.cpp</a></code>
 exercises the <code>integer_traits</code> class.

 <h2>Acknowledgements</h2>
@ -85,10 +85,5 @@ exercises the <code>integer_traits</code> class.
 Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers discussed the integer
 traits idea on the boost mailing list in August 1999.
 <hr>
-<p>Revised
-<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan -->06 November 2007<!--webbot bot="Timestamp" endspan i-checksum="40336" --></p>
-<p><EFBFBD> Copyright Beman Dawes 2000</p>
-
-<p>Distributed under the Boost Software License, Version 1.0. See
-<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
-
+<a href="../../people/jens_maurer.htm">
+Jens Maurer</a>, 2000-02-20
--- a/test/integer_traits_test.cpp
+++ b/test/integer_traits_test.cpp
@ -53,19 +53,11 @@ void runtest(const char * type, T)
            << "; min is " << make_char_numeric_for_streaming((traits::min)())
            << ", max is " << make_char_numeric_for_streaming((traits::max)())
            << std::endl;
-  BOOST_CHECK(traits::is_specialized);
-#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1200)
-  // MSVC++ 6.0 issues a LNK1179 error (duplicate comdat) when the compiler
-  // generates different symbol names with a very long common prefix:
-  // the dummy "&& true" disambiguates between the symbols generated by this
-  // BOOST_CHECK instantiation and the preceding one.
-  BOOST_CHECK(traits::is_integer && true);
-#else
-  BOOST_CHECK(traits::is_integer);
-#endif
-  BOOST_CHECK(traits::is_integral == true);
-  BOOST_CHECK(traits::const_min == (traits::min)());
-  BOOST_CHECK(traits::const_max == (traits::max)());
+  BOOST_TEST(traits::is_specialized);
+  BOOST_TEST(traits::is_integer);
+  BOOST_TEST(traits::is_integral);
+  BOOST_TEST(traits::const_min == (traits::min)());
+  BOOST_TEST(traits::const_max == (traits::max)());
 }

 int test_main(int, char*[])
--- a/module.cmake
+++ b/module.cmake
@ -1 +0,0 @@
-boost_module(integer DEPENDS utility)
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@ -1,9 +0,0 @@
-boost_additional_test_dependencies(integer BOOST_DEPENDS test) 
-
-boost_test_run(cstdint_test cstdint_test.cpp)
-boost_test_run(integer_mask_test integer_mask_test.cpp DEPENDS boost_test_exec_monitor)
-boost_test_run(integer_test integer_test.cpp DEPENDS boost_test_exec_monitor)
-boost_test_run(integer_traits_test integer_traits_test.cpp DEPENDS boost_test_exec_monitor)
-boost_test_run(issue_2134 issue_2134.cpp)
-boost_test_run(static_log2_test static_log2_test.cpp DEPENDS boost_test_exec_monitor)
-boost_test_run(static_min_max_test static_min_max_test.cpp DEPENDS boost_test_exec_monitor)
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@ -1,20 +0,0 @@
-#~ Copyright Rene Rivera 2008
-#~ 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)
-
-import testing ;
-
-test-suite integer
-    :   [ run cstdint_test.cpp ]
-        [ run integer_test.cpp
-            /boost/test//boost_unit_test_framework ]
-        [ run integer_traits_test.cpp
-            /boost/test//boost_test_exec_monitor/<link>static ]
-        [ run integer_mask_test.cpp
-            /boost/test//boost_unit_test_framework ]
-        [ run static_log2_test.cpp
-            /boost/test//boost_test_exec_monitor/<link>static ]
-        [ run static_min_max_test.cpp
-            /boost/test//boost_test_exec_monitor/<link>static ]
-        [ compile issue_2134.cpp ]
-    ;
--- a/test/integer_mask_test.cpp
+++ b/test/integer_mask_test.cpp
@ -8,149 +8,104 @@
 //  See http://www.boost.org for most recent version including documentation.

 //  Revision History
-//  29 Jul 2008  Added MPL-compatible variants of the integer-mask templates.
-//               (Daryle Walker)
-//  27 Jul 2008  Changed tests to use the unit-test system; added
-//               extended-integer support. (Daryle Walker)
 //  23 Sep 2001  Initial version (Daryle Walker)

-#define BOOST_TEST_MODULE  "Integer mask tests"
-#include <boost/test/unit_test.hpp>  // unit testing framework
+#define  BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>  // for main

-#include <boost/cstdint.hpp>               // for boost::uintmax_t
+#include <boost/cstdlib.hpp>               // for boost::exit_success
 #include <boost/integer/integer_mask.hpp>  // for boost::high_bit_mask_t, etc.
-#include <boost/limits.hpp>                // for std::numeric_limits
-#include <boost/mpl/assert.hpp>            // for BOOST_MPL_ASSERT_RELATION,etc.
-#include <boost/mpl/bool.hpp>              // for boost::mpl::bool_
-#include <boost/mpl/bitwise.hpp>           // for boost::mpl::bitor_, shift_left
-#include <boost/mpl/equal_to.hpp>          // for boost::mpl::equal_to
-#include <boost/mpl/int.hpp>               // for boost::mpl::int_
-#include <boost/mpl/integral_c.hpp>        // for boost::mpl::integral_c
-#include <boost/mpl/next_prior.hpp>        // for boost::mpl::prior
-#include <boost/mpl/range_c.hpp>           // for boost::mpl::range_c

-#include <cstddef>   // for std::size_t
-#include <ios>       // for std::hex
+#include <iostream>  // for std::cout (std::endl indirectly)


-// Custom types/templates, helper functions, and objects
-namespace
+#define PRIVATE_HIGH_BIT_SLOW_TEST(v)  BOOST_TEST( ::boost::high_bit_mask_t< \
+ (v) >::high_bit == (1ul << (v)) );
+#define PRIVATE_HIGH_BIT_FAST_TEST(v)  BOOST_TEST( ::boost::high_bit_mask_t< \
+ (v) >::high_bit_fast == (1ul << (v)) );
+#define PRIVATE_HIGH_BIT_TEST(v)  do { PRIVATE_HIGH_BIT_SLOW_TEST(v); \
+ PRIVATE_HIGH_BIT_FAST_TEST(v); } while (false)
+
+#define PRIVATE_LOW_BITS_SLOW_TEST(v)  BOOST_TEST( ::boost::low_bits_mask_t< \
+ (v) >::sig_bits == ((1ul << (v)) - 1) );
+#define PRIVATE_LOW_BITS_FAST_TEST(v)  BOOST_TEST( ::boost::low_bits_mask_t< \
+ (v) >::sig_bits_fast == ((1ul << (v)) - 1) );
+#define PRIVATE_LOW_BITS_TEST(v)  do { PRIVATE_LOW_BITS_SLOW_TEST(v); \
+ PRIVATE_LOW_BITS_FAST_TEST(v); } while (false)
+
+
+int test_main( int, char*[] )
 {
+    using std::cout;
+    using std::endl;

-// List the ranges of template parameters tests (ranges are half-open)
-int const  max_offset = std::numeric_limits<boost::uintmax_t>::digits;
+    cout << "Doing high_bit_mask_t tests." << endl;
+    PRIVATE_HIGH_BIT_TEST( 31 );
+    PRIVATE_HIGH_BIT_TEST( 30 );
+    PRIVATE_HIGH_BIT_TEST( 29 );
+    PRIVATE_HIGH_BIT_TEST( 28 );
+    PRIVATE_HIGH_BIT_TEST( 27 );
+    PRIVATE_HIGH_BIT_TEST( 26 );
+    PRIVATE_HIGH_BIT_TEST( 25 );
+    PRIVATE_HIGH_BIT_TEST( 24 );
+    PRIVATE_HIGH_BIT_TEST( 23 );
+    PRIVATE_HIGH_BIT_TEST( 22 );
+    PRIVATE_HIGH_BIT_TEST( 21 );
+    PRIVATE_HIGH_BIT_TEST( 20 );
+    PRIVATE_HIGH_BIT_TEST( 19 );
+    PRIVATE_HIGH_BIT_TEST( 18 );
+    PRIVATE_HIGH_BIT_TEST( 17 );
+    PRIVATE_HIGH_BIT_TEST( 16 );
+    PRIVATE_HIGH_BIT_TEST( 15 );
+    PRIVATE_HIGH_BIT_TEST( 14 );
+    PRIVATE_HIGH_BIT_TEST( 13 );
+    PRIVATE_HIGH_BIT_TEST( 12 );
+    PRIVATE_HIGH_BIT_TEST( 11 );
+    PRIVATE_HIGH_BIT_TEST( 10 );
+    PRIVATE_HIGH_BIT_TEST(  9 );
+    PRIVATE_HIGH_BIT_TEST(  8 );
+    PRIVATE_HIGH_BIT_TEST(  7 );
+    PRIVATE_HIGH_BIT_TEST(  6 );
+    PRIVATE_HIGH_BIT_TEST(  5 );
+    PRIVATE_HIGH_BIT_TEST(  4 );
+    PRIVATE_HIGH_BIT_TEST(  3 );
+    PRIVATE_HIGH_BIT_TEST(  2 );
+    PRIVATE_HIGH_BIT_TEST(  1 );
+    PRIVATE_HIGH_BIT_TEST(  0 );

-typedef boost::mpl::range_c<int, 0, max_offset>             high_bit_offsets;
-typedef boost::mpl::range_c<int, 0, max_offset + 1>          low_bit_lengths;
-typedef boost::mpl::range_c<int, 1, max_offset + 1>  special_low_bit_lengths;
+    cout << "Doing low_bits_mask_t tests." << endl;
+    PRIVATE_LOW_BITS_TEST( 32 );  // Undefined behavior?  Whoops!
+    PRIVATE_LOW_BITS_TEST( 31 );
+    PRIVATE_LOW_BITS_TEST( 30 );
+    PRIVATE_LOW_BITS_TEST( 29 );
+    PRIVATE_LOW_BITS_TEST( 28 );
+    PRIVATE_LOW_BITS_TEST( 27 );
+    PRIVATE_LOW_BITS_TEST( 26 );
+    PRIVATE_LOW_BITS_TEST( 25 );
+    PRIVATE_LOW_BITS_TEST( 24 );
+    PRIVATE_LOW_BITS_TEST( 23 );
+    PRIVATE_LOW_BITS_TEST( 22 );
+    PRIVATE_LOW_BITS_TEST( 21 );
+    PRIVATE_LOW_BITS_TEST( 20 );
+    PRIVATE_LOW_BITS_TEST( 19 );
+    PRIVATE_LOW_BITS_TEST( 18 );
+    PRIVATE_LOW_BITS_TEST( 17 );
+    PRIVATE_LOW_BITS_TEST( 16 );
+    PRIVATE_LOW_BITS_TEST( 15 );
+    PRIVATE_LOW_BITS_TEST( 14 );
+    PRIVATE_LOW_BITS_TEST( 13 );
+    PRIVATE_LOW_BITS_TEST( 12 );
+    PRIVATE_LOW_BITS_TEST( 11 );
+    PRIVATE_LOW_BITS_TEST( 10 );
+    PRIVATE_LOW_BITS_TEST(  9 );
+    PRIVATE_LOW_BITS_TEST(  8 );
+    PRIVATE_LOW_BITS_TEST(  7 );
+    PRIVATE_LOW_BITS_TEST(  6 );
+    PRIVATE_LOW_BITS_TEST(  5 );
+    PRIVATE_LOW_BITS_TEST(  4 );
+    PRIVATE_LOW_BITS_TEST(  3 );
+    PRIVATE_LOW_BITS_TEST(  2 );
+    PRIVATE_LOW_BITS_TEST(  1 );

-// List a range with out-of-service values
-typedef boost::mpl::range_c<int, -10, max_offset + 11>  wild_bit_lengths;
-
-// Use SFINAE to check if a particular parameter is supported
-template < typename ValueT, template<ValueT> class Tmpl, ValueT Value >
-bool
-print_out_template( Tmpl<Value> const &, ValueT setting, char const
- *template_name, typename Tmpl<Value>::type *unused = 0 )
-{
-    // Too bad the type-id expression couldn't use the compact form "*unused",
-    // but type-ids of dereferenced null pointers throw by order of C++ 2003,
-    // sect. 5.2.8, para. 2 (although the result is not conceptually needed).
-    BOOST_TEST_MESSAGE( "There is an " << template_name << "<" << setting <<
-     "> specialization with type '" << typeid(typename
-     Tmpl<Value>::value_type).name() << "' and value '" << std::hex <<
-     Tmpl<Value>::value << "'." );
-    return true;
+    return boost::exit_success;
 }
-
-template < typename ValueT, typename T >
-bool
-print_out_template( T const &, ValueT setting, char const *template_name )
-{
-    BOOST_TEST_MESSAGE( "There is no " << template_name << "<" << setting <<
-     "> specialization." );
-    return false;
-}
-
-}  // unnamed namespace
-
-
-// Check the various integer-valued bit-masks
-BOOST_AUTO_TEST_SUITE( integer_mask_tests )
-
-// Check the bit-masks of one offset bit
-BOOST_AUTO_TEST_CASE_TEMPLATE( high_bit_mask_test, T, high_bit_offsets )
-{
-    typedef boost::mpl::integral_c<typename
-     boost::high_bit_mask_t<T::value>::least, 1u>   one_type;
-    typedef boost::mpl::shift_left<one_type, T>  result_type;
-
-    BOOST_MPL_ASSERT_RELATION( boost::high_bit_mask_t<T::value>::high_bit, ==,
-     result_type::value );
-    BOOST_MPL_ASSERT_RELATION( boost::high_bit_mask_t<T::value>::high_bit_fast,
-     ==, result_type::value );
-}
-
-// Check the bit-masks of a block of low-valued bits, non-zero block-lengths
-BOOST_AUTO_TEST_CASE_TEMPLATE( low_bits_mask_test, T, special_low_bit_lengths )
-{
-    // One can express (2^x - 1) in two ways
-    // 1. (1 << x) - 1
-    // 2. (1 << (x-1)) | ((1 << (x-1)) - 1)
-    // Since unsigneds have modulo arithmetic, [1] gives the right answer even
-    // when x is the number of bits in the register.  However, that last case
-    // gives warnings about the sole bit flowing past the register.  Applying
-    // distributive property backwards gives [2], which works without overflow.
-    typedef typename boost::mpl::prior<T>::type                  shift_type;
-    typedef boost::mpl::integral_c<typename
-     boost::low_bits_mask_t<T::value>::least, 1u>                  one_type;
-    typedef boost::mpl::shift_left<one_type, shift_type>      high_bit_type;
-    typedef typename boost::mpl::prior<high_bit_type>::type   low_bits_type;
-    typedef boost::mpl::bitor_<high_bit_type, low_bits_type>    result_type;
-
-    BOOST_MPL_ASSERT_RELATION( boost::low_bits_mask_t<T::value>::sig_bits, ==,
-     result_type::value );
-    BOOST_MPL_ASSERT_RELATION( boost::low_bits_mask_t<T::value>::sig_bits_fast,
-     ==, result_type::value );
-}
-
-// Check the bit-masks of a block of low-valued bits, zero block-length
-BOOST_AUTO_TEST_CASE( special_low_bits_mask_test )
-{
-    // Just like "low_bits_mask_test" above, except that the shifts are negative
-    // when the bit-count is zero.  That causes a lot of warnings and errors, so
-    // special-case that bit-count.
-    BOOST_MPL_ASSERT_RELATION( boost::low_bits_mask_t<0u>::sig_bits, ==, 0 );
-    BOOST_MPL_ASSERT_RELATION(boost::low_bits_mask_t<0u>::sig_bits_fast, ==, 0);
-}
-
-// Check the specialization type status of given bit-offsets/lengths
-BOOST_AUTO_TEST_CASE_TEMPLATE( confirm_bounds_test, T, wild_bit_lengths )
-{
-    typedef boost::integer_hi_mask<T::value>                    hi_type;
-    typedef boost::mpl::int_<hi_type::bit_offset>        hi_offset_type;
-    typedef boost::mpl::bool_<hi_type::is_specialized>  special_hi_type;
-
-    BOOST_MPL_ASSERT( (boost::mpl::equal_to< hi_offset_type, T >) );
-    BOOST_MPL_ASSERT( (boost::mpl::equal_to< special_hi_type,
-     boost::mpl::bool_<(T::value >= 0) && (T::value < max_offset)> >) );
-    BOOST_CHECK_EQUAL( print_out_template(hi_type(), hi_offset_type::value,
-     "integer_hi_mask"), special_hi_type::value );
-
-    typedef boost::integer_lo_mask<T::value>                    lo_type;
-    typedef boost::mpl::int_<lo_type::bit_count>         lo_length_type;
-    typedef boost::mpl::bool_<lo_type::is_specialized>  special_lo_type;
-
-    BOOST_MPL_ASSERT( (boost::mpl::equal_to< lo_length_type, T >) );
-    BOOST_MPL_ASSERT( (boost::mpl::equal_to< special_lo_type,
-     boost::mpl::bool_<(T::value >= 0) && (T::value <= max_offset)> >) );
-    BOOST_CHECK_EQUAL( print_out_template(lo_type(), lo_length_type::value,
-     "integer_lo_mask"), special_lo_type::value );
-}
-
-BOOST_AUTO_TEST_SUITE_END()
-
-// Verification of bugs and their fixes
-BOOST_AUTO_TEST_SUITE( bug_fix_tests )
-
-BOOST_AUTO_TEST_SUITE_END()
--- a/test/integer_test.cpp
+++ b/test/integer_test.cpp
@ -1,669 +0,0 @@
-//  boost integer.hpp test program  ------------------------------------------//
-
-//  Copyright Beman Dawes 1999.  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)
-
-//  See http://www.boost.org/libs/integer for documentation.
-
-//  Revision History
-//   16 Jul 08  Added MPL-compatible variants of the minimum-size and value-
-//              based integer templates. (Daryle Walker)
-//   15 Jul 08  Added exact-integer templates; added MPL-compatible variant of
-//              processor-optimized integer template. (Daryle Walker)
-//   14 Jul 08  Improved testing of processor-optimized integer template; added
-//              extended-integer support. (Daryle Walker)
-//   13 Jul 08  Modernized tests w/ MPL instead of giant macros (Daryle Walker)
-//   07 Jul 08  Changed tests to use the unit-test system (Daryle Walker)
-//   04 Oct 01  Added tests for new templates; rewrote code (Daryle Walker)
-//   10 Mar 01  Boost Test Library now used for tests (Beman Dawes)
-//   31 Aug 99  Initial version
-
-#define BOOST_TEST_MODULE  "Integer size-selection tests"
-
-#include <boost/test/unit_test.hpp>  // unit testing framework
-
-#include <boost/config.hpp>          // for BOOST_NO_SFINAE
-#include <boost/cstdint.hpp>         // for boost::uintmax_t, intmax_t
-#include <boost/integer.hpp>         // for boost::int_t, boost::uint_t, etc.
-#include <boost/integer_traits.hpp>  // for boost::integer_traits
-#include <boost/limits.hpp>          // for std::numeric_limits
-
-#include <boost/detail/extended_integer.hpp>  // BOOST_HAS_XINT, BOOST_UXINT_MAX
-
-#include <boost/mpl/arithmetic.hpp>      // for boost::mpl::plus, divides
-#include <boost/mpl/assert.hpp>          // for BOOST_MPL_ASSERT_RELATION, etc.
-#include <boost/mpl/back.hpp>            // for boost::mpl::back
-#include <boost/mpl/copy.hpp>            // for boost::mpl::copy
-#include <boost/mpl/equal.hpp>           // for boost::mpl::equal
-#include <boost/mpl/front_inserter.hpp>  // for boost::mpl::front_inserter
-#include <boost/mpl/int.hpp>             // for boost::mpl::int_
-#include <boost/mpl/integral_c.hpp>      // for boost::mpl::integral_c
-#include <boost/mpl/joint_view.hpp>      // for boost::mpl::joint_view
-#include <boost/mpl/pop_back.hpp>        // for boost::mpl::pop_back
-#include <boost/mpl/push_back.hpp>       // for boost::mpl::push_back 
-#include <boost/mpl/push_front.hpp>      // for boost::mpl::push_front
-#include <boost/mpl/range_c.hpp>         // for boost::mpl::range_c
-#include <boost/mpl/shift_right.hpp>     // for boost::mpl::shift_right
-#include <boost/mpl/sort.hpp>            // for boost::mpl::sort
-#include <boost/mpl/transform.hpp>       // for boost::mpl::transform
-#include <boost/mpl/transform_view.hpp>  // for boost::mpl::transform_view
-#include <boost/mpl/unpack_args.hpp>     // for boost::mpl::unpack_args
-#include <boost/mpl/vector.hpp>          // for boost::mpl::vector
-#include <boost/mpl/zip_view.hpp>        // for boost::mpl::zip_view
-
-#include <boost/type_traits/is_same.hpp>      // for boost::is_same
-#include <boost/type_traits/make_signed.hpp>  // for boost::make_signed
-
-#include <algorithm>  // for std::binary_search
-#include <climits>    // for ULONG_MAX, LONG_MAX, LONG_MIN, etc.
-#include <cstddef>    // for std::size_t
-#include <typeinfo>   // for std::type_info
-
-
-// Control what the "fast" specialization of "short" is
-#ifndef CONTROL_FAST_SHORT
-#define CONTROL_FAST_SHORT  long
-#endif
-
-// Control if every potential bit-count is used, or only a selection
-// For me, full counts increase compile time from 90 seconds to 20 minutes!
-#ifndef CONTROL_FULL_COUNTS
-#define CONTROL_FULL_COUNTS  1
-#endif
-
-
-// If specializations have not already been done, then we can confirm
-// the effects of the fast types by making a specialization.  If there
-// is a specialization for "short," make sure that CONTROL_FAST_SHORT
-// is set to a type distinct from "short" and the default implementation.
-namespace boost
-{
-    template < >
-    struct fast_integral< short >
-    {
-        typedef CONTROL_FAST_SHORT  type;
-    };
-}
-
-
-// Custom types/templates, helper functions, and objects
-namespace
-{
-
-// List the built-in integral types, excluding the ones that are strong-typedefs
-// of a lower type.
-typedef boost::mpl::vector<
-    unsigned char
-#if USHRT_MAX > UCHAR_MAX
-    , unsigned short
-#endif
-#if UINT_MAX > USHRT_MAX
-    , unsigned int
-#endif
-#if ULONG_MAX > UINT_MAX
-    , unsigned long
-#endif
-#if BOOST_HAS_XINT && (BOOST_UXINT_MAX > ULONG_MAX)
-    , boost::detail::uxint_t
-#endif
->  distinct_unsigned_types;
-
-typedef boost::mpl::transform<
-    distinct_unsigned_types,
-    boost::make_signed< boost::mpl::_1 >
->::type  distinct_signed_types;
-
-// List the digit counts for each integral type
-template < typename T >
-struct digits_of
-    : boost::mpl::int_< std::numeric_limits<T>::digits >
-{
-};
-
-typedef boost::mpl::transform<
-    distinct_unsigned_types,
-    digits_of< boost::mpl::_1 >
->::type  distinct_integral_bit_counts;
-
-// Make list of bit counts between each offical point, plus CHAR_BIT/2
-typedef boost::mpl::transform_view<
-    boost::mpl::zip_view<
-        boost::mpl::vector<
-            boost::mpl::push_front<
-                boost::mpl::pop_back< distinct_integral_bit_counts >::type,
-                boost::mpl::integral_c< int, 0 >
-            >::type,
-            distinct_integral_bit_counts
-        >
-    >,
-    boost::mpl::unpack_args<
-        boost::mpl::divides<
-            boost::mpl::plus< boost::mpl::_1, boost::mpl::_2 >,
-            boost::mpl::integral_c< int, 2 >
-        >
-    >
->  median_bit_counts;
-
-// Maximum number of bits allowed
-typedef std::numeric_limits<boost:: intmax_t>   intmax_limits;
-typedef std::numeric_limits<boost::uintmax_t>  uintmax_limits;
-
-int const   intmax_bits =  intmax_limits::digits + 1;
-int const  uintmax_bits = uintmax_limits::digits;
-
-// Make master lists including an outlier beyond all valid bit counts
-#if CONTROL_FULL_COUNTS
-typedef boost::mpl::range_c<int, 0, uintmax_bits + 2>  bits_list;
-#else
-typedef boost::mpl::sort<
-    boost::mpl::copy<
-        boost::mpl::joint_view<
-            distinct_integral_bit_counts,
-            median_bit_counts
-        >,
-        boost::mpl::front_inserter<
-            boost::mpl::vector<
-                boost::mpl::integral_c<int, uintmax_bits + 1>
-            >
-        >
-    >::type
->::type  bits_list;
-#endif
-
-// Remove the outlier when all bits counts must be valid
-#if CONTROL_FULL_COUNTS
-typedef boost::mpl::range_c<int, 0, uintmax_bits + 1>  valid_bits_list;
-#else
-typedef boost::mpl::pop_back<bits_list>::type  valid_bits_list;
-#endif
-
-// Replace the minimum bit count with one more, so right-shifting by a stored
-// value doesn't give an invalid result
-#if CONTROL_FULL_COUNTS
-typedef boost::mpl::range_c<int, 1, uintmax_bits + 1>
-  valid_to_decrease_bits_list;
-#else
-typedef valid_bits_list  valid_to_decrease_bits_list;
-#endif
-
-// Replace the maximum bit count with one less, so left-shifting by a stored
-// value doesn't give an invalid result
-#if CONTROL_FULL_COUNTS
-typedef boost::mpl::range_c<int, 0, uintmax_bits>  valid_to_increase_ubits_list;
-#else
-typedef boost::mpl::push_back<
-    boost::mpl::pop_back< valid_bits_list >::type,
-    boost::mpl::integral_c< int, uintmax_bits - 1 >
->::type  valid_to_increase_ubits_list;
-#endif
-
-// Do it again for signed types since they have one-less bit to use for the
-// mantissa (don't want to shift into the sign bit)
-#if CONTROL_FULL_COUNTS
-typedef boost::mpl::range_c<int, 0, intmax_bits - 2>
-  valid_to_increase_sbits_list;
-#else
-typedef boost::mpl::push_back<
-    boost::mpl::pop_back< valid_bits_list >::type,
-    boost::mpl::integral_c< int, intmax_bits - 3 >
->::type  valid_to_increase_sbits_list;
-#endif
-
-// List the digit counts for each integral type, this time as an object, an
-// array working as a sorted list
-int const  integral_bit_lengths[] = {
-    std::numeric_limits< unsigned char >::digits
-#if USHRT_MAX > UCHAR_MAX
-    , std::numeric_limits< unsigned short >::digits
-#endif
-#if UINT_MAX > USHRT_MAX
-    , std::numeric_limits< unsigned int >::digits
-#endif
-#if ULONG_MAX > UINT_MAX
-    , std::numeric_limits< unsigned long >::digits
-#endif
-#if BOOST_HAS_XINT && (BOOST_UXINT_MAX > ULONG_MAX)
-    , std::numeric_limits< boost::detail::uxint_t >::digits
-#endif
-};
-
-std::size_t const  integral_type_count = sizeof(integral_bit_lengths) /
- sizeof(integral_bit_lengths[0]);
-
-// "Template-typedefs" to reduce two-argument templates to single-argument.
-// This way, all the MPL-compatible templates have the same form, for below.
-template < int Bits >
-struct signed_sized_integral  : boost::sized_integral<Bits, signed>  {};
-
-template < int Bits >
-struct unsigned_sized_integral  : boost::sized_integral<Bits, unsigned>  {};
-
-template < int Bits >
-struct signed_exact_integral  : boost::exact_integral<Bits, signed>  {};
-
-template < int Bits >
-struct unsigned_exact_integral  : boost::exact_integral<Bits, unsigned>  {};
-
-// Use SFINAE to check if a particular parameter is supported
-#ifndef BOOST_NO_SFINAE
-template < typename ValueT, template<ValueT> class Tmpl, ValueT Value >
-bool
-print_out_template( Tmpl<Value> const &, ValueT setting, char const
- *template_pre_name, char const *template_post_name, typename Tmpl<Value>::type
- *unused = 0 )
-{
-    // Too bad the type-id expression couldn't use the compact form "*unused",
-    // but type-ids of dereferenced null pointers throw by order of C++ 2003,
-    // sect. 5.2.8, para. 2 (although the result is not conceptually needed).
-    BOOST_TEST_MESSAGE( "This is " << template_pre_name << setting
-     << template_post_name << " specialization, with type '" << typeid(typename
-     Tmpl<Value>::type).name() << "'." );
-    return true;
-}
-
-template < typename ValueT, typename T >
-bool
-print_out_template( T const &, ValueT setting, char const *template_pre_name,
- char const *template_post_name )
-{
-    BOOST_TEST_MESSAGE( "Looking for " << template_pre_name << setting
-     << template_post_name << " specialization?  It doesn't exist." );
-    return false;
-}
-#else
-#error "These tests cannot work without Substitution-Failure-Is-Not-An-Error"
-#endif
-
-// Get the extreme values for each integral type
-template < typename T >
-struct minimum_of
-    : boost::mpl::integral_c< T, boost::integer_traits<T>::const_min >
-{
-};
-
-template < typename T >
-struct maximum_of
-    : boost::mpl::integral_c< T, boost::integer_traits<T>::const_max >
-{
-};
-
-}  // unnamed namespace
-
-
-// Check the processor-optimzed type system
-BOOST_AUTO_TEST_SUITE( optimized_type_tests )
-
-// Check the optimzed type override of a given type
-BOOST_AUTO_TEST_CASE( fast_type_test )
-{
-    typedef short                               least_type;
-    typedef boost::int_fast_t<least_type>::fast  fast_type;
-    typedef std::numeric_limits<least_type>     least_limits;
-    typedef std::numeric_limits<fast_type>       fast_limits;
-
-    typedef boost::fast_integral<least_type>::type  real_fast_type;
-
-    BOOST_MPL_ASSERT_RELATION( (boost::is_same<least_type, fast_type>::value),
-     ==, false );
-    BOOST_MPL_ASSERT_RELATION( (boost::is_same<fast_type,
-     real_fast_type>::value), ==, true );
-    BOOST_MPL_ASSERT_RELATION( fast_limits::is_specialized, ==, true );
-    BOOST_MPL_ASSERT_RELATION( fast_limits::is_signed &&
-     fast_limits::is_bounded, ==, true );
-    BOOST_MPL_ASSERT_RELATION( fast_limits::radix, ==, 2 );
-    BOOST_MPL_ASSERT_RELATION( fast_limits::digits, >=, least_limits::digits );
-}
-
-BOOST_AUTO_TEST_SUITE_END()
-
-// Check if given types can support given size parameters
-BOOST_AUTO_TEST_SUITE( show_type_tests )
-
-// Check the specialization type status of given bit lengths, minimum
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_lengths_test, T, bits_list )
-{
-    BOOST_CHECK_EQUAL( print_out_template(signed_sized_integral<T::value>(),
-     T::value, "a sized_integral<", ", signed>"), T::value && (T::value <=
-     intmax_bits) );
-    BOOST_CHECK_EQUAL( print_out_template(unsigned_sized_integral<T::value>(),
-     T::value, "a sized_integral<", ", unsigned>"), T::value <= uintmax_bits );
-}
-
-// Check the classic specialization type status of given bit lengths, minimum,
-// unsigned
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_classic_lengths_unsigned_test, T,
- valid_bits_list )
-{
-    // This test is supposed to replace the following printouts given in
-    // puesdo-code by:
-    // Routine: Template, Type
-    //  for N := 32 downto 0
-    //      cout << "Type '" << Template << "<" N << ">::" << Type << "' is '"
-    //      << typeid(Template<N>::Type).name << ".'\n"
-    //  end for
-    // end Routine
-    // with Template = {int_t, uint_t}; Type = {least, fast}
-    // But now we'll use template meta-programming instead of macros.  The limit
-    // of type-lists is usually less than 32 (not to mention 64) elements, so we
-    // have to take selected values.  The only interesting part is if the bit
-    // count is too large, and we can't check that yet.
-    BOOST_MPL_ASSERT_RELATION( std::numeric_limits<typename
-     boost::uint_t<T::value>::least>::digits, >=, T::value );
-    BOOST_MPL_ASSERT_RELATION( std::numeric_limits<typename
-     boost::uint_t<T::value>::fast>::digits, >=, T::value );
-}
-
-// Check the classic specialization type status of given bit lengths, minimum,
-// signed
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_classic_lengths_signed_test, T,
- valid_to_decrease_bits_list )
-{
-    BOOST_MPL_ASSERT_RELATION( std::numeric_limits<typename
-     boost::int_t<T::value>::least>::digits, >=, T::value - 1 );
-    BOOST_MPL_ASSERT_RELATION( std::numeric_limits<typename
-     boost::int_t<T::value>::fast>::digits, >=, T::value - 1 );
-}
-
-// Check size comparisons of given value support, unsigned
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_shifted_unsigned_values_test, T,
- valid_to_increase_ubits_list )
-{
-    // This test is supposed to replace the following printouts given in
-    // puesdo-code by:
-    // Routine: Type
-    //  for N := 30 downto 0
-    //      cout << "Type '" << uint_value_t << "<" (1ul << N) << ">::" << Type
-    //       << "' is '"<< typeid(uint_value_t<(1ul << N)>::Type).name << ".'\n"
-    //  end for
-    // end Routine
-    // with Type = {least, fast}
-    // But now we'll use template meta-programming instead of macros.  The limit
-    // of type-lists is usually less than 32 (not to mention 64) elements, so we
-    // have to take selected values.  The interesting parts are where N is the
-    // length of a integral type, so 1 << N would have to fit in the next larger
-    // type.  (This is why N can't be more than bitlength(uintmax_t) - 1.)
-    boost::uintmax_t const  one = 1u;
-
-    BOOST_MPL_ASSERT( (boost::mpl::equal< boost::maximum_unsigned_integral<(one
-     << T::value)>, unsigned_sized_integral<T::value + 1> >) );
-}
-
-// Check size comparisons of given value support, signed
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_shifted_signed_values_test, T,
- valid_to_increase_sbits_list )
-{
-    // This test is supposed to replace the following printouts given in
-    // puesdo-code by:
-    // Routine: Type
-    //  for N := 30 downto 0
-    //      cout << "Type '" << int_max_value_t << "<" +(1ul << N) << ">::" <<
-    //       Type << "' is '" << typeid(int_max_value_t<+(1ul << N)>::Type).name
-    //       << ".'\n"
-    //      cout << "Type '" << int_min_value_t << "<" -(1ul << N) << ">::" <<
-    //       Type << "' is '" << typeid(int_min_value_t<-(1ul << N)>::Type).name
-    //       << ".'\n"
-    //  end for
-    // end Routine
-    // with Type = {least, fast}
-    // But now we'll use template meta-programming instead of macros.  The limit
-    // of type-lists is usually less than 32 (not to mention 64) elements, so we
-    // have to take selected values.  The interesting parts are where N is the
-    // length of a integral type, so 1 << N would have to fit in the next larger
-    // type.  (This is why N can't be more than bitlength(intmax_t) - 1.  Note
-    // that bitlength(intmax_t) + 1 == bitlength(uintmax_t).)
-    static  boost::intmax_t const  one = 1;
-
-    BOOST_MPL_ASSERT( (boost::mpl::equal< boost::maximum_signed_integral<+(one
-     << T::value)>, signed_sized_integral<T::value + 1> >) );
-    BOOST_MPL_ASSERT( (boost::mpl::equal< boost::minimum_signed_integral<-(one
-     << T::value)>, signed_sized_integral<T::value + 1> >) );
-}
-
-// Check the specialization type status of given bit lengths, exact only
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_exact_lengths_test, T, bits_list )
-{
-    bool const  is_exact_length = std::binary_search( integral_bit_lengths,
-     integral_bit_lengths + integral_type_count, T::value );
-
-    BOOST_CHECK_EQUAL( print_out_template(signed_exact_integral<T::value>(),
-     T::value, "an exact_integral<", ", signed>"), is_exact_length );
-    BOOST_CHECK_EQUAL( print_out_template(unsigned_exact_integral<T::value>(),
-     T::value, "an exact_integral<", ", unsigned>"), is_exact_length );
-}
-
-// Check the classic specialization type status of given bit lengths, exact only
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_classic_exact_lengths_test, T,
- distinct_integral_bit_counts )
-{
-    BOOST_MPL_ASSERT_RELATION( std::numeric_limits<typename
-     boost::int_exact_t<T::value>::exact>::digits, ==, T::value - 1 );
-    BOOST_MPL_ASSERT_RELATION( std::numeric_limits<typename
-     boost::uint_exact_t<T::value>::exact>::digits, ==, T::value );
-}
-
-// Check if MPL-compatible templates give bad returns for out-of-range values
-BOOST_AUTO_TEST_CASE( show_not_type_for_parameter_test )
-{
-    typedef signed_sized_integral< 3>   ssz3_type;
-    typedef signed_sized_integral< 0>   ssz0_type;
-    typedef signed_sized_integral<-3>  ssz3n_type;
-
-    BOOST_CHECK(  print_out_template(ssz3_type(), ssz3_type::bit_count,
-     "a sized_integral<", ", signed>") );
-    BOOST_CHECK( !print_out_template(ssz0_type(), ssz0_type::bit_count,
-     "a sized_integral<", ", signed>") );
-    BOOST_CHECK( !print_out_template(ssz3n_type(), ssz3n_type::bit_count,
-     "a sized_integral<", ", signed>") );
-
-    typedef unsigned_sized_integral< 3>   usz3_type;
-    typedef unsigned_sized_integral< 0>   usz0_type;
-    typedef unsigned_sized_integral<-3>  usz3n_type;
-
-    BOOST_CHECK(  print_out_template(usz3_type(), usz3_type::bit_count,
-     "a sized_integral<", ", unsigned>") );
-    BOOST_CHECK(  print_out_template(usz0_type(), usz0_type::bit_count,
-     "a sized_integral<", ", unsigned>") );
-    BOOST_CHECK( !print_out_template(usz3n_type(), usz3n_type::bit_count,
-     "a sized_integral<", ", unsigned>") );
-
-    typedef signed_exact_integral< CHAR_BIT >     se8_type;
-    typedef signed_exact_integral< 3>             se3_type;
-    typedef signed_exact_integral< 0>             se0_type;
-    typedef signed_exact_integral<-3>            se3n_type;
-    typedef signed_exact_integral< - CHAR_BIT >  se8n_type;
-
-    BOOST_CHECK(  print_out_template(se8_type(), se8_type::bit_count,
-     "an exact_integral<", ", signed>") );
-    BOOST_CHECK( !print_out_template(se3_type(), se3_type::bit_count,
-     "an exact_integral<", ", signed>") );
-    BOOST_CHECK( !print_out_template(se0_type(), se0_type::bit_count,
-     "an exact_integral<", ", signed>") );
-    BOOST_CHECK( !print_out_template(se3n_type(), se3n_type::bit_count,
-     "an exact_integral<", ", signed>") );
-    BOOST_CHECK( !print_out_template(se8n_type(), se8n_type::bit_count,
-     "an exact_integral<", ", signed>") );
-
-    typedef unsigned_exact_integral< CHAR_BIT >     ue8_type;
-    typedef unsigned_exact_integral< 3>             ue3_type;
-    typedef unsigned_exact_integral< 0>             ue0_type;
-    typedef unsigned_exact_integral<-3>            ue3n_type;
-    typedef unsigned_exact_integral< - CHAR_BIT >  ue8n_type;
-
-    BOOST_CHECK(  print_out_template(ue8_type(), ue8_type::bit_count,
-     "an exact_integral<", ", unsigned>") );
-    BOOST_CHECK( !print_out_template(ue3_type(), ue3_type::bit_count,
-     "an exact_integral<", ", unsigned>") );
-    BOOST_CHECK( !print_out_template(ue0_type(), ue0_type::bit_count,
-     "an exact_integral<", ", unsigned>") );
-    BOOST_CHECK( !print_out_template(ue3n_type(), ue3n_type::bit_count,
-     "an exact_integral<", ", unsigned>") );
-    BOOST_CHECK( !print_out_template(ue8n_type(), ue8n_type::bit_count,
-     "an exact_integral<", ", unsigned>") );
-
-    typedef boost::maximum_signed_integral< 15>   max15_type;
-    typedef boost::maximum_signed_integral<  0>    max0_type;
-    typedef boost::maximum_signed_integral<-15>  max15n_type;
-
-    BOOST_CHECK(  print_out_template(max15_type(), max15_type::bound,
-     "a maximum_signed_integral<", ">") );
-    BOOST_CHECK( !print_out_template(max0_type(), max0_type::bound,
-     "a maximum_signed_integral<", ">") );
-    BOOST_CHECK( !print_out_template(max15n_type(), max15n_type::bound,
-     "a maximum_signed_integral<", ">") );
-
-    typedef boost::minimum_signed_integral< 15>   min15_type;
-    typedef boost::minimum_signed_integral<  0>    min0_type;
-    typedef boost::minimum_signed_integral<-15>  min15n_type;
-
-    BOOST_CHECK( !print_out_template(min15_type(), min15_type::bound,
-     "a minimum_signed_integral<", ">") );
-    BOOST_CHECK( !print_out_template(min0_type(), min0_type::bound,
-     "a minimum_signed_integral<", ">") );
-    BOOST_CHECK(  print_out_template(min15n_type(), min15n_type::bound,
-     "a minimum_signed_integral<", ">") );
-
-    typedef boost::maximum_unsigned_integral<15>   umax15_type;
-    typedef boost::maximum_unsigned_integral< 0>    umax0_type;
-
-    BOOST_CHECK( print_out_template(umax15_type(), umax15_type::bound,
-     "a maximum_unsigned_integral<", ">") );
-    BOOST_CHECK( print_out_template(umax0_type(), umax0_type::bound,
-     "a maximum_unsigned_integral<", ">") );
-}
-
-BOOST_AUTO_TEST_SUITE_END()
-
-// Check if given constants can fit in given types
-BOOST_AUTO_TEST_SUITE( fit_type_tests )
-
-// Check if large value can fit its minimum required size, by size
-BOOST_AUTO_TEST_CASE_TEMPLATE( fit_for_masked_values_test, T,
- valid_to_decrease_bits_list )
-{
-    // This test is supposed to replace the following checks given in
-    // puesdo-code by:
-    // Routine: Template, Type
-    //  for ( N = 32, V = Template:Max ; N >= 0 ; --N, V >>= 1 )
-    //      Confirm( static_cast<typename Template<N>::Type>(V) == V );
-    //  end for
-    // end Routine
-    // with Template = {int_t, uint_t}; Type = {least, fast};
-    //      Template:Max = { intmax_t.Max for int_t, uintmax_t.Max for uint_t }
-    // In other words, the selected type doesn't mask out any bits it's not
-    // supposed to.  But now we'll use template meta-programming instead of
-    // macros.  The limit of type-lists is usually less than 32 (not to mention
-    // 64) elements, so we have to take selected values.
-    static  int const       count = T::value;
-    int const               shift = uintmax_bits - count;
-    boost::uintmax_t const  value_u = uintmax_limits::max
-     BOOST_PREVENT_MACRO_SUBSTITUTION () >> shift;
-    boost::intmax_t const   value_s = intmax_limits::max
-     BOOST_PREVENT_MACRO_SUBSTITUTION () >> shift;
-
-    BOOST_CHECK_EQUAL( static_cast<typename
-     unsigned_sized_integral<count>::type>(value_u), value_u );
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::uint_t<count>::least>(value_u), value_u );
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::uint_t<count>::fast>(value_u), value_u );
-
-    BOOST_CHECK_EQUAL( static_cast<typename
-     signed_sized_integral<count>::type>(value_s), value_s );
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::int_t<count>::least>(value_s), value_s );
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::int_t<count>::fast>(value_s), value_s );
-}
-
-// Check if a large value can only fit of its exact bit length
-BOOST_AUTO_TEST_CASE_TEMPLATE( fit_for_exact_lengths_test, T,
- distinct_integral_bit_counts )
-{
-    typename boost::exact_integral<T::value, unsigned>::type const  one_u( 1u ),
-     high_bit_u( one_u << (T::value - 1) ), repeated_bits_u( (high_bit_u << 1) |
-     high_bit_u );
-
-    BOOST_CHECK( high_bit_u );
-    BOOST_CHECK_EQUAL( repeated_bits_u, high_bit_u );
-
-    typename boost::exact_integral<T::value, signed>::type const  one_s( 1 ),
-     high_bit_s( one_s << (T::value - 2) ), repeated_bits_s( (high_bit_s << 1) |
-     high_bit_s ), repeated_2bits_s( (repeated_bits_s << 1) | high_bit_s );
-
-    BOOST_CHECK( high_bit_s > 0 );
-    BOOST_CHECK( repeated_bits_s < 0 );
-    BOOST_CHECK_EQUAL( repeated_bits_s, repeated_2bits_s );
-}
-
-// Check if large value can fit its minimum required size, by value, unsigned
-BOOST_AUTO_TEST_CASE_TEMPLATE( fit_for_shifted_unsigned_values_test, T,
- valid_to_increase_ubits_list )
-{
-    // This test is supposed to replace the following checks given in
-    // puesdo-code by:
-    // Routine: Template, Type
-    //  for ( N = 0, V = Template:Extreme ; N < 32 ; ++N, V >>= 1 )
-    //      Confirm( static_cast<typename Template<V>::Type>(V) == V );
-    //  end for
-    // end Routine
-    // with Template = {uint_value_t}; Type = {least, fast}; Template:Extreme =
-    //      {uintmax_t.Max for uint_value_t}
-    // In other words, the selected type doesn't mask out any bits it's not
-    // supposed to.  But now we'll use template meta-programming instead of
-    // macros.  The limit of type-lists is usually less than 32 (not to mention
-    // 64) elements, so we have to take selected values.
-    using boost::uintmax_t;
-
-    typedef boost::mpl::shift_right<maximum_of<uintmax_t>, T>  maxi_type;
-
-    uintmax_t const  maxi = maxi_type::value;
-
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::uint_value_t<maxi_type::value>::least>(maxi), maxi );
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::uint_value_t<maxi_type::value>::fast>(maxi), maxi );
-}
-
-// Check if large value can fit its minimum required size, by value, signed
-BOOST_AUTO_TEST_CASE_TEMPLATE( fit_for_shifted_signed_values_test, T,
- valid_to_increase_sbits_list )
-{
-    // This test is supposed to replace the following checks given in
-    // puesdo-code by:
-    // Routine: Template, Type
-    //  for ( N = 0, V = Template:Extreme ; N < 32 ; ++N, V >>= 1 )
-    //      Confirm( static_cast<typename Template<V>::Type>(V) == V );
-    //  end for
-    // end Routine
-    // with Template = {int_max_value_t, int_min_value_t}; Type = {least, fast};
-    //      Template:Extreme = {intmax_t.Min for int_min_value_t, intmax_t.Max
-    //      for int_max_value_t}
-    // In other words, the selected type doesn't mask out any bits it's not
-    // supposed to.  But now we'll use template meta-programming instead of
-    // macros.  The limit of type-lists is usually less than 32 (not to mention
-    // 64) elements, so we have to take selected values.
-    using boost::intmax_t;
-
-    typedef boost::mpl::shift_right<minimum_of<intmax_t>, T>  mini_type;
-    typedef boost::mpl::shift_right<maximum_of<intmax_t>, T>  maxi_type;
-
-    intmax_t const  maxi = maxi_type::value, mini = mini_type::value;
-
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::int_max_value_t<maxi_type::value>::least>(maxi), maxi );
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::int_max_value_t<maxi_type::value>::fast>(maxi), maxi );
-
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::int_min_value_t<mini_type::value>::least>(mini), mini );
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::int_min_value_t<mini_type::value>::fast>(mini), mini );
-}
-
-BOOST_AUTO_TEST_SUITE_END()
-
-// Verification of bugs and their fixes
-BOOST_AUTO_TEST_SUITE( bug_fix_tests )
-
-BOOST_AUTO_TEST_SUITE_END()
--- a/test/issue_2134.cpp
+++ b/test/issue_2134.cpp
@ -1,33 +0,0 @@
-//  boost Issue #2134 test program  ------------------------------------------//
-
-//  Copyright Daryle Walker 2008.  Distributed under the Boost
-//  Software License, Version 1.0. (See the accompanying file
-//  LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
-
-//  See <http://www.boost.org/libs/integer> for documentation.
-//  See <http://svn.boost.org/trac/boost/ticket/2134> for the issue involved.
-
-//  Revision History
-//   23 Jul 2008  Initial version
-
-// Control if the inclusion error is triggered
-#ifndef CONTROL_INCLUDE_TRAITS
-#define CONTROL_INCLUDE_TRAITS  1
-#endif
-
-#if CONTROL_INCLUDE_TRAITS
-// This file defines boost::detail::integer_traits.
-#include <boost/detail/numeric_traits.hpp>
-#endif
-
-// This is the file with the issue.  It has items within the boost::detail
-// namespace that referenced an unadorned "integer_traits".  This was meant to
-// refer to boost::integer_traits.  However, <boost/detail/numeric_traits.hpp>
-// defines a boost::detail::integer_traits.  If that header is #included before
-// this one, then b.d.integer_traits (rightfully) took priority, which lead to a
-// syntax error.
-#include <boost/integer.hpp>
-
-
-// Main program, minimal (since this is a compile test)
-int  main()  { return 0; }
--- a/test/static_log2_test.cpp
+++ b/test/static_log2_test.cpp
@ -20,7 +20,7 @@


 // Macros to compact code
-#define PRIVATE_LB_TEST( v, e )  BOOST_CHECK( ::boost::static_log2<v>::value == e )
+#define PRIVATE_LB_TEST( v, e )  BOOST_TEST( ::boost::static_log2<v>::value == e )

 #define PRIVATE_PRINT_LB( v )    ::std::cout << "boost::static_log2<" << (v) \
 << "> = " << ::boost::static_log2< (v) >::value << '.' << ::std::endl
--- a/test/static_min_max_test.cpp
+++ b/test/static_min_max_test.cpp
@ -11,7 +11,7 @@
 //  23 Sep 2001  Initial version (Daryle Walker)

 #define  BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>  // for main, BOOST_CHECK
+#include <boost/test/test_tools.hpp>  // for main, BOOST_TEST

 #include <boost/cstdlib.hpp>                 // for boost::exit_success
 #include <boost/integer/static_min_max.hpp>  // for boost::static_signed_min, etc.
@ -37,57 +37,57 @@ test_main
    // Two positives
    cout << "Doing tests with two positive values." << endl;

-    BOOST_CHECK( (static_signed_min< 9, 14>::value) ==  9 );
-    BOOST_CHECK( (static_signed_max< 9, 14>::value) == 14 );
-    BOOST_CHECK( (static_signed_min<14,  9>::value) ==  9 );
-    BOOST_CHECK( (static_signed_max<14,  9>::value) == 14 );
+    BOOST_TEST( (static_signed_min< 9, 14>::value) ==  9 );
+    BOOST_TEST( (static_signed_max< 9, 14>::value) == 14 );
+    BOOST_TEST( (static_signed_min<14,  9>::value) ==  9 );
+    BOOST_TEST( (static_signed_max<14,  9>::value) == 14 );

-    BOOST_CHECK( (static_unsigned_min< 9, 14>::value) ==  9 );
-    BOOST_CHECK( (static_unsigned_max< 9, 14>::value) == 14 );
-    BOOST_CHECK( (static_unsigned_min<14,  9>::value) ==  9 );
-    BOOST_CHECK( (static_unsigned_max<14,  9>::value) == 14 );
+    BOOST_TEST( (static_unsigned_min< 9, 14>::value) ==  9 );
+    BOOST_TEST( (static_unsigned_max< 9, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_min<14,  9>::value) ==  9 );
+    BOOST_TEST( (static_unsigned_max<14,  9>::value) == 14 );

    // Two negatives
    cout << "Doing tests with two negative values." << endl;

-    BOOST_CHECK( (static_signed_min<  -8, -101>::value) == -101 );
-    BOOST_CHECK( (static_signed_max<  -8, -101>::value) ==   -8 );
-    BOOST_CHECK( (static_signed_min<-101,   -8>::value) == -101 );
-    BOOST_CHECK( (static_signed_max<-101,   -8>::value) ==   -8 );
+    BOOST_TEST( (static_signed_min<  -8, -101>::value) == -101 );
+    BOOST_TEST( (static_signed_max<  -8, -101>::value) ==   -8 );
+    BOOST_TEST( (static_signed_min<-101,   -8>::value) == -101 );
+    BOOST_TEST( (static_signed_max<-101,   -8>::value) ==   -8 );

    // With zero
    cout << "Doing tests with zero and a positive or negative value." << endl;

-    BOOST_CHECK( (static_signed_min< 0, 14>::value) ==  0 );
-    BOOST_CHECK( (static_signed_max< 0, 14>::value) == 14 );
-    BOOST_CHECK( (static_signed_min<14,  0>::value) ==  0 );
-    BOOST_CHECK( (static_signed_max<14,  0>::value) == 14 );
+    BOOST_TEST( (static_signed_min< 0, 14>::value) ==  0 );
+    BOOST_TEST( (static_signed_max< 0, 14>::value) == 14 );
+    BOOST_TEST( (static_signed_min<14,  0>::value) ==  0 );
+    BOOST_TEST( (static_signed_max<14,  0>::value) == 14 );

-    BOOST_CHECK( (static_unsigned_min< 0, 14>::value) ==  0 );
-    BOOST_CHECK( (static_unsigned_max< 0, 14>::value) == 14 );
-    BOOST_CHECK( (static_unsigned_min<14,  0>::value) ==  0 );
-    BOOST_CHECK( (static_unsigned_max<14,  0>::value) == 14 );
+    BOOST_TEST( (static_unsigned_min< 0, 14>::value) ==  0 );
+    BOOST_TEST( (static_unsigned_max< 0, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_min<14,  0>::value) ==  0 );
+    BOOST_TEST( (static_unsigned_max<14,  0>::value) == 14 );

-    BOOST_CHECK( (static_signed_min<   0, -101>::value) == -101 );
-    BOOST_CHECK( (static_signed_max<   0, -101>::value) ==    0 );
-    BOOST_CHECK( (static_signed_min<-101,    0>::value) == -101 );
-    BOOST_CHECK( (static_signed_max<-101,    0>::value) ==    0 );
+    BOOST_TEST( (static_signed_min<   0, -101>::value) == -101 );
+    BOOST_TEST( (static_signed_max<   0, -101>::value) ==    0 );
+    BOOST_TEST( (static_signed_min<-101,    0>::value) == -101 );
+    BOOST_TEST( (static_signed_max<-101,    0>::value) ==    0 );

    // With identical
    cout << "Doing tests with two identical values." << endl;

-    BOOST_CHECK( (static_signed_min<0, 0>::value) == 0 );
-    BOOST_CHECK( (static_signed_max<0, 0>::value) == 0 );
-    BOOST_CHECK( (static_unsigned_min<0, 0>::value) == 0 );
-    BOOST_CHECK( (static_unsigned_max<0, 0>::value) == 0 );
+    BOOST_TEST( (static_signed_min<0, 0>::value) == 0 );
+    BOOST_TEST( (static_signed_max<0, 0>::value) == 0 );
+    BOOST_TEST( (static_unsigned_min<0, 0>::value) == 0 );
+    BOOST_TEST( (static_unsigned_max<0, 0>::value) == 0 );

-    BOOST_CHECK( (static_signed_min<14, 14>::value) == 14 );
-    BOOST_CHECK( (static_signed_max<14, 14>::value) == 14 );
-    BOOST_CHECK( (static_unsigned_min<14, 14>::value) == 14 );
-    BOOST_CHECK( (static_unsigned_max<14, 14>::value) == 14 );
+    BOOST_TEST( (static_signed_min<14, 14>::value) == 14 );
+    BOOST_TEST( (static_signed_max<14, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_min<14, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_max<14, 14>::value) == 14 );

-    BOOST_CHECK( (static_signed_min< -101, -101>::value) == -101 );
-    BOOST_CHECK( (static_signed_max< -101, -101>::value) == -101 );
+    BOOST_TEST( (static_signed_min< -101, -101>::value) == -101 );
+    BOOST_TEST( (static_signed_max< -101, -101>::value) == -101 );

    return boost::exit_success;
 }
Author	SHA1	Message	Date
Joel de Guzman	0a77cbf63d	Removing unecessary files [SVN r26375]	2004-12-01 02:44:55 +00:00
Hartmut Kaiser	e851ffc866	Removed part of the Boost files from the SPIRIT_MINIBOOST branch. [SVN r26368]	2004-11-30 07:52:25 +00:00
Hartmut Kaiser	78f19c428b	Removed part of the Boost files from the SPIRIT_MINIBOOST branch. [SVN r26352]	2004-11-29 15:59:10 +00:00
nobody	e43a56311e	This commit was manufactured by cvs2svn to create branch 'SPIRIT_MINIBOOST'. [SVN r26343]	2004-11-29 07:29:20 +00:00