YiPredef.h

Go to the documentation of this file.

// © You i Labs Inc. 2000-2017. All rights reserved.
#ifndef _YI_PREDEF_H_
#define _YI_PREDEF_H_

#define YI_DRAW_SKIP

#if defined(__x86_64__) || defined(__powerpc64__) || defined(__powerpc64__) || defined(_WIN64) || \
    defined(__powerpc64__) || defined(__alpha__) || defined(__ia64__) || defined(__s390__) || \
    defined(__s390x__) || defined(__arm64) || defined(__aarch64__) || defined(__amd64__) || \
    defined(_M_AMD64) || defined(_M_X64)
    #define YI_ENV_64 1
#else
    #define YI_ENV_32 1
#endif

// Enforce debuging preprocessor directive
#if !defined(YI_DEBUG) && !defined(_DEBUG) && !defined(DEBUG) && !defined(NDEBUG)
    #error None of the expected debugging (or release) macros can be found. YI_DEBUG must be defined for debug builds, and NDEBUG must be defined for release builds.
#endif
#if defined(YI_DEBUG) || defined(_DEBUG) || defined(DEBUG)
    #if !defined(YI_DEBUG)
        #define YI_DEBUG 1
    #endif
    #if !defined(_DEBUG)
        #define _DEBUG 1
    #endif
    #if !defined(DEBUG)
        #define DEBUG 1
    #endif
#endif
#if defined(YI_DEBUG) && defined(NDEBUG)
    #error YI_DEBUG and NDEBUG cannot both be defined at the same time.
#endif

#include <framework/YiPredefPlatform.h>
#include <utility/YiPreprocessorMacros.h>

// Mandatory CWE-120 preventions
#if !defined(YI_DISABLE_SECURITY)
#define strcat(dst, src)        YI_ERROR("strcat: Does not check for buffer overflows when concatenating to destination (CWE-120). Consider using YI_STRNCAT, strcat_s, or strlcat (warning, YI_STRNCAT is easily misused).")
#define strcpy(dst, src)        YI_ERROR("strcpy: Does not check for buffer overflows when copying to destination (CWE-120). Consider using YI_STRNCPY, strcpy_s, or strlcpy (warning, YI_STRNCAT is easily misused).")
#define sprintf(str, fmt, ...)  YI_ERROR("sprintf: Does not check for buffer overflows (CWE-120). Use YI_SNPRINTF, YI_VSNPRINTF, or sprintf_s.")
#define gets(str)               YI_ERROR("gets: Does not check for buffer overflows (CWE-120, CWE-20). Use fgets() instead.")
#define wcscpy(dst, src)        YI_ERROR("wcscpy: Does not check for buffer overflows when copying to destination (CWE-120). Consider using a function version that stops copying at the end of the buffer.")
#define wcscat(dst, src)        YI_ERROR("wcscat: Does not check for buffer overflows when concatenating to destination (CWE-120).")
#define swprintf(str, fmt, ...) YI_ERROR("swprintf: Does not check for buffer overflows (CWE-120). Use YI_SNPRINTF, YI_VSNPRINTF, or sprintf_s.")
#endif

// By default, allow printing of URLs to the console for debug builds
#ifndef NDEBUG
#define YI_DISABLE_URL_SECURITY
#endif

#include <cstdint>

#define YI_WTEXT(quote) (const wchar_t *)L##quote
#define YI_TEXT(quote) (const char *)quote
#define YI_TEXT16(quote) (const char16_t *)L##quote
#define YI_TEXT32(quote) (const char32_t *)L##quote

// framework/YiPredefXXXXX.h should define YI_HASINLINE if platform supports
// however the double underscored __inline is Microsoft specific and no other platforms define YI_HASINLINE at the moment
// presumably they would use inline
#ifdef YI_HASINLINE
#define YI_INLINE   __inline
#define YI_EXTERNINLINE extern __inline
#else
#define YI_INLINE
#define YI_EXTERNINLINE
#endif
#define YI_SEEK_SET 0
#define YI_SEEK_END 1
#define YI_SEEK_CUR 2
#define YI_MAX_PATH 260
#define YI_MAX_BUFFER 1024

#define YI_MIN(a, b) (((a) < (b)) ? (a) : (b))
#define YI_MAX(a, b) (((a) < (b)) ? (b) : (a))
#define YI_FLOAT_EQUAL(a, b) ((a) >= ((b) - FLT_EPSILON) && (a) <= ((b) + FLT_EPSILON))
#define YI_UNUSED(param) (void)(param)
//#define YI_HASPROFILER                        //Show a time profiler of various functions.

#if defined(_MSC_VER)
#define YI_UNUSED_ATTRIBUTE
#else
#define YI_UNUSED_ATTRIBUTE __attribute__((unused))
#endif

#if defined(__clang__) || defined(__GNUC__)
#define YI_FORCE_INLINE __attribute__((always_inline)) inline
#elif defined(_MSC_VER)
#define YI_FORCE_INLINE __forceinline
#else
#define YI_FORCE_INLINE inline
#endif

