This commit was manufactured by cvs2svn to create branch

'python-v2-dev'. [SVN r14785]
Fix unversioned VC++ checks
2026-05-31 21:19:05 +02:00 · 2002-08-12 13:35:54 +00:00 · 2002-07-13 12:26:19 +00:00 · 2002-05-21 16:24:07 +00:00 · 2002-03-03 10:16:50 +00:00 · 2002-01-24 12:37:38 +00:00
11 changed files with 286 additions and 250 deletions
@@ -0,0 +1,16 @@
 subproject libs/static_assert ;
 unit-test static_assert_test : static_assert_test.cpp
 	: <sysinclude>$(BOOST_ROOT) : ;
 unit-test static_assert_example_1 : static_assert_example_1.cpp
 	: <sysinclude>$(BOOST_ROOT) : ;
 unit-test static_assert_example_2 : static_assert_example_2.cpp
 	: <sysinclude>$(BOOST_ROOT) : ;
 unit-test static_assert_example_3 : static_assert_example_3.cpp
 	: <sysinclude>$(BOOST_ROOT) : ;
@@ -8,8 +8,8 @@
 /*
 Revision history:
- 	02 August 2000
+   02 August 2000
- 		Initial version.
+      Initial version.
 */
 #ifndef BOOST_STATIC_ASSERT_HPP
@@ -25,11 +25,13 @@
 namespace boost{
-template <bool> struct STATIC_ASSERTION_FAILURE;
+// HP aCC cannot deal with missing names for template value parameters
 template <bool x> struct STATIC_ASSERTION_FAILURE;
 template <> struct STATIC_ASSERTION_FAILURE<true>{};
-template<int> struct static_assert_test{};
+// HP aCC cannot deal with missing names for template value parameters
 template<int x> struct static_assert_test{};
 }
@@ -51,39 +53,34 @@ template<int> struct static_assert_test{};
 // an eye catching error message.  The result of the sizeof expression is either
 // used as an enum initialiser, or as a template argument depending which version
 // is in use...
 // Note that the argument to the assert is explicitly cast to bool using old-
 // style casts: too many compilers currently have problems with static_cast
 // when used inside integral constant expressions.
 //
-#ifndef BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS
+#if !defined(BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS) && !defined(__MWERKS__)
 #ifndef BOOST_MSVC
 #define BOOST_STATIC_ASSERT( B ) \
   typedef ::boost::static_assert_test<\
-      sizeof(::boost::STATIC_ASSERTION_FAILURE< ( B ) >)>\
+      sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >)>\
-         BOOST_ASSERT_JOIN(boost_static_assert_typedef_, __LINE__)
+         BOOST_JOIN(boost_static_assert_typedef_, __LINE__)
 #else
 // __LINE__ macro broken when -ZI is used see Q199057
-// fortunately MSVC ignores duplicate typedef's:
+// fortunately MSVC ignores duplicate typedef's.
 #define BOOST_STATIC_ASSERT( B ) \
   typedef ::boost::static_assert_test<\
-      sizeof(::boost::STATIC_ASSERTION_FAILURE< ( B ) >)\
+      sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >)\
      > boost_static_assert_typedef_
 #endif
 #else
 // alternative enum based implementation:
 #define BOOST_STATIC_ASSERT( B ) \
-   enum { BOOST_ASSERT_JOIN(boost_static_assert_enum_, __LINE__) \
+   enum { BOOST_JOIN(boost_static_assert_enum_, __LINE__) \
-      = sizeof(::boost::STATIC_ASSERTION_FAILURE< ( B ) >) }
+      = sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >) }
 #endif
 //
 // The following piece of macro magic joins the two 
 // arguments together, even when one of the arguments is
 // itself a macro (see 16.3.1 in C++ standard).  The key
 // is that macro expantion of macro arguments does not
 // occur in BOOST_DO_ASSERT_JOIN but does in BOOST_ASSERT_JOIN
 // provided it is called from within another macro.
 #define BOOST_ASSERT_JOIN( X, Y ) BOOST_DO_ASSERT_JOIN( X, Y )
 #define BOOST_DO_ASSERT_JOIN( X, Y ) X##Y
 #endif // BOOST_STATIC_ASSERT_HPP
