--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/epoc32/include/stdapis/boost/static_warning.hpp Tue Mar 16 16:12:26 2010 +0000
@@ -0,0 +1,180 @@
+#ifndef BOOST_STATIC_WARNING_HPP
+#define BOOST_STATIC_WARNING_HPP
+
+// (C) Copyright Robert Ramey 2003. Jonathan Turkanis 2004.
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org/libs/static_assert for documentation.
+
+/*
+ Revision history:
+ 15 June 2003 - Initial version.
+ 31 March 2004 - improved diagnostic messages and portability
+ (Jonathan Turkanis)
+ 03 April 2004 - works on VC6 at class and namespace scope
+ - ported to DigitalMars
+ - static warnings disabled by default; when enabled,
+ uses pragmas to enable required compiler warnings
+ on MSVC, Intel, Metrowerks and Borland 5.x.
+ (Jonathan Turkanis)
+ 30 May 2004 - tweaked for msvc 7.1 and gcc 3.3
+ - static warnings ENabled by default; when enabled,
+ (Robert Ramey)
+*/
+
+#include <boost/config.hpp>
+
+//
+// Implementation
+// Makes use of the following warnings:
+// 1. GCC prior to 3.3: division by zero.
+// 2. BCC 6.0 preview: unreferenced local variable.
+// 3. DigitalMars: returning address of local automatic variable.
+// 4. VC6: class previously seen as struct (as in 'boost/mpl/print.hpp')
+// 5. All others: deletion of pointer to incomplete type.
+//
+// The trick is to find code which produces warnings containing the name of
+// a structure or variable. Details, with same numbering as above:
+// 1. static_warning_impl<B>::value is zero iff B is false, so diving an int
+// by this value generates a warning iff B is false.
+// 2. static_warning_impl<B>::type has a constructor iff B is true, so an
+// unreferenced variable of this type generates a warning iff B is false.
+// 3. static_warning_impl<B>::type overloads operator& to return a dynamically
+// allocated int pointer only is B is true, so returning the address of an
+// automatic variable of this type generates a warning iff B is fasle.
+// 4. static_warning_impl<B>::STATIC_WARNING is decalred as a struct iff B is
+// false.
+// 5. static_warning_impl<B>::type is incomplete iff B is false, so deleting a
+// pointer to this type generates a warning iff B is false.
+//
+
+//------------------Enable selected warnings----------------------------------//
+
+// Enable the warnings relied on by BOOST_STATIC_WARNING, where possible. The
+// only pragma which is absolutely necessary here is for Borland 5.x, since
+// W8073 is disabled by default. If enabling selected warnings is considered
+// unacceptable, this section can be replaced with:
+// #if defined(__BORLANDC__) && (__BORLANDC__ <= 0x600)
+// pragma warn +stu
+// #endif
+
+# if defined(BOOST_MSVC)
+# pragma warning(2:4150) // C4150: deletion of pointer to incomplete type 'type'.
+# elif defined(BOOST_INTEL) && (defined(__WIN32__) || defined(WIN32))
+# pragma warning(2:457) // #457: delete of pointer to incomplete class.
+# elif defined(__BORLANDC__) && (__BORLANDC__ <= 0x600)
+# pragma warn +stu // W8073: Undefined structure 'structure'.
+# elif defined(__MWERKS__)
+# pragma extended_errorcheck on // Enable 'extended error checking'.
+# endif
+
+//------------------Configure-------------------------------------------------//
+
+# if defined(__BORLANDC__) && (__BORLANDC__ >= 0x600)
+# define BOOST_HAS_DESCRIPTIVE_UNREFERENCED_VARIABLE_WARNING
+# elif defined(__GNUC__) && !defined(BOOST_INTEL) // && (__GNUC__ * 100 + __GNUC_MINOR__ <= 302)
+# define BOOST_HAS_DESCRIPTIVE_DIVIDE_BY_ZERO_WARNING
+# elif defined(__DMC__)
+# define BOOST_HAS_DESCRIPTIVE_RETURNING_ADDRESS_OF_TEMPORARY_WARNING
+# elif defined(BOOST_MSVC) // && (BOOST_MSVC < 1300)
+# define BOOST_NO_PREDEFINED_LINE_MACRO
+# pragma warning(disable:4094) // C4094: untagged 'stuct' declared no symbols
+#endif
+
+//------------------Helper templates------------------------------------------//
+
+namespace boost {
+
+struct STATIC_WARNING;
+
+template<bool>
+struct static_warning_impl;
+
+template<>
+struct static_warning_impl<false> {
+ enum { value = 0 };
+ #if !defined(BOOST_HAS_DESCRIPTIVE_UNREFERENCED_VARIABLE_WARNING) && \
+ !defined(BOOST_HAS_DESCRIPTIVE_RETURNING_ADDRESS_OF_TEMPORARY_WARNING)
+ typedef boost::STATIC_WARNING type;
+ #else
+ typedef int type;
+ #endif
+ #if defined(BOOST_NO_PREDEFINED_LINE_MACRO)
+ struct STATIC_WARNING { };
+ #endif
+};
+
+template<>
+struct static_warning_impl<true> {
+ enum { value = 1 };
+ struct type { type() { } int* operator&() { return new int; } };
+ #if defined(BOOST_NO_PREDEFINED_LINE_MACRO)
+ class STATIC_WARNING { };
+ #endif
+};
+
+} // namespace boost
+
+//------------------Definition of BOOST_STATIC_WARNING------------------------//
+
+#if defined(BOOST_HAS_DESCRIPTIVE_UNREFERENCED_VARIABLE_WARNING)
+# define BOOST_STATIC_WARNING_IMPL(B) \
+ struct BOOST_JOIN(STATIC_WARNING, __LINE__) { \
+ void f() { \
+ ::boost::static_warning_impl<(bool)( B )>::type \
+ STATIC_WARNING; \
+ } \
+ } \
+ /**/
+#elif defined(BOOST_HAS_DESCRIPTIVE_RETURNING_ADDRESS_OF_TEMPORARY_WARNING)
+# define BOOST_STATIC_WARNING_IMPL(B) \
+ struct BOOST_JOIN(STATIC_WARNING, __LINE__) { \
+ int* f() { \
+ ::boost::static_warning_impl<(bool)( B )>::type \
+ STATIC_WARNING; \
+ return &STATIC_WARNING; \
+ } \
+ } \
+ /**/
+#elif defined(BOOST_HAS_DESCRIPTIVE_DIVIDE_BY_ZERO_WARNING)
+# define BOOST_STATIC_WARNING_IMPL(B) \
+ struct BOOST_JOIN(STATIC_WARNING, __LINE__) { \
+ int f() { int STATIC_WARNING = 1; \
+ return STATIC_WARNING / \
+ boost::static_warning_impl<(bool)( B )>::value; } \
+ } \
+ /**/
+#elif defined(BOOST_NO_PREDEFINED_LINE_MACRO)
+ // VC6; __LINE__ macro broken when -ZI is used see Q199057, so
+ // non-conforming workaround is used.
+# define BOOST_STATIC_WARNING_IMPL(B) \
+ struct { \
+ struct S { \
+ typedef boost::static_warning_impl<(bool)( B )> f; \
+ friend class f::STATIC_WARNING; \
+ }; \
+ } \
+ /**/
+#else // Deletion of pointer to incomplete type.
+# define BOOST_STATIC_WARNING_IMPL(B) \
+ struct BOOST_JOIN(STATIC_WARNING, __LINE__) { \
+ ::boost::static_warning_impl<(bool)( B )>::type* p; \
+ void f() { delete p; } \
+ } \
+ /**/
+#endif
+
+#ifndef BOOST_DISABLE_STATIC_WARNINGS
+# define BOOST_STATIC_WARNING(B) BOOST_STATIC_WARNING_IMPL(B)
+#else // #ifdef BOOST_ENABLE_STATIC_WARNINGS //-------------------------------//
+# define BOOST_STATIC_WARNING(B) BOOST_STATIC_WARNING_IMPL(true)
+#endif
+
+#endif // BOOST_STATIC_WARNING_HPP