coherence/lang/compatibility.hpp

/*
* compatibility.hpp
*
* Copyright 2001-2008 by Oracle. All rights reserved.
*
* Oracle is a registered trademarks of Oracle Corporation and/or its
* affiliates.
*
* This software is the confidential and proprietary information of Oracle
* Corporation. You shall not disclose such confidential and proprietary
* information and shall use it only in accordance with the terms of the
* license agreement you entered into with Oracle.
*
* This notice may not be removed or altered.
*/
#ifndef COH_COMPATIBILITY_HPP
#define COH_COMPATIBILITY_HPP

/// @cond EXCLUDE

// ----- identify operating system ------------------------------------------

#if defined(_WIN32)
#   if defined(_WIN64)
#      define COH_OS_WIN64 // Windows 2003/2008/Vista
#      define COH_PLATFORM Microsoft Windows x64
#   else
#      define COH_OS_WIN32 // Windows NT/2000/XP
#      define COH_PLATFORM Microsoft Windows x86
#   endif
#   define COH_OS_WINDOWS
#elif defined(__sun) || defined(sun) && \
    (defined(__x86_32__) || defined(__i386__))
#   define COH_OS_SOLARIS // Sun Solaris
#   define COH_OS_UNIX
#   define COH_PLATFORM Sun Solaris x86
#elif defined(__linux__) && \
    (defined(__x86_32__) || defined(__i386__) || \
     defined(__x86_64__) || defined(__amd64__))
#   if defined(__LP64__)
#       define COH_OS_LINUX64
#       define COH_PLATFORM Linux x64
#   else
#       define COH_OS_LINUX32
#       define COH_PLATFORM Linux x86
#   endif
#   define COH_OS_LINUX // Linux
#   define COH_OS_UNIX
#elif defined(__APPLE__) && \
    (defined(__x86_32__) || defined(__i386__) && \
   !(defined(__x86_64__) || defined(__amd64__)))
#   define COH_OS_DARWIN // Mac OS X
#   define COH_OS_UNIX
#   define COH_PLATFORM Apple Mac OS X x86
#else
#   error "Coherence for C++ does not support this OS."
#endif


// ----- identify compiler --------------------------------------------------

#if defined(_MSC_VER) && _MSC_VER >= 1400 // Visual C++ 2005
#   define COH_CC_MSVC // Microsoft Visual C/C++
#elif defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x590
#   define COH_CC_SUN // Forte Developer, or Sun Studio C++
#elif defined(__GNUG__) && (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#   define COH_CC_GNU // GNU C++
#else
#   error "Coherence for C++ does not support this compiler or compiler version."
#endif


// ----- disable select warnings --------------------------------------------

/**
* Macro for disabling select warnings on MSVC. The warnings are automatically
* disabled upon openeing a coherence namespace (using the COH_OPEN_NAMESPACE
* macros), and re-enabled when the namespace is exited via
* COH_CLOSE_NAMESPACE.
*/
#if defined(COH_CC_MSVC)
    #define COH_PRAGMA_PUSH \
    __pragma(warning(push)) \
    /* Allow mupliple interface inheritance (inheritance via dominance) */ \
    __pragma(warning(disable : 4250)) \
    /* Allow non-exported DLL templates */ \
    __pragma(warning(disable : 4251)) \
    /* Exported class inheritance from non-exported class, needed for specs */ \
    __pragma(warning(disable : 4275)) \
    /* Member/WeakHandle: assignment operators for const/non-const type */ \
    __pragma(warning(disable : 4522)) \
    /* Lack of return statements are being promoted to errors, when control \
       path results in throw */ \
    __pragma(warning(disable : 4715; disable : 4716))

    #define COH_PRAGMA_POP __pragma(warning(pop))
#else
    #define COH_PRAGMA_PUSH
    #define COH_PRAGMA_POP
#endif

/**
* Macro for temporarily disabling above warnings for the duration of a
* single statement.  This is only needed for code which is not enclosed in a
* COH_OPEN/CLOSE_NAMESPACE block.
*/
#define COH_NO_WARN(STMT) COH_PRAGMA_PUSH STMT COH_PRAGMA_POP