@@ -1,46 +1,58 @@
-<!DOCTYPE HTML PUBLIC "-//SoftQuad Software//DTD HoTMetaL PRO 5.0::19981217::extensions to HTML 4.0//EN" "hmpro5.dtd">
+<html>
-<HTML>
+<head>
 <meta http-equiv="Content-Type"
 content="text/html; charset=iso-8859-1">
 <meta name="Template"
 content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
 <meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
 <title>static assertions</title>
 </head>
-<HEAD>
+<body bgcolor="#FFFFFF" text="#000000" link="#0000FF"
-<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1"> 
+vlink="#800080">
 <META NAME="Template"
 CONTENT="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot"> 
 <META NAME="GENERATOR" CONTENT="Microsoft FrontPage Express 2.0"> 
 <TITLE>static assertions</TITLE>
 </HEAD>
-<BODY BGCOLOR="#FFFFFF" TEXT="#000000" LINK="#0000FF" VLINK="#800080">
+<h1><img src="../../c++boost.gif" width="276" height="86">Header
-<H1><IMG SRC="../../c++boost.gif" WIDTH="276" HEIGHT="86">Header &lt;<A
+&lt;<a href="../../boost/static_assert.hpp">boost/static_assert.hpp</a>&gt;</h1>
-HREF="../../boost/detail/call_traits.hpp">boost/static_assert.hpp</A>&gt;</H1>
+
-<P>The header &lt;boost/static_assert.hpp&gt; supplies a single macro
+<p>The header &lt;boost/static_assert.hpp&gt; supplies a single
-BOOST_STATIC_ASSERT(x), which generates a compile time error message if the
+macro BOOST_STATIC_ASSERT(x), which generates a compile time
-integral-constant-expression <I>x</I> is not true. In other words it is the
+error message if the <a
-compile time equivalent of the assert macro; this is sometimes known as a
+href="../../more/int_const_guidelines.htm">integral-constant-expression</a>
 <i>x</i> is not true. In other words it is the compile time
 equivalent of the assert macro; this is sometimes known as a
 &quot;compile-time-assertion&quot;, but will be called a &quot;static
-assertion&quot; throughout these docs. Note that if the condition is true, then
+assertion&quot; throughout these docs. Note that if the condition
-the macro will generate neither code nor data - and the macro can also be used
+is true, then the macro will generate neither code nor data - and
-at either namespace, class or function scope. When used in a template, the
+the macro can also be used at either namespace, class or function
-static assertion will be evaluated at the time the template is instantiated;
+scope. When used in a template, the static assertion will be
-this is particularly useful for validating template parameters. </P>
+evaluated at the time the template is instantiated; this is
-<P>One of the aims of BOOST_STATIC_ASSERT is to generate readable error
+particularly useful for validating template parameters. </p>
 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: </P>
 <PRE>Illegal use of COMPILE_TIME_ASSERTION_FAILURE&lt;false&gt;</PRE>
