/* ***** BEGIN LICENSE BLOCK ***** 
 * Version: RCSL 1.0/RPSL 1.0 
 *  
 * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
 *      
 * The contents of this file, and the files included with this file, are 
 * subject to the current version of the RealNetworks Public Source License 
 * Version 1.0 (the "RPSL") available at 
 * http://www.helixcommunity.org/content/rpsl unless you have licensed 
 * the file under the RealNetworks Community Source License Version 1.0 
 * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
 * in which case the RCSL will apply. You may also obtain the license terms 
 * directly from RealNetworks.  You may not use this file except in 
 * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
 * applicable to this file, the RCSL.  Please see the applicable RPSL or 
 * RCSL for the rights, obligations and limitations governing use of the 
 * contents of the file.  
 *  
 * This file is part of the Helix DNA Technology. RealNetworks is the 
 * developer of the Original Code and owns the copyrights in the portions 
 * it created. 
 *  
 * This file, and the files included with this file, is distributed and made 
 * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
 * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
 * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
 * 
 * Technology Compatibility Kit Test Suite(s) Location: 
 *    http://www.helixcommunity.org/content/tck 
 * 
 * Contributor(s): 
 *  
 * ***** END LICENSE BLOCK ***** */ 

/////////////////////////////////////////////////////////////////////////////
// HXASSERT.H
//
// Debugging support header.
//
// HX_ASSERT()	- asserts an expression is TRUE. Compiles to no-ops in
//				retail builds. Provides message box or other UI when 
//				expression fails.
//
// HX_ASSERT_VALID_PTR() - asserts that a pointer is valid. Performs more
//				rigid verification specifically appropriate for pointers.
//
// HX_VERIFY()	- verifies an expression is TRUE. Expression or code DOES NOT 
//				compile away in retail builds, but UI of failure is removed.
//				In debug builds provides message box or other UI when 
//				expression fails.
//
// HX_TRACE()	- Similar to DEBUGPRINTF() but no buffer is required. 
//				Compiles to no-ops in retail builds.
//

#ifndef _HXASSERT_H_
#define _HXASSERT_H_

#include "hlxclib/assert.h"

#ifndef ASSERT
#if defined (DEBUG) || defined (_DEBUG)
#if defined (_OSF1) && defined (_NATIVE_COMPILER)
#	define ASSERT(x)	assert(((long)(x)) != 0L)
#else
#       define ASSERT(x)        assert(x)
#endif
#else
#	define ASSERT(x)	/* x */
#endif /* DEBUG */
#endif /* ndef ASSERT */

#include "hlxclib/limits.h"
#include "hxtypes.h"
#include "hxresult.h"           // for HX_RESULT
#include "hlxclib/stdio.h"      // for sprintf

#ifdef _SUN
#include <stddef.h>     // for size_t
#endif