/**
* These macros are used to indicate that a function will not return normally.
*
* Usage example:
* @code
* COH_NO_RETURN_PRE void doSomething() COH_NO_RETURN_POST
*     {
*     COH_NO_RETURN_STMT(doSomething2());
*     }
* @endcode
*/
#if defined(COH_CC_MSVC)
    #define COH_NO_RETURN_PRE __declspec(noreturn)
    #define COH_NO_RETURN_POST
    #define COH_NO_RETURN_STMT(expr) expr
#elif defined(COH_CC_GNU)
    #define COH_NO_RETURN_PRE
    #define COH_NO_RETURN_POST __attribute__((noreturn))
    #define COH_NO_RETURN_STMT(expr) expr
#elif defined(COH_CC_SUN)
    #define COH_NO_RETURN_PRE
    #define COH_NO_RETURN_POST
    #define COH_NO_RETURN_STMT(expr)\
        do { expr; throw std::exception(); } while (0)
#else
    #define COH_NO_RETURN_PRE
    #define COH_NO_RETURN_POST
    #define COH_NO_RETURN_STMT(expr) expr
#endif


// ----- namespace macros ---------------------------------------------------

/**
* Define the existance of the coherence::lang namespace
*/
namespace coherence { namespace lang {}}

#define COH_OPEN_NAMESPACE(ns) namespace ns { \
    COH_PRAGMA_PUSH \
    using namespace coherence::lang;

#define COH_INNER_NAMESPACE(ns) namespace ns {

#define COH_OPEN_NAMESPACE2(ns1, ns2)\
    COH_OPEN_NAMESPACE (ns1) COH_INNER_NAMESPACE (ns2)

#define COH_OPEN_NAMESPACE3(ns1, ns2, ns3)\
    COH_OPEN_NAMESPACE2 (ns1, ns2) COH_INNER_NAMESPACE (ns3)

#define COH_OPEN_NAMESPACE4(ns1, ns2, ns3, ns4)\
    COH_OPEN_NAMESPACE3 (ns1, ns2, ns3) COH_INNER_NAMESPACE (ns4)

#define COH_OPEN_NAMESPACE5(ns1, ns2, ns3, ns4, ns5)\
    COH_OPEN_NAMESPACE4 (ns1, ns2, ns3, ns4) COH_INNER_NAMESPACE (ns5)

#define COH_OPEN_NAMESPACE6(ns1, ns2, ns3, ns4, ns5, ns6)\
    COH_OPEN_NAMESPACE5 (ns1, ns2, ns3, ns4, ns5) COH_INNER_NAMESPACE (ns6)

#define COH_OPEN_NAMESPACE7(ns1, ns2, ns3, ns4, ns5, ns6, ns7)\
    COH_OPEN_NAMESPACE6 (ns1, ns2, ns3, ns4, ns5, ns6) COH_INNER_NAMESPACE (ns7)

#define COH_CLOSE_NAMESPACE COH_PRAGMA_POP }

#define COH_CLOSE_NAMESPACE2 COH_PRAGMA_POP } }

#define COH_CLOSE_NAMESPACE3 COH_PRAGMA_POP } } }

#define COH_CLOSE_NAMESPACE4 COH_PRAGMA_POP } } } }

#define COH_CLOSE_NAMESPACE5 COH_PRAGMA_POP } } } } }

#define COH_CLOSE_NAMESPACE6 COH_PRAGMA_POP } } } } } }

#define COH_CLOSE_NAMESPACE7 COH_PRAGMA_POP } } } } } } }


// ----- general utility macros ---------------------------------------------

/**
* This macro "mangles" the specified @a Name, producing an identifier which
* is unique in the current file.
*
* Note. This implementation of COH_UNIQUE_IDENTIFIER (as well as macros that
* use it) won't work in MSVC 6.0 when -ZI is on! See Q199057.
*
* @param Name the name to produce a new identifier on its basis
*/
#define COH_JOIN(X, Y) COH_DO_JOIN(X, Y)
#define COH_DO_JOIN(X, Y) COH_DO_JOIN2(X, Y)
#define COH_DO_JOIN2(X, Y) X##Y
#ifdef COH_CC_MSVC_NET // MSVC 2002 and later
#   define COH_UNIQUE_IDENTIFIER(Name) COH_JOIN(Name, __COUNTER__)
#else
#   define COH_UNIQUE_IDENTIFIER(Name) COH_JOIN(Name, __LINE__)
#endif

