#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