-<P>Which is intended to at least catch the eye!</P>
+<p>One of the aims of BOOST_STATIC_ASSERT is to generate readable
-<P>You can use BOOST_STATIC_ASSERT at any place where you can place a
+error messages. These immediately tell the user that a library is
-declaration, that is at <A HREF="#class">class</A>, <A
+being used in a manner that is not supported. While error
-HREF="#function">function</A> or <A HREF="#namespace">namespace</A> scope, this
+messages obviously differ from compiler to compiler, but you
-is illustrated by the following examples:</P>
+should see something like: </p>
-<H3><A NAME="namespace"></A>Use at namespace scope.</H3>
+
-<P>The macro can be used at namespace scope, if there is some requirement must
+<pre>Illegal use of COMPILE_TIME_ASSERTION_FAILURE&lt;false&gt;</pre>
-always be true; generally this means some platform specific requirement.
+
-Suppose we require that <B>int</B> be at least a 32-bit integral type, and that
+<p>Which is intended to at least catch the eye!</p>
-<B>wchar_t</B> be an unsigned type. We can verify this at compile time as
+
-follows:</P>
+<p>You can use BOOST_STATIC_ASSERT at any place where you can
-<PRE>#include &lt;climits&gt;
+place a declaration, that is at <a href="#class">class</a>, <a
 href="#function">function</a> or <a href="#namespace">namespace</a>
 scope, this is illustrated by the following examples:</p>
 <h3><a name="namespace"></a>Use at namespace scope.</h3>
 <p>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 <b>int</b>
 be at least a 32-bit integral type, and that <b>wchar_t</b> be an
 unsigned type. We can verify this at compile time as follows:</p>
 <pre>#include &lt;climits&gt;
 #include &lt;cwchar&gt;
 #include &lt;boost/static_assert.hpp&gt;
@@ -50,35 +62,41 @@ BOOST_STATIC_ASSERT(sizeof(int) * CHAR_BIT &gt;= 32);
 BOOST_STATIC_ASSERT(WCHAR_MIN &gt;= 0);
 } // namespace my_conditions
-</PRE>
+</pre>
-<P>The use of the namespace <I>my_conditions</I> here requires some comment.
+<p>The use of the namespace <i>my_conditions</i> here requires
-The macro BOOST_STATIC_ASSERT works by generating an <STRONG>typedef</STRONG>
+some comment. The macro BOOST_STATIC_ASSERT works by generating
-declaration, and since the typedef must have a name, the macro generates one
+an <strong>typedef</strong> declaration, and since the typedef
-automatically by mangling a stub name with the value of __LINE__. When
+must have a name, the macro generates one automatically by
-BOOST_STATIC_ASSERT is used at either class or function scope then each use of
+mangling a stub name with the value of __LINE__. When
-BOOST_STATIC_ASSERT is guaranteed to produce a name unique to that scope
+BOOST_STATIC_ASSERT is used at either class or function scope
-(provided you only use the macro once on each line). However when used in a
+then each use of BOOST_STATIC_ASSERT is guaranteed to produce a
-header at namespace scope, that namespace can be continued over multiple
+name unique to that scope (provided you only use the macro once
-headers, each of which may have their own static assertions, and on the
+on each line). However when used in a header at namespace scope,
-&quot;same&quot; lines, thereby generating duplicate declarations. In theory
+that namespace can be continued over multiple headers, each of
-the compiler should silently ignore duplicate typedef declarations, however
+which may have their own static assertions, and on the &quot;same&quot;
-many do not do so (and even if they do they are entitled to emit warnings in
+lines, thereby generating duplicate declarations. In theory the
-such cases). To avoid potential problems, if you use BOOST_STATIC_ASSERT in a
+compiler should silently ignore duplicate typedef declarations,
-header and at namespace scope, then enclose them in a namespace unique to that
+however many do not do so (and even if they do they are entitled
-header.</P>
+to emit warnings in such cases). To avoid potential problems, if
-<H3><A NAME="function"></A>Use at function scope</H3>
+you use BOOST_STATIC_ASSERT in a header and at namespace scope,
-<P>The macro is typically used at function scope inside template functions,
+then enclose them in a namespace unique to that header.</p>
-when the template arguments need checking. Imagine that we have an
+
-iterator-based algorithm that requires random access iterators. If the
+<h3><a name="function"></a>Use at function scope</h3>
-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
+<p>The macro is typically used at function scope inside template
-several templates, making it hard for the user to determine what went wrong.
+functions, when the template arguments need checking. Imagine
-One option is to add a static assertion at the top level of the template, in
+that we have an iterator-based algorithm that requires random
-that case if the condition is not met, then an error will be generated in a way
+access iterators. If the algorithm is instantiated with iterators
-that makes it reasonably obvious to the user that the template is being
+that do not meet our requirements then an error will be generated
-misused.</P>
+eventually, but this may be nested deep inside several templates,
-<PRE>#include &lt;iterator&gt;
+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.</p>
 <pre>#include &lt;iterator&gt;
 #include &lt;boost/static_assert.hpp&gt;
 #include &lt;boost/type_traits.hpp&gt;