/**
* This macro will ensure initialization of function local statics at library
* load time. This should be used to force the initialization of statics
* in a thread safe way.  The general form is:
*
* SomeType::Handle staticAccessorFunction()
*     {
*     static SomeType::Handle hStatic = SomeType::create();
*     return hStatic;
*     }
* COH_STATIC_INIT(staticAccessorFunction());
*
* @param FUNC  The static function and parameters to call that requires
*             initialization.
*/
#define COH_STATIC_INIT(FUNC) \
    static const bool COH_UNIQUE_IDENTIFIER(coh_static_init_func) = (FUNC, true)

COH_OPEN_NAMESPACE2(coherence,lang)
    template <bool x> struct STATIC_ASSERTION_FAILURE;
    template<> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
COH_CLOSE_NAMESPACE2

/**
* This macro generates a compile time error message if the integral constant
* expression @a B is not true. In other words, it is the compile time
* equivalent of the @c assert macro. Note that if the condition is true, then
* the macro will generate neither code nor data - and the macro 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.
*
* #COH_STATIC_ASSERT can be used at any place where a declaration can be
* placed, that is at class, function or namespace scope.
*
* @param B an integral constant expression to check its trueness during
*          translation phase
*/
#define COH_STATIC_ASSERT(B)                               \
    enum { COH_UNIQUE_IDENTIFIER(coh_static_assert_enum_) =\
        sizeof(coherence::lang::STATIC_ASSERTION_FAILURE<(bool)(B)>) }

/**
* DLL import/export macros.
*/
#if defined(COH_CC_MSVC)
    #ifdef COH_BUILD
        #define COH_EXPORT  __declspec(dllexport)
    #else
        #define COH_EXPORT  __declspec(dllimport)
    #endif
    #define COH_EXPORT_SPEC  __declspec(dllexport)
    #define COH_EXPORT_SPEC_MEMBER(DECL)
#else
    #define COH_EXPORT
    #define COH_EXPORT_SPEC
    #define COH_EXPORT_SPEC_MEMBER(DECL) DECL;
#endif



/**
* This macro expands to the name and signature of the current function.
*/
#if defined(__GNUC__)
    #define COH_CURRENT_FUNCTION __PRETTY_FUNCTION__
#elif defined(__FUNCSIG__)
    #define COH_CURRENT_FUNCTION __FUNCSIG__
#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
    #define COH_CURRENT_FUNCTION __func__
#else
    #define COH_CURRENT_FUNCTION "(unknown function)"
#endif


// ----- fixed size types ---------------------------------------------------

// We need to include an std lib header here in order to detect which library
// is in use (__GLIBC__ may not be defined without this including). Use
// <utility> as it's about the smallest of the std lib headers.
#include <utility>
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901 ||\
    defined(_POSIX_VERSION) && _POSIX_VERSION >= 200100 ||\
    defined(COH_OS_LINUX) &&\
        defined(__GLIBC__) &&\
        (__GLIBC__ > 2 || __GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) &&\
        defined(__GNUC__) ||\
    defined(COH_OS_DARWIN) && __MACH__ && !defined(_MSL_USING_MSL_C)
#       define COH_HAS_STDINT_H
#endif

#if defined(__GCCXML__) ||\
    defined(__GNUC__) ||\
    defined(_MSC_VER) && _MSC_VER >= 1310 && defined(_MSC_EXTENSIONS)
#       define COH_HAS_LONG_LONG
#endif

#if (defined(__GLIBCPP__) || defined(__GLIBCXX__)) &&\
        !defined(_GLIBCPP_USE_LONG_LONG) &&          \
        !defined(_GLIBCXX_USE_LONG_LONG) &&          \
        defined(COH_HAS_LONG_LONG)
    // Coming here indicates that the GNU compiler supports long long type,
    // but the GNU C++ runtime library does not. Particularly, no global
    // operator<<(std::ostream&, long long) implementation is provided. Let us
    // provide it, at least with minimum incomplete functionality.
#   include <ostream>
    namespace std
        {
        template<class E, class T>
        inline basic_ostream<E, T>& operator<<
                (basic_ostream<E, T>& out, long long l)
            {
            return out << static_cast<long>(l);
            }
        template<class E, class T>
        inline basic_ostream<E, T>& operator<<
                (basic_ostream<E, T>& out, unsigned long long l)
            {
            return out << static_cast<unsigned long>(l);
            }
        }
