244 lines
8.8 KiB
C++
244 lines
8.8 KiB
C++
#ifndef __WMSSTD_H__
|
|
#define __WMSSTD_H__
|
|
|
|
#if _MSC_VER > 1000
|
|
#pragma once
|
|
#endif // _MSC_VER > 1000
|
|
|
|
#include <windows.h>
|
|
#include <string.h>
|
|
#include <tchar.h>
|
|
#include <winnls.h>
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////// GENERIC MACROS //////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define MAX(a, b) (max((a), (b)))
|
|
#define MIN(a, b) (min((a), (b)))
|
|
|
|
#define MAKEULONGLONG(a, b) ((ULONGLONG)(((DWORD)(a)) | ((ULONGLONG)((DWORD)(b))) << 32))
|
|
#define MAKEUINT64(a, b) MAKEULONGLONG((a),(b))
|
|
#define MAKEQWORD(a, b) MAKEULONGLONG((a),(b))
|
|
#define LODWORD(l) ((DWORD)(l))
|
|
#define HIDWORD(l) ((DWORD)(((ULONGLONG)(l) >> 32) & 0xFFFFFFFF))
|
|
|
|
#if !defined(COUNTOF) // macro to obtain the storage size of an array.
|
|
#define COUNTOF( x ) ( sizeof(x) / sizeof( (x)[0] ) )
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////// WINSOCK MACROS //////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define NTOHULL(ull) MAKEULONGLONG(ntohl(LODWORD((ull))), ntohl(HIDWORD((ull))))
|
|
#define HTONULL(ull) MAKEULONGLONG(htonl(LODWORD((ull))), htonl(HIDWORD((ull))))
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////// TYPES ///////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
typedef ULONGLONG QWORD;
|
|
typedef QWORD *LPQWORD;
|
|
|
|
#ifndef _WIN64
|
|
|
|
typedef ULONG ULONG_PTR;
|
|
typedef LONG LONG_PTR;
|
|
|
|
#endif // _WIN64
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////// COMMENT MACROS //////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define PUBLIC
|
|
#define PROTECTED
|
|
#define PRIVATE
|
|
#define STATIC
|
|
#define VIRTUAL
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////// DEBUG/RETAIL MACROS ////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#if DBG
|
|
|
|
#define Debug(s) s // Statement/declaration included only if DBG
|
|
#define Retail(s) // Statement/declaration included only if !DBG
|
|
#define DebugOrRetail(d, r) d // d if DBG; r if !DBG
|
|
|
|
#else // !DBG
|
|
|
|
#define Debug(s) // Statement/declaration included only if DBG
|
|
#define Retail(s) s // Statement/declaration included only if !DBG
|
|
#define DebugOrRetail(d, r) r // d if DBG; r if !DBG
|
|
|
|
#endif // !DBG
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////// STRING MACROS ///////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#if UNICODE
|
|
#define Unicode(s) (s)
|
|
#define Ansi(s)
|
|
#define UnicodeOrAnsi(u, a) (u)
|
|
#define AnsiOrUnicode(a, u) (u)
|
|
#else
|
|
#define Unicode(s)
|
|
#define Ansi(s) (s)
|
|
#define UnicodeOrAnsi(u, a) (a)
|
|
#define AnsiOrUnicode(a, u) (a)
|
|
#endif
|
|
|
|
|
|
#define WcharToAchar(a, w, l) \
|
|
WideCharToMultiByte( \
|
|
CP_ACP, \
|
|
0, \
|
|
(w), \
|
|
-1, \
|
|
(a), \
|
|
(l), \
|
|
NULL, \
|
|
NULL \
|
|
)
|
|
|
|
#define AcharToWchar(w, a, l) \
|
|
MultiByteToWideChar( \
|
|
CP_ACP, \
|
|
0, \
|
|
(a), \
|
|
-1, \
|
|
(w), \
|
|
(l) \
|
|
)
|
|
|
|
#define WcharToTchar(t, w, l) UnicodeOrAnsi(wcscpy((t), (w)), WcharToAchar((t), (w), (l)))
|
|
#define WcharToTcharEx(t, w, l, p) UnicodeOrAnsi((p) = (w), (WcharToAchar((t), (w), (l)), (p) = (t)))
|
|
#define TcharToWchar(w, t, l) UnicodeOrAnsi(wcscpy((w), (t)), AcharToWchar((w), (t), (l)))
|
|
#define TcharToWcharEx(w, t, l, p) UnicodeOrAnsi((p) = (t), (AcharToWchar((w), (t), (l)), (p) = (w)))
|
|
|
|
#define AcharToTchar(t, a, l) AnsiOrUnicode(strcpy((t), (a)), AcharToWchar((t), (a), (l)))
|
|
#define AcharToTcharEx(t, a, l, p) AnsiOrUnicode((p) = (a), (AcharToWchar((t), (a), (l)), (p) = (t)))
|
|
#define TcharToAchar(a, t, l) AnsiOrUnicode(strcpy((a), (t)), WcharToAchar((a), (t), (l)))
|
|
#define TcharToAcharEx(a, t, l, p) AnsiOrUnicode((p) = (t), (WcharToAchar((a), (t), (l)), (p) = (a)))
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////// REFCOUNT AND SAFE_* MACROS /////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifdef INC_REF
|
|
#undef INC_REF
|
|
#endif
|
|
#ifdef DEC_REF
|
|
#undef DEC_REF
|
|
#endif
|
|
|
|
#ifdef SINGLE_THREADED
|
|
#define INC_REF(u) (++u)
|
|
#define DEC_REF(u) (--u)
|
|
#else // !SINGLE_THREADED
|
|
#define INC_REF(u) InterlockedIncrement((LONG*)&u)
|
|
#define DEC_REF(u) InterlockedDecrement((LONG*)&u)
|
|
#endif // SINGLE_THREADED
|
|
|
|
#ifndef _REF_ASSERT
|
|
#ifdef NO_DEBUG_SYNCHRO
|
|
#define _REF_ASSERT(x)
|
|
#else // !NO_DEBUG_SYNCHRO
|
|
#ifdef USE_MFC
|
|
#define _REF_ASSERT(x) ASSERT(x)
|
|
#else // !USE_MFC
|
|
#include <assert.h>
|
|
#define _REF_ASSERT(x) assert(x)
|
|
#endif // USE_MFC
|
|
#endif // NO_DEBUG_SYNCHRO
|
|
#endif
|
|
|
|
#ifdef WIN32
|
|
#define YIELD(hwnd,reps) (void)0
|
|
#else
|
|
#define YIELD(hwnd,reps) \
|
|
{MSG msg;int n=(int)(reps);while( n-- && PeekMessage( &msg, hwnd, 0, 0, PM_REMOVE ) ){TranslateMessage( &msg );DispatchMessage( &msg );}}
|
|
#endif
|
|
|
|
#define SAFE_ADDREF(p) if( NULL != p ) { ( p )->AddRef(); }
|
|
#define SAFE_DELETE(p) if( NULL != p ) { delete p; p = NULL; }
|
|
#define SAFE_ARRAY_DELETE(p) if( NULL != p ) { delete [] p; p = NULL; }
|
|
#define SAFE_RELEASE(p) if( NULL != p ) { ( p )->Release(); p = NULL; }
|
|
#define SAFE_SHUTRELEASE(p) if( NULL != p ) { ( p )->Shutdown(); ( p )->Release(); p = NULL; }
|
|
#define SAFE_COTASKMEMFREE(p) if( NULL != p ) { CoTaskMemFree( p ); p = NULL; }
|
|
#define SAFE_SYSFREESTRING(p) if( NULL != p ) { SysFreeString( p ); p = NULL; }
|
|
#define SAFE_ARRAYDELETE(p) if( NULL != p ) { delete [] p; p = NULL; }
|
|
#define SAFE_CLOSEHANDLE( h ) if( NULL != h ) { CloseHandle( h ); h = NULL; }
|
|
#define SAFE_CLOSEFILEHANDLE( h ) if( INVALID_HANDLE_VALUE != h ) { CloseHandle( h ); h = INVALID_HANDLE_VALUE; }
|
|
#define SAFE_GLOBALFREE(p) if( NULL != p ) { GlobalFree( p ); p = NULL; }
|
|
|
|
//
|
|
// Ref-count safe assignment of 'src' to 'dst'
|
|
//
|
|
#define SAFE_REPLACEREF( dst, src ) \
|
|
{ \
|
|
if( NULL != ( src ) ) \
|
|
{ \
|
|
( src )->AddRef( ); \
|
|
} \
|
|
if( NULL != ( dst ) ) \
|
|
{ \
|
|
( dst )->Release( ); \
|
|
} \
|
|
dst = src; \
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////// OUTPARAMETER VALIDATION AND INITIALIZATION //////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifdef __tagVARIANT
|
|
inline HRESULT ValidateOutPtr( VARIANT* pDest, VARIANT& /*bogus*/ )
|
|
{
|
|
if( reinterpret_cast< VARIANT* >( NULL ) == pDest )
|
|
{
|
|
return( E_POINTER );
|
|
}
|
|
::VariantClear( pDest );
|
|
return( S_OK );
|
|
}
|
|
#endif
|
|
|
|
template< class Tptr, class T > HRESULT ValidateOutPtr( Tptr& pVal, T&/* bogus*/ )
|
|
{
|
|
if( reinterpret_cast< Tptr >( NULL ) == pVal )
|
|
{
|
|
return( E_POINTER );
|
|
}
|
|
*pVal = static_cast< T >( 0 );
|
|
return( S_OK );
|
|
}
|
|
|
|
// Validate a pointer argument and initialize it if valid.
|
|
#define VALIDOUT_PTR( pVal ) \
|
|
{ \
|
|
HRESULT hr = ValidateOutPtr( pVal, *pVal ); \
|
|
if( FAILED( hr ) ) \
|
|
{ \
|
|
return( hr ); \
|
|
} \
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////// UTILITY MACROS//////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define ARRAYSIZE(x) (sizeof(x)/sizeof(x[0]))
|
|
|
|
|
|
#endif // __WMSSTD_H__
|