Imported Upstream version 1.49.0upstream/1.49.0

19 files changed, 888 insertions, 0 deletions

diff --git a/libs/static_assert/Jamfile.v2 b/libs/static_assert/Jamfile.v2
new file mode 100644
index 0000000000..14dfe2ffdb
--- /dev/null
+++ b/libs/static_assert/Jamfile.v2
@@ -0,0 +1,31 @@
+# copyright John Maddock 2003
+# Use, modification and distribution are subject to 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)
+
+# bring in the rules for testing
+import testing ;
+
+test-suite static_assert :
+	[ run static_assert_test.cpp ]
+#	[ run static_assert_example_1.cpp ]
+	[ run static_assert_example_2.cpp ]
+	[ run static_assert_example_3.cpp ]
+	[ compile-fail static_assert_test_fail_1.cpp ]
+	[ compile-fail static_assert_test_fail_2.cpp ]
+	[ compile-fail static_assert_test_fail_3.cpp ]
+	[ compile-fail static_assert_test_fail_4.cpp ]
+	[ compile-fail static_assert_test_fail_5.cpp ]
+	[ compile-fail static_assert_test_fail_6.cpp ]
+	[ compile-fail static_assert_test_fail_7.cpp ]
+	[ compile-fail static_assert_test_fail_8.cpp ]
+	[ compile-fail static_assert_test_fail_9.cpp ]
+	[ compile-fail static_assert_test_fail_10.cpp ]
+;
+
+
+
+
+
+
+
diff --git a/libs/static_assert/doc/Jamfile.v2 b/libs/static_assert/doc/Jamfile.v2
new file mode 100644
index 0000000000..1f8565d0e1
--- /dev/null
+++ b/libs/static_assert/doc/Jamfile.v2
@@ -0,0 +1,39 @@
+
+# Copyright John Maddock 2005. Use, modification, and distribution are
+# subject to 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)
+
+using quickbook ;
+
+path-constant boost-images : ../../../doc/src/images ;
+
+xml static_assert : static_assert.qbk ;
+boostbook standalone
+    :
+        static_assert
+    :
+        <xsl:param>boost.root=../../../..
+        <xsl:param>nav.layout=none
+        <xsl:param>navig.graphics=0
+        # PDF Options:
+        # TOC Generation: this is needed for FOP-0.9 and later:
+        <xsl:param>fop1.extensions=0
+        # Or enable this if you're using XEP:
+        <xsl:param>xep.extensions=1
+        # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
+        <xsl:param>fop.extensions=0
+        # No indent on body text:
+        <xsl:param>body.start.indent=0pt
+        # Margin size:
+        <xsl:param>page.margin.inner=0.5in
+        # Margin size:
+        <xsl:param>page.margin.outer=0.5in
+        # Yes, we want graphics for admonishments:
+        <xsl:param>admon.graphics=1
+        # Set this one for PDF generation *only*:
+        # default pnd graphics are awful in PDF form,
+        # better use SVG's instead:
+        <format>pdf:<xsl:param>admon.graphics.extension=".svg"
+        <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
+        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
+    ;
diff --git a/libs/static_assert/doc/static_assert.qbk b/libs/static_assert/doc/static_assert.qbk
new file mode 100644
index 0000000000..af62715e90
--- /dev/null
+++ b/libs/static_assert/doc/static_assert.qbk
@@ -0,0 +1,243 @@
+[library Boost.StaticAssert
+    [copyright 2000 2005 Steve Cleary and John Maddock]
+    [purpose Compile time diagnostics library]
+    [license
+        Distributed under the Boost Software License, Version 1.0.
+        (See accompanying file LICENSE_1_0.txt or copy at
+        <ulink url="http://www.boost.org/LICENSE_1_0.txt">
+            http://www.boost.org/LICENSE_1_0.txt
+        </ulink>)
+    ]
+    [authors [Maddock, John], [Cleary, Steve]]
+    [category template]
+    [category testing]
+    [category generic]
+    [last-revision $Date: 2011-04-25 13:27:05 -0400 (Mon, 25 Apr 2011) $]
+]
+
+This manual is also available in 
+[@http://sourceforge.net/projects/boost/files/boost-docs/ 
+printer friendly PDF format].
+
+[section:intro Overview and Tutorial]
+
+The header `<boost/static_assert.hpp>` supplies two macros:
+
+   BOOST_STATIC_ASSERT(x)
+   BOOST_STATIC_ASSERT_MSG(x, msg)
+   
+Both generate a compile time error message if the integral-constant-expression `x`
+is not true. In other words, they are the compile time equivalent of the assert macro; 
+this is sometimes known as a "compile-time-assertion", but will be called a 
+"static assertion" throughout these docs. Note that if the condition is `true`, 
+then the macros will generate neither code nor data - and the macros can also 
+be used at either namespace, class or function scope. When used in a template, 
+the static assertion will be evaluated at the time the template is instantiated; 
+this is particularly useful for validating template parameters.
+
+If the C++0x `static_assert` feature is available, both macros will use it.
+For `BOOST_STATIC_ASSERT(x)`, the error message with be a stringized version of `x`.
+For `BOOST_STATIC_ASSERT_MSG(x, msg)`, the error message will be the `msg` string.
+
+If the C++0x `static_assert` feature is not available, `BOOST_STATIC_ASSERT_MSG(x, msg)`
+will be treated as `BOOST_STATIC_ASSERT(x)`.
+
+The material that follows assumes the C++0x `static_assert` feature is not available.
+
+One of the aims of `BOOST_STATIC_ASSERT` is to generate readable error messages. 
+These immediately tell the user that a library is being used in a manner that 
+is not supported. While error messages obviously differ from compiler to compiler, 
+but you should see something like: 
+
+   Illegal use of STATIC_ASSERTION_FAILURE<false>
+
+Which is intended to at least catch the eye!
+
+You can use `BOOST_STATIC_ASSERT` at any place where you can place a declaration, 
+that is at class, function or namespace scope, this is illustrated by the 
+following examples:
+
+[section:namespace Use at namespace scope.]
+
+The macro can be used at namespace scope, if there is some requirement must 
+always be true; generally this means some platform specific requirement. 
+Suppose we require that `int` be at least a 32-bit integral type, and that `wchar_t` 
+be an unsigned type. We can verify this at compile time as follows:
+
+   #include <climits>
+   #include <cwchar>
+   #include <limits>
+   #include <boost/static_assert.hpp>
+
+   namespace my_conditions {
+
+      BOOST_STATIC_ASSERT(std::numeric_limits<int>::digits >= 32);
+      BOOST_STATIC_ASSERT(WCHAR_MIN >= 0);
+
+   } // namespace my_conditions
+
+The use of the namespace my_conditions here requires some comment. 
+The macro `BOOST_STATIC_ASSERT` works by generating an typedef declaration, 
+and since the typedef must have a name, the macro generates one automatically by 
+mangling a stub name with the value of `__LINE__`. When `BOOST_STATIC_ASSERT` is 
+used at either class or function scope then each use of `BOOST_STATIC_ASSERT` 
+is guaranteed to produce a name unique to that scope (provided you only use 
+the macro once on each line). However when used in a header at namespace 
+scope, that namespace can be continued over multiple headers, each of which 
+may have their own static assertions, and on the "same" lines, thereby generating 
+duplicate declarations. In theory the compiler should silently ignore duplicate 
+typedef declarations, however many do not do so (and even if they do they are 
+entitled to emit warnings in such cases). To avoid potential problems, if you 
+use `BOOST_STATIC_ASSERT` in a header and at namespace scope, then enclose 
+them in a namespace unique to that header.
+
+[endsect]
+
+[section:function Use at function scope]
+
+The macro is typically used at function scope inside template functions, 
+when the template arguments need checking. Imagine that we have an 
+iterator-based algorithm that requires random access iterators. 
+If the algorithm is instantiated with iterators that do not meet our 
+requirements then an error will be generated eventually, but this may 
+be nested deep inside several templates, making it hard for the user to 
+determine what went wrong. One option is to add a static assertion at 
+the top level of the template, in that case if the condition is not met, 
+then an error will be generated in a way that makes it reasonably obvious to 
+the user that the template is being misused.
+
+   #include <iterator>
+   #include <boost/static_assert.hpp>
+   #include <boost/type_traits.hpp>
+
+   template <class RandomAccessIterator >
+   RandomAccessIterator foo(RandomAccessIterator from, 
+                            RandomAccessIterator to)
+   {
+      // this template can only be used with
+      // random access iterators...
+      typedef typename std::iterator_traits< 
+            RandomAccessIterator >::iterator_category cat;
+      BOOST_STATIC_ASSERT(
+         (boost::is_convertible<
+            cat, 
+            const std::random_access_iterator_tag&>::value));
+      //
+      // detail goes here...
+      return from;
+   }
+
+A couple of footnotes are in order here: the extra set of parenthesis around the 
+assert, is to prevent the comma inside the `is_convertible` template being 
+interpreted by the preprocessor as a macro argument separator; the target type 
+for `is_convertible` is a reference type, as some compilers have problems 
+using `is_convertible` when the conversion is via a user defined constructor 
+(in any case there is no guarantee that the iterator tag classes are 
+copy-constructible).
+
+[endsect]
+
+[section:class Use at class scope]
+
+The macro is typically used inside classes that are templates. 
+Suppose we have a template-class that requires an unsigned integral type with 
+at least 16-bits of precision as a template argument, we can achieve this 
+using something like this:
+
+   #include <limits>
+   #include <boost/static_assert.hpp>
+
+   template <class UnsignedInt>
+   class myclass
+   {
+   private:
+      BOOST_STATIC_ASSERT((std::numeric_limits<UnsignedInt>::digits >= 16)
+                           && std::numeric_limits<UnsignedInt>::is_specialized
+                           && std::numeric_limits<UnsignedInt>::is_integer
+                           && !std::numeric_limits<UnsignedInt>::is_signed);
+   public:
+      /* details here */
+   };
+
+[endsect]
+
+[section:templates Use in templates]
+
+Normally static assertions when used inside a class or function template, 
+will not be instantiated until the template in which it is used is instantiated.  
+However, there is one potential problem to watch out for: if the static assertion 
+is not dependent upon one or more template parameters, then the compiler is 
+permitted to evaluate the static assertion at the point it is first seen, 
+irrespective of whether the template is ever instantiated, for example:
+
+   template <class T>
+   struct must_not_be_instantiated
+   {   
+      BOOST_STATIC_ASSERT(false);
+   };
+
+Will produce a compiler error with some compilers (for example Intel 8.1 
+or gcc 3.4), regardless of whether the template is ever instantiated.  A 
+workaround in cases like this is to force the assertion to be dependent 
+upon a template parameter:
+
+   template <class T>
+   struct must_not_be_instantiated
+   {   
+      // this will be triggered if this type is instantiated
+      BOOST_STATIC_ASSERT(sizeof(T) == 0); 
+   };
+
+
+[endsect]
+
+[endsect]
+
+[section:how How it works]
+
+`BOOST_STATIC_ASSERT` works as follows. There is class `STATIC_ASSERTION_FAILURE`
+ which is defined as:
+
+   namespace boost{
+
+   template <bool> struct STATIC_ASSERTION_FAILURE;
+
+   template <> struct STATIC_ASSERTION_FAILURE<true>{};
+
+   }
+
+The key feature is that the error message triggered by the undefined 
+expression `sizeof(STATIC_ASSERTION_FAILURE<0>)`, tends to be consistent 
+across a wide variety of compilers. The rest of the machinery of 
+`BOOST_STATIC_ASSERT` is just a way to feed the `sizeof` expression into a `typedef`. 
+The use of a macro here is somewhat ugly; however boost members have spent 
+considerable effort trying to invent a static assert that avoided macros, 
+all to no avail. The general conclusion was that the good of a static assert 
+working at namespace, function, and class scope outweighed the ugliness of a macro.
+
+[endsect]
+
+[section:test Test Programs]
+
+[table Test programs provided with static_assert
+[[Test Program][Expected to Compile][Description]]
+
+[[[@../../libs/static_assert/static_assert_test.cpp static_assert_test.cpp]] [Yes] [Illustrates usage, and should always compile, really just tests compiler compatibility.]] 
+[[[@../../libs/static_assert/static_assert_example_1.cpp static_assert_example_1.cpp]] [Platform dependent.] [Namespace scope test program, may compile depending upon the platform. ]]
+[[[@../../libs/static_assert/static_assert_example_2.cpp static_assert_example_2.cpp]] [Yes] [Function scope test program. ]]
+[[[@../../libs/static_assert/static_assert_example_3.cpp static_assert_example_3.cpp]] [Yes] [Class scope test program. ]]
+[[[@../../libs/static_assert/static_assert_test_fail_1.cpp static_assert_test_fail_1.cpp]] [No] [Illustrates failure at namespace scope. ]]
+[[[@../../libs/static_assert/static_assert_test_fail_2.cpp static_assert_test_fail_2.cpp]] [No] [Illustrates failure at non-template function scope. ]]
+[[[@../../libs/static_assert/static_assert_test_fail_3.cpp static_assert_test_fail_3.cpp]] [No] [Illustrates failure at non-template class scope. ]]
+[[[@../../libs/static_assert/static_assert_test_fail_4.cpp static_assert_test_fail_4.cpp]] [No] [Illustrates failure at non-template class scope. ]]
+[[[@../../libs/static_assert/static_assert_test_fail_5.cpp static_assert_test_fail_5.cpp]] [No] [Illustrates failure at template class scope. ]]
+[[[@../../libs/static_assert/static_assert_test_fail_6.cpp static_assert_test_fail_6.cpp]] [No] [Illustrates failure at template class member function scope. ]]
+[[[@../../libs/static_assert/static_assert_test_fail_7.cpp static_assert_test_fail_7.cpp]] [No] [Illustrates failure of class scope example. ]]
+[[[@../../libs/static_assert/static_assert_test_fail_8.cpp static_assert_test_fail_8.cpp]] [No] [Illustrates failure of function scope example. ]]
+[[[@../../libs/static_assert/static_assert_test_fail_9.cpp static_assert_test_fail_9.cpp]] [No] [Illustrates failure of function scope example (part 2). ]]
+
+]
+
+[endsect]
+
+
diff --git a/libs/static_assert/index.html b/libs/static_assert/index.html
new file mode 100644
index 0000000000..f1e6c3234c
--- /dev/null
+++ b/libs/static_assert/index.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+  <head>
+    <meta http-equiv="refresh" content="0; URL=../../doc/html/boost_staticassert.html">
+  </head>
+  <body>
+    Automatic redirection failed, please go to
+    <a href="../../doc/html/boost_staticassert.html">../../doc/html/boost_staticassert.html</a>
+    or view the online version at 
+    <a href="http://www.boost.org/regression-logs/cs-win32_metacomm/doc/html/boost_staticassert.html">
+    http://www.boost.org/regression-logs/cs-win32_metacomm/doc/html/boost_staticassert.html</a>
+      <P>Copyright&nbsp;John Maddock 2006</P>
+      <P>Distributed under the Boost Software License, Version 1.0. (See accompanying file <A href="../../LICENSE_1_0.txt">
+            LICENSE_1_0.txt</A> or copy at <A href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</A>).</P>
+  </body>
+</html>
+
+
diff --git a/libs/static_assert/static_assert.htm b/libs/static_assert/static_assert.htm
new file mode 100644
index 0000000000..f1e6c3234c
--- /dev/null
+++ b/libs/static_assert/static_assert.htm
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+  <head>
+    <meta http-equiv="refresh" content="0; URL=../../doc/html/boost_staticassert.html">
+  </head>
+  <body>
+    Automatic redirection failed, please go to
+    <a href="../../doc/html/boost_staticassert.html">../../doc/html/boost_staticassert.html</a>
+    or view the online version at 
+    <a href="http://www.boost.org/regression-logs/cs-win32_metacomm/doc/html/boost_staticassert.html">
+    http://www.boost.org/regression-logs/cs-win32_metacomm/doc/html/boost_staticassert.html</a>
+      <P>Copyright&nbsp;John Maddock 2006</P>
+      <P>Distributed under the Boost Software License, Version 1.0. (See accompanying file <A href="../../LICENSE_1_0.txt">
+            LICENSE_1_0.txt</A> or copy at <A href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</A>).</P>
+  </body>
+</html>
+
+
diff --git a/libs/static_assert/static_assert_example_1.cpp b/libs/static_assert/static_assert_example_1.cpp
new file mode 100644
index 0000000000..14c529c34e
--- /dev/null
+++ b/libs/static_assert/static_assert_example_1.cpp
@@ -0,0 +1,34 @@
+//  (C) Copyright Steve Cleary & John Maddock 2000.
+//  Use, modification and distribution are subject to 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 most recent version including documentation.
+
+#include <climits>
+#include <cwchar>
+#include <limits>
+#include <boost/static_assert.hpp>
+
+#if !defined(WCHAR_MIN)
+#define WCHAR_MIN 0
+#endif
+
+namespace boost{
+
+namespace my_conditions {
+BOOST_STATIC_ASSERT(std::numeric_limits<int>::digits >= 32);
+BOOST_STATIC_ASSERT(WCHAR_MIN >= 0);
+
+} // namespace my_conditions
+
+} // namespace boost
+
+int main()
+{
+   return 0;
+}
+
+
+
+
diff --git a/libs/static_assert/static_assert_example_2.cpp b/libs/static_assert/static_assert_example_2.cpp
new file mode 100644
index 0000000000..a32b79d980
--- /dev/null
+++ b/libs/static_assert/static_assert_example_2.cpp
@@ -0,0 +1,40 @@
+//  (C) Copyright John Maddock 2000.
+//  Use, modification and distribution are subject to 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 most recent version including documentation.
+
+#include <iterator>
+#include <list>
+#include <deque>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits.hpp>
+
+template <class RandomAccessIterator >
+RandomAccessIterator foo(RandomAccessIterator from, RandomAccessIterator /*to*/)
+{
+   // this template can only be used with
+   // random access iterators...
+   typedef typename std::iterator_traits< RandomAccessIterator >::iterator_category cat;
+   BOOST_STATIC_ASSERT((boost::is_convertible<cat, const std::random_access_iterator_tag&>::value));
+   //
+   // detail goes here...
+   return from;
+}
+
+int main()
+{
+   std::deque<int> d;
+   std::list<int> l;
+   foo(d.begin(), d.end()); // OK
+   //foo(l.begin(), l.end()); // error
+   return 0;
+}
+
+
+
+
+
+
+
diff --git a/libs/static_assert/static_assert_example_3.cpp b/libs/static_assert/static_assert_example_3.cpp
new file mode 100644
index 0000000000..1cc154505b
--- /dev/null
+++ b/libs/static_assert/static_assert_example_3.cpp
@@ -0,0 +1,33 @@
+//  (C) Copyright John Maddock 2000.
+//  Use, modification and distribution are subject to 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 most recent version including documentation.
+
+#include <limits>
+#include <boost/limits.hpp>
+#include <boost/static_assert.hpp>
+
+template <class UnsignedInt>
+class myclass
+{
+private:
+   BOOST_STATIC_ASSERT((std::numeric_limits<UnsignedInt>::digits >= 16)
+                        && std::numeric_limits<UnsignedInt>::is_specialized
+                        && std::numeric_limits<UnsignedInt>::is_integer
+                        && !std::numeric_limits<UnsignedInt>::is_signed);
+public:
+   /* details here */
+};
+
+myclass<unsigned>      m1; // this should be OK
+//myclass<int>           m2; // this should fail
+//myclass<unsigned char> m3; // and so should this
+
+int main()
+{
+   return 0;
+}
+
+
diff --git a/libs/static_assert/static_assert_test.cpp b/libs/static_assert/static_assert_test.cpp
new file mode 100644
index 0000000000..3147e5c74e
--- /dev/null
+++ b/libs/static_assert/static_assert_test.cpp
@@ -0,0 +1,97 @@
+//  (C) Copyright Steve Cleary & John Maddock 2000.
+//  Use, modification and distribution are subject to 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 most recent version including documentation.
+
+#include <boost/static_assert.hpp>
+
+//
+// all these tests should succeed.
+// some of these tests are rather simplistic (ie useless)
+// in order to ensure that they compile on all platforms.
+//
+
+// Namespace scope
+BOOST_STATIC_ASSERT(sizeof(int) >= sizeof(short));
+BOOST_STATIC_ASSERT(sizeof(char) == 1);
+BOOST_STATIC_ASSERT_MSG(sizeof(int) >= sizeof(short), "msg1");
+BOOST_STATIC_ASSERT_MSG(sizeof(char) == 1, "msg2");
+
+// Function (block) scope
+void f()
+{
+  BOOST_STATIC_ASSERT(sizeof(int) >= sizeof(short));
+  BOOST_STATIC_ASSERT(sizeof(char) == 1);
+  BOOST_STATIC_ASSERT_MSG(sizeof(int) >= sizeof(short), "msg3");
+  BOOST_STATIC_ASSERT_MSG(sizeof(char) == 1, "msg4");
+}
+
+struct Bob
+{
+  private:  // can be in private, to avoid namespace pollution
+    BOOST_STATIC_ASSERT(sizeof(int) >= sizeof(short));
+    BOOST_STATIC_ASSERT(sizeof(char) == 1);
+    BOOST_STATIC_ASSERT_MSG(sizeof(int) >= sizeof(short), "msg5");
+    BOOST_STATIC_ASSERT_MSG(sizeof(char) == 1, "msg6");
+  public:
+
+  // Member function scope: provides access to member variables
+  int x;
+  char c;
+  int f()
+  {
+#if defined(_MSC_VER) && _MSC_VER < 1300 // broken sizeof in VC6
+    BOOST_STATIC_ASSERT(sizeof(x) >= sizeof(short));
+    BOOST_STATIC_ASSERT(sizeof(c) == 1);
+    BOOST_STATIC_ASSERT_MSG(sizeof(x) >= sizeof(short), "msg7");
+    BOOST_STATIC_ASSERT_MSG(sizeof(c) == 1, "msg8");
+#endif
+    return x;
+  }
+};
+
+
+
+// Template class scope
+template <class Int, class Char>
+struct Bill
+{
+  private:  // can be in private, to avoid namespace pollution
+    BOOST_STATIC_ASSERT(sizeof(Int) > sizeof(char));
+    BOOST_STATIC_ASSERT_MSG(sizeof(Int) > sizeof(char), "msg9");
+  public:
+
+  // Template member function scope: provides access to member variables
+  Int x;
+  Char c;
+  template <class Int2, class Char2>
+  void f(Int2 , Char2 )
+  {
+    BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Int2));
+    BOOST_STATIC_ASSERT(sizeof(Char) == sizeof(Char2));
+    BOOST_STATIC_ASSERT_MSG(sizeof(Int) == sizeof(Int2), "msg10");
+    BOOST_STATIC_ASSERT_MSG(sizeof(Char) == sizeof(Char2), "msg11");
+  }
+};
+
+void test_Bill() // BOOST_STATIC_ASSERTs are not triggerred until instantiated
+{
+  Bill<int, char> z;
+  //Bill<int, int> bad; // will not compile
+  int i = 3;
+  char ch = 'a';
+  z.f(i, ch);
+  //z.f(i, i); // should not compile
+}
+
+int main()
+{ 
+   test_Bill();
+   return 0; 
+}
+
+
+
+
diff --git a/libs/static_assert/static_assert_test_fail_1.cpp b/libs/static_assert/static_assert_test_fail_1.cpp
new file mode 100644
index 0000000000..d8e010758e
--- /dev/null
+++ b/libs/static_assert/static_assert_test_fail_1.cpp
@@ -0,0 +1,23 @@
+//  (C) Copyright Steve Cleary & John Maddock 2000.
+//  Use, modification and distribution are subject to 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 most recent version including documentation.
+
+#include <boost/static_assert.hpp>
+
+//
+// all these tests should fail:
+//
+typedef char a1[2];
+typedef char a2[3];
+
+// Namespace scope
+BOOST_STATIC_ASSERT(sizeof(a1) == sizeof(a2)); // will not compile
+
+
+
+
+
+
diff --git a/libs/static_assert/static_assert_test_fail_10.cpp b/libs/static_assert/static_assert_test_fail_10.cpp
new file mode 100644
index 0000000000..ddc2d1a5de
--- /dev/null
+++ b/libs/static_assert/static_assert_test_fail_10.cpp
@@ -0,0 +1,18 @@
+//~ Copyright 2005 Redshift Software, Inc.
+//~ Distributed under the Boost Software License, Version 1.0.
+//~ (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/static_assert.hpp>
+
+template <int N>
+int foo()
+{
+    BOOST_STATIC_ASSERT( N < 2 );
+    
+    return N;
+}
+
+int main()
+{
+    return foo<5>();
+}
diff --git a/libs/static_assert/static_assert_test_fail_2.cpp b/libs/static_assert/static_assert_test_fail_2.cpp
new file mode 100644
index 0000000000..c75de491c4
--- /dev/null
+++ b/libs/static_assert/static_assert_test_fail_2.cpp
@@ -0,0 +1,25 @@
+//  (C) Copyright Steve Cleary & John Maddock 2000.
+//  Use, modification and distribution are subject to 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 most recent version including documentation.
+
+#include <boost/static_assert.hpp>
+
+//
+// all these tests should fail:
+//
+typedef char a1[2];
+typedef char a2[3];
+
+// Function (block) scope
+void f()
+{
+  BOOST_STATIC_ASSERT(sizeof(a1) == sizeof(a2)); // should not compile
+}
+
+
+
+
+
diff --git a/libs/static_assert/static_assert_test_fail_3.cpp b/libs/static_assert/static_assert_test_fail_3.cpp
new file mode 100644
index 0000000000..182658a459
--- /dev/null
+++ b/libs/static_assert/static_assert_test_fail_3.cpp
@@ -0,0 +1,39 @@
+//  (C) Copyright Steve Cleary & John Maddock 2000.
+//  Use, modification and distribution are subject to 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 most recent version including documentation.
+
+#include <boost/static_assert.hpp>
+
+//
+// this tests should fail:
+//
+typedef char a1[2];
+typedef char a2[3];
+
+struct Bob
+{
+  private:  // can be in private, to avoid namespace pollution
+    BOOST_STATIC_ASSERT(sizeof(a1) == sizeof(a2)); // will not compile
+  public:
+
+  // Member function scope: provides access to member variables
+  int x;
+  char c;
+  int f()
+  {
+#ifndef _MSC_VER // broken sizeof in VC6
+    BOOST_STATIC_ASSERT(sizeof(x) == 4);
+    BOOST_STATIC_ASSERT(sizeof(c) == 1);
+#endif
+    return x;
+  }
+};
+
+
+
+
+
+
diff --git a/libs/static_assert/static_assert_test_fail_4.cpp b/libs/static_assert/static_assert_test_fail_4.cpp
new file mode 100644
index 0000000000..89c27329f6
--- /dev/null
+++ b/libs/static_assert/static_assert_test_fail_4.cpp
@@ -0,0 +1,38 @@
+//  (C) Copyright Steve Cleary & John Maddock 2000.
+//  Use, modification and distribution are subject to 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 most recent version including documentation.
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+
+//
+// all these tests should fail:
+//
+
+
+struct Bob
+{
+  public:
+
+  // Member function scope: provides access to member variables
+  char x[4];
+  char c;
+  int f()
+  {
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1200 // broken sizeof in VC6
+    BOOST_STATIC_ASSERT(sizeof(x) == 4);
+    BOOST_STATIC_ASSERT(sizeof(c) == 1);
+    BOOST_STATIC_ASSERT((sizeof(x) == sizeof(c))); // should not compile
+#endif
+    return x;
+  }
+};
+
+
+
+
+
+
diff --git a/libs/static_assert/static_assert_test_fail_5.cpp b/libs/static_assert/static_assert_test_fail_5.cpp
new file mode 100644
index 0000000000..155c199eb2
--- /dev/null
+++ b/libs/static_assert/static_assert_test_fail_5.cpp
@@ -0,0 +1,39 @@
+//  (C) Copyright Steve Cleary & John Maddock 2000.
+//  Use, modification and distribution are subject to 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 most recent version including documentation.
+
+#include <boost/static_assert.hpp>
+
+//
+// all these tests should fail:
+//
+
+// Template class scope
+template <class Int, class Char>
+struct Bill
+{
+  private:  // can be in private, to avoid namespace pollution
+    BOOST_STATIC_ASSERT(sizeof(Int) == 4);
+    BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Char)); // should not compile when instantiated
+  public:
+
+  // Template member function scope: provides access to member variables
+  Int x;
+  Char c;
+  template <class Int2, class Char2>
+  void f(Int2 , Char2 )
+  {
+    BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Int2));
+    BOOST_STATIC_ASSERT(sizeof(Char) == sizeof(Char2));
+    //BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Char)); // should not compile when instantiated
+  }
+};
+
+Bill<int, char> b;
+
+
+
+
diff --git a/libs/static_assert/static_assert_test_fail_6.cpp b/libs/static_assert/static_assert_test_fail_6.cpp
new file mode 100644
index 0000000000..b41aa74719
--- /dev/null
+++ b/libs/static_assert/static_assert_test_fail_6.cpp
@@ -0,0 +1,46 @@
+//  (C) Copyright Steve Cleary & John Maddock 2000.
+//  Use, modification and distribution are subject to 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 most recent version including documentation.
+
+#include <boost/static_assert.hpp>
+
+//
+// all these tests should fail:
+//
+
+// Template class scope
+template <class Int, class Char>
+struct Bill
+{
+  private:  // can be in private, to avoid namespace pollution
+    BOOST_STATIC_ASSERT(sizeof(Int) == 4);
+    //BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Char)); // should not compile when instantiated
+  public:
+
+  // Template member function scope: provides access to member variables
+  Int x;
+  Char c;
+  template <class Int2, class Char2>
+  void f(Int2 , Char2 )
+  {
+    BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Int2));
+    BOOST_STATIC_ASSERT(sizeof(Char) == sizeof(Char2));
+    BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Char)); // should not compile when instantiated
+  }
+};
+
+void foo()
+{
+   int i = 0;
+   char c = 0;
+   Bill<int, char> b;
+   // this should fail:
+   b.f(i, c);
+}
+
+
+
+
diff --git a/libs/static_assert/static_assert_test_fail_7.cpp b/libs/static_assert/static_assert_test_fail_7.cpp
new file mode 100644
index 0000000000..7e90126946
--- /dev/null
+++ b/libs/static_assert/static_assert_test_fail_7.cpp
@@ -0,0 +1,31 @@
+//  (C) Copyright John Maddock 2000.
+//  Use, modification and distribution are subject to 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 most recent version including documentation.
+
+#include <climits>
+#include <boost/limits.hpp>
+#include <boost/static_assert.hpp>
+
+template <class UnsignedInt>
+class myclass
+{
+private:
+   BOOST_STATIC_ASSERT(sizeof(UnsignedInt) * CHAR_BIT >= 16);
+   BOOST_STATIC_ASSERT(std::numeric_limits<UnsignedInt>::is_specialized
+                        && std::numeric_limits<UnsignedInt>::is_integer
+                        && !std::numeric_limits<UnsignedInt>::is_signed);
+public:
+   /* details here */
+};
+
+myclass<int>           m2; // this should fail
+myclass<unsigned char> m3; // and so should this
+
+int main()
+{
+   return 0;
+}
+
diff --git a/libs/static_assert/static_assert_test_fail_8.cpp b/libs/static_assert/static_assert_test_fail_8.cpp
new file mode 100644
index 0000000000..a087bb7094
--- /dev/null
+++ b/libs/static_assert/static_assert_test_fail_8.cpp
@@ -0,0 +1,44 @@
+//  (C) Copyright John Maddock 2000.
+//  Use, modification and distribution are subject to 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 most recent version including documentation.
+
+#include <iterator>
+#include <list>
+#include <deque>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits.hpp>
+
+template <class RandomAccessIterator >
+RandomAccessIterator foo(RandomAccessIterator from, RandomAccessIterator)
+{
+   // this template can only be used with
+   // random access iterators...
+   typedef typename std::iterator_traits< RandomAccessIterator >::iterator_category cat;
+   BOOST_STATIC_ASSERT((boost::is_convertible<cat*, std::random_access_iterator_tag*>::value));
+   //
+   // detail goes here...
+   return from;
+}
+
+// ensure that delayed instantiation compilers like Comeau see the failure early
+// enough for "compile-fail" testing with the Boost.Build testing framework. (Greg Comeau)
+template
+std::list<int>::iterator
+   foo(std::list<int>::iterator, std::list<int>::iterator);
+
+int main()
+{
+   std::deque<int> d;
+   std::list<int> l;
+   foo(d.begin(), d.end()); // OK
+   foo(l.begin(), l.end()); // error
+   return 0;
+}
+
+
+ 
+
+
diff --git a/libs/static_assert/static_assert_test_fail_9.cpp b/libs/static_assert/static_assert_test_fail_9.cpp
new file mode 100644
index 0000000000..09e4af9e6f
--- /dev/null
+++ b/libs/static_assert/static_assert_test_fail_9.cpp
@@ -0,0 +1,32 @@
+//  (C) Copyright John Maddock 2000.
+//  Use, modification and distribution are subject to 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 most recent version including documentation.
+
+#include <climits>
+#include <boost/limits.hpp>
+#include <boost/static_assert.hpp>
+
+template <class UnsignedInt>
+class myclass
+{
+private:
+   BOOST_STATIC_ASSERT(sizeof(UnsignedInt) * CHAR_BIT >= 16);
+   BOOST_STATIC_ASSERT(std::numeric_limits<UnsignedInt>::is_specialized
+                        && std::numeric_limits<UnsignedInt>::is_integer
+                        && !std::numeric_limits<UnsignedInt>::is_signed);
+public:
+   /* details here */
+};
+
+myclass<unsigned>      m1; // this should be OK
+//myclass<int>           m2; // this should fail
+myclass<unsigned char> m3; // and so should this
+
+int main()
+{
+   return 0;
+}
+