// Detect if template specialization of templated functions is fully supported
#if defined(_MSC_VER)
#   if _MSC_VER != 1800 // there's a bug in vs2013 that prevents template specializations from working in some cases (e.g. when used with YiEnableIf)
#       define YI_FUNCTION_SPECIALIZATION_FULLY_SUPPORTED
#   endif
#else
#   define YI_FUNCTION_SPECIALIZATION_FULLY_SUPPORTED
#endif

#define YI_DISALLOW_COPY_AND_ASSIGN(TypeName) \
    TypeName(const TypeName &) = delete; \
    TypeName &operator=(const TypeName &) = delete;

#define YI_DEFAULT_MOVE_AND_COPY(TypeName) \
    TypeName &operator=(const TypeName &) = default; \
    TypeName &operator=(TypeName &&) = default; \
    TypeName(const TypeName &) = default; \
    TypeName(TypeName &&) = default;

#define YI_DEFAULT_MOVE_NO_COPY(TypeName) \
    TypeName &operator=(const TypeName &) = delete; \
    TypeName &operator=(TypeName &&) = default; \
    TypeName(const TypeName &) = delete; \
    TypeName(TypeName &&) = default;

#define YI_DEFAULT_MOVE(TypeName) \
    TypeName &operator=(TypeName &&) = default; \
    TypeName(TypeName &&) = default;

#define YI_DEFAULT_COPY(TypeName) \
    TypeName &operator=(const TypeName &) = default; \
    TypeName(const TypeName &) = default;

#if !defined(DOXY) && defined(YI_WIN32)
    #define YI_REMOVE_CONSTANT_CONDITION(x) \
        __pragma(warning(push)) \
        __pragma(warning(disable:4127)) \
        do { x } while ((void)0, 0) \
        __pragma(warning(pop))
#else

    #define YI_REMOVE_CONSTANT_CONDITION(x) do { x } while ((void)0, 0)
#endif

// Structures

struct YI_POINT
{
    int32_t nX;
    int32_t nY;
};

struct YI_POINT2D
{
    float fX;
    float fY;
};

struct YI_RECT
{
    int32_t nLeft;
    int32_t nTop;
    int32_t nRight;
    int32_t nBottom;

    bool operator<(YI_RECT const& other) const
    {
        if(nLeft < other.nLeft)
        {
            return true;
        }
        else if(nLeft == other.nLeft)
        {
            if(nTop < other.nTop)
            {
                return true;
            }
            else if(nTop == other.nTop)
            {
                if(nRight < other.nRight)
                {
                    return true;
                }
                else if(nRight == other.nRight)
                {
                    if(nBottom < other.nBottom)
                    {
                        return true;
                    }
                }
            }
        }
        return false;
    }
};

inline bool operator==(const YI_RECT &rLHS, const YI_RECT &rRHS)
{
    return (rLHS.nLeft   == rRHS.nLeft   ) &&
           (rLHS.nTop    == rRHS.nTop    ) &&
           (rLHS.nRight  == rRHS.nRight  ) &&
           (rLHS.nBottom == rRHS.nBottom );
}

inline bool operator!=(const YI_RECT &rLHS, const YI_RECT &rRHS)
{
    return !(rLHS == rRHS);
}

struct YI_RECT_REL
{
    YI_RECT_REL() : nX(0), nY(0), nWidth(0), nHeight(0)
    {}

    YI_RECT_REL(int32_t x, int32_t y, int32_t width, int32_t height) :
        nX(x),
        nY(y),
        nWidth(width),
        nHeight(height)
    {}

    void Set(int32_t x, int32_t y, int32_t width, int32_t height)
    {
        nX = x;
        nY = y;
        nWidth = width;
        nHeight = height;
    }

    int32_t nX;
    int32_t nY;
    int32_t nWidth;
    int32_t nHeight;
};

inline bool operator==(const YI_RECT_REL &rLHS, const YI_RECT_REL &rRHS)
{
    return (rLHS.nX      == rRHS.nX      ) &&
           (rLHS.nY      == rRHS.nY      ) &&
           (rLHS.nWidth  == rRHS.nWidth  ) &&
           (rLHS.nHeight == rRHS.nHeight );
}

inline bool operator!=(const YI_RECT_REL &rLHS, const YI_RECT_REL &rRHS)
{
    return !(rLHS == rRHS);
}

struct YI_FLOAT_RECT
{
    float fLeft;
    float fTop;
    float fRight;
    float fBottom;
};


inline bool operator<(const YI_FLOAT_RECT &lhs, const YI_FLOAT_RECT &rhs)
{
    if (lhs.fLeft < rhs.fLeft)
    {
        return true;
    }
    else if (lhs.fLeft > rhs.fLeft)
    {
        return false;
    }

    if (lhs.fTop < rhs.fTop)
    {
        return true;
    }
    else if (lhs.fTop > rhs.fTop)
    {
        return false;
    }

    if (lhs.fRight < rhs.fRight)
    {
        return true;
    }
    else if (lhs.fRight > rhs.fRight)
    {
        return false;
    }

    return lhs.fBottom < rhs.fBottom;
}

