|
|
|
/*==LICENSE==*
|
|
|
|
|
|
|
|
CyanWorlds.com Engine - MMOG client, server and tools
|
|
|
|
Copyright (C) 2011 Cyan Worlds, Inc.
|
|
|
|
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
Additional permissions under GNU GPL version 3 section 7
|
|
|
|
|
|
|
|
If you modify this Program, or any covered work, by linking or
|
|
|
|
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
|
|
|
|
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
|
|
|
|
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
|
|
|
|
(or a modified version of those libraries),
|
|
|
|
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
|
|
|
|
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
|
|
|
|
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
|
|
|
|
licensors of this Program grant you additional
|
|
|
|
permission to convey the resulting work. Corresponding Source for a
|
|
|
|
non-source form of such a combination shall include the source code for
|
|
|
|
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
|
|
|
|
work.
|
|
|
|
|
|
|
|
You can contact Cyan Worlds, Inc. by email legal@cyan.com
|
|
|
|
or by snail mail at:
|
|
|
|
Cyan Worlds, Inc.
|
|
|
|
14617 N Newport Hwy
|
|
|
|
Mead, WA 99021
|
|
|
|
|
|
|
|
*==LICENSE==*/
|
|
|
|
#include "HeadSpin.h"
|
|
|
|
|
|
|
|
#ifndef hsTypes_Defined
|
|
|
|
#define hsTypes_Defined
|
|
|
|
|
|
|
|
|
|
|
|
/************************** Other Includes *****************************/
|
|
|
|
|
|
|
|
#if !(HS_BUILD_FOR_REFERENCE)
|
|
|
|
#if HS_BUILD_FOR_MAC
|
|
|
|
#include <Types.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <memory.h>
|
|
|
|
#endif
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stddef.h>
|
|
|
|
|
|
|
|
#endif
|
|
|
|
#if HS_CAN_USE_FLOAT
|
|
|
|
#include <math.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/************************** Basic Macros *****************************/
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
#define hsCTypeDefStruct(foo)
|
|
|
|
#else
|
|
|
|
#define hsCTypeDefStruct(foo) typedef struct foo foo;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/************************** Basic Types *****************************/
|
|
|
|
|
|
|
|
typedef unsigned char byte;
|
|
|
|
typedef unsigned short word;
|
|
|
|
typedef unsigned long dword;
|
|
|
|
|
|
|
|
#ifdef _MSC_VER
|
|
|
|
typedef unsigned __int64 qword;
|
|
|
|
#else
|
|
|
|
typedef unsigned long long qword;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
typedef size_t unsigned_ptr;
|
|
|
|
|
|
|
|
typedef wchar_t wchar;
|
|
|
|
|
|
|
|
#define kPosInfinity16 (32767)
|
|
|
|
#define kNegInfinity16 (-32768)
|
|
|
|
|
|
|
|
#define kPosInfinity32 (0x7fffffff)
|
|
|
|
#define kNegInfinity32 (0x80000000)
|
|
|
|
|
|
|
|
#if HS_BUILD_FOR_PS2
|
|
|
|
typedef int Int32;
|
|
|
|
#else
|
|
|
|
typedef long Int32;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
typedef short Int16;
|
|
|
|
typedef signed char Int8;
|
|
|
|
|
|
|
|
#if !(HS_BUILD_FOR_MAC)
|
|
|
|
typedef unsigned char UInt8;
|
|
|
|
typedef unsigned short UInt16;
|
|
|
|
#if HS_BUILD_FOR_PS2
|
|
|
|
typedef unsigned int UInt32;
|
|
|
|
#else
|
|
|
|
typedef unsigned long UInt32;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef Byte
|
|
|
|
typedef UInt8 Byte;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef false
|
|
|
|
#define false 0
|
|
|
|
#endif
|
|
|
|
#ifndef true
|
|
|
|
#define true 1
|
|
|
|
#endif
|
|
|
|
#ifndef Boolean
|
|
|
|
#if HS_BUILD_FOR_UNIX
|
|
|
|
typedef char Boolean;
|
|
|
|
#else
|
|
|
|
typedef UInt8 Boolean;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HS_BUILD_FOR_WIN32
|
|
|
|
typedef __int64 Int64;
|
|
|
|
typedef unsigned __int64 UInt64;
|
|
|
|
#else
|
|
|
|
typedef long long Int64;
|
|
|
|
typedef unsigned long long UInt64;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
typedef Int32 hsFixed;
|
|
|
|
typedef Int32 hsFract;
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
|
|
|
|
typedef int hsBool;
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "hsScalar.h"
|
|
|
|
|
|
|
|
#if HS_CAN_USE_FLOAT
|
|
|
|
#define HS_PI 3.1415927
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef nil
|
|
|
|
#define nil (0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
typedef Int32 hsError;
|
|
|
|
typedef UInt32 hsGSeedValue;
|
|
|
|
|
|
|
|
#define hsOK 0
|
|
|
|
#define hsFail -1
|
|
|
|
#define hsFailed(r) ((hsError)(r)<hsOK)
|
|
|
|
#define hsSucceeded(r) ((hsError)(r)>=hsOK)
|
|
|
|
|
|
|
|
#define hsLongAlign(n) (((n) + 3) & ~3L)
|
|
|
|
|
|
|
|
#define hsMaximum(a, b) ((a) > (b) ? (a) : (b))
|
|
|
|
#define hsMinimum(a, b) ((a) < (b) ? (a) : (b))
|
|
|
|
#define hsABS(x) ((x) < 0 ? -(x) : (x))
|
|
|
|
#define hsSGN(x) (((x) < 0) ? -1 : ( ((x) > 0) ? 1 : 0 ))
|
|
|
|
|
|
|
|
#define hsBitTst2Bool(value, mask) (((value) & (mask)) != 0)
|
|
|
|
|
|
|
|
#define hsFourByteTag(a, b, c, d) (((UInt32)(a) << 24) | ((UInt32)(b) << 16) | ((UInt32)(c) << 8) | (d))
|
|
|
|
|
|
|
|
|
|
|
|
/************************** Swap Macros *****************************/
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
inline UInt16 hsSwapEndian16(UInt16 value)
|
|
|
|
{
|
|
|
|
return (value >> 8) | (value << 8);
|
|
|
|
}
|
|
|
|
inline UInt32 hsSwapEndian32(UInt32 value)
|
|
|
|
{
|
|
|
|
return (value << 24) |
|
|
|
|
((value & 0xFF00) << 8) |
|
|
|
|
((value >> 8) & 0xFF00) |
|
|
|
|
(value >> 24);
|
|
|
|
}
|
|
|
|
#if HS_CAN_USE_FLOAT
|
|
|
|
inline float hsSwapEndianFloat(float fvalue)
|
|
|
|
{
|
|
|
|
UInt32 value = *(UInt32*)&fvalue;
|
|
|
|
value = hsSwapEndian32(value);
|
|
|
|
return *(float*)&value;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HS_CPU_LENDIAN
|
|
|
|
#define hsUNSWAP16(n) hsSwapEndian16(n)
|
|
|
|
#define hsUNSWAP32(n) hsSwapEndian32(n)
|
|
|
|
#define hsSWAP16(n) (n)
|
|
|
|
#define hsSWAP32(n) (n)
|
|
|
|
#else
|
|
|
|
#define hsUNSWAP16(n) (n)
|
|
|
|
#define hsUNSWAP32(n) (n)
|
|
|
|
#define hsSWAP16(n) hsSwapEndian16(n)
|
|
|
|
#define hsSWAP32(n) hsSwapEndian32(n)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
inline void hsSwap(Int32& a, Int32& b)
|
|
|
|
{
|
|
|
|
Int32 c = a;
|
|
|
|
a = b;
|
|
|
|
b = c;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void hsSwap(UInt32& a, UInt32& b)
|
|
|
|
{
|
|
|
|
UInt32 c = a;
|
|
|
|
a = b;
|
|
|
|
b = c;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if HS_CAN_USE_FLOAT
|
|
|
|
inline void hsSwap(float& a, float& b)
|
|
|
|
{
|
|
|
|
float c = a;
|
|
|
|
a = b;
|
|
|
|
b = c;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/************************** Color32 Type *****************************/
|
|
|
|
|
|
|
|
struct hsColor32 {
|
|
|
|
|
|
|
|
#if 1 // hsColor32 fixed-format optimization
|
|
|
|
UInt8 b, g, r, a;
|
|
|
|
#else
|
|
|
|
#if (HS_BUILD_FOR_WIN32 || HS_BUILD_FOR_BE)
|
|
|
|
UInt8 b, g, r, a;
|
|
|
|
#elif (HS_BUILD_FOR_UNIX && HS_CPU_BENDIAN)
|
|
|
|
UInt8 a, b, g, r;
|
|
|
|
#else
|
|
|
|
UInt8 a, r, g, b;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
void SetARGB(UInt8 aa, UInt8 rr, UInt8 gg, UInt8 bb)
|
|
|
|
{
|
|
|
|
this->a = aa; this->r = rr; this->g = gg; this->b = bb;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Compatibility inlines, should be depricated
|
|
|
|
void Set(UInt8 rr, UInt8 gg, UInt8 bb)
|
|
|
|
{
|
|
|
|
this->r = rr; this->g = gg; this->b = bb;
|
|
|
|
}
|
|
|
|
void Set(UInt8 aa, UInt8 rr, UInt8 gg, UInt8 bb)
|
|
|
|
{
|
|
|
|
this->SetARGB(aa, rr, gg, bb);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
friend int operator==(const hsColor32& a, const hsColor32& b)
|
|
|
|
{
|
|
|
|
return *(UInt32*)&a == *(UInt32*)&b;
|
|
|
|
}
|
|
|
|
friend int operator!=(const hsColor32& a, const hsColor32& b) { return !(a == b); }
|
|
|
|
#else
|
|
|
|
int operator==(const hsColor32& aa) const
|
|
|
|
{
|
|
|
|
return *(UInt32*)&aa == *(UInt32*)this;
|
|
|
|
}
|
|
|
|
int operator!=(const hsColor32& aa) { return !(aa == *this); }
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
hsCTypeDefStruct(hsColor32)
|
|
|
|
|
|
|
|
typedef hsColor32 hsRGBAColor32;
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* NULL_STMT
|
|
|
|
* Declares a null statement
|
|
|
|
*
|
|
|
|
* Example:
|
|
|
|
*
|
|
|
|
* for (; *str && (*str != ch); ++str)
|
|
|
|
* NULL_STMT;
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
#if _MSC_VER >= 7
|
|
|
|
# define NULL_STMT __noop
|
|
|
|
#else
|
|
|
|
# define NULL_STMT ((void)0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* REF
|
|
|
|
* References a variable to prevent compiler warnings
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
#define REF(a) ((void *)&(a))
|
|
|
|
|
|
|
|
#if _MSC_VER < 1400
|
|
|
|
// For compatibility only, deprecated - use REF instead
|
|
|
|
#define ref(a) REF(a)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* UNIQUE_SYMBOL
|
|
|
|
* Creates a symbol that is unique within a file
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
#define UNIQUE_SYMBOL_EXPAND_1(prefix,line) UNIQUE_SYMBOL_##prefix##_##line
|
|
|
|
#define UNIQUE_SYMBOL_EXPAND_0(prefix,line) UNIQUE_SYMBOL_EXPAND_1(prefix,line)
|
|
|
|
#define UNIQUE_SYMBOL(prefix) UNIQUE_SYMBOL_EXPAND_0(prefix,__LINE__)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* COMPILER_ASSERT
|
|
|
|
* Performs a "compile-time" assertion
|
|
|
|
* Can be used at function or file scope
|
|
|
|
* Upon assertion failure, creates a negative subscript error
|
|
|
|
* Use COMPILER_ASSERT_HEADER in header files to prevent symbol collision
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
#define COMPILER_ASSERT(expr) static char UNIQUE_SYMBOL(a)[(expr) ? 1 : -1]
|
|
|
|
#define COMPILER_ASSERT_HEADER(prefix,expr) static char UNIQUE_SYMBOL(prefix)[(expr) ? 1 : -1]
|
|
|
|
#define COMPILER_ASSERT_SYMBOL(symbol,expr) static char symbol[(expr) ? 1 : -1]
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* max/min inline functions
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
#ifdef max
|
|
|
|
#undef max
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef min
|
|
|
|
#undef min
|
|
|
|
#endif
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
template<class T>
|
|
|
|
inline T max (const T & a, const T & b) {
|
|
|
|
return (a > b) ? a : b;
|
|
|
|
}
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
inline unsigned max (int a, unsigned b) {
|
|
|
|
return ((unsigned)a > b) ? a : b;
|
|
|
|
}
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
inline unsigned max (unsigned a, int b) {
|
|
|
|
return (a > (unsigned)b) ? a : b;
|
|
|
|
}
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
template<class T>
|
|
|
|
inline T min (const T & a, const T & b) {
|
|
|
|
return (a < b) ? a : b;
|
|
|
|
}
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
inline unsigned min (int a, unsigned b) {
|
|
|
|
return ((unsigned)a < b) ? a : b;
|
|
|
|
}
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
inline unsigned min (unsigned a, int b) {
|
|
|
|
return (a < (unsigned)b) ? a : b;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* MAX/MIN macros
|
|
|
|
* These are less safe than the inline function versions, since they
|
|
|
|
* evaluate parameters twice. However, they can be used to produce
|
|
|
|
* compile-time constants.
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
|
|
|
|
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* SWAP
|
|
|
|
* Swaps the values of two variables
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
template<class T>
|
|
|
|
void SWAP (T & a, T & b) {
|
|
|
|
T temp = a;
|
|
|
|
a = b;
|
|
|
|
b = temp;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* AUTO_INIT_FUNC
|
|
|
|
* Declares a function that is automatically called at program startup time
|
|
|
|
*
|
|
|
|
* Example:
|
|
|
|
*
|
|
|
|
* AUTO_INIT_FUNC(BuildLookupTables) {
|
|
|
|
* ...
|
|
|
|
* }
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
#define AUTO_INIT_FUNC(name) namespace { struct name { name (); } name##_instance; } name::name ()
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* Calculate the address to the base of a structure given its type, and the
|
|
|
|
* address of a field within the structure.
|
|
|
|
*
|
|
|
|
* Example:
|
|
|
|
*
|
|
|
|
* CONTAINING_STRUCT(trans, INetTrans, m_trans);
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
#define CONTAINING_STRUCT(a, t, f) ((t *) ((byte *)(a) - (unsigned_ptr)(&((t *)0)->f)))
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* arrsize/marrsize
|
|
|
|
* arrsize returns the number of elements in an array variable
|
|
|
|
* marrsize returns the number of elements in an array field in a structure
|
|
|
|
*
|
|
|
|
* Example:
|
|
|
|
*
|
|
|
|
* StrPrintf(buffer, arrsize(buffer), "%u", value);
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
#define arrsize(a) (sizeof(a) / sizeof((a)[0]))
|
|
|
|
#define marrsize(c,a) (arrsize(((c *)0)->a))
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* offsetof/moffsetof
|
|
|
|
* offsetof returns the offset in bytes of a field inside a structure based on a type
|
|
|
|
* moffsetof returns the offset in bytes of a field inside a structure based on a variable
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
#ifndef offsetof
|
|
|
|
#define offsetof(s,m) (size_t)&(((s *)0)->m)
|
|
|
|
#endif // ifndef offsetof
|
|
|
|
|
|
|
|
#define moffsetof(v,f) (((byte *) &((v)->f)) - ((byte *) v))
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* msizeof
|
|
|
|
* Returns the size of a field in a structure
|
|
|
|
*
|
|
|
|
* Example:
|
|
|
|
*
|
|
|
|
* unsigned bufferSize = msizeof(CommandStruct, buffer);
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
#define msizeof(c,a) (sizeof(((c *)0)->a))
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* ONCE
|
|
|
|
* Shortcut to create a 'for' loop that executes only once
|
|
|
|
*
|
|
|
|
* for (ONCE) {
|
|
|
|
* ...
|
|
|
|
* }
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
#ifndef ONCE
|
|
|
|
#define ONCE bool UNIQUE_SYMBOL(ONCE) = true; UNIQUE_SYMBOL(ONCE); UNIQUE_SYMBOL(ONCE) = false
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* IS_POW2
|
|
|
|
*
|
|
|
|
***/
|
|
|
|
|
|
|
|
#define IS_POW2(val) (!((val) & ((val) - 1)))
|
|
|
|
|
|
|
|
|
|
|
|
/************************ Debug/Error Macros **************************/
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
|
|
|
|
typedef void (*hsDebugMessageProc)(const char message[]);
|
|
|
|
extern hsDebugMessageProc gHSDebugProc;
|
|
|
|
#define HSDebugProc(m) { if (gHSDebugProc) gHSDebugProc(m); }
|
|
|
|
hsDebugMessageProc hsSetDebugMessageProc(hsDebugMessageProc newProc);
|
|
|
|
|
|
|
|
extern hsDebugMessageProc gHSStatusProc;
|
|
|
|
hsDebugMessageProc hsSetStatusMessageProc(hsDebugMessageProc newProc);
|
|
|
|
|
|
|
|
void __cdecl ErrorAssert (int line, const char file[], const char fmt[], ...);
|
|
|
|
void __cdecl ErrorFatal (int line, const char file[], const char fmt[], ...);
|
|
|
|
void ErrorMinimizeAppWindow ();
|
|
|
|
|
|
|
|
enum EErrorOption {
|
|
|
|
kErrOptNonGuiAsserts,
|
|
|
|
kErrOptDisableMemLeakChecking,
|
|
|
|
kNumErrorOptions
|
|
|
|
};
|
|
|
|
bool ErrorSetOption (EErrorOption option, bool on);
|
|
|
|
bool ErrorGetOption (EErrorOption option);
|
|
|
|
|
|
|
|
bool DebugIsDebuggerPresent ();
|
|
|
|
void DebugBreakIfDebuggerPresent ();
|
|
|
|
void DebugMsg (const char fmt[], ...);
|
|
|
|
void DebugMsgV (const char fmt[], va_list args);
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef HS_DEBUGGING
|
|
|
|
|
|
|
|
void hsDebugMessage(const char message[], long refcon);
|
|
|
|
#define hsDebugCode(code) code
|
|
|
|
#define hsIfDebugMessage(expr, msg, ref) (void)( ((expr) != 0) || (hsDebugMessage(msg, ref), 0) )
|
|
|
|
#define hsAssert(expr, msg) (void)( ((expr) != 0) || (ErrorAssert(__LINE__, __FILE__, msg), 0) )
|
|
|
|
#define ASSERT(expr) (void)( ((expr) != 0) || (ErrorAssert(__LINE__, __FILE__, #expr), 0) )
|
|
|
|
#define ASSERTMSG(expr, msg) (void)( ((expr) != 0) || (ErrorAssert(__LINE__, __FILE__, msg), 0) )
|
|
|
|
#define FATAL(msg) ErrorAssert(__LINE__, __FILE__, msg)
|
|
|
|
#define DEBUG_MSG DebugMsg
|
|
|
|
#define DEBUG_MSGV DebugMsgV
|
|
|
|
#define DEBUG_BREAK_IF_DEBUGGER_PRESENT DebugBreakIfDebuggerPresent
|
|
|
|
|
|
|
|
#else /* Not debugging */
|
|
|
|
|
|
|
|
#define hsDebugMessage(message, refcon) NULL_STMT
|
|
|
|
#define hsDebugCode(code) /* empty */
|
|
|
|
#define hsIfDebugMessage(expr, msg, ref) NULL_STMT
|
|
|
|
#define hsAssert(expr, msg) NULL_STMT
|
|
|
|
#define ASSERT(expr) NULL_STMT
|
|
|
|
#define ASSERTMSG(expr, msg) NULL_STMT
|
|
|
|
#define FATAL(msg) NULL_STMT
|
|
|
|
#define DEBUG_MSG NULL_STMT
|
|
|
|
#define DEBUG_MSGV NULL_STMT
|
|
|
|
#define DEBUG_BREAK_IF_DEBUGGER_PRESENT NULL_STMT
|
|
|
|
|
|
|
|
#endif // HS_DEBUGGING
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef _MSC_VER
|
|
|
|
#define DEFAULT_FATAL(var) default: FATAL("No valid case for switch variable '" #var "'"); __assume(0); break;
|
|
|
|
#else
|
|
|
|
#define DEFAULT_FATAL(var) default: FATAL("No valid case for switch variable '" #var "'"); break;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef PLASMA_EXTERNAL_RELEASE
|
|
|
|
|
|
|
|
#define hsStatusMessage(x) NULL_STMT
|
|
|
|
#define hsStatusMessageF(x,y) NULL_STMT
|
|
|
|
|
|
|
|
#else /* Not external release */
|
|
|
|
|
|
|
|
void hsStatusMessage(const char message[]);
|
|
|
|
void hsStatusMessageF(const char * fmt, ...);
|
|
|
|
|
|
|
|
#endif // PLASMA_EXTERNAL_RELEASE
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif
|