@@ -92,24 +110,28 @@ RandomAccessIterator foo(RandomAccessIterator from, RandomAccessIterator to)
   //
   // detail goes here...
   return from;
-}</PRE>
+}</pre>
-<P>A couple of footnotes are in order here: the extra set of parenthesis around
+<p>A couple of footnotes are in order here: the extra set of
-the assert, is to prevent the comma inside the is_convertible template being
+parenthesis around the assert, is to prevent the comma inside the
-interpreted by the preprocessor as a macro argument separator; the target type
+is_convertible template being interpreted by the preprocessor as
-for is_convertible is a reference type, as some compilers have problems using
+a macro argument separator; the target type for is_convertible is
-is_convertible when the conversion is via a user defined constructor (in any
+a reference type, as some compilers have problems using
-case there is no guarantee that the iterator tag classes are
+is_convertible when the conversion is via a user defined
-copy-constructible).</P>
+constructor (in any case there is no guarantee that the iterator
-<H3><A NAME="class"></A>Use at class scope</H3>
+tag classes are copy-constructible).</p>
-<P>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
+<h3><a name="class"></a>Use at class scope</h3>
-16-bits of precision as a template argument, we can achieve this using
+
-something like this:</P>
+<p>The macro is typically used inside classes that are templates.
-<PRE>#include &lt;climits&gt;
+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:</p>
 <pre>#include &lt;climits&gt;
 #include &lt;boost/static_assert.hpp&gt;
-Template &lt;class UnsignedInt&gt;template &lt;class UnsignedInt&gt;
+template &lt;class UnsignedInt&gt;
 class myclass
 {
 private:
@@ -120,133 +142,138 @@ private:
 public:
   /* details here */
 };