#ifdef __cplusplus
extern "C" {
#endif

#if defined (_SOLARIS) || defined (_IRIX) || defined (_DECALPHA)
#ifndef __inline
#define __inline inline
#endif
#endif

#if defined (_OSF1) && defined (_NATIVE_COMPILER)
#if defined __cplusplus
#define __inline inline
#else
#define __inline static
#endif /* __cplusplus */
#endif

#ifdef _HPUX 
#if defined __cplusplus
#define __inline inline
#else
#define __inline 
#endif /* __cplusplus */
#endif

#if defined _AIX
#if defined __cplusplus
#define __inline inline
#else
#define __inline 
#endif /* __cplusplus */
#endif /* _AIX */

#ifdef _UNIX
#include <signal.h> /* For kill() */
#include <unistd.h> /* For getpid() */
#include <stdio.h>
void HXUnixDebugBreak();
#endif


/////////////////////////////////////////////////////////////////////////////
// Diagnostic support

// For _MAX_PATH
#if defined ( _MACINTOSH )
#include "platform/mac/maclibrary.h"
#elif defined (_UNIX)
#include <stdlib.h>
#if !defined(_VXWORKS)
#include <sys/param.h>
#endif
#define _MAX_PATH       MAXPATHLEN
#elif defined (_WINDOWS)
#include <stdlib.h>
#endif

#ifdef _SYMBIAN
# include <unistd.h>
# define _MAX_PATH MAXPATHLEN
#endif

#ifdef _OPENWAVE
#ifndef _MAX_PATH
#define _MAX_PATH 256
#endif
#endif

#if defined (DEBUG) || defined (_DEBUG)

#ifdef _MACINTOSH
#  define MAX_TRACE_OUTPUT  255
#else
# ifdef _UNIX
#  define MAX_TRACE_OUTPUT  255
# elif _WIN16
#  define MAX_TRACE_OUTPUT  255
# elif _SYMBIAN
#  define MAX_TRACE_OUTPUT  255
# else
#  define MAX_TRACE_OUTPUT  (_MAX_PATH*2 + 20)
# endif
#endif


/////////////////////////////////////////////////////////////////////////////
//
//	HXDebugOptionEnabled: 
//		Determine if the given debug option is enabled.
//		A lookup is done to the registry key, and if it's present
//		and set to '1', TRUE is returned otherwise FALSE
//		Similar to HXWantTraceMessages, except not specific to one option.
#ifdef _WIN16
// The STDMETHODCALLTYPE includes the _export keyword, even though this is
// a static, not dll, library.  Seems to work on win32 ok, but not a win16
// .exe.  rpapp would see this as duplicate symbol, until the _export was
// removed, and all the libraries that rpapp linked with rebuilt.  There
// may be a define for STDMETHODCALLTYPE without the _export that should be
// used here. XXXTW.  april 98.
BOOL far _cdecl HXDebugOptionEnabled(const char* szOption);
#else
BOOL STDMETHODCALLTYPE HXDebugOptionEnabled(const char* szOption);
#endif

/////////////////////////////////////////////////////////////////////////////
//
//	HXWantTraceMessages: 
//		Helper function used to determine if the system has asked for trace 
//		messages.
//
BOOL STDMETHODCALLTYPE HXWantTraceMessages();

/////////////////////////////////////////////////////////////////////////////
//
//	HXOutputDebugString: 
//		Helper function used by DEBUGOUTSTR(). This is better than 
//		OutputDebugString, because it will check to see if output
//		tracing is turned off in the registry. This prevents the massive
//		slew of output messages.
//
void STDMETHODCALLTYPE HXOutputDebugString(const char* pString);

/////////////////////////////////////////////////////////////////////////////
//
// HXTrace: Helper function used by HX_TRACE()
//
void STDMETHODVCALLTYPE HXTrace(const char* pszFormat, ...);


/////////////////////////////////////////////////////////////////////////////
//
// HXAssertFailedLine: Helper function used by HX_ASSERT()
//
#ifdef _WIN16
// The STDMETHODCALLTYPE includes the _export keyword, even though this is
// a static, not dll, library.  Seems to work on win32 ok, but not a win16
// .exe.  rpapp would see this as duplicate symbol, until the _export was
// removed, and all the libraries that rpapp linked with rebuilt.  There
// may be a define for STDMETHODCALLTYPE without the _export that should be
// used here. XXXTW.  april 98.
BOOL far _cdecl HXAssertFailedLine(const char* pszExpression, const char* pszFileName, int nLine);
#else
BOOL STDMETHODCALLTYPE HXAssertFailedLine(const char* pszExpression, const char* pszFileName, int nLine);
#endif

/////////////////////////////////////////////////////////////////////////////
//
// HXAssertValidPointer, HXIsValidAddress: Helper functions used by
// HX_ASSERT_VALID_PTR()
//
void STDMETHODCALLTYPE HXAssertValidPointer(const void* pVoid, const char* pszFileName, int nLine);
#ifdef __cplusplus
#ifdef _WIN16
    // see note above on the problem with STDMETHODCALLTYPE on win16
    BOOL far _cdecl        HXIsValidAddress(const void* lp, ULONG32 nBytes = 1, BOOL bReadWrite = TRUE);
#else
    BOOL STDMETHODCALLTYPE HXIsValidAddress(const void* lp, ULONG32 nBytes = 1, BOOL bReadWrite = TRUE);
#endif
#else
#ifdef _WIN16
    // see note above on the problem with STDMETHODCALLTYPE on win16
    BOOL far _cdecl        HXIsValidAddress(const void* lp, ULONG32 nBytes, BOOL bReadWrite);
#else
    BOOL STDMETHODCALLTYPE HXIsValidAddress(const void* lp, ULONG32 nBytes, BOOL bReadWrite);
#endif
#endif

#ifdef _WIN16
BOOL far _cdecl        HXIsValidString(const char* lpsz, int nLength);
#else
BOOL STDMETHODCALLTYPE HXIsValidString(const char* lpsz, int nLength);
#endif

/////////////////////////////////////////////////////////////////////////////
//
// HXDebugBreak: used to break into debugger at critical times
//
#ifndef HXDebugBreak
// by default, debug break is asm int 3, or a call to DebugBreak, or nothing

#if defined(_WINDOWS)
#if !defined(_M_IX86)
#include "windows.h"
#define HXDebugBreak() DebugBreak()
#else
#define HXDebugBreak() _asm { int 3 }
#endif // _M_ALPHA
#elif defined( _MACINTOSH )
#define HXDebugBreak() Debugger()
#elif defined(_OPENWAVE)
#if defined(_OPENWAVE_SIMULATOR) // windows app...
#define HXDebugBreak() _asm { int 3 }
#else
void HXDebugBreak();
#endif
#elif defined(_SYMBIAN)
#if defined(__WINS__)
#define HXDebugBreak() _asm { int 3 }
#else
void HXDebugBreak();
#endif //_SYMBIAN
#elif  defined(_UNIX)
void HXDebugBreak();
#elif defined(_VXWORKS)
#include <taskLib.h>
#define HXDebugBreak() (taskSuspend(taskIdSelf()))

#endif // end of#if defined(_WIN32) || defined(_WINDOWS)

#endif // end of#ifndef HXDebugBreak

#ifdef _UNIX
#include "signal.h"
#include "stdlib.h"

#define HX_ENABLE_JIT_DEBUGGING()               \
do {						\
    signal (SIGSEGV, (void (*)(int))HXDebugBreak);		\
    signal (SIGBUS,  (void (*)(int))HXDebugBreak);		\
    signal (SIGFPE,  (void (*)(int))HXDebugBreak);		\
    if (!getenv("PROCESS_NAME"))                \
    {                                           \
    char *progname = new char[strlen(argv[0]) + 30]; \
    sprintf(progname, "PROCESS_NAME=%s", argv[0]); /* Flawfinder: ignore */ \
    putenv(progname);                           \
    } \
} while (0);
#else
#define HX_ENABLE_JIT_DEBUGGING()
#endif

/////////////////////////////////////////////////////////////////////////////
//
// HXAbort: used to shut down the application at critical times
//
#ifndef HXAbort

#if (defined(_WIN32) || defined(_WINDOWS)) && !defined(WIN32_PLATFORM_PSPC)
# define HXAbort() 	abort()
#elif defined(WIN32_PLATFORM_PSPC)
# define HXAbort()   exit(1)
#elif defined(_SYMBIAN)
# define HXAbort() exit(1)
#elif defined(_OPENWAVE)
// XXXSAB is this right??
# define HXAbort() exit(1)
#elif defined ( _MACINTOSH )
# define HXAbort() DebugStr("\pHXAbort: Please exit this program.")
#elif defined ( _UNIX )
# define HXAbort() printf("\npnabort: Please exit this program.\n")
#endif // end of#if defined(_WIN32) || defined(_WINDOWS)

#endif // end of#ifndef HXAbort


/////////////////////////////////////////////////////////////////////////////
//
// HX_TRACE: see above.
//
#define HX_TRACE			::HXTrace

/////////////////////////////////////////////////////////////////////////////
//
// HX_ASSERT: see above.
//
//#define HX_ASSERT(f) \
//	do \
//	{ \
//	if (!(f) && HXAssertFailedLine(#f, __FILE__, __LINE__)) \
//		HXDebugBreak(); \
//	} while (0) \
//
#define HX_ASSERT(f) (0)

#define REQUIRE_REPORT(targ,file,line)	HXAssertFailedLine(targ,file,line)




/////////////////////////////////////////////////////////////////////////////
//
//	Macros Defined for logging messges in the player. 
//  
//  STARTLOGSINK: Query for an IHXErrorSink
//
//  LOGINFO: Report the error to the error sink
//
//  STOPLOGSINK: Shutdown and Release the error sink.	       
//
/////////////////////////////////////////////////////////////////////////////
#ifndef _GOLD

#ifndef _INTERFACE
#define _INTERFACE struct
#endif

typedef _INTERFACE IHXErrorMessages IHXErrorMessages;

    const char*	    FileAndLine(const char* pFile, UINT32 ulLine);
    HX_RESULT	    HXLogf(IHXErrorMessages *pErr, UINT8 sev, HX_RESULT err, UINT32 usr, const char* pURL, const char* pUsrStr, ...);
    HX_RESULT	    HXLog(IHXErrorMessages *pErr, UINT8 sev, HX_RESULT err, UINT32 usr, const char* pStr, const char* pURL);

#define THIS_LINE() FileAndLine(__FILE__, __LINE__)

#define HX_STARTLOG(__IUnknown, __ErrorMessages) \
	__IUnknown->QueryInterface(IID_IHXErrorMessages, (void **)&__ErrorMessages); \
	HX_ASSERT(__ErrorMessages != NULL && "Must have IHXErrorMessages interface to start logging")

#define HX_LOG HXLog
#define HX_LOGF HXLogf

#define HX_STOPLOG(__ErrorMessages)	HX_RELEASE(__ErrorMessages)

#else // _GOLD
#define HX_STARTLOG(x,y)    (void)0
#define HX_LOG		1 ? (void)0 : HXLog
#define HX_LOGF		1 ? (void)0 : HXLogf
#define HX_STOPLOG(x)	(void)0
#endif

/////////////////////////////////////////////////////////////////////////////
//
// HX_SAFESIZE_T
//
#define HX_SAFESIZE_T(f) \
	( ((ULONG32)(f) <= (size_t)-1)?((size_t)(f)): \
		(HXAssertFailedLine("size_t overflow",__FILE__, __LINE__), (size_t)(f)) ) \

/////////////////////////////////////////////////////////////////////////////
//
// HX_SAFEINT
//
#ifndef _VXWORKS
#define HX_SAFEINT(f) \
	( ((LONG32)(f) <= LONG_MAX && ((LONG32)(f)) >= ((LONG32)(LONG_MIN)))?((int)(f)): \
		(HXAssertFailedLine("Integer Size Overflow",__FILE__, __LINE__), (int)(f)) ) \

#else

#ifdef __cplusplus
extern "C"
#endif
int safe_int_func_call(LONG32 f);
#define HX_SAFEINT(f) safe_int_func_call((LONG32)(f))
#endif

#define HX_SAFEUINT(f) \
	( ((ULONG32)(f) <= ULONG_MAX && (LONG32)(f) >= 0)?((unsigned int)(f)): \
		(HXAssertFailedLine("Unsigned Integer Size Overflow",__FILE__, __LINE__), (unsigned int)(f)) ) \

#define HX_SAFEINT16(f) \
	( ((LONG32)(f) <= SHRT_MAX && (LONG32)(f) >= SHRT_MIN)?((short)(f)): \
		(HXAssertFailedLine("Short Integer Size Overflow",__FILE__, __LINE__), (short)(f)) ) \

#define HX_SAFEUINT16(f) \
	( ((ULONG32)(f) <= USHRT_MAX && (LONG32)(f) >= 0)?((unsigned short)(f)): \
		(HXAssertFailedLine("Unsigned Short Integer Size Overflow",__FILE__, __LINE__), (unsigned short)(f)) ) \

#define HX_SAFEINT8(f) \
	( ((LONG32)(f) <= SCHAR_MAX && (LONG32)(f) >= SCHAR_MIN)?((char)(f)): \
		(HXAssertFailedLine("Signed Char Size Overflow",__FILE__, __LINE__), (char)(f)) ) \

#define HX_SAFEUINT8(f) \
	( ((ULONG32)(f) <= UCHAR_MAX && (LONG32)(f) >= 0)?((unsigned char)(f)): \
		(HXAssertFailedLine("Unsigned Char Size Overflow",__FILE__, __LINE__), (unsigned char)(f)) ) \



	
/////////////////////////////////////////////////////////////////////////////
//
// HX_SAFE_VOID2HANDLE
//
#if defined(_WINDOWS)

#ifdef _WIN32
#define HX_SAFE_VOID2HANDLE(f) ((HANDLE)(f))
#else // !_WIN23
#define HX_SAFE_VOID2HANDLE(f) ((HANDLE)LOWORD(f))
// this doesn't work most of the time since the assignment of a handle (near *) to a
// void * sets the high word to the SS.
//	( ( (0xFFFF0000 & ((ULONG32)(f))) == 0)?((HANDLE)LOWORD(f)): 
//		(HXAssertFailedLine("HANDLE HIWORD NOT NULL",__FILE__, __LINE__), (HANDLE)LOWORD(f)) ) 

#endif

#elif defined ( __MWERKS__ )
#define HX_SAFE_VOID2HANDLE(f)	(f)
#elif defined ( _UNIX )
#define HX_SAFE_VOID2HANDLE(f)	(f)
#endif // end of#if defined(_WIN32) || defined(_WINDOWS)

/////////////////////////////////////////////////////////////////////////////
//
// HX_VERIFY: see above.
//
#define HX_VERIFY(f)          HX_ASSERT(f)

/////////////////////////////////////////////////////////////////////////////
//
// HX_ASSERT_VALID_PTR: see above.
//
#define HX_ASSERT_VALID_PTR(pOb)  (::HXAssertValidPointer(pOb, __FILE__, __LINE__))
#define HX_ASSERT_VALID_READ_PTR(pOb)  HX_ASSERT(::HXIsValidAddress(pOb, 1, FALSE))

/////////////////////////////////////////////////////////////////////////////
//
// _SAFESTRING: Similar to HX_TRACE() except that it assume you are
// using a single format string, with a single parameter string, this will
// ensure that the length of the resulting format is less than the maximum
// trace string, and gracefully handle the situation...
//
#define HX_TRACE_SAFESTRING(f,s)\
	if ((strlen(f) + strlen(s)) < (size_t)MAX_TRACE_OUTPUT)\
	{\
		HX_TRACE(f,s);\
	}\
	else\
	{\
		HX_TRACE(f,"Some really big URL");\
	}\

#else   // _DEBUG

#ifndef _DEBUG

#ifndef HX_ENABLE_JIT_DEBUGGING
#define HX_ENABLE_JIT_DEBUGGING()
#endif

#ifdef HXAbort
#undef HXAbort
#endif // end of#ifdef HXAbort

#define HXAbort()

#endif  // _DEBUG

#ifndef _DEBUG

#ifdef HXDebugBreak
#undef HXDebugBreak
#endif // end of#ifdef HXDebugBreak

#define HXDebugBreak()

#endif  // _DEBUG || DEBUG

/////////////////////////////////////////////////////////////////////////////
//
// HX_SAFEINT
//
#define HX_SAFEINT(f) ((int)(f)) 
#define HX_SAFEUINT(f) ((unsigned int)(f)) 
#define HX_SAFEINT16(f) ((short)(f)) 
#define HX_SAFEUINT16(f) ((unsigned short)(f)) 
#define HX_SAFEINT8(f) ((char)(f)) 
#define HX_SAFEUINT8(f) ((unsigned char)(f)) 

#define HX_ASSERT(f)			        ((void)0)
#define HX_SAFESIZE_T(f)			((size_t)(f))
#define HX_SAFEINT(f)				((int)(f))
#define HX_SAFE_VOID2HANDLE(f)		((HANDLE)(ULONG32)(f))
#define HX_ASSERT_VALID_PTR(pOb)	((void)0)
#define HX_ASSERT_VALID_READ_PTR(pOb)   ((void)0)
#define HXOutputDebugString(f)			((void)0)

#define REQUIRE_REPORT(targ,file,line)	((int)0)

#if defined (_MACINTOSH)
// this is the proper release version of HX_VERIFY that preserves the syntactic
// role of the debug version; it's necessary to quiet warnings on the Mac
#define HX_VERIFY(f)				do { if (!(f)) {} } while (0)
#else
#define HX_VERIFY(f)				((void)(f))
#endif

#if defined (_WINDOWS)
__inline void __cdecl HXTrace(const char* x, ...) { }
#else
static __inline void HXTrace(const char* x, ...) {}
#endif

#define HX_TRACE              		1 ? (void)0 : ::HXTrace
#define HX_TRACE_SAFESTRING			HX_TRACE

#endif // !_DEBUG

#ifdef __cplusplus
}	// end extern "C"
#endif

