///////////////////////////////////////////////////////////////////////////////
|
// Copyright (C) 2002-2016, Open Design Alliance (the "Alliance").
|
// All rights reserved.
|
//
|
// This software and its documentation and related materials are owned by
|
// the Alliance. The software may only be incorporated into application
|
// programs owned by members of the Alliance, subject to a signed
|
// Membership Agreement and Supplemental Software License Agreement with the
|
// Alliance. The structure and organization of this software are the valuable
|
// trade secrets of the Alliance and its suppliers. The software is also
|
// protected by copyright law and international treaty provisions. Application
|
// programs incorporating this software must include the following statement
|
// with their copyright notices:
|
//
|
// This application incorporates Teigha(R) software pursuant to a license
|
// agreement with Open Design Alliance.
|
// Teigha(R) Copyright (C) 2002-2016 by Open Design Alliance.
|
// All rights reserved.
|
//
|
// By use of this software, its documentation or related materials, you
|
// acknowledge and accept the above terms.
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
#ifndef _OD_PLATFORM_H_
|
#define _OD_PLATFORM_H_
|
|
|
#include "OdPlatformSettings.h"
|
#include "OdGUID.h"
|
// Moved from OdaCommon.h, to be used in string functions
|
#define odmin(X,Y) ((X) < (Y) ? (X) : (Y))
|
#define odmax(X,Y) ((X) > (Y) ? (X) : (Y))
|
|
|
#if defined(ODA_WINDOWS)
|
#include <cmath>
|
#include <float.h>
|
#define Odisnan ::_isnan
|
#define Odfinite ::_finite
|
#define GETSS(s,n) ::gets_s(s,n)
|
#define OdWprintf _wprintf_p
|
#define OdPrintf _printf_p
|
|
#if defined(_MSC_VER) && (_MSC_VER < 1400)
|
#ifndef GET_X_LPARAM
|
#define GET_X_LPARAM(lParam) ((int)(short)LOWORD(lParam))
|
#endif
|
#ifndef GET_Y_LPARAM
|
#define GET_Y_LPARAM(lParam) ((int)(short)HIWORD(lParam))
|
#endif
|
#endif
|
|
#else
|
#include <stdio.h>
|
#include <limits.h>
|
#define GETSS(s, n) gets(s)
|
#define MAX_PATH PATH_MAX
|
|
#define OdWprintf wprintf
|
#define OdPrintf printf
|
|
#if defined(__APPLE__)
|
#include <math.h>
|
#define Odisnan std::isnan
|
#define Odfinite std::isfinite
|
#else
|
#include <math.h>
|
#define Odisnan isnan
|
#define Odfinite finite
|
#endif
|
#endif
|
|
#ifdef ANDROID_WCHAR
|
#include "../../ThirdParty/wchar/stdlib_.h"
|
#include "../../ThirdParty/wchar/wchar_.h"
|
#define Od_atof Citrus::atof
|
#define Od_abs Citrus::abs
|
#define Od_labs Citrus::labs
|
#define Od_llabs Citrus::llabs
|
#define Od_srand Citrus::srand
|
#define Od_rand Citrus::rand
|
#define Od_wcstombs Citrus::wcstombs
|
#define Od_wcscpy Citrus::wcscpy
|
#define Od_wcscmp Citrus::wcscmp
|
#define Od_wcscat Citrus::wcscat
|
#define Od_wcschr Citrus::wcschr
|
#define Od_wcscpy Citrus::wcscpy
|
#define Od_wcslen Citrus::wcslen
|
#define Od_wcsncpy Citrus::wcsncpy
|
#else
|
#define Od_atof atof
|
#define Od_abs abs
|
#define Od_labs labs
|
#define Od_llabs llabs
|
#define Od_srand srand
|
#define Od_rand rand
|
#define Od_wcstombs wcstombs
|
#define Od_wcscpy wcscpy
|
#define Od_wcscmp wcscmp
|
#define Od_wcscat wcscat
|
#define Od_wcschr wcschr
|
#define Od_wcscpy wcscpy
|
#define Od_wcslen wcslen
|
#define Od_wcsncpy wcsncpy
|
#endif
|
|
#ifndef odStrChr
|
#define odStrChr(str, ch) strchr(str, ch)
|
#endif
|
|
#ifndef odWStrChr
|
#define odWStrChr(str, ch) Od_wcschr(str, ch)
|
#endif
|
|
#ifdef OD_STRING_FNS
|
|
|
extern int Od_stricmp(const OdChar*str, const OdChar* str2);
|
extern int Od_strnicmp(const OdChar *s1, const OdChar *s2, int len);
|
extern OdChar* Od_strupr(OdChar* str);
|
extern OdChar* Od_strlwr(OdChar* str);
|
extern OdChar* Od_strrev(OdChar* str);
|
extern int Od_strnicmpA(const char *s1, const char *s2, int len);
|
extern int Od_stricmpA(const char* str, const char* str2);
|
extern char* Od_struprA(char* str);
|
extern char* Od_strlwrA(char* str);
|
extern char* Od_strrevA(char* str);
|
|
#define odStrUpr(str) Od_strupr(str)
|
#define odStrLwr(str) Od_strlwr(str)
|
#define odStrRev(str) Od_strrev(str)
|
|
#if !defined(__linux__)
|
|
#define odStrICmp(str, str2) Od_stricmp(str, str2)
|
#define odStrnICmp(str, str2, n) Od_strnicmp(str, str2, n)
|
#define odStrnICmpA Od_strnicmpA
|
#define odStrICmpA(str, str2) Od_stricmpA(str, str2)
|
#define odStrUprA(str) Od_struprA(str)
|
#define odStrLwrA(str) Od_strlwrA(str)
|
#define odStrRevA(str) Od_strrevA(str)
|
|
#endif // !defined(__linux__)
|
|
#endif /* OD_STRING_FNS */
|
|
/* strings functions */
|
|
#if defined(ANDROID_WCHAR)
|
#include <string>
|
#if !defined(OD_WSTRING_DEFINED) && (!defined(_STRINGFWD_H) || !defined(_GLIBCXX_USE_WCHAR_T))
|
#define OD_WSTRING_DEFINED
|
#include <bits/basic_string.h>
|
//#include <iosfwd>
|
namespace std
|
{
|
typedef basic_string<wchar_t> wstring;
|
typedef basic_istringstream<wchar_t> wistringstream;
|
typedef basic_stringstream<wchar_t> wstringstream;
|
}
|
#endif
|
#include "../../ThirdParty/wchar/wchar_.h" // #include <wchar_.h>
|
|
#define odStrLen(str) Citrus::wcslen(str)
|
#define odStrCmp(str, str2) Citrus::wcscmp(str, str2)
|
inline long Od_strtoint(const OdChar* str)
|
{
|
return Citrus::wcstol((const wchar_t*)str, 0, 10);
|
}
|
#define odStrToInt(str) Od_strtoint(str)
|
|
#pragma MARKMESSAGE("DNA: odStrToInt() looses highest bit of UInt32: FFFFFFFF -> 7FFFFFFF (at least on WIN64)")
|
#define odStrToUInt(str) reinterpret_cast<unsigned long>(Od_strtoint(str))
|
// TODO
|
//inline unsigned long Od_strtouint(const OdChar* str)
|
//{
|
// return Citrus::wcstoul((const wchar_t*)str, 0, 10);
|
//}
|
//#define odStrToUInt(str) Od_strtouint(str)
|
|
// #define odSScanf Citrus::swscanf
|
// #define odSprintf Citrus::swprintf
|
inline double Od_wtof(const wchar_t* str)
|
{
|
wchar_t *endptr = 0;
|
return Citrus::wcstold(str, &endptr);
|
}
|
#define odStrToF Od_wtof
|
#define odStrStr Citrus::wcsstr
|
// see OdDToStr.h and TD/Source/fltcvt/OdGdtoa.cpp for odDToStr and odStrToD
|
#define wcsicmp Citrus::wcscasecmp
|
#define wcsnicmp Citrus::wcsncasecmp
|
#else
|
#include <wchar.h>
|
#endif
|
|
#ifndef odStrLen
|
#define odStrLen(str) wcslen(str)
|
#endif
|
|
#ifndef odStrLenA
|
#define odStrLenA(str) strlen(str)
|
#endif
|
|
#ifndef odStrCmp
|
#define odStrCmp(str, str2) wcscmp(str, str2)
|
#endif
|
|
#ifndef odStrCmpA
|
#define odStrCmpA(str, str2) strcmp(str, str2)
|
#endif
|
|
#if defined(ODA_WINDOWS)
|
#include <Windows.h>
|
#endif
|
|
#if defined( ANDROID ) || defined ( _WIN32_WCE ) || (defined (_MSC_VER) && _MSC_VER < 1400) || defined(_WINRT)
|
#define FSEEK fseek
|
#define FTELL ftell
|
#define FOPEN fopen
|
#define OFFSETTYPE(offset) (long)offset
|
|
#elif defined(__APPLE__) || defined( __hpux )
|
#define FSEEK fseeko
|
#define FTELL ftello
|
#define FOPEN fopen
|
#define OFFSETTYPE(offset) offset
|
#else
|
#define FSEEK fseeko64
|
#define FTELL ftello64
|
#define FOPEN fopen64
|
#define OFFSETTYPE(offset) offset
|
#endif
|
|
#if defined(__linux__) || defined(EMCC)
|
|
#include <wctype.h> // towlower, towupper
|
#if !defined(EMCC) && !defined(__clang__)
|
#include <bits/stl_algobase.h> // For std::swap (gcc 3.3 and 3.4)
|
#endif
|
#include <utility> // std::swap
|
|
#ifndef wcsicmp
|
#define wcsicmp wcscasecmp
|
#endif
|
|
#ifndef wcsnicmp
|
#define wcsnicmp wcsncasecmp
|
#endif
|
|
#ifndef wcsupr
|
inline wchar_t* wcsupr(wchar_t* s)
|
{
|
if(!s)
|
return 0;
|
for(wchar_t* p = s; *p; ++p)
|
*p = towupper(*p);
|
return s;
|
}
|
#endif
|
|
#ifndef wcslwr
|
inline wchar_t* wcslwr(wchar_t* s)
|
{
|
if(!s)
|
return 0;
|
for(wchar_t* p = s; *p; ++p)
|
*p = towlower(*p);
|
return s;
|
}
|
#endif
|
#ifndef wcsrev
|
inline wchar_t* wcsrev(wchar_t* s)
|
{
|
if(!s)
|
return 0;
|
wchar_t* e = s + wcslen(s) - 1;
|
wchar_t* s_ = s;
|
while(s < e)
|
{
|
std::swap(*s, *e);
|
++s;
|
--e;
|
}
|
return s_;
|
}
|
#endif
|
|
#ifdef OD_STRING_FNS
|
|
#ifndef stricmp
|
#define stricmp Od_stricmpA
|
#endif
|
|
#ifndef strupr
|
#define strupr Od_struprA
|
#endif
|
|
#ifndef strlwr
|
#define strlwr Od_strlwrA
|
#endif
|
|
#ifndef strrev
|
#define strrev Od_strrevA
|
#endif
|
|
#ifndef strnicmp
|
#define strnicmp Od_strnicmpA
|
#endif
|
|
#endif //OD_STRING_FNS
|
|
#endif //defined(__linux__) || defined(EMCC)
|
|
#ifndef odStrICmp
|
|
#if defined(_WINRT)
|
#include <WinNls.h>
|
inline int Od_stricmpW(const OdChar* str, const OdChar* str2){ return CompareStringEx( LOCALE_NAME_INVARIANT, NORM_IGNORECASE, (const wchar_t*)str, -1, (const wchar_t*)str2, -1, NULL, NULL, 0) - 2; }
|
#elif defined(_WIN32) ||defined(_WIN64) || defined(_WIN32_WCE)
|
inline int Od_stricmpW(const OdChar* str, const OdChar* str2){ return CompareStringW( LOCALE_NEUTRAL, NORM_IGNORECASE, (const wchar_t*)str, -1, (const wchar_t*)str2, -1) - 2; }
|
#elif (defined ( __BORLANDC__ ) && (__BORLANDC__) >= 0x530) ||(defined(_MSC_VER) && _MSC_VER > 1200)
|
inline int Od_stricmpW(const OdChar* str, const OdChar* str2){ return _wcsicmp(str, str2); }
|
#else
|
inline int Od_stricmpW(const OdChar* str, const OdChar* str2){ return wcsicmp(str, str2); }
|
#endif
|
#define odStrICmp Od_stricmpW
|
#endif
|
|
#ifndef odStrICmpA
|
#if defined(_WINRT)
|
#define odStrICmpA(str, str2) _stricmp(str, str2)
|
#else
|
#define odStrICmpA(str, str2) stricmp(str, str2)
|
#endif
|
#endif
|
|
#ifndef odStrnICmp
|
#if defined(_WINRT)
|
#include <WinNls.h>
|
inline int Od_stricmpW(const OdChar* str, const OdChar* str2, size_t n){ return CompareStringEx( LOCALE_NAME_INVARIANT, NORM_IGNORECASE, (const wchar_t*)str, (int)odmin(wcslen((const wchar_t*)str), n), (const wchar_t*)str2, (int)odmin(wcslen((const wchar_t*)str), n), NULL, NULL, 0) - 2; }
|
#elif defined(_WIN32) ||defined(_WIN64) || defined(_WIN32_WCE)
|
inline int Od_stricmpW(const OdChar* str, const OdChar* str2, size_t n){ return CompareStringW( LOCALE_NEUTRAL, NORM_IGNORECASE, (const wchar_t*)str, (int)odmin(wcslen((const wchar_t*)str), n), (const wchar_t*)str2, (int)odmin(wcslen((const wchar_t*)str2), n))-2;}
|
#elif (defined ( __BORLANDC__ ) && (__BORLANDC__) >= 0x530) || (defined(_MSC_VER) && _MSC_VER > 1200)
|
inline int Od_stricmpW(const OdChar* str, const OdChar* str2, size_t n){ return _wcsnicmp(str, str2, n);}
|
#else
|
inline int Od_stricmpW(const OdChar* str, const OdChar* str2, size_t n){ return wcsnicmp(str, str2, n);}
|
#endif
|
#define odStrnICmp Od_stricmpW
|
#endif
|
|
#ifndef odStrnICmpA
|
#define odStrnICmpA(str, str2, n) strnicmp(str, str2, n)
|
#endif
|
|
|
#ifndef odStrUpr
|
#if defined(ODA_WINDOWS) && !defined(_WINRT)
|
inline OdChar* Od_struprW(OdChar* str){return (OdChar*)CharUpperW((wchar_t*)str);}
|
#elif defined(_WINRT)
|
inline OdChar* Od_struprW(OdChar* str){return (OdChar*)_wcsupr((wchar_t*)str);}
|
#else
|
inline OdChar* Od_struprW(OdChar* str){return (OdChar*)wcsupr((OdChar*)str);}
|
#endif
|
#define odStrUpr(str) Od_struprW(str)
|
#endif
|
|
#ifndef odStrUprA
|
#define odStrUprA(str) strupr(str)
|
#endif
|
|
#ifndef odStrLwr
|
#if defined(ODA_WINDOWS) && !defined(_WINRT)
|
inline OdChar* Od_strlwrW(OdChar* str){return (OdChar*)CharLowerW((wchar_t*)str);}
|
#elif defined (_WINRT)
|
inline OdChar* Od_strlwrW(OdChar* str){return (OdChar*)_wcslwr((wchar_t*)str);}
|
#else
|
inline OdChar* Od_strlwrW(OdChar* str){return (OdChar*)wcslwr((OdChar*)str);}
|
#endif
|
#define odStrLwr(str) Od_strlwrW(str)
|
#endif
|
|
#ifndef odStrLwrA
|
#define odStrLwrA(str) strlwr(str)
|
#endif
|
|
#ifndef odStrRev
|
#if defined(ODA_WINDOWS)
|
inline OdChar* Od_strrevW(OdChar* str) {return (OdChar*)_wcsrev((wchar_t*)str);}
|
#else
|
inline OdChar* Od_strrevW(OdChar* str) {return (OdChar*)wcsrev((wchar_t*)str);}
|
#endif
|
#define odStrRev(str) Od_strrevW(str)
|
#endif
|
|
#ifndef odStrRevA
|
#define odStrRevA(str) strrev(str)
|
#endif
|
|
#ifndef odStrToInt
|
inline long Od_strtoint(const OdChar* str){ return wcstol((const wchar_t*)str, 0, 10);}
|
#define odStrToInt(str) Od_strtoint(str)
|
#endif
|
|
#ifndef odStrToUInt
|
inline long Od_strtouint(const OdChar* str){ return wcstoul((const wchar_t*)str, 0, 10);}
|
#define odStrToUInt(str) Od_strtouint(str)
|
#endif
|
|
#if (defined(sgi) || defined(_AIX) || defined(sparc)) && !defined(__GNUC__)
|
#define TD_NEED_SWFNS
|
#endif
|
#if defined(TD_NEED_SWFNS) || defined(__APPLE__) || defined(EMCC)// #7324
|
#define TD_NEED_SWFNS_SCANF
|
#endif
|
#if defined(TD_NEED_SWFNS) || defined(__APPLE__) || defined(__hpux) || defined(ANDROID) || defined(EMCC)// #7324 & #8357 & #9786
|
#define TD_NEED_SWFNS_PRINTF
|
#endif
|
|
#ifndef odSScanf
|
#if defined(TD_NEED_SWFNS_SCANF)
|
#ifdef ANDROID_WCHAR
|
#include "../../ThirdParty/wchar/wchar_.h"
|
#else
|
#include <wchar.h>
|
#endif
|
#include <stdio.h>
|
#include <stdarg.h>
|
#include <string>
|
FIRSTDLL_EXPORT int Od_vswscanfV(const wchar_t* buffer, const wchar_t* lpszFormat, va_list argList);
|
inline int ddswscanf(const wchar_t* buffer, const wchar_t* format, ...)
|
{
|
va_list argList;
|
va_start(argList, format);
|
int count = Od_vswscanfV(buffer, format, argList);
|
va_end(argList);
|
return count;
|
}
|
#define odSScanf ddswscanf
|
#else
|
#if defined(_WINRT)
|
#define odSScanf swscanf_s
|
#else
|
#define odSScanf swscanf
|
#endif
|
#endif
|
#endif
|
|
#ifndef odSprintf
|
#if defined(ODA_WINDOWS)
|
#define odSprintf _snwprintf
|
#elif defined(TD_NEED_SWFNS_PRINTF)
|
#include <stdio.h>
|
#include <stdarg.h>
|
#include <string>
|
extern std::wstring Od_vswprintfV(const wchar_t* lpszFormat, va_list argList);
|
inline int ddswprintf(wchar_t *buffer, size_t count, const wchar_t *format, ...)
|
{
|
va_list argList;
|
va_start(argList, format);
|
std::wstring ws = Od_vswprintfV(format, argList);
|
va_end(argList);
|
int toCopy = ws.length() < count - 1 ? ws.length() : count - 1;
|
Od_wcsncpy(buffer, ws.c_str(), toCopy);
|
buffer[toCopy] = '\0';
|
return 0;
|
}
|
#define odSprintf ddswprintf
|
#else
|
#define odSprintf swprintf
|
#endif
|
#endif
|
|
#ifndef odSprintfA
|
#if defined(ODA_WINDOWS)
|
#define odSprintfA _snprintf
|
#else
|
#define odSprintfA snprintf
|
#endif
|
#endif
|
|
#ifndef odStrToF
|
#if defined (ODA_WINDOWS)
|
#define odStrToF _wtof
|
#else
|
#include <wchar.h>
|
inline double Od_wtof(const wchar_t* str)
|
{
|
wchar_t *endptr = 0;
|
return wcstod(str, &endptr);
|
}
|
#define odStrToF Od_wtof
|
#endif
|
#endif
|
|
|
#ifndef OD_TYPENAME
|
#define OD_TYPENAME
|
#endif
|
|
#ifndef OD_TYPENAME2
|
#define OD_TYPENAME2
|
#endif
|
|
#ifndef OD_TYPENAME3
|
#define OD_TYPENAME3
|
#endif
|
|
#ifndef OD_BSEARCH
|
#define OD_BSEARCH ::bsearch
|
#endif
|
|
#ifndef TD_USING
|
#define TD_USING(a) using a
|
#endif
|
|
#ifndef OD_LINKEDARRAY_SCOPE
|
#define OD_LINKEDARRAY_SCOPE
|
#endif
|
|
#ifndef odStrStr
|
#ifdef TD_NEED_WCSSTR
|
// This is missing on some older HP compiler versions.
|
extern wchar_t *wcsstr(const wchar_t* wcs1, const wchar_t* wcs2);
|
#endif
|
#define odStrStr ::wcsstr
|
#endif
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
#define OD_MAKEWORD(a, b) ((OdUInt16)(((OdUInt8)(a)) | ((OdUInt16)((OdUInt8)(b))) << 8))
|
#define OD_MAKELONG(a, b) ((OdInt32)(((OdUInt16)(a)) | ((OdUInt32)((OdUInt16)(b))) << 16))
|
#define OD_LOWORD(l) ((OdUInt16)(l))
|
#define OD_HIWORD(l) ((OdUInt16)(((OdUInt32)(l) >> 16) & 0xFFFF))
|
#define OD_LOBYTE(w) ((OdUInt8)(w))
|
#define OD_HIBYTE(w) ((OdUInt8)(((OdUInt16)(w) >> 8) & 0xFF))
|
|
inline void odSwapBytes(OdUInt8& xX, OdUInt8& yY) { xX ^= yY; yY ^= xX; xX ^= yY; }
|
inline void odSwapWords(OdUInt16& xX, OdUInt16& yY) { xX ^= yY; yY ^= xX; xX ^= yY; }
|
|
#ifdef ODA_BIGENDIAN
|
|
inline void odSwap2BytesNumber(OdUInt16& W)
|
{
|
odSwapBytes(((OdUInt8*)&(W))[0], ((OdUInt8*)&(W))[1]);
|
}
|
|
inline void odSwap2BytesNumber(OdInt16& W)
|
{
|
odSwapBytes(((OdUInt8*)&(W))[0], ((OdUInt8*)&(W))[1]);
|
}
|
|
inline void odSwap4BytesNumber(OdUInt32& DW)
|
{
|
odSwapWords(((OdUInt16*)&(DW))[0], ((OdUInt16*)&(DW))[1]);
|
odSwapBytes(((OdUInt8*)&(DW))[0], ((OdUInt8*)&(DW))[1]);
|
odSwapBytes(((OdUInt8*)&(DW))[2], ((OdUInt8*)&(DW))[3]);
|
}
|
|
inline void odSwap4BytesNumber(OdInt32& DW)
|
{
|
// NOTE: Using above unsigned version on AIX results in runtime errors.
|
// Macro version also causes errors on AIX.
|
OdInt8* p = (OdInt8*)&DW;
|
OdInt8 tmp;
|
tmp = p[0]; p[0] = p[3]; p[3] = tmp;
|
tmp = p[1]; p[1] = p[2]; p[2] = tmp;
|
}
|
|
inline void odSwap8Bytes(void* pBytes)
|
{
|
odSwapBytes(((OdUInt8*)(pBytes))[0], ((OdUInt8*)(pBytes))[7]);
|
odSwapBytes(((OdUInt8*)(pBytes))[1], ((OdUInt8*)(pBytes))[6]);
|
odSwapBytes(((OdUInt8*)(pBytes))[2], ((OdUInt8*)(pBytes))[5]);
|
odSwapBytes(((OdUInt8*)(pBytes))[3], ((OdUInt8*)(pBytes))[4]);
|
}
|
|
inline void odSwap4Bytes(void* pBytes)
|
{
|
odSwapBytes(((OdUInt8*)(pBytes))[0], ((OdUInt8*)(pBytes))[3]);
|
odSwapBytes(((OdUInt8*)(pBytes))[1], ((OdUInt8*)(pBytes))[2]);
|
}
|
|
#define odSwapInt64(n)
|
|
#else
|
|
#define odSwap2BytesNumber(n)
|
#define odSwap4BytesNumber(n)
|
#define odSwap8Bytes(bytes)
|
#define odSwap4Bytes(bytes)
|
|
inline void odSwapInt64(void* pBytes)
|
{
|
odSwapBytes(((OdUInt8*)(pBytes))[0], ((OdUInt8*)(pBytes))[7]);
|
odSwapBytes(((OdUInt8*)(pBytes))[1], ((OdUInt8*)(pBytes))[6]);
|
odSwapBytes(((OdUInt8*)(pBytes))[2], ((OdUInt8*)(pBytes))[5]);
|
odSwapBytes(((OdUInt8*)(pBytes))[3], ((OdUInt8*)(pBytes))[4]);
|
}
|
|
#endif // ODA_BIGENDIAN
|
|
/** \details
|
Checks if 8 bytes buffer represents a valid non-zero IEEE double value.
|
(In this format doubles are stored in .dwg files.)
|
*/
|
inline bool isValidNonZeroIEEEDouble(const OdUInt8 * buf)
|
{
|
#ifdef ODA_BIGENDIAN
|
int nExponent = (buf[0] & 0x7F) << 4 | (buf[1] & 0xF0) >> 4;
|
#else
|
int nExponent = (buf[7] & 0x7F) << 4 | (buf[6] & 0xF0) >> 4;
|
#endif
|
switch (nExponent)
|
{
|
case 0: // The value is zero or possibly denormalized
|
case 2047: // -INF, +INF or Nan
|
return false;
|
}
|
return true;
|
}
|
|
inline void fixDouble(double * pD)
|
{
|
ODA_ASSUME(sizeof(double) == 8)
|
odSwap8Bytes(pD);
|
if (!isValidNonZeroIEEEDouble((OdUInt8 *)pD))
|
{ // if unnormalized or NaN or infinity, set it to 0.0
|
//*pD = 0.;
|
::memset((void*)pD, 0, sizeof(double)); // Support TD_STRICT_ALIGNMENT (#8352)
|
}
|
}
|
|
|
#define OD_INT8_FROM_BUFFPTR(pBuffPtr) *(pBuffPtr++)
|
|
inline OdUInt64 OD_INT64_FROM_BUFFPTR(const OdUInt8 *pBuffPtr)
|
{
|
OdUInt32 low(*pBuffPtr++);
|
low |= ((OdUInt32)*pBuffPtr++) << 8;
|
low |= ((OdUInt32)*pBuffPtr++) << 16;
|
low |= ((OdUInt32)*pBuffPtr++) << 24;
|
|
OdUInt32 high(*pBuffPtr++);
|
high |= ((OdUInt32)*pBuffPtr++) << 8;
|
high |= ((OdUInt32)*pBuffPtr++) << 16;
|
high |= ((OdUInt32)*pBuffPtr++) << 24;
|
|
OdUInt64 res(high);
|
res <<= 32;
|
res |= low;
|
return res;
|
}
|
|
#define OD_BYTES_FROM_BUFFPTR(pBuffPtr, ResBuff, nCount) (pBuffPtr+=nCount, ::memcpy(ResBuff, pBuffPtr-nCount, nCount))
|
|
#define OD_INT8_TO_BUFFPTR(pBuffPtr, val) (++pBuffPtr, pBuffPtr[-1] = OdUInt8(val))
|
#define OD_BYTES_TO_BUFFPTR(pBuffPtr, FromBuff, nCount) (pBuffPtr+=nCount, ::memcpy(pBuffPtr-nCount, FromBuff, nCount))
|
|
|
|
#ifndef ODA_BIGENDIAN
|
|
#ifdef TD_STRICT_ALIGNMENT
|
|
extern double getStrictDouble(OdUInt8** ppBuff);
|
extern void setStrictDouble(OdUInt8** ppBuff, double d);
|
extern void setStrictInt16(OdUInt8** ppBuff, OdInt16 val);
|
extern void setStrictInt32(OdUInt8** ppBuff, OdInt32 val);
|
extern void setStrictInt64(OdUInt8** ppBuff, OdInt64 val);
|
|
#define OD_INT16_FROM_BUFFPTR(pBuffPtr) (pBuffPtr += 2, (OdInt16)( *(pBuffPtr - 2) \
|
| (*(pBuffPtr - 1) << 8)))
|
#define OD_INT32_FROM_BUFFPTR(pBuffPtr) (pBuffPtr += 4, (OdInt32)( *(pBuffPtr - 4) \
|
| (*(pBuffPtr - 3) << 8) \
|
| (*(pBuffPtr - 2) << 16) \
|
| (*(pBuffPtr - 1) << 24)))
|
|
#define OD_INT64_FROM_BUFFPTR(pBuffPtr) (pBuffPtr += 8, (OdInt64)( *(pBuffPtr - 8) \
|
| (OdInt64(*(pBuffPtr - 7)) << 8) \
|
| (OdInt64(*(pBuffPtr - 6)) << 16) \
|
| (OdInt64(*(pBuffPtr - 5)) << 24) \
|
| (OdInt64(*(pBuffPtr - 4)) << 32) \
|
| (OdInt64(*(pBuffPtr - 3)) << 40) \
|
| (OdInt64(*(pBuffPtr - 2)) << 48) \
|
| (OdInt64(*(pBuffPtr - 1)) << 56)))
|
|
#define OD_DOUBLE_FROM_BUFFPTR(pBuffPtr) getStrictDouble(&pBuffPtr)
|
|
#define OD_INT16_TO_BUFFPTR(pBuffPtr, val) setStrictInt16(&pBuffPtr, val)
|
#define OD_INT32_TO_BUFFPTR(pBuffPtr, val) setStrictInt32(&pBuffPtr, val)
|
#define OD_INT64_TO_BUFFPTR(pBuffPtr, val) setStrictInt64(&pBuffPtr, val)
|
|
#define OD_DOUBLE_TO_BUFFPTR(pBuffPtr, val) setStrictDouble(&pBuffPtr, val)
|
|
|
#else
|
|
inline double getValidDouble(OdUInt8** ppBuff)
|
{
|
double d = isValidNonZeroIEEEDouble(*ppBuff) ? *((double*)(*ppBuff)) : 0.0;
|
*ppBuff+=8;
|
return d;
|
}
|
|
#define OD_INT16_FROM_BUFFPTR(pBuffPtr) (pBuffPtr += 2, *((OdInt16*)(pBuffPtr - 2)))
|
#define OD_INT32_FROM_BUFFPTR(pBuffPtr) (pBuffPtr += 4, *((OdInt32*)(pBuffPtr - 4)))
|
#define OD_INT64_FROM_BUFFPTR(pBuffPtr) (pBuffPtr += 8, *((OdInt64*)(pBuffPtr - 8)))
|
|
#define OD_DOUBLE_FROM_BUFFPTR(pBuffPtr) getValidDouble(&pBuffPtr)
|
//#define OD_POINT3D_FROM_BUFFPTR(pBuffPtr) (pBuffPtr+=24, *((OdGePoint3d*)(pBuffPtr-24)))
|
|
#define OD_INT16_TO_BUFFPTR(pBuffPtr, val) (pBuffPtr+=2, *((OdInt16*)(pBuffPtr-2)) = OdInt16(val))
|
#define OD_INT32_TO_BUFFPTR(pBuffPtr, val) (pBuffPtr+=4, *((OdInt32*)(pBuffPtr-4)) = OdInt32(val))
|
#define OD_INT64_TO_BUFFPTR(pBuffPtr, val) (pBuffPtr+=8, *((OdInt64*)(pBuffPtr-8)) = OdInt64(val))
|
|
#define OD_DOUBLE_TO_BUFFPTR(pBuffPtr, val) (pBuffPtr+=8, *((double*)(pBuffPtr-8)) = double(val))
|
//#define OD_POINT3D_TO_BUFFPTR(pBuffPtr, val) (pBuffPtr+=24, *((OdGePoint3d*)(pBuffPtr-24)) = val)
|
|
#endif // TD_STRICT_ALIGNMENT
|
|
|
#else
|
|
|
extern double getBeDouble(OdUInt8** ppBuff);
|
//extern OdGePoint3d getBePnt3d(OdUInt8** ppBuff);
|
extern void setStrictInt16(OdUInt8** ppBuff, OdInt16 val);
|
extern void setStrictInt32(OdUInt8** ppBuff, OdInt32 val);
|
extern void setStrictInt64(OdUInt8** ppBuff, OdInt64 val);
|
extern void setBeDouble(OdUInt8** ppBuff, double d);
|
//extern void setBePnt3(OdUInt8** ppBuff, const OdGePoint3d& p);
|
|
|
// SGI doesn't like these versions.
|
//#define OD_INT16_FROM_BUFFPTR(pBuffPtr) ((OdInt16)(*pBuffPtr++ | (*pBuffPtr++ << 8)))
|
//#define OD_INT32_FROM_BUFFPTR(pBuffPtr) ((OdInt32)(*pBuffPtr++ | (*pBuffPtr++ << 8) | (*pBuffPtr++ << 16) | (*pBuffPtr++ << 24)))
|
// So use these instead
|
#define OD_INT16_FROM_BUFFPTR(pBuffPtr) (pBuffPtr += 2, (OdInt16)( *(pBuffPtr - 2) \
|
| (*(pBuffPtr - 1) << 8)))
|
#define OD_INT32_FROM_BUFFPTR(pBuffPtr) (pBuffPtr += 4, (OdInt32)( *(pBuffPtr - 4) \
|
| (*(pBuffPtr - 3) << 8) \
|
| (*(pBuffPtr - 2) << 16) \
|
| (*(pBuffPtr - 1) << 24)))
|
#define OD_INT64_FROM_BUFFPTR(pBuffPtr) (pBuffPtr += 8, (OdInt64)( *(pBuffPtr - 8) \
|
| (((OdInt64)(*(pBuffPtr - 7))) << 8) \
|
| (((OdInt64)(*(pBuffPtr - 6))) << 16) \
|
| (((OdInt64)(*(pBuffPtr - 5))) << 24) \
|
| (((OdInt64)(*(pBuffPtr - 4))) << 32) \
|
| (((OdInt64)(*(pBuffPtr - 3))) << 40) \
|
| (((OdInt64)(*(pBuffPtr - 2))) << 48) \
|
| (((OdInt64)(*(pBuffPtr - 1))) << 56)))
|
|
#define OD_DOUBLE_FROM_BUFFPTR(pBuffPtr) getBeDouble(&pBuffPtr)
|
//#define OD_POINT3D_FROM_BUFFPTR(pBuffPtr) getBePnt3d(&pBuffPtr)
|
|
#define OD_INT16_TO_BUFFPTR(pBuffPtr, val) setStrictInt16(&pBuffPtr, val)
|
#define OD_INT32_TO_BUFFPTR(pBuffPtr, val) setStrictInt32(&pBuffPtr, val)
|
#define OD_INT64_TO_BUFFPTR(pBuffPtr, val) setStrictInt64(&pBuffPtr, val)
|
|
#define OD_DOUBLE_TO_BUFFPTR(pBuffPtr, val) setBeDouble(&pBuffPtr, val)
|
//#define OD_POINT3D_TO_BUFFPTR(pBuffPtr, val) setBePnt3(&pBuffPtr, val)
|
|
#endif // ODA_BIGENDIAN
|
|
|
#if defined(ODA_WINDOWS)
|
#include "WINDOWS.H"
|
#include "WINGDI.H"
|
#endif
|
|
#if defined(_WIN32) && !defined(WIN64) && !defined(_WINRT)
|
// COLORREF on WIN64 is 8 bytes
|
#define ODCOLORREF COLORREF
|
#define ODRGB(r,g,b) RGB(r,g,b)
|
#define ODRGBA(r,g,b,a) (((ODCOLORREF)ODRGB(r,g,b))|(((DWORD)(BYTE)(a))<<24))
|
#define ODGETRED(rgb) GetRValue(rgb)
|
#define ODGETGREEN(rgb) GetGValue(rgb)
|
#define ODGETBLUE(rgb) GetBValue(rgb)
|
#define ODGETALPHA(rgba) ((BYTE)((rgba)>>24))
|
#define ODRECT RECT
|
|
#else //#ifdef _WIN32
|
|
#define ODCOLORREF OdUInt32
|
#define ODRGB(r,g,b) ((ODCOLORREF)(((OdUInt8)(r)|((OdUInt16)((OdUInt8)(g))<<8))|(((OdUInt32)(OdUInt8)(b))<<16)))
|
#define ODRGBA(r,g,b,a) (((ODCOLORREF)ODRGB(r,g,b))|(((OdUInt32)(OdUInt8)(a))<<24))
|
|
#define ODGETRED(rgb) ((OdUInt8)(rgb))
|
#define ODGETGREEN(rgb) ((OdUInt8)(((OdUInt16)(rgb)) >> 8))
|
#define ODGETBLUE(rgb) ((OdUInt8)((rgb)>>16))
|
#define ODGETALPHA(rgba) ((OdUInt8)((rgba)>>24))
|
|
typedef struct OdTagRECT{
|
OdInt32 left;
|
OdInt32 top;
|
OdInt32 right;
|
OdInt32 bottom;
|
} ODRECT;
|
|
#if !defined(WIN64) || defined(_WINRT)
|
|
#if !defined(_WINRT)
|
#ifndef RGBQUAD_DEFINED
|
#define RGBQUAD_DEFINED
|
#if defined(__sun)
|
#pragma pack(2)
|
#else
|
#pragma pack(push,2)
|
#endif
|
/** \details
|
<group !!RECORDS_TD_APIRef>
|
*/
|
typedef struct tagRGBQUAD
|
{
|
OdUInt8 rgbBlue;
|
OdUInt8 rgbGreen;
|
OdUInt8 rgbRed;
|
OdUInt8 rgbReserved;
|
} RGBQUAD, *LPRGBQUAD;
|
#if defined(__sun)
|
#pragma pack()
|
#else
|
#pragma pack(pop)
|
#endif
|
#endif
|
|
#ifndef BITMAPINFOHEADER_DEFINED
|
#define BITMAPINFOHEADER_DEFINED
|
/** \details
|
<group !!RECORDS_TD_APIRef>
|
*/
|
#if defined(__sun)
|
#pragma pack(2)
|
#else
|
#pragma pack(push,2)
|
#endif
|
|
typedef struct tagBITMAPINFOHEADER {
|
OdUInt32 biSize;
|
OdInt32 biWidth;
|
OdInt32 biHeight;
|
OdUInt16 biPlanes;
|
OdUInt16 biBitCount;
|
OdUInt32 biCompression;
|
OdUInt32 biSizeImage;
|
OdInt32 biXPelsPerMeter;
|
OdInt32 biYPelsPerMeter;
|
OdUInt32 biClrUsed;
|
OdUInt32 biClrImportant;
|
} BITMAPINFOHEADER, *PBITMAPINFOHEADER;
|
|
#if defined(__sun)
|
#pragma pack()
|
#else
|
#pragma pack(pop)
|
#endif
|
|
#endif
|
|
#ifndef BITMAPINFO_DEFINED
|
#define BITMAPINFO_DEFINED
|
typedef struct tagBITMAPINFO {
|
BITMAPINFOHEADER bmiHeader;
|
RGBQUAD bmiColors[1];
|
} BITMAPINFO, *PBITMAPINFO;
|
|
#endif //BITMAPINFO_DEFINED
|
|
#endif //_WINRT
|
#ifndef BITMAPFILEHEADER_DEFINED
|
#define BITMAPFILEHEADER_DEFINED
|
#if defined(__sun)
|
#pragma pack(2)
|
#else
|
#pragma pack(push,2)
|
#endif
|
/** \details
|
<group !!RECORDS_TD_APIRef>
|
*/
|
typedef struct tagBITMAPFILEHEADER
|
{
|
OdUInt16 bfType;
|
OdUInt32 bfSize;
|
OdUInt16 bfReserved1;
|
OdUInt16 bfReserved2;
|
OdUInt32 bfOffBits;
|
} BITMAPFILEHEADER, *PBITMAPFILEHEADER;
|
#if defined(__sun)
|
#pragma pack()
|
#else
|
#pragma pack(pop)
|
#endif
|
#endif
|
|
#endif //#ifndef WIN64
|
#endif //#ifdef _WIN32
|
|
#ifndef ODA_WINDOWS
|
#ifndef CLSID
|
#define CLSID OdGUID
|
#endif
|
#endif
|
|
#define ODTOCMCOLOR(colorref) OdCmEntityColor( ODGETRED(colorref), ODGETGREEN(colorref), ODGETBLUE(colorref) )
|
#define ODTOCOLORREF(cmColor) ODRGB( cmColor.red(), cmColor.green(), cmColor.blue() )
|
|
//////////////////////////////////////////////////////////////////////////
|
// IR.111706. MacOS X dynamic library loading.
|
// Some code taken from Dlcompat open source library.
|
// www.opendarwin.org/projects/dlcompat/
|
|
#if defined(_TOOLKIT_IN_DLL_) && defined(__GNUC__) && defined(__APPLE__) // GNU compiler MacOS X
|
|
#include <mach-o/dyld.h>
|
|
# ifndef RTLD_LAZY
|
# define RTLD_LAZY 0x1
|
# endif
|
# ifndef RTLD_NOW
|
# define RTLD_NOW 0x2
|
# endif
|
# ifndef RTLD_LOCAL
|
# define RTLD_LOCAL 0x4
|
# endif
|
# ifndef RTLD_GLOBAL
|
# define RTLD_GLOBAL 0x8
|
# endif
|
# ifndef RTLD_NOLOAD
|
# define RTLD_NOLOAD 0x10
|
# endif
|
# ifndef RTLD_NODELETE
|
# define RTLD_NODELETE 0x80
|
# endif
|
|
class OdString;
|
void* LoadSharedLibrary(const OdString& path, int mode = 2);
|
void *GetFunction(void *handle, char *symbol);
|
bool FreeSharedLibrary(void *handle);
|
|
#endif //defined(__GNUC__) && defined(__APPLE__) // GNU compiler MacOS X
|
|
#if defined(_TOOLKIT_IN_DLL_) && defined(__GNUC__) && !defined(__APPLE__) // GNU compiler Linux
|
|
#include <dlfcn.h>
|
|
#endif // defined(_TOOLKIT_IN_DLL_) && defined(__GNUC__) && !defined(__APPLE__) // GNU compiler Linux
|
|
#include <time.h>
|
|
size_t od_strftime(char *s, size_t maxsize, const char *format, const struct tm *t);
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
#endif // _OD_PLATFORM_H_
|