-</PRE>
+</pre>
-<H3>How it works</H3>
+<h3>How it works</h3>
-<P>BOOST_STATIC_ASSERT works as follows. There is class
+
-STATIC_ASSERTION_FAILURE which is defined as:</P>
+<p>BOOST_STATIC_ASSERT works as follows. There is class
-<PRE>namespace boost{
+STATIC_ASSERTION_FAILURE which is defined as:</p>
 <pre>namespace boost{
 template &lt;bool&gt; struct STATIC_ASSERTION_FAILURE;
 template &lt;&gt; struct STATIC_ASSERTION_FAILURE&lt;true&gt;{};
-}</PRE>
+}</pre>
-<P>The key feature is that the error message triggered by the undefined
+<p>The key feature is that the error message triggered by the
-expression sizeof(STATIC_ASSERTION_FAILURE&lt;0&gt;), tends to be consistent
+undefined expression sizeof(STATIC_ASSERTION_FAILURE&lt;0&gt;),
-across a wide variety of compilers. The rest of the machinery of
+tends to be consistent across a wide variety of compilers. The
-BOOST_STATIC_ASSERT is just a way to feed the sizeof expression into a typedef.
+rest of the machinery of BOOST_STATIC_ASSERT is just a way to
-The use of a macro here is somewhat ugly; however boost members have spent
+feed the sizeof expression into a typedef. The use of a macro
-considerable effort trying to invent a static assert that avoided macros, all
+here is somewhat ugly; however boost members have spent
-to no avail. The general conclusion was that the good of a static assert
+considerable effort trying to invent a static assert that avoided
-working at namespace, function, and class scope outweighed the ugliness of a
+macros, all to no avail. The general conclusion was that the good
-macro.</P>
+of a static assert working at namespace, function, and class
-<H3>Test Programs</H3>
+scope outweighed the ugliness of a macro.</p>
 <P>The following test programs are provided with this library:</P>
 <TABLE BORDER="0" WIDTH="100%">
 <TR>
 <TD WIDTH="33%"><I>Test Program</I></TD>
 <TD WIDTH="33%"><I>Expected to Compile</I></TD>
 <TD WIDTH="34%"><I>Description</I></TD>
 </TR>
 <TR>
 <TD WIDTH="33%"><A
 HREF="static_assert_test.cpp">static_assert_test.cpp</A></TD>
 <TD WIDTH="33%">Yes</TD>
 <TD WIDTH="34%">Illustrates usage, and should always compile, really just tests
 compiler compatibility.</TD>
 </TR>
 <TR>
 <TD WIDTH="33%"><A
 HREF="static_assert_example_1.cpp">static_assert_example_1.cpp</A></TD>
 <TD WIDTH="33%">Platform dependent.</TD>
 <TD WIDTH="34%">Namespace scope test program, may compile depending upon the
 platform.</TD>
 </TR>
 <TR>
 <TD WIDTH="33%"><A
 HREF="static_assert_example_2.cpp">static_assert_example_2.cpp</A></TD>
 <TD WIDTH="33%">Yes</TD>
 <TD WIDTH="34%">Function scope test program.</TD>
 </TR>
 <TR>
 <TD WIDTH="33%"><A
 HREF="static_assert_example_3.cpp">static_assert_example_3.cpp</A></TD>
 <TD WIDTH="33%">Yes</TD>
 <TD WIDTH="34%">Class scope test program.</TD>
 </TR>
 <TR>
 <TD WIDTH="33%"><A
 HREF="static_assert_test_fail_1.cpp">static_assert_test_fail_1.cpp</A></TD>
 <TD WIDTH="33%">No</TD>
 <TD WIDTH="34%">Illustrates failure at namespace scope.</TD>
 </TR>
 <TR>
 <TD WIDTH="33%"><A
 HREF="static_assert_test_fail_2.cpp">static_assert_test_fail_2.cpp</A></TD>
 <TD WIDTH="33%">No</TD>
 <TD WIDTH="34%">Illustrates failure at non-template function scope.</TD>
 </TR>
 <TR>
 <TD WIDTH="33%"><A
 HREF="static_assert_test_fail_3.cpp">static_assert_test_fail_3.cpp</A></TD>
 <TD WIDTH="33%">No</TD>
 <TD WIDTH="34%">Illustrates failure at non-template class scope.</TD>
 </TR>
 <TR>
 <TD WIDTH="33%"><A
 HREF="static_assert_test_fail_4.cpp">static_assert_test_fail_4.cpp</A></TD>
 <TD WIDTH="33%">No</TD>
 <TD WIDTH="34%">Illustrates failure at non-template class scope.</TD>
 </TR>
 <TR>
 <TD WIDTH="33%"><A
 HREF="static_assert_test_fail_5.cpp">static_assert_test_fail_5.cpp</A></TD>
 <TD WIDTH="33%">No</TD>
 <TD WIDTH="34%">Illustrates failure at template class scope.</TD>
 </TR>
 <TR>
 <TD WIDTH="33%"><A
 HREF="static_assert_test_fail_6.cpp">static_assert_test_fail_6.cpp</A></TD>
 <TD WIDTH="33%">No</TD>
 <TD WIDTH="34%">Illustrates failure at template class member function
 scope.</TD>
 </TR>
 <TR>
 <TD WIDTH="33%"><A
 HREF="static_assert_test_fail_7.cpp">static_assert_test_fail_7.cpp</A></TD>
 <TD WIDTH="33%">No</TD>
 <TD WIDTH="34%">Illustrates failure of class scope example.</TD>
 </TR>
 <TR>
 <TD><A
 HREF="static_assert_test_fail_8.cpp">static_assert_test_fail_8.cpp</A></TD>
 <TD>No</TD>
 <TD>Illustrates failure of function scope example.</TD>
 </TR>
 <TR>
 <TD><A
 HREF="static_assert_test_fail_9.cpp">static_assert_test_fail_9.cpp</A></TD>
 <TD>No</TD>
 <TD>Illustrates failure of function scope example (part 2).</TD>
 </TR>
 </TABLE>
 <HR>
 <P>Revised 27th Nov 2000</P>
 <P>Documentation &copy; Copyright John Maddock 2000. 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>
 <P>Based on contributions by Steve Cleary and John Maddock.</P>
 <P>Maintained by <A HREF="mailto:John_Maddock@compuserve.com">John Maddock</A>,
 the latest version of this file can be found at <A
 HREF="http://www.boost.org/">www.boost.org</A>, and the boost discussion list
 at <A HREF="http://www.egroups.com/list/boost">www.egroups.com/list/boost</A>.
 </P>
 <P>&nbsp;</P>
 <P>&nbsp;</P>
 </BODY>
 </HTML>
 <h3>Test Programs</h3>
 <p>The following test programs are provided with this library:</p>
 <table border="0" width="100%">
    <tr>
        <td width="33%"><i>Test Program</i></td>
        <td width="33%"><i>Expected to Compile</i></td>
        <td width="34%"><i>Description</i></td>
    </tr>
    <tr>
        <td width="33%"><a href="static_assert_test.cpp">static_assert_test.cpp</a></td>
        <td width="33%">Yes</td>
        <td width="34%">Illustrates usage, and should always
        compile, really just tests compiler compatibility.</td>
    </tr>
    <tr>
        <td width="33%"><a href="static_assert_example_1.cpp">static_assert_example_1.cpp</a></td>
        <td width="33%">Platform dependent.</td>
        <td width="34%">Namespace scope test program, may compile
        depending upon the platform.</td>
    </tr>
    <tr>
        <td width="33%"><a href="static_assert_example_2.cpp">static_assert_example_2.cpp</a></td>
        <td width="33%">Yes</td>
        <td width="34%">Function scope test program.</td>
    </tr>
    <tr>
        <td width="33%"><a href="static_assert_example_3.cpp">static_assert_example_3.cpp</a></td>
        <td width="33%">Yes</td>
        <td width="34%">Class scope test program.</td>
    </tr>
    <tr>
        <td width="33%"><a href="static_assert_test_fail_1.cpp">static_assert_test_fail_1.cpp</a></td>
        <td width="33%">No</td>
        <td width="34%">Illustrates failure at namespace scope.</td>
    </tr>
    <tr>
        <td width="33%"><a href="static_assert_test_fail_2.cpp">static_assert_test_fail_2.cpp</a></td>
        <td width="33%">No</td>
        <td width="34%">Illustrates failure at non-template
        function scope.</td>
    </tr>
    <tr>
        <td width="33%"><a href="static_assert_test_fail_3.cpp">static_assert_test_fail_3.cpp</a></td>
        <td width="33%">No</td>
        <td width="34%">Illustrates failure at non-template class
        scope.</td>
    </tr>
    <tr>
        <td width="33%"><a href="static_assert_test_fail_4.cpp">static_assert_test_fail_4.cpp</a></td>
        <td width="33%">No</td>
        <td width="34%">Illustrates failure at non-template class
        scope.</td>
    </tr>
    <tr>
        <td width="33%"><a href="static_assert_test_fail_5.cpp">static_assert_test_fail_5.cpp</a></td>
        <td width="33%">No</td>
        <td width="34%">Illustrates failure at template class
        scope.</td>
    </tr>
    <tr>
        <td width="33%"><a href="static_assert_test_fail_6.cpp">static_assert_test_fail_6.cpp</a></td>
        <td width="33%">No</td>
        <td width="34%">Illustrates failure at template class
        member function scope.</td>
    </tr>
    <tr>
        <td width="33%"><a href="static_assert_test_fail_7.cpp">static_assert_test_fail_7.cpp</a></td>
        <td width="33%">No</td>
        <td width="34%">Illustrates failure of class scope
        example.</td>
    </tr>
    <tr>
        <td><a href="static_assert_test_fail_8.cpp">static_assert_test_fail_8.cpp</a></td>
        <td>No</td>
        <td>Illustrates failure of function scope example.</td>
    </tr>
    <tr>
        <td><a href="static_assert_test_fail_9.cpp">static_assert_test_fail_9.cpp</a></td>
        <td>No</td>
        <td>Illustrates failure of function scope example (part 2).</td>
    </tr>
 </table>
 <hr>
 <p>Revised 27th Nov 2000</p>
 <p>Documentation © Copyright John Maddock 2000. 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>
 <p>Based on contributions by Steve Cleary and John Maddock.</p>
 <p>Maintained by <a href="mailto:John_Maddock@compuserve.com">John
 Maddock</a>, the latest version of this file can be found at <a
 href="http://www.boost.org/">www.boost.org</a>, and the boost
 discussion list at <a
 href="http://www.yahoogroups.com/list/boost">www.yahoogroups.com/list/boost</a>.
 </p>
 <p>&nbsp;</p>
 <p>&nbsp;</p>
 </body>
 </html>