inline bool operator>(const YI_FLOAT_RECT &lhs, const YI_FLOAT_RECT &rhs)
{
    return rhs < lhs;
}

inline bool operator<=(const YI_FLOAT_RECT &lhs, const YI_FLOAT_RECT &rhs)
{
    return !(rhs < lhs);
}

inline bool operator>=(const YI_FLOAT_RECT &lhs, const YI_FLOAT_RECT &rhs)
{
    return !(lhs < rhs);
}

inline bool operator==(const YI_FLOAT_RECT &rLHS, const YI_FLOAT_RECT &rRHS)
{
    return YI_FLOAT_EQUAL(rLHS.fLeft, rRHS.fLeft) &&
           YI_FLOAT_EQUAL(rLHS.fTop, rRHS.fTop) &&
           YI_FLOAT_EQUAL(rLHS.fRight, rRHS.fRight) &&
           YI_FLOAT_EQUAL(rLHS.fBottom, rRHS.fBottom);
}

inline bool operator!=(const YI_FLOAT_RECT &rLHS, const YI_FLOAT_RECT &rRHS)
{
    return !(rLHS == rRHS);
}

struct YI_FLOAT_RECT_REL
{
    YI_FLOAT_RECT_REL() : fX(0), fY(0), fWidth(0), fHeight(0)
    {}

    YI_FLOAT_RECT_REL(float x, float y, float width, float height) :
        fX(x),
        fY(y),
        fWidth(width),
        fHeight(height)
    {}

    void Set(float x, float y, float width, float height)
    {
        fX = x;
        fY = y;
        fWidth = width;
        fHeight = height;
    }

    float fX;
    float fY;
    float fWidth;
    float fHeight;
};

inline bool operator==(const YI_FLOAT_RECT_REL &rLHS, const YI_FLOAT_RECT_REL &rRHS)
{
    return YI_FLOAT_EQUAL(rLHS.fX, rRHS.fX) &&
           YI_FLOAT_EQUAL(rLHS.fY, rRHS.fY) &&
           YI_FLOAT_EQUAL(rLHS.fWidth, rRHS.fWidth) &&
           YI_FLOAT_EQUAL(rLHS.fHeight, rRHS.fHeight);
}

inline bool operator!=(const YI_FLOAT_RECT_REL &rLHS, const YI_FLOAT_RECT_REL &rRHS)
{
    return !(rLHS == rRHS);
}

/*****************************************************************************
    Bitmap rotation modes
****************************************************************************/
enum YI_BUFFER_REORENT
{
    YI_BUFFER_REORIENT_0_DEGREES = 0,
    YI_BUFFER_REORIENT_90_DEGREES,
    YI_BUFFER_REORIENT_180_DEGREES,
    YI_BUFFER_REORIENT_270_DEGREES,
    YI_BUFFER_REORIENT_FLIPHORIZ,
    YI_BUFFER_REORIENT_FLIPVERT,
    YI_BUFFER_REORIENT_LIMIT,
};

// Macros to help with endianess
#if defined(__BIG_ENDIAN__)
#define YI_LITTLE_ENDIAN_16(a) (((a & 0xff) << 8) | ((a & 0xff00) >> 8))
#define YI_LITTLE_ENDIAN_24(a) (((a >> 16) & 0xff) | (a & 0xff00)| ((a&0xff)<<16))
#define YI_LITTLE_ENDIAN_32(a) (((a >> 24) & 0xff) | ((a >> 8) & 0xff00) | ((a & 0xff00) << 8) | ((a & 0xff) << 24))
#ifdef _MSC_VER
#define YI_LITTLE_ENDIAN_64(a) (((a >> 56) & 0xff) | ((a >> 40) & 0xff00) | ((a >> 24) & 0xff0000) | ((a >> 8) & 0xff000000) | \
                                ((a << 8) & DECL_U64(0xff00000000)) | ((a << 24) & DECL_U64(0xff0000000000)) | \
                                ((a << 40) & DECL_U64(0xff000000000000)) | ((a << 56) & DECL_U64(0xff00000000000000)))
#else
#define YI_LITTLE_ENDIAN_64(a) (((a >> 56) & 0xff) | ((a >> 40) & 0xff00) | ((a >> 24) & 0xff0000) | ((a >> 8) & 0xff000000) | \
                                ((a << 8) & 0xff00000000LLU) | ((a << 24) & 0xff0000000000LLU) | \
                                ((a << 40) & 0xff000000000000LLU) | ((a << 56) & 0xff00000000000000LLU))
#endif
#else
#define YI_LITTLE_ENDIAN_16(a) (a)
#define YI_LITTLE_ENDIAN_24(a) (a)
#define YI_LITTLE_ENDIAN_32(a) (a)
#define YI_LITTLE_ENDIAN_64(a) (a)
#endif

#include "deprecated/YiPredefDeprecated.h"

#endif // _YI_PREDEF_H_