gls_version.h

Go to the documentation of this file.

/*! \file
  \brief  Used for matching version of libraries and headers.
  \note   THIS IS A GENERATED FILE. DO NOT MODIFY. (Edit gls_version.h.in instead.)
 
  \par Copyright Information
 
  Copyright (c) 2018 by The DiSTI Corporation.<br>
  11301 Corporate Blvd; Suite 100<br>
  Orlando, Florida 32817<br>
  USA<br>
  <br>
  All rights reserved.<br>
 
  This Software contains proprietary trade secrets of DiSTI and may not be
reproduced, in whole or part, in any form, or by any means of electronic,
mechanical, or otherwise, without the written permission of DiSTI.  Said
permission may be derived through the purchase of applicable DiSTI product
licenses which detail the distribution rights of this content and any
Derivative Works based on this or other copyrighted DiSTI Software.
 
  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.
 
  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
EXCEED FIVE DOLLARS (US$5.00).
 
  The aforementioned terms and restrictions are governed by the laws of the
State of Florida and the United States of America.
 
*/
 
#ifndef INCLUDED_GLS_VERSION_H
#define INCLUDED_GLS_VERSION_H
 
#include "gls_include.h"
 
// For atoi
#include <stdlib.h>
 
namespace disti
{
/*
  GL Studio version pattern
  -----------------------------
  X.Y.B00M
  X = Major version
  Y = Minor version
  B = Build.  Increment for maintenance releases.
  0 = Padding zeros.
  M = Build Minor.  Increment for in-house, pre-release builds and release candidates.  This does not have to be zero when a product ships.
*/
 
/// The major version of this runtime library build. i.e. X.0.0000
#define GLS_VERSION_MAJOR 8
 
/// The minor version of this runtime library build. i.e. 0.X.0000
#define GLS_VERSION_MINOR 1
 
/// The build and build minor versions of this runtime library build. i.e. 0.0.XXXX
#define GLS_VERSION_BUILD 0000
 
/// Inner macro to convert preprocessor defines into strings. Don't call this directly.
#define GLS_STRINGIZE( x ) #x
 
/// Convenience macro to convert preprocessor defines into strings.
#define GLS_STRINGIZE_VALUE( x ) GLS_STRINGIZE( x )
 
/// Inner macro to build the X.Y version string. Don't call this directly.
#define GLS_VERSION_1( a, b ) GLS_STRINGIZE( a.b )
 
/// Macro containing the X.Y version string.
#define GLS_VERSION GLS_VERSION_1( GLS_VERSION_MAJOR, GLS_VERSION_MINOR )
 
/// The license version of this runtime library, matches the major version.
/// This allows customers to upgrade within major versions without requiring an updated license.
#define GLS_LICENSE_VERSION GLS_VERSION_1( GLS_VERSION_MAJOR, 0 )
 
/// Macro containing the B00M version string
#define GLS_BUILD_VERSION GLS_STRINGIZE_VALUE( GLS_VERSION_BUILD )
 
#if defined( WIN32 )
 
#    if !defined( GLS_COMPILER_VERSION )
#        if _MSC_VER < 1400
#            pragma message( "Warning (gls_version.h): Unrecognized compiler version" )
#            define GLS_COMPILER_VERSION vcXX
#        else
#            if _MSC_VER < 1700
#                pragma message( "Warning (gls_version.h): Unrecognized compiler version" )
#                define GLS_COMPILER_VERSION vcXX
#            elif _MSC_VER < 1800
#                define GLS_COMPILER_VERSION vc110
#            elif _MSC_VER < 1900
#                define GLS_COMPILER_VERSION vc120
#            elif _MSC_VER < 1910
#                define GLS_COMPILER_VERSION vc140
#            elif _MSC_VER < 1920
#                define GLS_COMPILER_VERSION vc141
#            elif _MSC_VER < 1930
#                define GLS_COMPILER_VERSION vc142
#            elif _MSC_VER < 1940
#                define GLS_COMPILER_VERSION vc143
#            else
#                pragma message( "Warning (gls_version.h): Unrecognized compiler version" )
#                define GLS_COMPILER_VERSION vcXX
#            endif
#        endif
#    endif
 
// 0x00FFFFFF - Reserved for _MSC_VER
// 0x01000000 - ML
// 0x02000000 - MT
// 0x04000000 - DLL
// 0x08000000 - DEBUG
#    define GLS_CRT_VERSION_INT_MD 0x06000000  // MT + DLL
#    define GLS_CRT_VERSION_INT_MT 0x02000000  // MT
#    define GLS_CRT_VERSION_INT_ML 0x01000000  // ML
#    define GLS_CRT_VERSION_INT_MDD 0x0E000000 // DEBUG + MT + DLL
#    define GLS_CRT_VERSION_INT_MTD 0x0A000000 // DEBUG + MT
#    define GLS_CRT_VERSION_INT_MLD 0x09000000 // DEBUG + ML
 
#    define GLS_CRT_VERSION_INT_MD_64 0x16000000  // MT + DLL
#    define GLS_CRT_VERSION_INT_MT_64 0x12000000  // MT
#    define GLS_CRT_VERSION_INT_ML_64 0x11000000  // ML
#    define GLS_CRT_VERSION_INT_MDD_64 0x1E000000 // DEBUG + MT + DLL
#    define GLS_CRT_VERSION_INT_MTD_64 0x1A000000 // DEBUG + MT
#    define GLS_CRT_VERSION_INT_MLD_64 0x19000000 // DEBUG + ML
 
#    if !defined( GLS_CRT_VERSION )
#        if defined( _DEBUG )
#            if defined( _MT )
#                if defined( _DLL )
#                    if defined( _WIN64 )
#                        define GLS_CRT_VERSION _64mdd
#                        define GLS_CRT_VERSION_INT GLS_CRT_VERSION_INT_MDD_64
#                    else
#                        define GLS_CRT_VERSION mdd
#                        define GLS_CRT_VERSION_INT GLS_CRT_VERSION_INT_MDD
#                    endif
#                else
#                    if defined( _WIN64 )
#                        define GLS_CRT_VERSION _64mtd
#                        define GLS_CRT_VERSION_INT GLS_CRT_VERSION_INT_MTD_64
#                    else
#                        define GLS_CRT_VERSION mtd
#                        define GLS_CRT_VERSION_INT GLS_CRT_VERSION_INT_MTD
#                    endif
#                endif
#            else
#                if defined( _WIN64 )
#                    define GLS_CRT_VERSION _64mld
#                    define GLS_CRT_VERSION_INT GLS_CRT_VERSION_INT_MLD_64
#                else
#                    define GLS_CRT_VERSION mld
#                    define GLS_CRT_VERSION_INT GLS_CRT_VERSION_INT_MLD
#                endif
#            endif
#        else
#            if defined( _MT )
#                if defined( _DLL )
#                    if defined( _WIN64 )
#                        define GLS_CRT_VERSION _64md
#                        define GLS_CRT_VERSION_INT GLS_CRT_VERSION_INT_MD_64
#                    else
#                        define GLS_CRT_VERSION md
#                        define GLS_CRT_VERSION_INT GLS_CRT_VERSION_INT_MD
#                    endif
#                else
#                    if defined( _WIN64 )
#                        define GLS_CRT_VERSION _64mt
#                        define GLS_CRT_VERSION_INT GLS_CRT_VERSION_INT_MT_64
#                    else
#                        define GLS_CRT_VERSION mt
#                        define GLS_CRT_VERSION_INT GLS_CRT_VERSION_INT_MT
#                    endif
#                endif
#            else
#                if defined( _WIN64 )
#                    define GLS_CRT_VERSION _64ml
#                    define GLS_CRT_VERSION_INT GLS_CRT_VERSION_INT_ML_64
#                else
#                    define GLS_CRT_VERSION ml
#                    define GLS_CRT_VERSION_INT GLS_CRT_VERSION_INT_ML
#                endif
#            endif
#        endif
#    endif
 
/// Inner macro to stringize all parts of the version check string. Don't call directly.
#    define GLS_CHECK_VERSION_ID_2( a, b, c, d, e ) GLS_VERSION_##a##_##b##_##c##_##d##_##e // Complete check
 
/// Outer macro to build the version check string. Don't call directly.
#    define GLS_CHECK_VERSION_ID_1( v1, v2, v3, c1, c2 ) GLS_CHECK_VERSION_ID_2( v1, v2, v3, c1, c2 )
 
/// The version check string, present as a symbol in the runtime library.
#    define GLS_CHECK_VERSION_ID GLS_CHECK_VERSION_ID_1( GLS_VERSION_MAJOR, GLS_VERSION_MINOR, GLS_VERSION_BUILD, GLS_COMPILER_VERSION, GLS_CRT_VERSION )
 
#else // UNIX
 
/// Inner macro to stringize all parts of the version check string. Don't call directly.
#    define GLS_CHECK_VERSION_ID_2( a, b, c ) GLS_VERSION_##a##_##b##_##c##_LIBRARY
 
/// Outer macro to build the version check string. Don't call directly.
#    define GLS_CHECK_VERSION_ID_1( v1, v2, v3 ) GLS_CHECK_VERSION_ID_2( v1, v2, v3 )
 
/// The version check string, present as a symbol in the runtime library.
#    define GLS_CHECK_VERSION_ID GLS_CHECK_VERSION_ID_1( GLS_VERSION_MAJOR, GLS_VERSION_MINOR, GLS_VERSION_BUILD )
 
#endif
 
/// The version symbol string as instantated in this runtime library build.
/// Used to ensure a linker error if the runtime library being linked doesn't match the runtime headers being built against.
/// If a linker error occurs related to this identifier, double check to make sure the correct runtime library is being linked.
GLS_EXPORT void GLS_CHECK_VERSION_ID();
 
/** This is a type which shall remain consistant.  If an item must
  * be added, it shall be added at the end of the structure to avoid
  * compatibility issues.
  * This object is used to check dynamically loaded code with the container
  * performing the load.
  * This must be inline to work properly.
  */
class GlsBuiltVersionInfo2
{
public:
    int _glsMajor;        ///< The major runtime version.
    int _glsMinor;        ///< The minor runtime version.
    int _glsBuild;        ///< The build, and build minor runtime version.
    int _compilerVersion; ///< The compiler version.
 