@@ -10,7 +10,7 @@
 #include <cwchar>
 #include <boost/static_assert.hpp>
-#if defined(__BORLANDC__) && !defined(WCHAR_MIN)
+#if !defined(WCHAR_MIN)
 #define WCHAR_MIN 0
 #endif
@@ -29,3 +29,4 @@ int main()
   return 0;
 }
@@ -26,11 +26,11 @@ RandomAccessIterator foo(RandomAccessIterator from, RandomAccessIterator to)
 int main()
 {
-	std::deque<int> d;
+   std::deque<int> d;
-	std::list<int> l;
+   std::list<int> l;
-	foo(d.begin(), d.end()); // OK
+   foo(d.begin(), d.end()); // OK
-	//foo(l.begin(), l.end()); // error
+   //foo(l.begin(), l.end()); // error
-	return 0;
+   return 0;
 }
@@ -7,7 +7,7 @@
 //  See http://www.boost.org for most recent version including documentation.
 #include <climits>
-#include <limits>
+#include <boost/limits.hpp>
 #include <boost/static_assert.hpp>
 template <class UnsignedInt>
@@ -84,5 +84,3 @@ int main()
@@ -13,10 +13,6 @@
 // all these tests should fail:
 //
 #ifdef BOOST_MSVC
 #error "VC6 not supported in this test (buggy compiler problem)"
 #endif
 struct Bob
 {
@@ -27,7 +23,7 @@ struct Bob
  char c;
  int f()
  {
-#ifndef _MSC_VER // broken sizeof in VC6
+#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
@@ -7,7 +7,7 @@
 //  See http://www.boost.org for most recent version including documentation.
 #include <climits>
-#include <limits>
+#include <boost/limits.hpp>
 #include <boost/static_assert.hpp>
 template <class UnsignedInt>
@@ -12,13 +12,13 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits.hpp>
-template <class RandonAccessIterator >
+template <class RandomAccessIterator >
-RandonAccessIterator foo(RandonAccessIterator from, RandonAccessIterator to)
+RandomAccessIterator foo(RandomAccessIterator from, RandomAccessIterator)
 {
   // this template can only be used with
   // random access iterators...
-   typedef typename std::iterator_traits< RandonAccessIterator >::iterator_category cat;
+   typedef typename std::iterator_traits< RandomAccessIterator >::iterator_category cat;
-   BOOST_STATIC_ASSERT((boost::is_convertible<cat, const std::random_access_iterator_tag&>::value));
+   BOOST_STATIC_ASSERT((boost::is_convertible<cat*, std::random_access_iterator_tag*>::value));
   //
   // detail goes here...
   return from;
@@ -26,12 +26,13 @@ RandonAccessIterator foo(RandonAccessIterator from, RandonAccessIterator to)
 int main()
 {
-	std::deque<int> d;
+   std::deque<int> d;
-	std::list<int> l;
+   std::list<int> l;
-	foo(d.begin(), d.end()); // OK
+   foo(d.begin(), d.end()); // OK
-	foo(l.begin(), l.end()); // error
+   foo(l.begin(), l.end()); // error
-	return 0;
+   return 0;
 }
@@ -7,7 +7,7 @@
 //  See http://www.boost.org for most recent version including documentation.
 #include <climits>
-#include <limits>
+#include <boost/limits.hpp>
 #include <boost/static_assert.hpp>
 template <class UnsignedInt>
Author	SHA1	Message	Date
nobody	46b4482b2f	This commit was manufactured by cvs2svn to create branch 'python-v2-dev'. [SVN r14785]	2002-08-12 13:35:54 +00:00
Dave Abrahams	9d3c2ed75f	Fix unversioned VC++ checks [SVN r14436]	2002-07-13 12:26:19 +00:00
Dave Abrahams	38b5799e33	respect <sysinclude> [SVN r13995]	2002-05-21 16:24:07 +00:00
Jens Maurer	22bb032a79	fix typo in template parameter name [SVN r13043]	2002-03-03 10:16:50 +00:00
John Maddock	f2725b11af	Fixed typo [SVN r12473]	2002-01-24 12:37:38 +00:00
John Maddock	3ab5f7708e	Stripped tabs from source [SVN r12351]	2002-01-19 12:38:14 +00:00
Darin Adler	07628a01a7	Fixed unused variables that show up as warnings when doing regression tests. [SVN r11241]	2001-09-24 23:21:16 +00:00
John Maddock	10425f4864	commit of split-config, including any changes required to existing libraries (mainly regex). [SVN r11138]	2001-09-18 11:13:39 +00:00
John Maddock	3bfec69135	Added Jamfile [SVN r11074]	2001-09-08 12:07:08 +00:00
John Maddock	90ff3895af	Fixed WCHAR_MIN issues [SVN r11073]	2001-09-08 12:06:21 +00:00
John Maddock	b776265f02	Tweeked so that test fails under VC6 (it should due to a compiler bug). [SVN r10612]	2001-07-14 11:18:31 +00:00
John Maddock	a674ac4176	Added comment about lack of static_cast [SVN r10243]	2001-05-30 11:31:15 +00:00
John Maddock	2b67e5a182	cast integral constant expression to bool to fix some compiler warnings and some compiler bugs. [SVN r10230]	2001-05-26 10:58:43 +00:00
Jens Maurer	8b37ed2072	add HP aCC workarounds [SVN r10025]	2001-05-05 20:26:38 +00:00
John Maddock	a947d4039a	updated url's [SVN r9993]	2001-04-30 11:28:03 +00:00
Beman Dawes	976f1c78a5	Change all eGroups references to YahooGroups [SVN r9979]	2001-04-25 00:24:50 +00:00
John Maddock	5d68bc2fd8	fixed typo [SVN r9836]	2001-04-19 10:53:11 +00:00
John Maddock	362a22e3a7	added integral constant expression links, added tentative fix to is_function_test for older EDG based compilers [SVN r9833]	2001-04-18 11:28:53 +00:00
John Maddock	1cd7ee8570	Added boost-wide <limits> woraround [SVN r9688]	2001-04-01 11:59:18 +00:00
John Maddock	cb09a717dd	tentative fix for MWCW [SVN r8914]	2001-02-04 12:59:54 +00:00
John Maddock	e26b873c29	Fix for EDG based compilers [SVN r8888]	2001-02-03 11:32:24 +00:00
John Maddock	fa0ce33cc6	Undone accidental changes to static_assert_test.cpp [SVN r8753]	2001-01-24 12:17:46 +00:00
Beman Dawes	42013c6295	Fix broken link [SVN r8603]	2001-01-15 17:13:18 +00:00
John Maddock	8cb6da5df0	Static assert initial checkin [SVN r8381]	2000-12-03 12:29:42 +00:00