#ifdef __cplusplus
/////////////////////////////////////////////////////////////////////////////
//
// Helper for loginfo for LOGINFO()
//
#ifndef _INTERFACE
#define _INTERFACE struct
#endif

typedef _INTERFACE IHXErrorSink IHXErrorSink;

class LogInfo
{
    public:
	static void STDMETHODCALLTYPE FileandLine(const char* file, int nLine);
	static void STDMETHODCALLTYPE Report(IHXErrorSink* mySink, const char* pUserInfo, ...);
    private:
	static char m_pFile[_MAX_PATH]; /* Flawfinder: ignore */
};

#endif


/////////////////////////////////////////////////////////////////////////////
// CHECK/REQUIRE MACROS
//
// These macros are always valid (debug and release builds)
//
//

//
// REQUIRE and REQUIRE_ACTION _always_ emit code for the goto if the statement is false
//
// REQUIRE_REPORT only generates code in Debug builds
//
// The do {} while (0) construct ensures this is legal wherever a statement is legal
//

#define CHECK(stmt)  HX_ASSERT(stmt)

#define REQUIRE_VOID_RETURN(stmt) \
	do { if ((stmt) == 0) { if (REQUIRE_REPORT(#stmt,__FILE__,__LINE__)) HXDebugBreak(); return; } } while (0)
#define REQUIRE_RETURN(stmt,returned) \
	do { if ((stmt) == 0) { if (REQUIRE_REPORT(#stmt,__FILE__,__LINE__)) HXDebugBreak(); return (returned); } } while (0)
#define REQUIRE_VOID_RETURN_QUIET(stmt) \
	do { if ((stmt) == 0) { return; } } while (0)
#define REQUIRE_RETURN_QUIET(stmt,returned) \
	do { if ((stmt) == 0) { return (returned); } } while (0)
#define REQUIRE(stmt,target) \
	do { if ((stmt) == 0) { REQUIRE_REPORT(#target,__FILE__,__LINE__); goto target; } } while (0)
#define REQUIRE_ACTION(stmt,target,action) \
	do { if ((stmt) == 0) { REQUIRE_REPORT(#target,__FILE__,__LINE__); {{action;} goto target;} } } while (0)
#define REQUIRE_QUIET(stmt,target) \
	do { if ((stmt) == 0) goto target; } while (0)
#define REQUIRE_ACTION_QUIET(stmt,target,action) \
	do { if ((stmt) == 0) {{action;} goto target;} } while (0)
#define PRE_REQUIRE_RETURN(stmt,returned) \
	REQUIRE_RETURN(stmt,returned)
#define PRE_REQUIRE_VOID_RETURN(stmt) \
	REQUIRE_VOID_RETURN(stmt)
#define POST_REQUIRE_RETURN(stmt,returned) \
	REQUIRE_RETURN(stmt,returned)
#define POST_REQUIRE_VOID_RETURN(stmt) \
	REQUIRE_VOID_RETURN(stmt)

#define REQUIRE_SUCCESS_RETURN_QUIET(expr) \
	do { register HX_RESULT const res = expr; if (FAILED (res)) return res; } while (0)
#define REQUIRE_SUCCESS_RETURN(expr) \
	do { register HX_RESULT const res = expr; if (FAILED (res)) {  REQUIRE_REPORT("False condition, Aborting...",__FILE__,__LINE__); return res; } } while (0)

//
// REQUIRE_SUCCESS reports the error if an expected result failed
// Ideally, this should report the status value as well
//

#define CHECK_SUCCESS(stat) HX_ASSERT(((unsigned long)(stat)>>31) == 0)

#define REQUIRE_SUCCESS(stat,target) \
	do { if (((unsigned long)(stat)>>31) != 0) { REQUIRE_REPORT(#target,__FILE__,__LINE__); goto target; } } while (0)
#define REQUIRE_SUCCESS_ACTION(stat,target,action) \
	do { if (((unsigned long)(stat)>>31) != 0) { REQUIRE_REPORT(#target,__FILE__,__LINE__); {{action;} goto target;} } } while (0)
#define REQUIRE_SUCCESS_QUIET(stat,target) \
	do { if (((unsigned long)(stat)>>31) != 0) goto target; } while (0)
#define REQUIRE_SUCCESS_ACTION_QUIET(stat,target,action) \
	do { if (((unsigned long)(stat)>>31) != 0) {{action;} goto target;} } while (0)

//
// REQUIRE_NOERR reports the error if the error value is non-zero
// Ideally, this should report the error value as well
//

#define CHECK_NOERR(err) HX_ASSERT((err) == 0)

#define REQUIRE_NOERR_RETURN(err,returned) \
	do { if ((err) != 0) { REQUIRE_REPORT("Toolbox error, Aborting...",__FILE__,__LINE__); return (returned); } } while (0)
#define REQUIRE_NOERR(err,target) \
	do { if ((err) != 0) { REQUIRE_REPORT(#target,__FILE__,__LINE__); goto target; } } while (0)
#define REQUIRE_NOERR_ACTION(err,target,action) \
	do { if ((err) != 0) { REQUIRE_REPORT(#target,__FILE__,__LINE__); {{action;} goto target;} } } while (0)
#define REQUIRE_NOERR_QUIET(err,target) \
	do { if ((err) != 0) goto target; } while (0)
#define REQUIRE_NOERR_ACTION_QUIET(err,target,action) \
	do { if ((err) != 0) {{action;} goto target;} } while (0)

//
// REQUIRE_NONNULL reports the error if the ptr value is null
// Ideally, this should report the error value as well
//
#define CHECK_NONNULL(ptr)	HX_ASSERT((ptr) != 0L)
#define CHECK_NULL(ptr)		HX_ASSERT((ptr) == 0L)

#define REQUIRE_NONNULL_VOID_RETURN(ptr) \
	do { if ((ptr) == 0L) { REQUIRE_REPORT(#ptr" is nil, Aborting...",__FILE__,__LINE__); return; } } while (0)
#define REQUIRE_NONNULL_RETURN(ptr,returned) \
	do { if ((ptr) == 0L) { REQUIRE_REPORT(#ptr" is nil, Aborting...",__FILE__,__LINE__); return (returned); } } while (0)
#define REQUIRE_NONNULL(ptr,target) \
	do { if ((ptr) == 0L) { REQUIRE_REPORT(#target,__FILE__,__LINE__); goto target; } } while (0)
#define REQUIRE_NONNULL_ACTION(ptr,target,action) \
	do { if ((ptr) == 0L) { REQUIRE_REPORT(#target,__FILE__,__LINE__); {{action;} goto target;} } } while (0)
#define REQUIRE_NONNULL_QUIET(ptr,target) \
	do { if ((ptr) == 0L) goto target; } while (0)
#define REQUIRE_NONNULL_ACTION_QUIET(ptr,target,action) \
	do { if ((ptr) == 0L) {{action;} goto target;} } while (0)
// lower case versions make source code more readable

#if defined(_CARBON) || defined(_MAC_MACHO)
#undef check
#undef require
#undef require_action
#undef require_quiet
#undef check_noerr
#undef require_action_quiet
#undef require_noerr
#undef require_noerr_action
#undef require_noerr_quiet
#undef require_noerr_action_quiet
#endif

#define check(stmt) 										CHECK(stmt)

#define require_void_return(stmt)							REQUIRE_VOID_RETURN(stmt)
#define require_return_void(stmt)							REQUIRE_VOID_RETURN(stmt)
#define require_return(stmt,returned)						REQUIRE_RETURN(stmt,returned)
#define require(stmt,target) 								REQUIRE(stmt,target)
#define require_action(stmt,target,action) 					REQUIRE_ACTION(stmt,target,action)
#define require_quiet(stmt,target) 							REQUIRE_QUIET(stmt,target)
#define require_action_quiet(stmt,target,action)			REQUIRE_ACTION_QUIET(stmt,target,action)

#define check_success(stat)									CHECK_SUCCESS(stat)

#define require_success(stat,target) 						REQUIRE_SUCCESS(stat,target)
#define require_success_action(stat,target,action) 			REQUIRE_SUCCESS_ACTION(stat,target,action)
#define require_success_quiet(stat,target) 					REQUIRE_SUCCESS_QUIET(stat,target)
#define require_success_action_quiet(stat,target,action)	REQUIRE_SUCCESS_ACTION_QUIET(stat,target,action)

#define check_noerr(err)									CHECK_NOERR(err)

#define require_noerr_return(err,returned)					REQUIRE_NOERR_RETURN(err,returned)
#define require_noerr(err,target) 							REQUIRE_NOERR(err,target)
#define require_noerr_action(err,target,action) 			REQUIRE_NOERR_ACTION(err,target,action)
#define require_noerr_quiet(err,target) 					REQUIRE_NOERR_QUIET(err,target)
#define require_noerr_action_quiet(err,target,action)		REQUIRE_NOERR_ACTION_QUIET(err,target,action)

#define check_nonnull(ptr)									CHECK_NONNULL(ptr)
#define check_null(ptr)										CHECK_NULL(ptr)

#define require_nonnull_void_return(ptr)					REQUIRE_NONNULL_VOID_RETURN(ptr)
#define require_nonnull_return(ptr,returned)				REQUIRE_NONNULL_RETURN(ptr,returned)
#define require_nonnull(ptr,target) 						REQUIRE_NONNULL(ptr,target)
#define require_nonnull_action(ptr,target,action) 			REQUIRE_NONNULL_ACTION(ptr,target,action)
#define require_nonnull_quiet(ptr,target) 					REQUIRE_NONNULL_QUIET(ptr,target)
#define require_nonnull_action_quiet(ptr,target,action)		REQUIRE_NONNULL_ACTION_QUIET(ptr,target,action)


#endif // !_HXASSERT_H_