    /// Constructor
    /// \param glsMajor The major runtime version.
    /// \param glsMinor The minor runtime version.
    /// \param glsBuild The build, and build minor runtime version.
    /// \param compilerVersion The compiler version.
    inline GlsBuiltVersionInfo2(
        int glsMajor = GLS_VERSION_MAJOR,
        int glsMinor = GLS_VERSION_MINOR,
        int glsBuild = GLS_VERSION_BUILD,
#if defined( _MSC_VER )
        int compilerVersion = _MSC_VER + GLS_CRT_VERSION_INT ) // Complete check
#elif defined( __GNUC__ )
        int compilerVersion = __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ )
#else
        int compilerVersion = 0 )
#endif
    {
        _glsMajor        = glsMajor;
        _glsMinor        = glsMinor;
        _glsBuild        = glsBuild;
        _compilerVersion = compilerVersion;
    }
};
 
typedef GlsBuiltVersionInfo2 GlsBuiltVersionInfo; ///< Typedef for backward compatibilty purposes.
 
/// \return True if the version info matches exactly (they reference the same shared library).
/// \param a One set of version info to compare.
/// \param b The other set of version info to compare.
inline bool GlsBuiltVersionsMatchExactly( const GlsBuiltVersionInfo& a, const GlsBuiltVersionInfo& b )
{
    return a._glsMajor == b._glsMajor && a._glsMinor == b._glsMinor && a._glsBuild == b._glsBuild && a._compilerVersion == b._compilerVersion;
}
 
/// \return True if the versions are binary compatible (may be different shared library, but they are link compatible).
/// \param a One set of version info to compare.
/// \param b The other set of version info to compare.
inline bool GlsBuiltVersionsAreBinaryCompatible( const GlsBuiltVersionInfo& a, const GlsBuiltVersionInfo& b )
{
    bool compiler_compatible = ( a._compilerVersion == b._compilerVersion );
 
#if defined( __GNUC__ )
    if( !compiler_compatible )
    {
        if( a._compilerVersion >= 30400 && b._compilerVersion >= 30400 )
        {
            // GCC 3.4.0 or newer
            // The C runtime library changed with 3.4.0
            compiler_compatible = true;
        }
    }
#endif
 
    // If this does not match, we fallback to RSO interface
    return ( compiler_compatible && a._glsMajor == b._glsMajor && a._glsMinor == b._glsMinor && a._glsBuild / 1000 == b._glsBuild / 1000 );
}
 
} // namespace disti
 
#endif