#   undef COH_HAS_LONG_LONG
#endif

#if !defined(COH_HAS_LONG_LONG) && !defined(COH_CC_MSVC)
#   include <limits.h>
#   if defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) ||\
            defined(ULONGLONG_MAX)
#       define COH_HAS_LONG_LONG
#   endif
#endif

#if defined(_MSC_VER) && _MSC_VER >= 1200
#       define COH_HAS_MS_INT64
#endif

/**
* Fixed width primitive types.
*/
#if defined(COH_HAS_STDINT_H)
#   include <stdint.h>
#elif defined(COH_CC_SUN)
#   include <inttypes.h>
#else
//  This platform does not support the C99 stdint.h types. This code block
//  defines them in the global namespace, alternativaley you may define
//  COH_NAMESPACED_FIXED_INTS, in which case these definitions will be within
//  the coherence::lang namespace.
#   include <climits>
#   ifdef COH_NAMESPACED_FIXED_INTS
      COH_OPEN_NAMESPACE2(coherence,lang)
#   endif
    COH_STATIC_ASSERT(UCHAR_MAX == 0xFF);
    typedef signed char   int8_t;
    typedef unsigned char uint8_t;
    COH_STATIC_ASSERT(USHRT_MAX == 0xFFFF);
    typedef short          int16_t;
    typedef unsigned short uint16_t;
#   if UINT_MAX == 0xFFFFFFFF
        typedef int          int32_t;
        typedef unsigned int uint32_t;
#   elif ULONG_MAX == 0xFFFFFFFF
        typedef long          int32_t;
        typedef unsigned long uint32_t;
#   else
#       error int size not correct
#   endif
#   if defined(COH_HAS_LONG_LONG) &&\
        !defined(COH_CC_MSVC) &&\
        (!defined(__GLIBCPP__) || defined(_GLIBCPP_USE_LONG_LONG)) && \
        (defined(ULLONG_MAX) ||\
            defined(ULONG_LONG_MAX) ||\
            defined(ULONGLONG_MAX))
#               if defined(ULLONG_MAX)
                    COH_STATIC_ASSERT(ULLONG_MAX == 0xFFFFFFFFFFFFFFFFULL);
#               elif defined(ULONG_LONG_MAX)
                    COH_STATIC_ASSERT
                        (ULONG_LONG_MAX == 0xFFFFFFFFFFFFFFFFULL);
#               elif defined(ULONGLONG_MAX)
                    COH_STATIC_ASSERT
                        (ULONGLONG_MAX == 0xFFFFFFFFFFFFFFFFULL));
#               else
#                   error long long size not correct
#               endif
                typedef long long          int64_t;
                typedef unsigned long long uint64_t;
#   elif ULONG_MAX != 0xFFFFFFFF
        COH_STATIC_ASSERT(ULONG_MAX == 0xFFFFFFFFFFFFFFFFULL);
        typedef long          int64_t;
        typedef unsigned long uint64_t;
#   elif defined(__GNUC__) && defined(COH_HAS_LONG_LONG)
        __extension__ typedef long long          int64_t;
        __extension__ typedef unsigned long long uint64_t;
#   elif defined(COH_HAS_MS_INT64)
        typedef __int64          int64_t;
        typedef unsigned __int64 uint64_t;
#   else
#       error no 64-bit integer support
#   endif
#   ifdef COH_NAMESPACED_FIXED_INTS
      COH_CLOSE_NAMESPACE2
#   endif
#endif

/**
* Non-standard primitive type definitions.
*/
COH_OPEN_NAMESPACE2(coherence,lang)
    typedef unsigned char octet_t;
    typedef uint16_t      char16_t;
    typedef uint32_t      size32_t;
    typedef uint64_t      size64_t;
    typedef float         float32_t; COH_STATIC_ASSERT(sizeof(float32_t) >= sizeof(int32_t));
    typedef double        float64_t; COH_STATIC_ASSERT(sizeof(float64_t) >= sizeof(int64_t));
COH_CLOSE_NAMESPACE2

/// @endcond

#endif // COH_COMPATIBILITY_HPP

Copyright (c) 2000-2008 Oracle. All rights reserved.