rik/jlibcom
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add ATL header files from https://github.com/michaellukashov/Far-NetBox

Browse Source
This commit is contained in:
Rik Veenboer
2014-11-23 17:53:53 +00:00
parent 45984cd432
commit 15a336b668
15 changed files with 19525 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

767
src/main/headers/atlalloc.h Normal file
View File

@@ -0,0 +1,767 @@
// This is a part of the Active Template Library.
// Copyright (C) Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Active Template Library Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Active Template Library product.
#pragma once
#ifndef __ATLALLOC_H__
#define __ATLALLOC_H__
#endif
#include <nbglobals.h>
#include <windows.h>
#include <ole2.h>
#pragma pack(push,_ATL_PACKING)
namespace ATL
{
/*
This is more than a little unsatisfying. /Wp64 warns when we convert a size_t to an int
because it knows such a conversion won't port.
But, when we have overloaded templates, there may well exist both conversions and we need
to fool the warning into not firing on 32 bit builds
*/
#if !defined(_ATL_W64)
#if !defined(__midl) && (defined(_X86_) || defined(_M_IX86))
#define _ATL_W64 __w64
#else
#define _ATL_W64
#endif
#endif
/* Can't use ::std::numeric_limits<T> here because we don't want to introduce a new
deprendency of this code on SCL
*/
template<typename T>
class AtlLimits;
template<>
class AtlLimits<int _ATL_W64>
{
public:
static const int _Min=INT_MIN;
static const int _Max=INT_MAX;
};
template<>
class AtlLimits<unsigned int _ATL_W64>
{
public:
static const unsigned int _Min=0;
static const unsigned int _Max=UINT_MAX;
};
template<>
class AtlLimits<long _ATL_W64>
{
public:
static const long _Min=LONG_MIN;
static const long _Max=LONG_MAX;
};
template<>
class AtlLimits<unsigned long _ATL_W64>
{
public:
static const unsigned long _Min=0;
static const unsigned long _Max=ULONG_MAX;
};
template<>
class AtlLimits<long long>
{
public:
static const long long _Min=LLONG_MIN;
static const long long _Max=LLONG_MAX;
};
template<>
class AtlLimits<unsigned long long>
{
public:
static const unsigned long long _Min=0;
static const unsigned long long _Max=ULLONG_MAX;
};
/* generic version */
template<typename T>
inline HRESULT AtlAdd(
_Out_ T* ptResult,
_In_ T tLeft,
_In_ T tRight)
{
if(::ATL::AtlLimits<T>::_Max-tLeft < tRight)
{
return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
}
*ptResult= tLeft + tRight;
return S_OK;
}
/* generic but compariatively slow version */
template<typename T>
inline HRESULT AtlMultiply(
_Out_ T* ptResult,
_In_ T tLeft,
_In_ T tRight)
{
/* avoid divide 0 */
if(tLeft==0)
{
*ptResult=0;
return S_OK;
}
if(::ATL::AtlLimits<T>::_Max/tLeft < tRight)
{
return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
}
*ptResult= tLeft * tRight;
return S_OK;
}
/* fast version for 32 bit integers */
template<>
inline HRESULT AtlMultiply(
_Out_ int _ATL_W64 *piResult,
_In_ int _ATL_W64 iLeft,
_In_ int _ATL_W64 iRight)
{
__int64 i64Result=static_cast<__int64>(iLeft) * static_cast<__int64>(iRight);
if(i64Result>INT_MAX || i64Result < INT_MIN)
{
return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
}
*piResult=static_cast<int _ATL_W64>(i64Result);
return S_OK;
}
template<>
inline HRESULT AtlMultiply(
_Out_ unsigned int _ATL_W64 *piResult,
_In_ unsigned int _ATL_W64 iLeft,
_In_ unsigned int _ATL_W64 iRight)
{
unsigned __int64 i64Result=static_cast<unsigned __int64>(iLeft) * static_cast<unsigned __int64>(iRight);
if(i64Result>UINT_MAX)
{
return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
}
*piResult=static_cast<unsigned int _ATL_W64>(i64Result);
return S_OK;
}
template<>
inline HRESULT AtlMultiply(
_Out_ long _ATL_W64 *piResult,
_In_ long _ATL_W64 iLeft,
_In_ long _ATL_W64 iRight)
{
__int64 i64Result=static_cast<__int64>(iLeft) * static_cast<__int64>(iRight);
if(i64Result>LONG_MAX || i64Result < LONG_MIN)
{
return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
}
*piResult=static_cast<long _ATL_W64>(i64Result);
return S_OK;
}
template<>
inline HRESULT AtlMultiply(
_Out_ unsigned long _ATL_W64 *piResult,
_In_ unsigned long _ATL_W64 iLeft,
_In_ unsigned long _ATL_W64 iRight)
{
unsigned __int64 i64Result=static_cast<unsigned __int64>(iLeft) * static_cast<unsigned __int64>(iRight);
if(i64Result>ULONG_MAX)
{
return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
}
*piResult=static_cast<unsigned long _ATL_W64>(i64Result);
return S_OK;
}
template <typename T>
inline T AtlMultiplyThrow(
_In_ T tLeft,
_In_ T tRight)
{
T tResult;
HRESULT hr=AtlMultiply(&tResult, tLeft, tRight);
if(FAILED(hr))
{
AtlThrow(hr);
}
return tResult;
}
template <typename T>
inline T AtlAddThrow(
_In_ T tLeft,
_In_ T tRight)
{
T tResult;
HRESULT hr=AtlAdd(&tResult, tLeft, tRight);
if(FAILED(hr))
{
AtlThrow(hr);
}
return tResult;
}
_Ret_opt_bytecount_x_(nCount * nSize) inline LPVOID AtlCoTaskMemCAlloc(
_In_ ULONG nCount,
_In_ ULONG nSize)
{
HRESULT hr;
ULONG nBytes=0;
if( FAILED(hr=::ATL::AtlMultiply(&nBytes, nCount, nSize)))
{
return NULL;
}
return ::CoTaskMemAlloc(nBytes);
}
_Ret_opt_bytecount_x_(nCount * nSize) inline LPVOID AtlCoTaskMemRecalloc(
_In_opt_ void *pvMemory,
_In_ ULONG nCount,
_In_ ULONG nSize)
{
HRESULT hr;
ULONG nBytes=0;
if( FAILED(hr=::ATL::AtlMultiply(&nBytes, nCount, nSize)))
{
return NULL;
}
return ::CoTaskMemRealloc(pvMemory, nBytes);
}
} // namespace ATL
#pragma pack(pop)
#pragma pack(push,8)
namespace ATL
{
// forward declaration of Checked::memcpy_s
namespace Checked
{
void __cdecl memcpy_s(
_Out_bytecap_post_bytecount_(_S1max,_N) void *s1,
_In_ size_t _S1max,
_In_bytecount_(_N) const void *s2,
_In_ size_t _N);
}
/////////////////////////////////////////////////////////////////////////////
// Allocation helpers
class CCRTAllocator
{
public:
_Ret_opt_bytecap_(nBytes) static void* Reallocate(
_In_ void* p,
_In_ size_t nBytes) throw()
{
return nb_realloc(p, nBytes);
}
_Ret_opt_bytecap_(nBytes) static void* Allocate(_In_ size_t nBytes) throw()
{
return nb_malloc(nBytes);
}
static void Free(_In_ void* p) throw()
{
nb_free(p);
}
};
class CLocalAllocator
{
public:
_Ret_opt_bytecap_(nBytes) static void* Allocate(_In_ size_t nBytes) throw()
{
return ::LocalAlloc(LMEM_FIXED, nBytes);
}
_Ret_opt_bytecap_(nBytes) static void* Reallocate(
_In_ void* p,
_In_ size_t nBytes) throw()
{
if (p==NULL){
return ( Allocate(nBytes) );
}
if (nBytes==0){
Free(p);
return NULL;
}
return ::LocalReAlloc(p, nBytes, 0);
}
static void Free(_In_ void* p) throw()
{
::LocalFree(p);
}
};
class CGlobalAllocator
{
public:
_Ret_opt_bytecap_(nBytes) static void* Allocate(_In_ size_t nBytes) throw()
{
return ::GlobalAlloc(GMEM_FIXED, nBytes);
}
_Ret_opt_bytecap_(nBytes) static void* Reallocate(
_In_ void* p,
_In_ size_t nBytes) throw()
{
if (p==NULL){
return ( Allocate(nBytes) );
}
if (nBytes==0){
Free(p);
return NULL;
}
return ::GlobalReAlloc(p, nBytes, 0);
}
static void Free(_In_ void* p) throw()
{
::GlobalFree(p);
}
};
template <class T, class Allocator = CCRTAllocator>
class CHeapPtrBase
{
protected:
CHeapPtrBase() throw() :
m_pData(NULL)
{
}
CHeapPtrBase(_Inout_ CHeapPtrBase<T, Allocator>& p) throw()
{
m_pData = p.Detach(); // Transfer ownership
}
explicit CHeapPtrBase(_In_ T* pData) throw() :
m_pData(pData)
{
}
public:
~CHeapPtrBase() throw()
{
Free();
}
protected:
CHeapPtrBase<T, Allocator>& operator=(_Inout_ CHeapPtrBase<T, Allocator>& p) throw()
{
if(m_pData != p.m_pData)
Attach(p.Detach()); // Transfer ownership
return *this;
}
public:
operator T*() const throw()
{
return m_pData;
}
T* operator->() const throw()
{
ATLASSERT(m_pData != NULL);
return m_pData;
}
T** operator&() throw()
{
ATLASSUME(m_pData == NULL);
return &m_pData;
}
// Allocate a buffer with the given number of bytes
bool AllocateBytes(_In_ size_t nBytes) throw()
{
ATLASSERT(m_pData == NULL);
m_pData = static_cast<T*>(Allocator::Allocate(nBytes));
if (m_pData == NULL)
return false;
return true;
}
// Attach to an existing pointer (takes ownership)
void Attach(_In_ T* pData) throw()
{
Allocator::Free(m_pData);
m_pData = pData;
}
// Detach the pointer (releases ownership)
T* Detach() throw()
{
T* pTemp = m_pData;
m_pData = NULL;
return pTemp;
}
// Free the memory pointed to, and set the pointer to NULL
void Free() throw()
{
Allocator::Free(m_pData);
m_pData = NULL;
}
// Reallocate the buffer to hold a given number of bytes
bool ReallocateBytes(_In_ size_t nBytes) throw()
{
T* pNew;
pNew = static_cast<T*>(Allocator::Reallocate(m_pData, nBytes));
if (pNew == NULL)
return false;
m_pData = pNew;
return true;
}
public:
T* m_pData;
};
template <typename T, class Allocator = CCRTAllocator>
class CHeapPtr :
public CHeapPtrBase<T, Allocator>
{
public:
CHeapPtr() throw()
{
}
CHeapPtr(_Inout_ CHeapPtr<T, Allocator>& p) throw() :
CHeapPtrBase<T, Allocator>(p)
{
}
explicit CHeapPtr(_In_ T* p) throw() :
CHeapPtrBase<T, Allocator>(p)
{
}
CHeapPtr<T, Allocator>& operator=(_Inout_ CHeapPtr<T, Allocator>& p) throw()
{
CHeapPtrBase<T, Allocator>::operator=(p);
return *this;
}
// Allocate a buffer with the given number of elements
bool Allocate(_In_ size_t nElements = 1) throw()
{
size_t nBytes=0;
if(FAILED(::ATL::AtlMultiply(&nBytes, nElements, sizeof(T))))
{
return false;
}
return this->AllocateBytes(nBytes);
}
// Reallocate the buffer to hold a given number of elements
bool Reallocate(_In_ size_t nElements) throw()
{
size_t nBytes=0;
if(FAILED(::ATL::AtlMultiply(&nBytes, nElements, sizeof(T))))
{
return false;
}
return this->ReallocateBytes(nBytes);
}
};
template< typename T, int t_nFixedBytes = 128, class Allocator = CCRTAllocator >
class CTempBuffer
{
public:
CTempBuffer() throw() :
m_p( NULL )
{
}
CTempBuffer(_In_ size_t nElements) throw() :
m_p( NULL )
{
Allocate( nElements );
}
~CTempBuffer() throw()
{
if( m_p != reinterpret_cast< T* >( m_abFixedBuffer ) )
{
FreeHeap();
}
}
operator T*() const throw()
{
return( m_p );
}
T* operator->() const throw()
{
ATLASSERT( m_p != NULL );
return( m_p );
}
_Ret_opt_bytecap_x_(nElements * sizeof(T)) T* Allocate(_In_ size_t nElements) throw()
{
return( this->AllocateBytes( ::ATL::AtlMultiplyThrow(nElements,sizeof( T )) ) );
}
_Ret_opt_bytecap_x_(nElements * sizeof(T)) T* Reallocate(_In_ size_t nElements) throw()
{
ATLENSURE(nElements < size_t(-1)/sizeof(T) );
size_t nNewSize = nElements*sizeof( T ) ;
if (m_p == NULL)
return this->AllocateBytes(nNewSize);
if (nNewSize > t_nFixedBytes)
{
if( m_p == reinterpret_cast< T* >( m_abFixedBuffer ) )
{
// We have to allocate from the heap and copy the contents into the new buffer
AllocateHeap(nNewSize);
Checked::memcpy_s(m_p, nNewSize, m_abFixedBuffer, t_nFixedBytes);
}
else
{
ReAllocateHeap( nNewSize );
}
}
else
{
if (m_p != reinterpret_cast< T* >( m_abFixedBuffer ))
{
Checked::memcpy_s(m_abFixedBuffer, t_nFixedBytes, m_p, nNewSize);
FreeHeap();
}
m_p = reinterpret_cast< T* >( m_abFixedBuffer );
}
return m_p;
}
_Ret_opt_bytecap_(nBytes) T* AllocateBytes(_In_ size_t nBytes)
{
ATLASSERT( m_p == NULL );
if( nBytes > t_nFixedBytes )
{
AllocateHeap( nBytes );
}
else
{
m_p = reinterpret_cast< T* >( m_abFixedBuffer );
}
return( m_p );
}
private:
void AllocateHeap(_In_ size_t nBytes)
{
T* p = static_cast< T* >( Allocator::Allocate( nBytes ) );
if( p == NULL )
{
AtlThrow( E_OUTOFMEMORY );
}
m_p = p;
}
void ReAllocateHeap(_In_ size_t nNewSize)
{
T* p = static_cast< T* >( Allocator::Reallocate(m_p, nNewSize) );
if ( p == NULL )
{
AtlThrow( E_OUTOFMEMORY );
}
m_p = p;
}
void FreeHeap() throw()
{
Allocator::Free( m_p );
}
private:
T* m_p;
BYTE m_abFixedBuffer[t_nFixedBytes];
};
// Allocating memory on the stack without causing stack overflow.
// Only use these through the _ATL_SAFE_ALLOCA_* macros
namespace _ATL_SAFE_ALLOCA_IMPL
{
#ifndef _ATL_STACK_MARGIN
#if defined(_M_IX86)
#define _ATL_STACK_MARGIN 0x2000 // Minimum stack available after call to _ATL_SAFE_ALLOCA
#else //_M_AMD64 _M_IA64
#define _ATL_STACK_MARGIN 0x4000
#endif
#endif //_ATL_STACK_MARGIN
//Verifies if sufficient space is available on the stack.
//Note: This function should never be inlined, because the stack allocation
//may not be freed until the end of the calling function (instead of the end of _AtlVerifyStackAvailable).
__declspec(noinline) inline bool _AtlVerifyStackAvailable(_In_ SIZE_T Size)
{
bool bStackAvailable = true;
#if !defined(__MINGW32__)
__try
#else
try
#endif
{
SIZE_T size=0;
HRESULT hrAdd=::ATL::AtlAdd(&size, Size, static_cast<SIZE_T>(_ATL_STACK_MARGIN));
if(FAILED(hrAdd))
{
ATLASSERT(FALSE);
bStackAvailable = false;
}
else
{
PVOID p = _alloca(size);
(p);
}
}
#if !defined(__MINGW32__)
__except ((EXCEPTION_STACK_OVERFLOW == GetExceptionCode()) ?
EXCEPTION_EXECUTE_HANDLER :
EXCEPTION_CONTINUE_SEARCH)
{
bStackAvailable = false;
_resetstkoflw();
}
#else
catch (...)
{
bStackAvailable = false;
_resetstkoflw();
}
#endif
return bStackAvailable;
}
// Helper Classes to manage heap buffers for _ATL_SAFE_ALLOCA
template < class Allocator>
class CAtlSafeAllocBufferManager
{
private :
struct CAtlSafeAllocBufferNode
{
CAtlSafeAllocBufferNode* m_pNext;
#if defined(_M_IX86)
BYTE _pad[4];
#elif defined(_M_IA64)
BYTE _pad[8];
#elif defined(_M_AMD64)
BYTE _pad[8];
#else
#error Only supported for X86, AMD64 and IA64
#endif
void* GetData()
{
return (this + 1);
}
};
CAtlSafeAllocBufferNode* m_pHead;
public :
CAtlSafeAllocBufferManager() : m_pHead(NULL)
{
}
_Ret_opt_bytecap_(nRequestedSize) void* Allocate(_In_ SIZE_T nRequestedSize)
{
CAtlSafeAllocBufferNode *p = (CAtlSafeAllocBufferNode*)Allocator::Allocate(::ATL::AtlAddThrow(nRequestedSize, static_cast<SIZE_T>(sizeof(CAtlSafeAllocBufferNode))));
if (p == NULL)
return NULL;
// Add buffer to the list
p->m_pNext = m_pHead;
m_pHead = p;
return p->GetData();
}
~CAtlSafeAllocBufferManager()
{
// Walk the list and free the buffers
while (m_pHead != NULL)
{
CAtlSafeAllocBufferNode* p = m_pHead;
m_pHead = m_pHead->m_pNext;
Allocator::Free(p);
}
}
};
} // namespace _ATL_SAFE_ALLOCA_IMPL
} // namespace ATL
#pragma pack(pop)
// Use one of the following macros before using _ATL_SAFE_ALLOCA
// EX version allows specifying a different heap allocator
#define USES_ATL_SAFE_ALLOCA_EX(x) ATL::_ATL_SAFE_ALLOCA_IMPL::CAtlSafeAllocBufferManager<x> _AtlSafeAllocaManager
#ifndef USES_ATL_SAFE_ALLOCA
#define USES_ATL_SAFE_ALLOCA USES_ATL_SAFE_ALLOCA_EX(ATL::CCRTAllocator)
#endif
// nRequestedSize - requested size in bytes
// nThreshold - size in bytes beyond which memory is allocated from the heap.
// Defining _ATL_SAFE_ALLOCA_ALWAYS_ALLOCATE_THRESHOLD_SIZE always allocates the size specified
// for threshold if the stack space is available irrespective of requested size.
// This available for testing purposes. It will help determine the max stack usage due to _alloca's
// Disable _alloca not within try-except prefast warning since we verify stack space is available before.
#ifdef _ATL_SAFE_ALLOCA_ALWAYS_ALLOCATE_THRESHOLD_SIZE
#define _ATL_SAFE_ALLOCA(nRequestedSize, nThreshold) \
__pragma(warning(push))\
__pragma(warning(disable:4616))\
__pragma(warning(disable:6255))\
((nRequestedSize <= nThreshold && ATL::_ATL_SAFE_ALLOCA_IMPL::_AtlVerifyStackAvailable(nThreshold) ) ? \
_alloca(nThreshold) : \
((ATL::_ATL_SAFE_ALLOCA_IMPL::_AtlVerifyStackAvailable(nThreshold)) ? _alloca(nThreshold) : 0), \
_AtlSafeAllocaManager.Allocate(nRequestedSize))\
__pragma(warning(pop))
#else
#if !defined(__MINGW32__)
#define _ATL_SAFE_ALLOCA(nRequestedSize, nThreshold) \
__pragma(warning(push))\
__pragma(warning(disable:4616))\
__pragma(warning(disable:6255))\
((nRequestedSize <= nThreshold && ATL::_ATL_SAFE_ALLOCA_IMPL::_AtlVerifyStackAvailable(nRequestedSize) ) ? \
_alloca(nRequestedSize) : \
_AtlSafeAllocaManager.Allocate(nRequestedSize))\
__pragma(warning(pop))
#else
#define _ATL_SAFE_ALLOCA(nRequestedSize, nThreshold) \
((nRequestedSize <= nThreshold && ATL::_ATL_SAFE_ALLOCA_IMPL::_AtlVerifyStackAvailable(nRequestedSize) ) ? \
_alloca(nRequestedSize) : \
_AtlSafeAllocaManager.Allocate(nRequestedSize))
#endif
#endif
// Use 1024 bytes as the default threshold in ATL
#ifndef _ATL_SAFE_ALLOCA_DEF_THRESHOLD
#define _ATL_SAFE_ALLOCA_DEF_THRESHOLD 1024
#endif

6534
src/main/headers/atlbase.h Normal file
View File

File diff suppressed because it is too large Load Diff

475
src/main/headers/atlbase.inl Normal file
View File

@@ -0,0 +1,475 @@
// This is a part of the Active Template Library.
// Copyright (C) Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Active Template Library Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Active Template Library product.
#ifndef __ATLBASE_INL__
#define __ATLBASE_INL__
#pragma once
#ifndef __ATLBASE_H__
#error atlbase.inl requires atlbase.h to be included first
#endif
#pragma warning(push)
#pragma warning(disable:4571) //catch(...) blocks compiled with /EHs do NOT catch or re-throw Structured Exceptions
namespace ATL
{
/////////////////////////////////////////////////////////////////////////////
// Connection Point Helpers
ATLINLINE ATLAPI AtlAdvise(
_Inout_ IUnknown* pUnkCP,
_Inout_opt_ IUnknown* pUnk,
_In_ const IID& iid,
_Out_ LPDWORD pdw)
{
if(pUnkCP == NULL)
return E_INVALIDARG;
CComPtr<IConnectionPointContainer> pCPC;
CComPtr<IConnectionPoint> pCP;
HRESULT hRes = pUnkCP->QueryInterface(__uuidof(IConnectionPointContainer), (void**)&pCPC);
if (SUCCEEDED(hRes))
hRes = pCPC->FindConnectionPoint(iid, &pCP);
if (SUCCEEDED(hRes))
hRes = pCP->Advise(pUnk, pdw);
return hRes;
}
ATLINLINE ATLAPI AtlUnadvise(
_Inout_ IUnknown* pUnkCP,
_In_ const IID& iid,
_In_ DWORD dw)
{
if(pUnkCP == NULL)
return E_INVALIDARG;
CComPtr<IConnectionPointContainer> pCPC;
CComPtr<IConnectionPoint> pCP;
HRESULT hRes = pUnkCP->QueryInterface(__uuidof(IConnectionPointContainer), (void**)&pCPC);
if (SUCCEEDED(hRes))
hRes = pCPC->FindConnectionPoint(iid, &pCP);
if (SUCCEEDED(hRes))
hRes = pCP->Unadvise(dw);
return hRes;
}
/////////////////////////////////////////////////////////////////////////////
// Inproc Marshaling helpers
//This API should be called from the same thread that called
//AtlMarshalPtrInProc
ATLINLINE ATLAPI AtlFreeMarshalStream(_Inout_ IStream* pStream)
{
HRESULT hRes=S_OK;
if (pStream != NULL)
{
LARGE_INTEGER l;
l.QuadPart = 0;
pStream->Seek(l, STREAM_SEEK_SET, NULL);
hRes=CoReleaseMarshalData(pStream);
pStream->Release();
}
return hRes;
}
ATLPREFAST_SUPPRESS(6387)
ATLINLINE ATLAPI AtlMarshalPtrInProc(
_Inout_ IUnknown* pUnk,
_In_ const IID& iid,
_Deref_out_ IStream** ppStream)
{
ATLASSERT(ppStream != NULL);
if (ppStream == NULL)
return E_POINTER;
HRESULT hRes = CreateStreamOnHGlobal(NULL, TRUE, ppStream);
if (SUCCEEDED(hRes))
{
hRes = CoMarshalInterface(*ppStream, iid,
pUnk, MSHCTX_INPROC, NULL, MSHLFLAGS_TABLESTRONG);
if (FAILED(hRes))
{
(*ppStream)->Release();
*ppStream = NULL;
}
}
return hRes;
}
ATLPREFAST_UNSUPPRESS()
ATLINLINE ATLAPI AtlUnmarshalPtr(
_Inout_ IStream* pStream,
_In_ const IID& iid,
_Deref_out_ IUnknown** ppUnk)
{
ATLASSERT(ppUnk != NULL);
if (ppUnk == NULL)
return E_POINTER;
*ppUnk = NULL;
HRESULT hRes = E_INVALIDARG;
if (pStream != NULL)
{
LARGE_INTEGER l;
l.QuadPart = 0;
pStream->Seek(l, STREAM_SEEK_SET, NULL);
hRes = CoUnmarshalInterface(pStream, iid, (void**)ppUnk);
}
return hRes;
}
/////////////////////////////////////////////////////////////////////////////
// Module
ATLPREFAST_SUPPRESS(6387)
ATLINLINE ATLAPI AtlComModuleGetClassObject(
_Inout_ _ATL_COM_MODULE* pComModule,
_In_ REFCLSID rclsid,
_In_ REFIID riid,
_Deref_out_ LPVOID* ppv)
{
if (ppv == NULL)
{
return E_POINTER;
}
*ppv = NULL;
ATLASSERT(pComModule != NULL);
if (pComModule == NULL)
{
return E_INVALIDARG;
}
if (pComModule->cbSize == 0) // Module hasn't been initialized
{
return E_UNEXPECTED;
}
HRESULT hr = S_OK;
for (_ATL_OBJMAP_ENTRY** ppEntry = pComModule->m_ppAutoObjMapFirst; ppEntry < pComModule->m_ppAutoObjMapLast; ppEntry++)
{
if (*ppEntry != NULL)
{
const _ATL_OBJMAP_ENTRY* pEntry = *ppEntry;
if ((pEntry->pfnGetClassObject != NULL) && InlineIsEqualGUID(rclsid, *pEntry->pclsid))
{
if (pEntry->pCF == NULL)
{
CComCritSecLock<CComCriticalSection> lock(pComModule->m_csObjMap, false);
hr = lock.Lock();
if (FAILED(hr))
{
ATLASSERT(FALSE);
break;
}
if (pEntry->pCF == NULL)
{
hr = pEntry->pfnGetClassObject(pEntry->pfnCreateInstance, __uuidof(IUnknown), (LPVOID*)&pEntry->pCF);
}
}
if (pEntry->pCF != NULL)
{
hr = pEntry->pCF->QueryInterface(riid, ppv);
}
break;
}
}
}
if (*ppv == NULL && hr == S_OK)
{
hr = CLASS_E_CLASSNOTAVAILABLE;
}
return hr;
}
ATLPREFAST_UNSUPPRESS()
ATLINLINE ATLAPI AtlComModuleRegisterClassObjects(
_Inout_ _ATL_COM_MODULE* pComModule,
_In_ DWORD dwClsContext,
_In_ DWORD dwFlags)
{
ATLASSERT(pComModule != NULL);
if (pComModule == NULL)
return E_INVALIDARG;
HRESULT hr = S_FALSE;
for (_ATL_OBJMAP_ENTRY** ppEntry = pComModule->m_ppAutoObjMapFirst; ppEntry < pComModule->m_ppAutoObjMapLast && SUCCEEDED(hr); ppEntry++)
{
if (*ppEntry != NULL)
hr = (*ppEntry)->RegisterClassObject(dwClsContext, dwFlags);
}
return hr;
}
ATLINLINE ATLAPI AtlComModuleRevokeClassObjects(
_Inout_ _ATL_COM_MODULE* pComModule)
{
ATLASSERT(pComModule != NULL);
if (pComModule == NULL)
return E_INVALIDARG;
HRESULT hr = S_OK;
for (_ATL_OBJMAP_ENTRY** ppEntry = pComModule->m_ppAutoObjMapFirst; ppEntry < pComModule->m_ppAutoObjMapLast && hr == S_OK; ppEntry++)
{
if (*ppEntry != NULL)
hr = (*ppEntry)->RevokeClassObject();
}
return hr;
}
ATLINLINE ATLAPI_(BOOL) AtlWaitWithMessageLoop(_In_ HANDLE hEvent)
{
DWORD dwRet;
MSG msg;
while(1)
{
dwRet = MsgWaitForMultipleObjectsEx(1, &hEvent, INFINITE, QS_ALLINPUT, MWMO_INPUTAVAILABLE);
if (dwRet == WAIT_OBJECT_0)
return TRUE; // The event was signaled
if (dwRet != WAIT_OBJECT_0 + 1)
break; // Something else happened
// There is one or more window message available. Dispatch them
while(PeekMessage(&msg,0,0,0,PM_NOREMOVE))
{
// check for unicode window so we call the appropriate functions
BOOL bUnicode = ::IsWindowUnicode(msg.hwnd);
BOOL bRet;
if (bUnicode)
bRet = ::GetMessageW(&msg, NULL, 0, 0);
else
bRet = ::GetMessageA(&msg, NULL, 0, 0);
if (bRet > 0)
{
::TranslateMessage(&msg);
if (bUnicode)
::DispatchMessageW(&msg);
else
::DispatchMessageA(&msg);
}
if (WaitForSingleObject(hEvent, 0) == WAIT_OBJECT_0)
return TRUE; // Event is now signaled.
}
}
return FALSE;
}
/////////////////////////////////////////////////////////////////////////////
// QI support
ATLPREFAST_SUPPRESS(6387)
ATLINLINE ATLAPI AtlInternalQueryInterface(
_Inout_ void* pThis,
_In_ const _ATL_INTMAP_ENTRY* pEntries,
_In_ REFIID iid,
_Deref_out_ void** ppvObject)
{
ATLASSERT(pThis != NULL);
ATLASSERT(pEntries!= NULL);
if(pThis == NULL || pEntries == NULL)
return E_INVALIDARG;
// First entry in the com map should be a simple map entry
ATLASSERT(pEntries->pFunc == _ATL_SIMPLEMAPENTRY);
if (ppvObject == NULL)
return E_POINTER;
*ppvObject = NULL;
if (InlineIsEqualUnknown(iid)) // use first interface
{
IUnknown* pUnk = (IUnknown*)((INT_PTR)pThis+pEntries->dw);
pUnk->AddRef();
*ppvObject = pUnk;
return S_OK;
}
while (pEntries->pFunc != NULL)
{
BOOL bBlind = (pEntries->piid == NULL);
if (bBlind || InlineIsEqualGUID(*(pEntries->piid), iid))
{
if (pEntries->pFunc == _ATL_SIMPLEMAPENTRY) //offset
{
ATLASSERT(!bBlind);
IUnknown* pUnk = (IUnknown*)((INT_PTR)pThis+pEntries->dw);
pUnk->AddRef();
*ppvObject = pUnk;
return S_OK;
}
else //actual function call
{
HRESULT hRes = pEntries->pFunc(pThis,
iid, ppvObject, pEntries->dw);
if (hRes == S_OK || (!bBlind && FAILED(hRes)))
return hRes;
}
}
pEntries++;
}
return E_NOINTERFACE;
}
ATLPREFAST_UNSUPPRESS()
ATLINLINE ATLAPI_(DWORD) AtlGetVersion(_In_opt_ void* /* pReserved */)
{
return _ATL_VER;
}
/////////////////////////////////////////////////////////////////////////////
// Windowing
ATLINLINE ATLAPI_(void) AtlWinModuleAddCreateWndData(
_Inout_ _ATL_WIN_MODULE* pWinModule,
_Inout_ _AtlCreateWndData* pData,
_In_ void* pObject)
{
if (pWinModule == NULL)
_AtlRaiseException((DWORD)EXCEPTION_ACCESS_VIOLATION);
ATLASSERT(pData != NULL && pObject != NULL);
if(pData == NULL || pObject == NULL)
_AtlRaiseException((DWORD)EXCEPTION_ACCESS_VIOLATION);
pData->m_pThis = pObject;
pData->m_dwThreadID = ::GetCurrentThreadId();
CComCritSecLock<CComCriticalSection> lock(pWinModule->m_csWindowCreate, false);
if (FAILED(lock.Lock()))
{
ATLASSERT(0);
return;
}
pData->m_pNext = pWinModule->m_pCreateWndList;
pWinModule->m_pCreateWndList = pData;
}
ATLINLINE ATLAPI_(void*) AtlWinModuleExtractCreateWndData(
_Inout_opt_ _ATL_WIN_MODULE* pWinModule)
{
if (pWinModule == NULL)
return NULL;
void* pv = NULL;
CComCritSecLock<CComCriticalSection> lock(pWinModule->m_csWindowCreate, false);
if (FAILED(lock.Lock()))
{
ATLASSERT(0);
return pv;
}
_AtlCreateWndData* pEntry = pWinModule->m_pCreateWndList;
if(pEntry != NULL)
{
DWORD dwThreadID = ::GetCurrentThreadId();
_AtlCreateWndData* pPrev = NULL;
while(pEntry != NULL)
{
if(pEntry->m_dwThreadID == dwThreadID)
{
if(pPrev == NULL)
pWinModule->m_pCreateWndList = pEntry->m_pNext;
else
pPrev->m_pNext = pEntry->m_pNext;
pv = pEntry->m_pThis;
break;
}
pPrev = pEntry;
pEntry = pEntry->m_pNext;
}
}
return pv;
}
ATLINLINE ATLAPI AtlWinModuleInit(
_Inout_ _ATL_WIN_MODULE* pWinModule)
{
if (pWinModule == NULL)
return E_INVALIDARG;
// check only in the DLL
if (pWinModule->cbSize != sizeof(_ATL_WIN_MODULE))
return E_INVALIDARG;
pWinModule->m_pCreateWndList = NULL;
HRESULT hr = pWinModule->m_csWindowCreate.Init();
if (FAILED(hr))
{
ATLASSERT(0);
}
return hr;
}
/////////////////////////////////////////////////////////////////////////////
// Module
ATLINLINE ATLAPI AtlModuleAddTermFunc(
_Inout_ _ATL_MODULE* pModule,
_In_ _ATL_TERMFUNC* pFunc,
_In_ DWORD_PTR dw)
{
if (pModule == NULL)
return E_INVALIDARG;
HRESULT hr = S_OK;
_ATL_TERMFUNC_ELEM* pNew = NULL;
ATLTRY(pNew = new _ATL_TERMFUNC_ELEM);
if (pNew == NULL)
hr = E_OUTOFMEMORY;
else
{
pNew->pFunc = pFunc;
pNew->dw = dw;
CComCritSecLock<CComCriticalSection> lock(pModule->m_csStaticDataInitAndTypeInfo, false);
hr = lock.Lock();
if (SUCCEEDED(hr))
{
pNew->pNext = pModule->m_pTermFuncs;
pModule->m_pTermFuncs = pNew;
}
else
{
delete pNew;
ATLASSERT(0);
}
}
return hr;
}
ATLINLINE ATLAPI_(void) AtlCallTermFunc(_Inout_ _ATL_MODULE* pModule)
{
if (pModule == NULL)
_AtlRaiseException((DWORD)EXCEPTION_ACCESS_VIOLATION);
_ATL_TERMFUNC_ELEM* pElem = pModule->m_pTermFuncs;
_ATL_TERMFUNC_ELEM* pNext = NULL;
while (pElem != NULL)
{
pElem->pFunc(pElem->dw);
pNext = pElem->pNext;
delete pElem;
pElem = pNext;
}
pModule->m_pTermFuncs = NULL;
}
} // namespace ATL
#pragma warning(pop)
#endif // __ATLBASE_INL__

398
src/main/headers/atlchecked.h Normal file
View File

@@ -0,0 +1,398 @@
// This is a part of the Active Template Library.
// Copyright (C) Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Active Template Library Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Active Template Library product.
#ifndef __ATLCHECKED_H__
#define __ATLCHECKED_H__
#pragma once
#include <atldef.h>
#include <atlexcept.h>
#include <malloc.h>
#include <string.h>
#include <mbstring.h>
#include <wchar.h>
#include <tchar.h>
#include <stdlib.h>
#pragma pack(push,_ATL_PACKING)
namespace ATL
{
inline errno_t AtlCrtErrorCheck(_In_ errno_t nError)
{
switch(nError)
{
case ENOMEM:
AtlThrow(E_OUTOFMEMORY);
break;
case EINVAL:
case ERANGE:
AtlThrow(E_INVALIDARG);
break;
case 0:
case STRUNCATE:
break;
default:
AtlThrow(E_FAIL);
break;
}
return nError;
}
/////////////////////////////////////////////////////////////////////////////
// Secure (Checked) CRT functions
namespace Checked
{
#ifdef _AFX
#define ATLMFC_CRT_ERRORCHECK(expr) AFX_CRT_ERRORCHECK(expr)
#else
#define ATLMFC_CRT_ERRORCHECK(expr) ATL_CRT_ERRORCHECK(expr)
#endif
inline void __cdecl memcpy_s(
_Out_bytecap_post_bytecount_(_S1max,_N) void *_S1,
_In_ size_t _S1max,
_In_bytecount_(_N) const void *_S2,
_In_ size_t _N)
{
ATLMFC_CRT_ERRORCHECK(::memcpy_s(_S1, _S1max, _S2, _N));
}
inline void __cdecl wmemcpy_s(
_Out_cap_post_count_(_N1,_N) wchar_t *_S1,
_In_ size_t _N1,
_In_count_(_N) const wchar_t *_S2,
_In_ size_t _N)
{
ATLMFC_CRT_ERRORCHECK(::wmemcpy_s(_S1, _N1, _S2, _N));
}
inline void __cdecl memmove_s(
_Out_bytecap_post_bytecount_(_S1max,_N) void *_S1,
_In_ size_t _S1max,
_In_bytecount_(_N) const void *_S2,
_In_ size_t _N)
{
ATLMFC_CRT_ERRORCHECK(::memmove_s(_S1, _S1max, _S2, _N));
}
inline void __cdecl strcpy_s(
_Out_z_cap_(_S1max) char *_S1,
_In_ size_t _S1max,
_In_z_ const char *_S2)
{
ATLMFC_CRT_ERRORCHECK(::strcpy_s(_S1, _S1max, _S2));
}
inline void __cdecl wcscpy_s(
_Out_z_cap_(_S1max) wchar_t *_S1,
_In_ size_t _S1max,
_In_z_ const wchar_t *_S2)
{
ATLMFC_CRT_ERRORCHECK(::wcscpy_s(_S1, _S1max, _S2));
}
inline void __cdecl tcscpy_s(
_Out_z_cap_(_SizeInChars) TCHAR * _Dst,
_In_ size_t _SizeInChars,
_In_z_ const TCHAR * _Src)
{
ATLMFC_CRT_ERRORCHECK(::_tcscpy_s(_Dst, _SizeInChars, _Src));
}
inline errno_t __cdecl strncpy_s(
_Out_z_cap_(_SizeInChars) char *_Dest,
_In_ size_t _SizeInChars,
_In_z_ const char *_Source,
_In_ size_t _Count)
{
return ATLMFC_CRT_ERRORCHECK(::strncpy_s(_Dest, _SizeInChars, _Source,_Count));
}
inline errno_t __cdecl wcsncpy_s(
_Out_z_cap_(_SizeInChars) wchar_t *_Dest,
_In_ size_t _SizeInChars,
_In_z_ const wchar_t *_Source,
_In_ size_t _Count)
{
return ATLMFC_CRT_ERRORCHECK(::wcsncpy_s(_Dest, _SizeInChars, _Source,_Count));
}
inline errno_t __cdecl tcsncpy_s(
_Out_z_cap_(_SizeInChars) TCHAR *_Dest,
_In_ size_t _SizeInChars,
_In_z_ const TCHAR *_Source,
_In_ size_t _Count)
{
return ATLMFC_CRT_ERRORCHECK(::_tcsncpy_s(_Dest, _SizeInChars, _Source,_Count));
}
inline void __cdecl strcat_s(
_Inout_z_cap_(_SizeInChars) char * _Dst,
_In_ size_t _SizeInChars,
_In_z_ const char * _Src)
{
ATLMFC_CRT_ERRORCHECK(::strcat_s(_Dst, _SizeInChars, _Src));
}
inline void __cdecl wcscat_s(
_Inout_z_cap_(_SizeInChars) wchar_t * _Dst,
_In_ size_t _SizeInChars,
_In_z_ const wchar_t * _Src)
{
ATLMFC_CRT_ERRORCHECK(::wcscat_s(_Dst, _SizeInChars, _Src));
}
inline void __cdecl tcscat_s(
_Inout_z_cap_(_SizeInChars) TCHAR * _Dst,
_In_ size_t _SizeInChars,
_In_z_ const TCHAR * _Src)
{
ATLMFC_CRT_ERRORCHECK(::_tcscat_s(_Dst, _SizeInChars, _Src));
}
inline void __cdecl strlwr_s(
_Inout_z_cap_(_SizeInChars) char * _Str,
_In_ size_t _SizeInChars)
{
ATLMFC_CRT_ERRORCHECK(::_strlwr_s(_Str, _SizeInChars));
}
inline void __cdecl wcslwr_s(
_Inout_z_cap_(_SizeInChars) wchar_t * _Str,
_In_ size_t _SizeInChars)
{
ATLMFC_CRT_ERRORCHECK(::_wcslwr_s(_Str, _SizeInChars));
}
inline void __cdecl mbslwr_s(
_Inout_z_bytecap_(_SizeInChars) unsigned char * _Str,
_In_ size_t _SizeInChars)
{
ATLMFC_CRT_ERRORCHECK(::_mbslwr_s(_Str, _SizeInChars));
}
inline void __cdecl tcslwr_s(
_Inout_z_cap_(_SizeInChars) TCHAR * _Str,
_In_ size_t _SizeInChars)
{
ATLMFC_CRT_ERRORCHECK(::_tcslwr_s(_Str, _SizeInChars));
}
inline void __cdecl strupr_s(
_Inout_z_cap_(_SizeInChars) char * _Str,
_In_ size_t _SizeInChars)
{
ATLMFC_CRT_ERRORCHECK(::_strupr_s(_Str, _SizeInChars));
}
inline void __cdecl wcsupr_s(
_Inout_z_cap_(_SizeInChars) wchar_t * _Str,
_In_ size_t _SizeInChars)
{
ATLMFC_CRT_ERRORCHECK(::_wcsupr_s(_Str, _SizeInChars));
}
inline void __cdecl mbsupr_s(
_Inout_z_bytecap_(_SizeInChars) unsigned char * _Str,
_In_ size_t _SizeInChars)
{
ATLMFC_CRT_ERRORCHECK(::_mbsupr_s(_Str, _SizeInChars));
}
inline void __cdecl tcsupr_s(
_Inout_z_cap_(_SizeInChars) TCHAR * _Str,
_In_ size_t _SizeInChars)
{
ATLMFC_CRT_ERRORCHECK(::_tcsupr_s(_Str, _SizeInChars));
}
inline void __cdecl itoa_s(
_In_ int _Val,
_Out_z_cap_(_SizeInChars) char *_Buf,
_In_ size_t _SizeInChars,
_In_ int _Radix)
{
ATLMFC_CRT_ERRORCHECK(::_itoa_s(_Val, _Buf, _SizeInChars, _Radix));
}
inline void __cdecl itot_s(
_In_ int _Val,
_Out_z_cap_(_SizeInChars) TCHAR *_Buf,
_In_ size_t _SizeInChars,
_In_ int _Radix)
{
ATLMFC_CRT_ERRORCHECK(::_itot_s(_Val, _Buf, _SizeInChars, _Radix));
}
inline void __cdecl ltoa_s(
_In_ long _Val,
_Out_z_cap_(_SizeInChars) char *_Buf,
_In_ size_t _SizeInChars,
_In_ int _Radix)
{
ATLMFC_CRT_ERRORCHECK(::_ltoa_s(_Val, _Buf, _SizeInChars, _Radix));
}
inline void __cdecl ltot_s(
_In_ long _Val,
_Out_z_cap_(_SizeInChars) TCHAR *_Buf,
_In_ size_t _SizeInChars,
_In_ int _Radix)
{
ATLMFC_CRT_ERRORCHECK(::_ltot_s(_Val, _Buf, _SizeInChars, _Radix));
}
inline void __cdecl ultoa_s(
_In_ unsigned long _Val,
_Out_z_cap_(_SizeInChars) char *_Buf,
_In_ size_t _SizeInChars,
_In_ int _Radix)
{
ATLMFC_CRT_ERRORCHECK(::_ultoa_s(_Val, _Buf, _SizeInChars, _Radix));
}
inline void __cdecl ultow_s(
_In_ unsigned long _Val,
_Out_z_cap_(_SizeInChars) wchar_t *_Buf,
_In_ size_t _SizeInChars,
_In_ int _Radix)
{
ATLMFC_CRT_ERRORCHECK(::_ultow_s(_Val, _Buf, _SizeInChars, _Radix));
}
inline void __cdecl ultot_s(
_In_ unsigned long _Val,
_Out_z_cap_(_SizeInChars) TCHAR *_Buf,
_In_ size_t _SizeInChars,
_In_ int _Radix)
{
ATLMFC_CRT_ERRORCHECK(::_ultot_s(_Val, _Buf, _SizeInChars, _Radix));
}
inline void __cdecl i64toa_s(
_In_ __int64 _Val,
_Out_z_cap_(_SizeInChars) char *_Buf,
_In_ size_t _SizeInChars,
_In_ int _Radix)
{
ATLMFC_CRT_ERRORCHECK(::_i64toa_s(_Val, _Buf, _SizeInChars, _Radix));
}
inline void __cdecl i64tow_s(
_In_ __int64 _Val,
_Out_z_cap_(_SizeInChars) wchar_t *_Buf,
_In_ size_t _SizeInChars,
_In_ int _Radix)
{
ATLMFC_CRT_ERRORCHECK(::_i64tow_s(_Val, _Buf, _SizeInChars, _Radix));
}
inline void __cdecl ui64toa_s(
_In_ unsigned __int64 _Val,
_Out_z_cap_(_SizeInChars) char *_Buf,
_In_ size_t _SizeInChars,
_In_ int _Radix)
{
ATLMFC_CRT_ERRORCHECK(::_ui64toa_s(_Val, _Buf, _SizeInChars, _Radix));
}
inline void __cdecl ui64tow_s(
_In_ unsigned __int64 _Val,
_Out_z_cap_(_SizeInChars) wchar_t *_Buf,
_In_ size_t _SizeInChars,
_In_ int _Radix)
{
ATLMFC_CRT_ERRORCHECK(::_ui64tow_s(_Val, _Buf, _SizeInChars, _Radix));
}
inline void __cdecl gcvt_s(
_Out_z_cap_(_SizeInChars) char *_Buffer,
_In_ size_t _SizeInChars,
_In_ double _Value,
_In_ int _Ndec)
{
ATLMFC_CRT_ERRORCHECK(::_gcvt_s(_Buffer, _SizeInChars, _Value, _Ndec));
}
inline void __cdecl tsplitpath_s(
_In_z_ const TCHAR *_Path,
_Out_opt_z_cap_(_Drive_len) TCHAR *_Drive,
_In_ size_t _Drive_len,
_Out_opt_z_cap_(_Dir_len) TCHAR *_Dir,
_In_ size_t _Dir_len,
_Out_opt_z_cap_(_Fname_len) TCHAR *_Fname,
_In_ size_t _Fname_len,
_Out_opt_z_cap_(_Ext_len) TCHAR *_Ext,
_In_ size_t _Ext_len)
{
ATLMFC_CRT_ERRORCHECK(::_tsplitpath_s(_Path, _Drive, _Drive_len, _Dir, _Dir_len, _Fname, _Fname_len, _Ext, _Ext_len));
}
inline void __cdecl tmakepath_s(
_Out_z_cap_(_SizeInChars) TCHAR *_Path,
_In_ size_t _SizeInChars,
_In_z_ const TCHAR *_Drive,
_In_z_ const TCHAR *_Dir,
_In_z_ const TCHAR *_Fname,
_In_z_ const TCHAR *_Ext)
{
ATLMFC_CRT_ERRORCHECK(::_tmakepath_s(_Path, _SizeInChars, _Drive, _Dir, _Fname, _Ext));
}
inline size_t __cdecl strnlen(
_In_z_count_(_Maxsize) const char *_Str,
_In_ size_t _Maxsize)
{
return ::strnlen(_Str, _Maxsize);
}
inline size_t __cdecl wcsnlen(
_In_z_count_(_Maxsize) const wchar_t *_Wcs,
_In_ size_t _Maxsize)
{
return ::wcsnlen(_Wcs, _Maxsize);
}
inline size_t __cdecl tcsnlen(
_In_z_count_(_Maxsize) const TCHAR *_Str,
_In_ size_t _Maxsize)
{
return ::_tcsnlen(_Str, _Maxsize);
}
inline int get_errno() throw()
{
int nErrNo=0;
errno_t nErrCall=::_get_errno(&nErrNo);
if(nErrCall)
{
return nErrCall;
}
return nErrNo;
}
inline void set_errno(_In_ int _Value)
{
ATLMFC_CRT_ERRORCHECK(::_set_errno(_Value));
}
} // namespace Checked
} // namespace ATL
#pragma pack(pop)
#endif // __ATLCHECKED_H__
/////////////////////////////////////////////////////////////////////////////

3210
src/main/headers/atlcomcli.h Normal file
View File

File diff suppressed because it is too large Load Diff

1485
src/main/headers/atlconv.h Normal file
View File

File diff suppressed because it is too large Load Diff

601
src/main/headers/atlcore.h Normal file
View File

@@ -0,0 +1,601 @@
// This is a part of the Active Template Library.
// Copyright (C) Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Active Template Library Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Active Template Library product.
#ifndef __ATLCORE_H__
#define __ATLCORE_H__
#pragma once
#ifdef _ATL_ALL_WARNINGS
#pragma warning( push )
#endif
#pragma warning(disable: 4786) // identifier was truncated in the debug information
#pragma warning(disable: 4127) // constant expression
#include <atldef.h>
#include <windows.h>
#include <ole2.h>
#include <limits.h>
#include <tchar.h>
#include <mbstring.h>
#include <atlchecked.h>
#include <atlsimpcoll.h>
#if _WIN32_WINNT < 0x0403
#error This file requires _WIN32_WINNT to be #defined at least to 0x0403. Value 0x0501 or higher is recommended.
#endif
#pragma pack(push,_ATL_PACKING)
namespace ATL
{
/////////////////////////////////////////////////////////////////////////////
// Verify that a null-terminated string points to valid memory
inline BOOL AtlIsValidString(
_In_z_count_(nMaxLength) LPCWSTR psz,
_In_ size_t nMaxLength = INT_MAX)
{
(nMaxLength);
return (psz != NULL);
}
// Verify that a null-terminated string points to valid memory
inline BOOL AtlIsValidString(
_In_z_count_(nMaxLength) LPCSTR psz,
_In_ size_t nMaxLength = UINT_MAX)
{
(nMaxLength);
return (psz != NULL);
}
// Verify that a pointer points to valid memory
inline BOOL AtlIsValidAddress(
_In_opt_bytecount_(nBytes) const void* p,
_In_ size_t nBytes,
_In_ BOOL bReadWrite = TRUE)
{
(bReadWrite);
(nBytes);
return (p != NULL);
}
template<typename T>
inline void AtlAssertValidObject(
_In_opt_ _Prepost_opt_bytecount_x_(sizeof(T)) const T *pOb)
{
ATLASSERT(pOb);
ATLASSERT(AtlIsValidAddress(pOb, sizeof(T)));
if(pOb)
pOb->AssertValid();
}
#ifdef _DEBUG
#define ATLASSERT_VALID(x) ATL::AtlAssertValidObject(x)
#else
#define ATLASSERT_VALID(x) __noop;
#endif
// COM Sync Classes
class CComCriticalSection
{
public:
CComCriticalSection() throw()
{
memset(&m_sec, 0, sizeof(CRITICAL_SECTION));
}
~CComCriticalSection()
{
}
HRESULT Lock() throw()
{
EnterCriticalSection(&m_sec);
return S_OK;
}
HRESULT Unlock() throw()
{
LeaveCriticalSection(&m_sec);
return S_OK;
}
HRESULT Init() throw()
{
HRESULT hRes = S_OK;
if (!InitializeCriticalSectionAndSpinCount(&m_sec, 0))
{
hRes = HRESULT_FROM_WIN32(GetLastError());
}
return hRes;
}
HRESULT Term() throw()
{
DeleteCriticalSection(&m_sec);
return S_OK;
}
CRITICAL_SECTION m_sec;
};
class CComAutoCriticalSection :
public CComCriticalSection
{
public:
CComAutoCriticalSection()
{
HRESULT hr = CComCriticalSection::Init();
if (FAILED(hr))
AtlThrow(hr);
}
~CComAutoCriticalSection() throw()
{
CComCriticalSection::Term();
}
private :
HRESULT Init(); // Not implemented. CComAutoCriticalSection::Init should never be called
HRESULT Term(); // Not implemented. CComAutoCriticalSection::Term should never be called
};
class CComSafeDeleteCriticalSection :
public CComCriticalSection
{
public:
CComSafeDeleteCriticalSection(): m_bInitialized(false)
{
}
~CComSafeDeleteCriticalSection() throw()
{
if (!m_bInitialized)
{
return;
}
m_bInitialized = false;
CComCriticalSection::Term();
}
HRESULT Init() throw()
{
ATLASSERT( !m_bInitialized );
HRESULT hr = CComCriticalSection::Init();
if (SUCCEEDED(hr))
{
m_bInitialized = true;
}
return hr;
}
HRESULT Term() throw()
{
if (!m_bInitialized)
{
return S_OK;
}
m_bInitialized = false;
return CComCriticalSection::Term();
}
HRESULT Lock()
{
// CComSafeDeleteCriticalSection::Init or CComAutoDeleteCriticalSection::Init
// not called or failed.
// m_critsec member of CComObjectRootEx is now of type
// CComAutoDeleteCriticalSection. It has to be initialized
// by calling CComObjectRootEx::_AtlInitialConstruct
ATLASSUME(m_bInitialized);
return CComCriticalSection::Lock();
}
private:
bool m_bInitialized;
};
class CComAutoDeleteCriticalSection :
public CComSafeDeleteCriticalSection
{
private:
// CComAutoDeleteCriticalSection::Term should never be called
HRESULT Term() throw();
};
class CComFakeCriticalSection
{
public:
HRESULT Lock() throw()
{
return S_OK;
}
HRESULT Unlock() throw()
{
return S_OK;
}
HRESULT Init() throw()
{
return S_OK;
}
HRESULT Term() throw()
{
return S_OK;
}
};
/////////////////////////////////////////////////////////////////////////////
// Module
// Used by any project that uses ATL
struct _ATL_BASE_MODULE70
{
UINT cbSize;
HINSTANCE m_hInst;
HINSTANCE m_hInstResource;
DWORD dwAtlBuildVer;
const GUID* pguidVer;
CComCriticalSection m_csResource;
CSimpleArray<HINSTANCE> m_rgResourceInstance;
};
typedef _ATL_BASE_MODULE70 _ATL_BASE_MODULE;
class CAtlBaseModule :
public _ATL_BASE_MODULE
{
public :
static bool m_bInitFailed;
CAtlBaseModule() throw();
~CAtlBaseModule() throw ();
HINSTANCE GetModuleInstance() throw()
{
return m_hInst;
}
HINSTANCE GetResourceInstance() throw()
{
return m_hInstResource;
}
HINSTANCE SetResourceInstance(_In_ HINSTANCE hInst) throw()
{
return static_cast< HINSTANCE >(InterlockedExchangePointer((void**)&m_hInstResource, hInst));
}
bool AddResourceInstance(_In_ HINSTANCE hInst) throw();
bool RemoveResourceInstance(_In_ HINSTANCE hInst) throw();
HINSTANCE GetHInstanceAt(_In_ int i) throw();
};
__declspec(selectany) bool CAtlBaseModule::m_bInitFailed = false;
extern CAtlBaseModule _AtlBaseModule;
/////////////////////////////////////////////////////////////////////////////
// String resource helpers
#pragma warning(push)
#pragma warning(disable: 4200)
struct ATLSTRINGRESOURCEIMAGE
{
WORD nLength;
WCHAR achString[];
};
#pragma warning(pop) // C4200
inline const ATLSTRINGRESOURCEIMAGE* _AtlGetStringResourceImage(
_In_ HINSTANCE hInstance,
_In_ HRSRC hResource,
_In_ UINT id) throw()
{
const ATLSTRINGRESOURCEIMAGE* pImage;
const ATLSTRINGRESOURCEIMAGE* pImageEnd;
ULONG nResourceSize;
HGLOBAL hGlobal;
UINT iIndex;
hGlobal = ::LoadResource( hInstance, hResource );
if( hGlobal == NULL )
{
return( NULL );
}
pImage = (const ATLSTRINGRESOURCEIMAGE*)::LockResource( hGlobal );
if( pImage == NULL )
{
return( NULL );
}
nResourceSize = ::SizeofResource( hInstance, hResource );
pImageEnd = (const ATLSTRINGRESOURCEIMAGE*)(LPBYTE( pImage )+nResourceSize);
iIndex = id&0x000f;
while( (iIndex > 0) && (pImage < pImageEnd) )
{
pImage = (const ATLSTRINGRESOURCEIMAGE*)(LPBYTE( pImage )+(sizeof( ATLSTRINGRESOURCEIMAGE )+(pImage->nLength*sizeof( WCHAR ))));
iIndex--;
}
if( pImage >= pImageEnd )
{
return( NULL );
}
if( pImage->nLength == 0 )
{
return( NULL );
}
return( pImage );
}
inline const ATLSTRINGRESOURCEIMAGE* AtlGetStringResourceImage(
_In_ HINSTANCE hInstance,
_In_ UINT id) throw()
{
HRSRC hResource;
/*
The and operation (& static_cast<WORD>(~0)) protects the expression from being greater
than WORD - this would cause a runtime error when the application is compiled with /RTCc flag.
*/
hResource = ::FindResourceW(hInstance, MAKEINTRESOURCEW( (((id>>4)+1) & static_cast<WORD>(~0)) ), (LPWSTR) RT_STRING);
if( hResource == NULL )
{
return( NULL );
}
return _AtlGetStringResourceImage( hInstance, hResource, id );
}
inline const ATLSTRINGRESOURCEIMAGE* AtlGetStringResourceImage(
_In_ HINSTANCE hInstance,
_In_ UINT id,
_In_ WORD wLanguage) throw()
{
HRSRC hResource;
/*
The and operation (& static_cast<WORD>(~0)) protects the expression from being greater
than WORD - this would cause a runtime error when the application is compiled with /RTCc flag.
*/
hResource = ::FindResourceExW(hInstance, (LPWSTR) RT_STRING, MAKEINTRESOURCEW( (((id>>4)+1) & static_cast<WORD>(~0)) ), wLanguage);
if( hResource == NULL )
{
return( NULL );
}
return _AtlGetStringResourceImage( hInstance, hResource, id );
}
inline const ATLSTRINGRESOURCEIMAGE* AtlGetStringResourceImage(_In_ UINT id) throw()
{
const ATLSTRINGRESOURCEIMAGE* p = NULL;
HINSTANCE hInst = _AtlBaseModule.GetHInstanceAt(0);
for (int i = 1; hInst != NULL && p == NULL; hInst = _AtlBaseModule.GetHInstanceAt(i++))
{
p = AtlGetStringResourceImage(hInst, id);
}
return p;
}
inline const ATLSTRINGRESOURCEIMAGE* AtlGetStringResourceImage(
_In_ UINT id,
_In_ WORD wLanguage) throw()
{
const ATLSTRINGRESOURCEIMAGE* p = NULL;
HINSTANCE hInst = _AtlBaseModule.GetHInstanceAt(0);
for (int i = 1; hInst != NULL && p == NULL; hInst = _AtlBaseModule.GetHInstanceAt(i++))
{
p = AtlGetStringResourceImage(hInst, id, wLanguage);
}
return p;
}
inline int AtlLoadString(
_In_ UINT nID,
_Out_z_cap_post_count_(nBufferMax, return + 1) LPTSTR lpBuffer,
_In_ int nBufferMax) throw()
{
HINSTANCE hInst = _AtlBaseModule.GetHInstanceAt(0);
int nRet = 0;
for (int i = 1; hInst != NULL && nRet == 0; hInst = _AtlBaseModule.GetHInstanceAt(i++))
{
nRet = LoadString(hInst, nID, lpBuffer, nBufferMax);
}
return nRet;
}
inline HINSTANCE AtlFindResourceInstance(
_In_z_ LPCTSTR lpName,
_In_z_ LPCTSTR lpType,
_In_ WORD wLanguage = 0) throw()
{
ATLASSERT(lpType != RT_STRING); // Call AtlFindStringResourceInstance to find the string
if (lpType == RT_STRING)
return NULL;
if (ATL_IS_INTRESOURCE(lpType))
{
/* Prefast false warnings caused by bad-shaped definition of MAKEINTRESOURCE macro from PSDK */
if (lpType == ATL_RT_ICON)
{
lpType = ATL_RT_GROUP_ICON;
}
else if (lpType == ATL_RT_CURSOR)
{
lpType = ATL_RT_GROUP_CURSOR;
}
}
HINSTANCE hInst = _AtlBaseModule.GetHInstanceAt(0);
HRSRC hResource = NULL;
for (int i = 1; hInst != NULL; hInst = _AtlBaseModule.GetHInstanceAt(i++))
{
hResource = ::FindResourceEx(hInst, lpType, lpName, wLanguage);
if (hResource != NULL)
{
return hInst;
}
}
return NULL;
}
inline HINSTANCE AtlFindResourceInstance(
_In_ UINT nID,
_In_z_ LPCTSTR lpType,
_In_ WORD wLanguage = 0) throw()
{
/*
The and operation (& static_cast<WORD>(~0)) protects the expression from being greater
than WORD - this would cause a runtime error when the application is compiled with /RTCc flag.
*/
return AtlFindResourceInstance(MAKEINTRESOURCE(nID & static_cast<WORD>(~0)), lpType, wLanguage);
}
inline HINSTANCE AtlFindStringResourceInstance(
_In_ UINT nID,
_In_ WORD wLanguage = 0) throw()
{
const ATLSTRINGRESOURCEIMAGE* p = NULL;
HINSTANCE hInst = _AtlBaseModule.GetHInstanceAt(0);
for (int i = 1; hInst != NULL && p == NULL; hInst = _AtlBaseModule.GetHInstanceAt(i++))
{
p = AtlGetStringResourceImage(hInst, nID, wLanguage);
if (p != NULL)
return hInst;
}
return NULL;
}
/*
Needed by both atlcomcli and atlsafe, so needs to be in here
*/
inline HRESULT AtlSafeArrayGetActualVartype(
_In_ SAFEARRAY *psaArray,
_Out_ VARTYPE *pvtType)
{
HRESULT hrSystem=::SafeArrayGetVartype(psaArray, pvtType);
if(FAILED(hrSystem))
{
return hrSystem;
}
/*
When Windows has a SAFEARRAY of type VT_DISPATCH with FADF_HAVEIID,
it returns VT_UNKNOWN instead of VT_DISPATCH. We patch the value to be correct
*/
if(pvtType && *pvtType==VT_UNKNOWN)
{
if(psaArray && ((psaArray->fFeatures & FADF_HAVEIID)!=0))
{
if(psaArray->fFeatures & FADF_DISPATCH)
{
*pvtType=VT_DISPATCH;
}
}
}
return hrSystem;
}
template <typename _CharType>
inline _CharType* AtlCharNext(_In_ const _CharType* p) throw()
{
ATLASSUME(p != NULL); // Too expensive to check separately here
if (*p == '\0') // ::CharNextA won't increment if we're at a \0 already
return const_cast<_CharType*>(p+1);
else
return ::CharNextA(p);
}
template <>
inline wchar_t* AtlCharNext<wchar_t>(_In_ const wchar_t* p) throw()
{
return const_cast< wchar_t* >( p+1 );
}
template<typename CharType>
inline const CharType* AtlstrchrT(
_In_z_ const CharType* p,
_In_ CharType ch) throw()
{
ATLASSERT(p != NULL);
if(p==NULL)
{
return NULL;
}
while( *p != 0 )
{
if (*p == ch)
{
return p;
}
p = AtlCharNext(p);
}
//strchr for '\0' should succeed - the while loop terminates
//*p == 0, but ch also == 0, so NULL terminator address is returned
return (*p == ch) ? p : NULL;
}
//Ansi and Unicode versions of printf, used with templated CharType trait classes.
#pragma warning(push)
#pragma warning(disable : 4793)
template<typename CharType>
inline int AtlprintfT(_In_z_ _Printf_format_string_ const CharType* pszFormat,...) throw()
{
int retval=0;
va_list argList;
va_start( argList, pszFormat );
retval=vprintf(pszFormat,argList);
va_end( argList );
return retval;
}
#pragma warning(pop)
#pragma warning(push)
#pragma warning(disable : 4793)
template<>
inline int AtlprintfT(_In_z_ _Printf_format_string_ const wchar_t* pszFormat,... ) throw()
{
int retval=0;
va_list argList;
va_start( argList, pszFormat );
retval=vwprintf(pszFormat, argList);
va_end( argList );
return retval;
}
#pragma warning(pop)
inline BOOL AtlConvertSystemTimeToVariantTime(
_In_ const SYSTEMTIME& systimeSrc,
_Out_ double* pVarDtTm)
{
ATLENSURE(pVarDtTm!=NULL);
//Convert using ::SystemTimeToVariantTime and store the result in pVarDtTm then
//convert variant time back to system time and compare to original system time.
BOOL ok = ::SystemTimeToVariantTime(const_cast<SYSTEMTIME*>(&systimeSrc), pVarDtTm);
SYSTEMTIME sysTime;
::ZeroMemory(&sysTime, sizeof(SYSTEMTIME));
ok = ok && ::VariantTimeToSystemTime(*pVarDtTm, &sysTime);
ok = ok && (systimeSrc.wYear == sysTime.wYear &&
systimeSrc.wMonth == sysTime.wMonth &&
systimeSrc.wDay == sysTime.wDay &&
systimeSrc.wHour == sysTime.wHour &&
systimeSrc.wMinute == sysTime.wMinute &&
systimeSrc.wSecond == sysTime.wSecond);
return ok;
}
/////////////////////////////////////////////////////////////////////////////
} // namespace ATL
#pragma pack(pop)
#ifdef _ATL_ALL_WARNINGS
#pragma warning( pop )
#endif
#endif // __ATLCORE_H__

712
src/main/headers/atldef.h Normal file
View File

@@ -0,0 +1,712 @@
// This is a part of the Active Template Library.
// Copyright (C) Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Active Template Library Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Active Template Library product.
#ifndef __ATLDEF_H__
#define __ATLDEF_H__
#pragma once
#pragma warning(disable : 4619) // there is no warning number
#include <atlrc.h>
#include <errno.h>
#include <sal.h>
// preprocessor string helpers
#ifndef _ATL_STRINGIZE
#define __ATL_STRINGIZE(_Value) #_Value
#define _ATL_STRINGIZE(_Value) __ATL_STRINGIZE(_Value)
#endif
#ifndef _ATL_APPEND
#define __ATL_APPEND(_Value1, _Value2) _Value1 ## _Value2
#define _ATL_APPEND(_Value1, _Value2) __ATL_APPEND(_Value1, _Value2)
#endif
#ifndef RC_INVOKED
#ifndef __cplusplus
#error ATL requires C++ compilation (use a .cpp suffix)
#endif
#ifdef UNDER_CE
#error This version of ATL is not currently supported for CE. Look for the CE specific version.
#endif
// If you are mixing compilation units that are built as
// native code with those that are built /clr, you must define
// the symbol '_ATL_MIXED'. _ATL_MIXED must be defined for all
// compilation units in an executable or it must be defined for none of them.
#if !defined(_ATL_MIXED)
namespace Inconsistent_definition_of_symbol__ATL_MIXED
{
struct _Please_define_it_the_same_throughout_your_project { };
}
#else
namespace Inconsistent_definition_of_symbol__ATL_MIXED
{
#ifdef _M_IX86
#pragma comment(linker, "/include:??3@YAXPAX@Z")
#else
#pragma comment(linker, "/include:??3@YAXPEAX@Z")
#endif
struct _Please_define_it_the_same_throughout_your_project { virtual void one(){} };
}
#endif
namespace Inconsistent_definition_of_symbol__ATL_MIXED
{
__declspec(selectany) _Please_define_it_the_same_throughout_your_project clash = _Please_define_it_the_same_throughout_your_project ();
}
#if !defined(_ATL_MIXED)
namespace Define_the_symbol__ATL_MIXED
{
#if defined(_M_CEE)
struct Thank_you { };
#else
#ifdef _M_IX86
#pragma comment(linker, "/include:??3@YAXPAX@Z")
#else
#pragma comment(linker, "/include:??3@YAXPEAX@Z")
#endif
struct Thank_you { virtual void one(){} };
#endif
__declspec(selectany) Thank_you clash = Thank_you();
}
#endif
#if defined(_ATL_MIXED)
#define _ATL_NATIVE_INITIALIZATION
#endif
#if !defined(_M_CEE)
#define _ATL_NATIVE_INITIALIZATION
#endif
#ifdef _UNICODE
#ifndef UNICODE
#define UNICODE // UNICODE is used by Windows headers
#endif
#endif
#ifdef UNICODE
#ifndef _UNICODE
#define _UNICODE // _UNICODE is used by C-runtime/MFC headers
#endif
#endif
#ifdef _DEBUG
#ifndef DEBUG
#define DEBUG
#endif
#endif
//PREFAST support static_assert from version 16.00
#if defined(_PREFAST_) && (_MSC_VER < 1600)
#define ATLSTATIC_ASSERT(expr, comment)
#else
#define ATLSTATIC_ASSERT(expr, comment) static_assert(expr, comment)
#endif
#ifdef _WIN64
#define _ATL_SUPPORT_VT_I8 // Always support VT_I8 on Win64.
#endif
#if !defined(UNALIGNED)
#if defined(_M_IA64) || defined(_M_AMD64)
#define UNALIGNED __unaligned
#else
#define UNALIGNED
#endif
#endif
#if !defined(_countof)
#if !defined(__cplusplus)
#define _countof(_Array) (sizeof(_Array) / sizeof(_Array[0]))
#else
extern "C++"
{
template <typename _CountofType, size_t _SizeOfArray>
char (*__countof_helper(UNALIGNED _CountofType (&_Array)[_SizeOfArray]))[_SizeOfArray];
#define _countof(_Array) sizeof(*__countof_helper(_Array))
}
#endif
#endif
#if defined(__MINGW32__)
#ifndef ATLASSERT
#define ATLASSERT(expr) _ASSERTE(expr)
#endif // ATLASSERT
#include <atlexcept.h>
#endif
#ifndef AtlThrow
#ifndef _ATL_CUSTOM_THROW
#define AtlThrow ATL::AtlThrowImpl
#endif
#endif // AtlThrow
#if !defined(__MINGW32__)
#ifndef ATLASSERT
#define ATLASSERT(expr) _ASSERTE(expr)
#endif // ATLASSERT
#endif
/*
Why does ATLASSUME exist?
ATL 8 has two existing validation models
ATLASSERT/ATLVERIFY - These are used to make sure a debug build reports a problem with the expression/invariant
ATLENSURE - Debug is the same as ATLVERIFY, retail throws a C++ exception
We added ATLENSURE because there were too many unreported error paths in ATL and we wanted to bail out of more
error conditions rather than just trying to continue in retail.
There might be a case for changing 'lots' of ATLASSERT to ATLENSURE, but we chose an incremental approach and only
changed over where we saw a problem with code reported from a customer or test case. This reduces code churn in our
code for this version.
In general, our approach is to try to make sure that when something goes wrong
- the client does not continue to run, because we report an error condition
- debug builds see an assertion about the problem
Sometimes we have code like
HRESULT ComMethod(void)
{
ATLASSUME(m_pFoo);
return m_pFoo->Method();
}
We could add
if(!m_pFoo) return E_POINTER;
But this is very unlikely to help, since it removes the ability of the developer to debug this problem if it's seen in a retail
build of the application.
We could try something more severe
if(!m_pFoo) terminate(); // or your favourite shutdown function
This would ensure good reporting (because VC8 terminate generates a Windows Error Report and crash dump), but hardly seems a big win
over the previous crash.
ATLENSURE might seem slightly better. It is debuggable and consistent with ATL in general. In fact, many parts of ATL do just this.
But in this specific context, it doesn't look like a great choice. COM methods should not in general be emitting native C++ exceptions
as an error reporting strategy.
So we find ourselves in a quandry. For these kinds of methods, the traditional code (ATLASSERT followed by a crash), seems be the most
debuggable thing to do in this situation. At least for VS8, we have decided to stick with this shape.
---
Now consider the impact of cl /analyze. We want cl /analyze to not warn about our potential dereferences when they refer to member variables
whose state was previously validated by another method. But we do want to see the impact of function contracts on the parameters of the
function.
So we've done a broad replace of all the member-related ATLASSERT to ATLASSUME.
*/
#ifndef ATLASSUME
#define ATLASSUME(expr) do { ATLASSERT(expr); __analysis_assume(!!(expr)); } while(0)
#endif // ATLASSUME
#ifndef ATLVERIFY
#ifdef _DEBUG
#define ATLVERIFY(expr) ATLASSERT(expr)
#else
#define ATLVERIFY(expr) (expr)
#endif // DEBUG
#endif // ATLVERIFY
#ifndef ATLENSURE_THROW
#define ATLENSURE_THROW(expr, hr) \
do { \
int __atl_condVal=!!(expr); \
ATLASSUME(__atl_condVal); \
if(!(__atl_condVal)) AtlThrow(hr); \
} while (0)
#endif // ATLENSURE_THROW
#ifndef ATLENSURE
#define ATLENSURE(expr) ATLENSURE_THROW(expr, E_FAIL)
#endif // ATLENSURE
#ifndef ATLENSURE_SUCCEEDED
#define ATLENSURE_SUCCEEDED(hr) ATLENSURE_THROW(SUCCEEDED(hr), hr)
#endif // ATLENSURE_SUCCEEDED
/* Used inside COM methods that do not want to throw */
#ifndef ATLENSURE_RETURN_VAL
#define ATLENSURE_RETURN_VAL(expr, val) \
do { \
int __atl_condVal=!!(expr); \
ATLASSERT(__atl_condVal); \
if(!(__atl_condVal)) return val; \
} while (0)
#endif // ATLENSURE_RETURN_VAL
/* Used inside COM methods that do not want to throw */
#ifndef ATLENSURE_RETURN
#define ATLENSURE_RETURN(expr) ATLENSURE_RETURN_HR(expr, E_FAIL)
#endif // ATLENSURE_RETURN
/* Naming is slightly off in these macros
ATLENSURE_RETURN is an HRESULT return of E_FAIL
ATLENSURE_RETURN_VAL is any return value (function can pick)
ATLENSURE_RETURN_HR is HRESULT-specific, though currently the same as _VAL
*/
#ifndef ATLENSURE_RETURN_HR
#define ATLENSURE_RETURN_HR(expr, hr) ATLENSURE_RETURN_VAL(expr, hr)
#endif // ATLENSURE_RETURN_HR
#ifndef ATL_CRT_ERRORCHECK
#define ATL_CRT_ERRORCHECK(expr) AtlCrtErrorCheck(expr)
#endif // ATL_CRT_ERRORCHECK
#ifndef ATL_CRT_ERRORCHECK_SPRINTF
#define ATL_CRT_ERRORCHECK_SPRINTF(expr) \
do { \
errno_t _saveErrno = errno; \
errno = 0; \
(expr); \
if(0 != errno) \
{ \
AtlCrtErrorCheck(errno); \
} \
else \
{ \
errno = _saveErrno; \
} \
} while (0)
#endif // ATL_CRT_ERRORCHECK_SPRINTF
///////////////////////////////////////////////////////////////////////////////
// __declspec(novtable) is used on a class declaration to prevent the vtable
// pointer from being initialized in the constructor and destructor for the
// class. This has many benefits because the linker can now eliminate the
// vtable and all the functions pointed to by the vtable. Also, the actual
// constructor and destructor code are now smaller.
///////////////////////////////////////////////////////////////////////////////
// This should only be used on a class that is not directly createable but is
// rather only used as a base class. Additionally, the constructor and
// destructor (if provided by the user) should not call anything that may cause
// a virtual function call to occur back on the object.
///////////////////////////////////////////////////////////////////////////////
// By default, the wizards will generate new ATL object classes with this
// attribute (through the ATL_NO_VTABLE macro). This is normally safe as long
// the restriction mentioned above is followed. It is always safe to remove
// this macro from your class, so if in doubt, remove it.
///////////////////////////////////////////////////////////////////////////////
#ifdef _ATL_DISABLE_NO_VTABLE
#define ATL_NO_VTABLE
#else
#define ATL_NO_VTABLE __declspec(novtable)
#endif
#ifdef _ATL_DISABLE_NOTHROW
#define ATL_NOTHROW
#else
#define ATL_NOTHROW __declspec(nothrow)
#endif
#ifdef _ATL_DISABLE_FORCEINLINE
#define ATL_FORCEINLINE
#else
#define ATL_FORCEINLINE __forceinline
#endif
#ifdef _ATL_DISABLE_NOINLINE
#define ATL_NOINLINE
#else
#define ATL_NOINLINE __declspec( noinline )
#endif
#ifdef _ATL_DISABLE_DEPRECATED
#define ATL_DEPRECATED(_Message)
#else
#define ATL_DEPRECATED(_Message) __declspec( deprecated(_Message) )
#endif
// If ATLXX.DLL is being used then _ATL_STATIC_REGISTRY doesn't really make sense
#ifdef _ATL_DLL
#undef _ATL_STATIC_REGISTRY
#else
// If not linking to ATLXX.DLL, use the static registrar and not building atl.dll
#ifndef _ATL_DLL_IMPL
#ifndef _ATL_STATIC_REGISTRY
#define _ATL_STATIC_REGISTRY
#endif
#endif
#endif
#ifdef _ATL_DEBUG_REFCOUNT
#ifndef _ATL_DEBUG_INTERFACES
#define _ATL_DEBUG_INTERFACES
#endif
#endif
#ifdef _DEBUG
#ifndef _ATL_DEBUG
#define _ATL_DEBUG
#endif // _ATL_DEBUG
#endif // _DEBUG
#ifdef _ATL_DEBUG_INTERFACES
#ifndef _ATL_DEBUG
#define _ATL_DEBUG
#endif // _ATL_DEBUG
#endif // _ATL_DEBUG_INTERFACES
#ifndef _ATL_HEAPFLAGS
#ifdef _MALLOC_ZEROINIT
#define _ATL_HEAPFLAGS HEAP_ZERO_MEMORY
#else
#define _ATL_HEAPFLAGS 0
#endif
#endif
#ifndef _ATL_PACKING
#define _ATL_PACKING 8
#endif
#if defined(_ATL_DLL)
#define ATLAPI extern "C" HRESULT __declspec(dllimport) __stdcall
#define ATLAPI_(x) extern "C" __declspec(dllimport) x __stdcall
#define ATLINLINE
#define ATLAPIINL extern "C" inline HRESULT __stdcall
#define ATLAPIINL_(x) extern "C" inline x __stdcall
#elif defined(_ATL_DLL_IMPL)
#define ATLAPI extern "C" inline HRESULT __stdcall
#define ATLAPI_(x) extern "C" inline x __stdcall
#define ATLAPIINL ATLAPI
#define ATLAPIINL_(x) ATLAPI_(x)
#define ATLINLINE
#else
#define ATLAPI __declspec(nothrow) HRESULT __stdcall
#define ATLAPI_(x) __declspec(nothrow) x __stdcall
#define ATLAPIINL ATLAPI
#define ATLAPIINL_(x) ATLAPI_(x)
#define ATLINLINE inline
#endif
#ifdef _ATL_NO_EXCEPTIONS
#ifdef _AFX
// #error MFC projects cannot define _ATL_NO_EXCEPTIONS
#endif
#else
#ifndef _CPPUNWIND
#define _ATL_NO_EXCEPTIONS
#endif
#endif
#ifdef _CPPUNWIND
#ifndef ATLTRYALLOC
#ifdef _AFX
#define ATLTRYALLOC(x) try{x;} catch(CException* e){e->Delete();}
#else
/* prefast noise VSW 489981 */
#define ATLTRYALLOC(x) __pragma(warning(push)) __pragma(warning(disable: 4571)) try{x;} catch(...) {} __pragma(warning(pop))
#endif //__AFX
#endif //ATLTRYALLOC
// If you define _ATLTRY before including this file, then
// you should define _ATLCATCH and _ATLRETHROW as well.
#ifndef _ATLTRY
#define _ATLTRY try
#ifdef _AFX
#define _ATLCATCH( e ) catch( CException* e )
#else
#define _ATLCATCH( e ) catch( CAtlException e )
#endif
#define _ATLCATCHALL() __pragma(warning(push)) __pragma(warning(disable: 4571)) catch( ... ) __pragma(warning(pop))
#ifdef _AFX
#define _ATLDELETEEXCEPTION(e) e->Delete();
#else
#define _ATLDELETEEXCEPTION(e) e;
#endif
#define _ATLRETHROW throw
#endif // _ATLTRY
/*
COM functions should not throw. Which means we should protect their callers from C++ exceptions leaking out. These macros
can help with that, though they have not yet been applied to the whole of ATL, which uses a variety of patterns to achieve
this end
*/
#ifndef _ATL_COM_BEGIN
#define _ATL_COM_BEGIN \
HRESULT __hrAtlComMethod=S_OK; \
try \
{
#endif
#ifdef _AFX
/* Nice to do something more complex here in future to translate an MFC exception to a better HR */
#define _AFX_COM_END_PART \
catch(CException *e) \
{ \
if(e) \
{ \
e->Delete(); \
} \
__hrAtlComMethod=E_FAIL; \
}
#else
#define _AFX_COM_END_PART \
catch(CAtlException e) \
{ \
__hrAtlComMethod=e.m_hr; \
}
#endif
#ifndef _ATL_COM_END
#define _ATL_COM_END \
_AFX_COM_END_PART \
catch(...) \
{ \
__hrAtlComMethod=E_FAIL; \
} \
return hr;
#endif
#else //_CPPUNWIND
#ifndef ATLTRYALLOC
#define ATLTRYALLOC(x) x;
#endif //ATLTRYALLOC
// if _ATLTRY is defined before including this file then
// _ATLCATCH and _ATLRETHROW should be defined as well.
#ifndef _ATLTRY
#define _ATLTRY
#define _ATLCATCH( e ) __pragma(warning(push)) __pragma(warning(disable: 4127)) if( false ) __pragma(warning(pop))
#define _ATLCATCHALL() __pragma(warning(push)) __pragma(warning(disable: 4127)) if( false ) __pragma(warning(pop))
#define _ATLDELETEEXCEPTION(e)
#define _ATLRETHROW
#endif // _ATLTRY
#endif //_CPPUNWIND
#ifndef ATLTRY
#define ATLTRY(x) ATLTRYALLOC(x)
#endif //ATLTRY
#define offsetofclass(base, derived) ((DWORD_PTR)(static_cast<base*>((derived*)_ATL_PACKING))-_ATL_PACKING)
/////////////////////////////////////////////////////////////////////////////
// Master version numbers
#define _ATL 1 // Active Template Library
#define _ATL_VER 0x0A00 // Active Template Library version 10.00
#ifndef _ATL_FILENAME_VER
#define _ATL_FILENAME_VER "100"
#endif
#ifndef _ATL_FILENAME_VER_NUM
#define _ATL_FILENAME_VER_NUM 100
#endif
#ifndef _ATL_VER_RBLD
#define _ATL_VER_RBLD "10.00"
#endif
/////////////////////////////////////////////////////////////////////////////
// Threading
#ifndef _ATL_SINGLE_THREADED
#ifndef _ATL_APARTMENT_THREADED
#ifndef _ATL_FREE_THREADED
#define _ATL_FREE_THREADED
#endif
#endif
#endif
// UUIDOF
#ifndef _ATL_NO_UUIDOF
#define _ATL_IIDOF(x) __uuidof(x)
#else
#define _ATL_IIDOF(x) IID_##x
#endif
// Lean and mean
#ifndef ATL_NO_LEAN_AND_MEAN
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#ifndef NOMCX
#define NOMCX
#endif
#endif // ATL_NO_LEAN_AND_MEAN
#ifdef NOSERVICE
#ifndef _ATL_NO_SERVICE
#define _ATL_NO_SERVICE
#endif // _ATL_NO_SERVICE
#else
#ifdef _ATL_NO_SERVICE
#ifndef NOSERVICE
#define NOSERVICE
#endif // NOSERVICE
#endif // _ATL_NO_SERVICE
#endif // NOSERVICE
#include <malloc.h>
#ifdef _DEBUG
#include <stdlib.h>
#endif
#ifndef _ATL_NO_DEBUG_CRT
// Warning: if you define the above symbol, you will have
// to provide your own definition of the ATLASSERT(x) macro
// in order to compile ATL
#include <crtdbg.h>
#endif
#endif // RC_INVOKED
// Note : we can not use macros to generate the window class names because it
// will require nested macros. rc.exe does not handle nested macros.
// #define ATLAXWIN_CLASS _ATL_STRINGIZE(_ATL_APPEND(AtlAxWin, _ATL_FILENAME_VER_NUM))
// #define ATLAXWINLIC_CLASS _ATL_STRINGIZE(_ATL_APPEND(AtlAxWinLic, _ATL_FILENAME_VER_NUM))
#define ATLAXWIN_CLASS "AtlAxWin100"
#define ATLAXWINLIC_CLASS "AtlAxWinLic100"
#if defined(_ATL_SECURE_NO_DEPRECATE) && !defined(_ATL_SECURE_NO_WARNINGS)
#define _ATL_SECURE_NO_WARNINGS
#endif
// _ATL_INSECURE_DEPRECATE define
#ifndef _ATL_INSECURE_DEPRECATE
#ifdef _ATL_SECURE_NO_WARNINGS
#define _ATL_INSECURE_DEPRECATE(_Message)
#else
#define _ATL_INSECURE_DEPRECATE(_Message) __declspec(deprecated(_Message))
#endif // _ATL_SECURE_NO_WARNINGS
#endif // _ATL_INSECURE_DEPRECATE
/*
This is called when something really bad happens -- so bad
that we consider it dangerous to even throw an exception
*/
#ifndef _ATL_FATAL_SHUTDOWN
#define _ATL_FATAL_SHUTDOWN do { ::TerminateProcess(::GetCurrentProcess(), 0); } while(0)
#endif
//ATL/MFC code should use standard pointer to member standard syntax &MyClass::MyMethod, instead
//of the legacy non-standard syntax - MyMethod.
#ifdef _ATL_ENABLE_PTM_WARNING
#define PTM_WARNING_DISABLE
#define PTM_WARNING_RESTORE
#else
#if !defined(__MINGW32__)
#define PTM_WARNING_DISABLE \
__pragma(warning( push )) \
__pragma(warning( disable : 4867 ))
#define PTM_WARNING_RESTORE \
__pragma(warning( pop ))
#else
#define PTM_WARNING_DISABLE
#define PTM_WARNING_RESTORE
#endif
#endif //_ATL_ENABLE_PTM_WARNING
/* we have to define our own versions of MAKEINTRESOURCE and IS_INTRESOURCE to
* fix warning 6268. At least until those macros are not cleanend in PSDK.
Same comes true for those definitions of constants which use the above macros
*/
#define ATL_MAKEINTRESOURCEA(i) ((LPSTR)((ULONG_PTR)((WORD)(i))))
#define ATL_MAKEINTRESOURCEW(i) ((LPWSTR)((ULONG_PTR)((WORD)(i))))
#ifdef UNICODE
#define ATL_MAKEINTRESOURCE ATL_MAKEINTRESOURCEW
#else
#define ATL_MAKEINTRESOURCE ATL_MAKEINTRESOURCEA
#endif // !UNICODE
#define ATL_IS_INTRESOURCE(_r) ((((ULONG_PTR)(_r)) >> 16) == 0)
/*
* Predefined Resource Types
*/
#define ATL_RT_CURSOR ATL_MAKEINTRESOURCE(1)
#define ATL_RT_BITMAP ATL_MAKEINTRESOURCE(2)
#define ATL_RT_ICON ATL_MAKEINTRESOURCE(3)
#define ATL_RT_MENU ATL_MAKEINTRESOURCE(4)
#define ATL_RT_DIALOG ATL_MAKEINTRESOURCE(5)
#define ATL_RT_STRING ATL_MAKEINTRESOURCE(6)
#define ATL_RT_FONTDIR ATL_MAKEINTRESOURCE(7)
#define ATL_RT_FONT ATL_MAKEINTRESOURCE(8)
#define ATL_RT_ACCELERATOR ATL_MAKEINTRESOURCE(9)
#define ATL_RT_RCDATA ATL_MAKEINTRESOURCE(10)
#define ATL_RT_MESSAGETABLE ATL_MAKEINTRESOURCE(11)
#define ATL_DIFFERENCE 11
#define ATL_RT_GROUP_CURSOR ATL_MAKEINTRESOURCE((ULONG_PTR)ATL_RT_CURSOR + ATL_DIFFERENCE)
#define ATL_RT_GROUP_ICON ATL_MAKEINTRESOURCE((ULONG_PTR)ATL_RT_ICON + ATL_DIFFERENCE)
#define ATL_RT_VERSION ATL_MAKEINTRESOURCE(16)
#define ATL_RT_DLGINCLUDE ATL_MAKEINTRESOURCE(17)
#define ATL_RT_PLUGPLAY ATL_MAKEINTRESOURCE(19)
#define ATL_RT_VXD ATL_MAKEINTRESOURCE(20)
#define ATL_RT_ANICURSOR ATL_MAKEINTRESOURCE(21)
#define ATL_RT_ANIICON ATL_MAKEINTRESOURCE(22)
#define ATL_RT_HTML ATL_MAKEINTRESOURCE(23)
/* sal.h stuff that is not in the current LKG */
#ifndef __out_ecount_part_z
#define __out_ecount_part_z(size,length) __out_ecount_part(size,length) __post __nullterminated
#endif
#ifndef __out_ecount_part_z_opt
#define __out_ecount_part_z_opt(size,length) __out_ecount_part_opt(size,length) __post __nullterminated
#endif
#ifndef __deref_opt_out_z
#define __deref_opt_out_z __deref_opt_out __post __deref __nullterminated
#endif
#ifndef __out_bcount_part_z
#define __out_bcount_part_z(size,length) __out_bcount_part(size,length) __post __nullterminated
#endif
#if !defined(__MINGW32__)
#define ATLPREFAST_SUPPRESS(x) __pragma(warning(push)) __pragma(warning(disable: x))
#define ATLPREFAST_UNSUPPRESS() __pragma(warning(pop))
#else
#define ATLPREFAST_SUPPRESS(x)
#define ATLPREFAST_UNSUPPRESS()
#endif
#ifndef _FormatMessage_format_string_
#define _FormatMessage_format_string_
#endif
/*
Helper functions for SAL annotation
*/
namespace ATL {
} // namespace ATL
#endif // __ATLDEF_H__
/////////////////////////////////////////////////////////////////////////////

120
src/main/headers/atlexcept.h Normal file
View File

@@ -0,0 +1,120 @@
// This is a part of the Active Template Library.
// Copyright (C) Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Active Template Library Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Active Template Library product.
#ifndef __ATLEXCEPT_H__
#define __ATLEXCEPT_H__
#pragma once
#if !defined(__MINGW32__)
#include <atldef.h>
#include <atltrace.h>
#endif
#pragma pack(push,_ATL_PACKING)
namespace ATL
{
/////////////////////////////////////////////////////////////////////////////
// Exception raise (for functions that cannot return an error code)
inline void __declspec(noreturn) _AtlRaiseException(
_In_ DWORD dwExceptionCode,
_In_ DWORD dwExceptionFlags = EXCEPTION_NONCONTINUABLE)
{
RaiseException( dwExceptionCode, dwExceptionFlags, 0, NULL );
}
class CAtlException
{
public:
CAtlException() throw() :
m_hr( E_FAIL )
{
}
CAtlException(_In_ HRESULT hr) throw() :
m_hr( hr )
{
}
operator HRESULT() const throw()
{
return( m_hr );
}
public:
HRESULT m_hr;
};
#ifndef ATL_NOINLINE
#ifdef _ATL_DISABLE_NOINLINE
#define ATL_NOINLINE
#else
#define ATL_NOINLINE __declspec( noinline )
#endif
#endif
#ifndef _ATL_NO_EXCEPTIONS
// Throw a CAtlException with the given HRESULT
#if defined( _ATL_CUSTOM_THROW ) // You can define your own AtlThrow to throw a custom exception.
#ifdef _AFX
#error MFC projects must use default implementation of AtlThrow()
#endif
#else
ATL_NOINLINE __declspec(noreturn) inline void WINAPI AtlThrowImpl(_In_ HRESULT hr)
{
throw CAtlException( hr );
}
#endif
// Throw a CAtlException corresponding to the result of ::GetLastError
ATL_NOINLINE __declspec(noreturn) inline void WINAPI AtlThrowLastWin32()
{
DWORD dwError = ::GetLastError();
AtlThrowImpl( HRESULT_FROM_WIN32( dwError ) );
}
#else // no exception handling
// Throw a CAtlException with th given HRESULT
#if !defined( _ATL_CUSTOM_THROW ) // You can define your own AtlThrow
ATL_NOINLINE inline void WINAPI AtlThrowImpl(_In_ HRESULT hr)
{
ATLASSERT( false );
DWORD dwExceptionCode;
switch(hr)
{
case E_OUTOFMEMORY:
dwExceptionCode = STATUS_NO_MEMORY;
break;
default:
dwExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
}
_AtlRaiseException((DWORD)dwExceptionCode);
}
#endif
// Throw a CAtlException corresponding to the result of ::GetLastError
ATL_NOINLINE inline void WINAPI AtlThrowLastWin32()
{
DWORD dwError = ::GetLastError();
AtlThrowImpl( HRESULT_FROM_WIN32( dwError ) );
}
#endif // no exception handling
} // namespace ATL
#pragma pack(pop)
#endif // __ATLEXCEPT_H__

2794
src/main/headers/atliface.h Normal file
View File

File diff suppressed because it is too large Load Diff

27
src/main/headers/atlrc.h Normal file
View File

@@ -0,0 +1,27 @@
// This is a part of the Active Template Library.
// Copyright (C) Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Active Template Library Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Active Template Library product.
#pragma once
#ifndef __ATLRC_H__
#define ATL_RESID_BASE 0xD800
#define ATL_STRING_BASE ATL_RESID_BASE
#define ATL_IDS_DATETIME_INVALID (ATL_STRING_BASE + 0)
#define ATL_IDS_DATETIMESPAN_INVALID (ATL_STRING_BASE + 1)
#define ATL_SERVICE_MANAGER_OPEN_ERROR (ATL_STRING_BASE + 10)
#define ATL_SERVICE_START_ERROR (ATL_STRING_BASE + 11)
#define ATL_SERVICE_OPEN_ERROR (ATL_STRING_BASE + 12)
#define ATL_SERVICE_DELETE_ERROR (ATL_STRING_BASE + 13)
#define ATL_SERVICE_STOP_ERROR (ATL_STRING_BASE + 14)
#endif // __ATLRC_H__

525
src/main/headers/atlsimpcoll.h Normal file
View File

@@ -0,0 +1,525 @@
// This is a part of the Active Template Library.
// Copyright (C) Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Active Template Library Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Active Template Library product.
#ifndef __ATLSIMPCOLL_H__
#define __ATLSIMPCOLL_H__
#pragma once
#include <atldef.h>
#include <atlchecked.h>
#include <wchar.h>
#include <atlalloc.h>
#pragma push_macro("malloc")
#undef malloc
#pragma push_macro("calloc")
#undef calloc
#pragma push_macro("realloc")
#undef realloc
#pragma push_macro("_recalloc")
#undef _recalloc
#pragma push_macro("free")
#undef free
#pragma warning(push)
#pragma warning(disable: 4800) // forcing 'int' value to bool
#pragma pack(push,_ATL_PACKING)
namespace ATL
{
#pragma push_macro("new")
#undef new
/////////////////////////////////////////////////////////////////////////////
// Collection helpers - CSimpleArray & CSimpleMap
// template class helpers with functions for comparing elements
// override if using complex types without operator==
template <class T>
class CSimpleArrayEqualHelper
{
public:
static bool IsEqual(
_In_ const T& t1,
_In_ const T& t2)
{
return (t1 == t2);
}
};
template <class T>
class CSimpleArrayEqualHelperFalse
{
public:
static bool IsEqual(
_In_ const T&,
_In_ const T&)
{
ATLASSERT(false);
return false;
}
};
template <class TKey, class TVal>
class CSimpleMapEqualHelper
{
public:
static bool IsEqualKey(
_In_ const TKey& k1,
_In_ const TKey& k2)
{
return CSimpleArrayEqualHelper<TKey>::IsEqual(k1, k2);
}
static bool IsEqualValue(
_In_ const TVal& v1,
_In_ const TVal& v2)
{
return CSimpleArrayEqualHelper<TVal>::IsEqual(v1, v2);
}
};
template <class TKey, class TVal>
class CSimpleMapEqualHelperFalse
{
public:
static bool IsEqualKey(
_In_ const TKey& k1,
_In_ const TKey& k2)
{
return CSimpleArrayEqualHelper<TKey>::IsEqual(k1, k2);
}
static bool IsEqualValue(
_In_ const TVal&,
_In_ const TVal&)
{
ATLASSERT(FALSE);
return false;
}
};
template <class T, class TEqual = CSimpleArrayEqualHelper< T > >
class CSimpleArray
{
public:
// Construction/destruction
CSimpleArray() :
m_aT(NULL), m_nSize(0), m_nAllocSize(0)
{
}
~CSimpleArray();
CSimpleArray(_In_ const CSimpleArray< T, TEqual >& src) :
m_aT(NULL), m_nSize(0), m_nAllocSize(0)
{
if (src.GetSize())
{
m_aT = (T*)nb_calloc(src.GetSize(), sizeof(T));
if (m_aT != NULL)
{
m_nAllocSize = src.GetSize();
for (int i=0; i<src.GetSize(); i++)
Add(src[i]);
}
}
}
CSimpleArray< T, TEqual >& operator=(_In_ const CSimpleArray< T, TEqual >& src)
{
if (GetSize() != src.GetSize())
{
RemoveAll();
m_aT = (T*)nb_calloc(src.GetSize(), sizeof(T));
if (m_aT != NULL)
m_nAllocSize = src.GetSize();
}
else
{
for (int i = GetSize(); i > 0; i--)
RemoveAt(i - 1);
}
for (int i=0; i<src.GetSize(); i++)
Add(src[i]);
return *this;
}
// Operations
int GetSize() const
{
return m_nSize;
}
BOOL Add(_In_ const T& t)
{
if(m_nSize == m_nAllocSize)
{
// Make sure newElement is not a reference to an element in the array.
// Or else, it will be invalidated by the reallocation.
ATLENSURE( (&t < m_aT) ||
(&t >= (m_aT + m_nAllocSize) ) );
T* aT;
int nNewAllocSize = (m_nAllocSize == 0) ? 1 : (m_nSize * 2);
if (nNewAllocSize<0||nNewAllocSize>INT_MAX/sizeof(T))
{
return FALSE;
}
aT = (T*)_recalloc(m_aT, nNewAllocSize, sizeof(T));
if(aT == NULL)
return FALSE;
m_nAllocSize = nNewAllocSize;
m_aT = aT;
}
InternalSetAtIndex(m_nSize, t);
m_nSize++;
return TRUE;
}
BOOL Remove(_In_ const T& t)
{
int nIndex = Find(t);
if(nIndex == -1)
return FALSE;
return RemoveAt(nIndex);
}
BOOL RemoveAt(_In_ int nIndex)
{
ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
if (nIndex < 0 || nIndex >= m_nSize)
return FALSE;
m_aT[nIndex].~T();
if(nIndex != (m_nSize - 1))
Checked::memmove_s((void*)(m_aT + nIndex), (m_nSize - nIndex) * sizeof(T), (void*)(m_aT + nIndex + 1), (m_nSize - (nIndex + 1)) * sizeof(T));
m_nSize--;
return TRUE;
}
void RemoveAll()
{
if(m_aT != NULL)
{
for(int i = 0; i < m_nSize; i++)
m_aT[i].~T();
nb_free(m_aT);
m_aT = NULL;
}
m_nSize = 0;
m_nAllocSize = 0;
}
const T& operator[] (_In_ int nIndex) const
{
ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
if(nIndex < 0 || nIndex >= m_nSize)
{
_AtlRaiseException((DWORD)EXCEPTION_ARRAY_BOUNDS_EXCEEDED);
}
return m_aT[nIndex];
}
T& operator[] (_In_ int nIndex)
{
ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
if(nIndex < 0 || nIndex >= m_nSize)
{
_AtlRaiseException((DWORD)EXCEPTION_ARRAY_BOUNDS_EXCEEDED);
}
return m_aT[nIndex];
}
T* GetData() const
{
return m_aT;
}
int Find(_In_ const T& t) const
{
for(int i = 0; i < m_nSize; i++)
{
if(TEqual::IsEqual(m_aT[i], t))
return i;
}
return -1; // not found
}
BOOL SetAtIndex(
_In_ int nIndex,
_In_ const T& t)
{
if (nIndex < 0 || nIndex >= m_nSize)
return FALSE;
InternalSetAtIndex(nIndex, t);
return TRUE;
}
// Implementation
class Wrapper
{
public:
Wrapper(_In_ const T& _t) : t(_t)
{
}
template <class _Ty>
void * __cdecl operator new(
_In_ size_t,
_In_ _Ty* p)
{
return p;
}
template <class _Ty>
void __cdecl operator delete(
_In_ void* /* pv */,
_In_ _Ty* /* p */)
{
}
T t;
};
// Implementation
void InternalSetAtIndex(
_In_ int nIndex,
_In_ const T& t)
{
new(m_aT + nIndex) Wrapper(t);
}
typedef T _ArrayElementType;
T* m_aT;
int m_nSize;
int m_nAllocSize;
};
#define CSimpleValArray CSimpleArray
template <class T, class TEqual> inline CSimpleArray<T, TEqual>::~CSimpleArray()
{
RemoveAll();
}
// intended for small number of simple types or pointers
template <class TKey, class TVal, class TEqual = CSimpleMapEqualHelper< TKey, TVal > >
class CSimpleMap
{
public:
TKey* m_aKey;
TVal* m_aVal;
int m_nSize;
typedef TKey _ArrayKeyType;
typedef TVal _ArrayElementType;
// Construction/destruction
CSimpleMap() :
m_aKey(NULL), m_aVal(NULL), m_nSize(0)
{
}
~CSimpleMap()
{
RemoveAll();
}
// Operations
int GetSize() const
{
return m_nSize;
}
BOOL Add(
_In_ const TKey& key,
_In_ const TVal& val)
{
TKey* pKey;
pKey = (TKey*)_recalloc(m_aKey, (m_nSize + 1), sizeof(TKey));
if(pKey == NULL)
return FALSE;
m_aKey = pKey;
TVal* pVal;
pVal = (TVal*)_recalloc(m_aVal, (m_nSize + 1), sizeof(TVal));
if(pVal == NULL)
return FALSE;
m_aVal = pVal;
InternalSetAtIndex(m_nSize, key, val);
m_nSize++;
return TRUE;
}
BOOL Remove(_In_ const TKey& key)
{
int nIndex = FindKey(key);
if(nIndex == -1)
return FALSE;
return RemoveAt(nIndex);
}
BOOL RemoveAt(_In_ int nIndex)
{
ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
if (nIndex < 0 || nIndex >= m_nSize)
return FALSE;
m_aKey[nIndex].~TKey();
m_aVal[nIndex].~TVal();
if(nIndex != (m_nSize - 1))
{
Checked::memmove_s((void*)(m_aKey + nIndex), (m_nSize - nIndex) * sizeof(TKey), (void*)(m_aKey + nIndex + 1), (m_nSize - (nIndex + 1)) * sizeof(TKey));
Checked::memmove_s((void*)(m_aVal + nIndex), (m_nSize - nIndex) * sizeof(TVal), (void*)(m_aVal + nIndex + 1), (m_nSize - (nIndex + 1)) * sizeof(TVal));
}
TKey* pKey;
pKey = (TKey*)_recalloc(m_aKey, (m_nSize - 1), sizeof(TKey));
if(pKey != NULL || m_nSize == 1)
m_aKey = pKey;
TVal* pVal;
pVal = (TVal*)_recalloc(m_aVal, (m_nSize - 1), sizeof(TVal));
if(pVal != NULL || m_nSize == 1)
m_aVal = pVal;
m_nSize--;
return TRUE;
}
void RemoveAll()
{
if(m_aKey != NULL)
{
for(int i = 0; i < m_nSize; i++)
{
m_aKey[i].~TKey();
m_aVal[i].~TVal();
}
nb_free(m_aKey);
m_aKey = NULL;
}
if(m_aVal != NULL)
{
nb_free(m_aVal);
m_aVal = NULL;
}
m_nSize = 0;
}
BOOL SetAt(
_In_ const TKey& key,
_In_ const TVal& val)
{
int nIndex = FindKey(key);
if(nIndex == -1)
return FALSE;
ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
m_aKey[nIndex].~TKey();
m_aVal[nIndex].~TVal();
InternalSetAtIndex(nIndex, key, val);
return TRUE;
}
TVal Lookup(_In_ const TKey& key) const
{
int nIndex = FindKey(key);
if(nIndex == -1)
return NULL; // must be able to convert
return GetValueAt(nIndex);
}
TKey ReverseLookup(_In_ const TVal& val) const
{
int nIndex = FindVal(val);
if(nIndex == -1)
return NULL; // must be able to convert
return GetKeyAt(nIndex);
}
TKey& GetKeyAt(_In_ int nIndex) const
{
ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
if(nIndex < 0 || nIndex >= m_nSize)
_AtlRaiseException((DWORD)EXCEPTION_ARRAY_BOUNDS_EXCEEDED);
return m_aKey[nIndex];
}
TVal& GetValueAt(_In_ int nIndex) const
{
ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
if(nIndex < 0 || nIndex >= m_nSize)
_AtlRaiseException((DWORD)EXCEPTION_ARRAY_BOUNDS_EXCEEDED);
return m_aVal[nIndex];
}
int FindKey(_In_ const TKey& key) const
{
for(int i = 0; i < m_nSize; i++)
{
if(TEqual::IsEqualKey(m_aKey[i], key))
return i;
}
return -1; // not found
}
int FindVal(_In_ const TVal& val) const
{
for(int i = 0; i < m_nSize; i++)
{
if(TEqual::IsEqualValue(m_aVal[i], val))
return i;
}
return -1; // not found
}
BOOL SetAtIndex(
_In_ int nIndex,
_In_ const TKey& key,
_In_ const TVal& val)
{
if (nIndex < 0 || nIndex >= m_nSize)
return FALSE;
InternalSetAtIndex(nIndex, key, val);
return TRUE;
}
// Implementation
template <typename T>
class Wrapper
{
public:
Wrapper(_In_ const T& _t) : t(_t)
{
}
template <class _Ty>
void *operator new(
_In_ size_t,
_In_ _Ty* p)
{
return p;
}
template <class _Ty>
void operator delete(
_In_ void* /* pv */,
_In_ _Ty* /* p */)
{
}
T t;
};
void InternalSetAtIndex(
_In_ int nIndex,
_In_ const TKey& key,
_In_ const TVal& val)
{
new(m_aKey + nIndex) Wrapper<TKey>(key);
new(m_aVal + nIndex) Wrapper<TVal>(val);
}
};
#pragma pop_macro("new")
}; // namespace ATL
#pragma pack(pop)
#pragma warning(pop)
#pragma pop_macro("free")
#pragma pop_macro("realloc")
#pragma pop_macro("_recalloc")
#pragma pop_macro("malloc")
#pragma pop_macro("calloc")
#endif // __ATLSIMPCOLL_H__

60
src/main/headers/atltrace.h Normal file
View File

@@ -0,0 +1,60 @@
// This is a part of the Active Template Library.
// Copyright (C) Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Active Template Library Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Active Template Library product.
#ifndef __ATLTRACE_H__
#define __ATLTRACE_H__
#pragma once
#include <atldef.h>
#include <atlconv.h>
#ifndef ATLTRACE
#define ATLTRACE
#define ATLTRACE2 ATLTRACE
#endif
#pragma warning(push)
#pragma warning(disable : 4793)
inline void __cdecl AtlTraceNull(...)
{
}
inline void __cdecl AtlTrace(
_In_z_ _Printf_format_string_ LPCSTR, ...)
{
}
inline void __cdecl AtlTrace2(
_In_ DWORD_PTR,
_In_ UINT,
_In_z_ _Printf_format_string_ LPCSTR, ...)
{
}
inline void __cdecl AtlTrace(
_In_z_ _Printf_format_string_ LPCWSTR, ...)
{
}
inline void __cdecl AtlTrace2(
_In_ DWORD_PTR,
_In_ UINT,
_In_z_ _Printf_format_string_ LPCWSTR, ...)
{
}
#pragma warning(pop)
#ifndef ATLTRACE
#define ATLTRACE __noop
#define ATLTRACE2 __noop
#endif //ATLTRACE
#define ATLTRACENOTIMPL(funcname) return E_NOTIMPL
#define DECLARE_NOUIASSERT()
#endif // __ATLTRACE_H__

208
src/main/headers/nbglobals.h Normal file
View File

@@ -0,0 +1,208 @@
#pragma once
#ifdef USE_DLMALLOC
#include "../../libs/dlmalloc/malloc-2.8.6.h"
#define nb_malloc(size) dlcalloc(1, size)
#define nb_calloc(count, size) dlcalloc(count, size)
#define nb_realloc(ptr, size) dlrealloc(ptr, size)
#if defined(__cplusplus)
#define nb_free(ptr) dlfree(reinterpret_cast<void *>(ptr))
#else
#define nb_free(ptr) dlfree((void *)(ptr))
#endif // if defined(__cplusplus)
#else
#define nb_malloc(size) malloc(size)
#define nb_calloc(count, size) calloc(count, size)
#define nb_realloc(ptr, size) realloc(ptr, size)
#if defined(__cplusplus)
#define nb_free(ptr) free(reinterpret_cast<void *>(ptr))
#else
#define nb_free(ptr) free((void *)(ptr))
#endif // if defined(__cplusplus)
#endif // ifdef USE_DLMALLOC
#if defined(_MSC_VER)
#ifndef noexcept
#define noexcept throw()
#endif
#endif
#if defined(__cplusplus)
inline void * operator_new(size_t size)
{
void * p = nb_malloc(size);
/*if (!p)
{
static std::bad_alloc badalloc;
throw badalloc;
}*/
return p;
}
inline void operator_delete(void * p)
{
nb_free(p);
}
#endif // if defined(__cplusplus)
#ifdef USE_DLMALLOC
/// custom memory allocation
#define DEF_CUSTOM_MEM_ALLOCATION_IMPL \
public: \
void * operator new(size_t size) \
{ \
return operator_new(size); \
} \
void operator delete(void * p, size_t) \
{ \
operator_delete(p); \
} \
void * operator new[](size_t size) \
{ \
return operator_new(size); \
} \
void operator delete[](void * p, size_t) \
{ \
operator_delete(p); \
} \
void * operator new(size_t, void * p) \
{ \
return p; \
} \
void operator delete(void *, void *) \
{ \
} \
void * operator new[](size_t, void * p) \
{ \
return p; \
} \
void operator delete[](void *, void *) \
{ \
}
#ifdef _DEBUG
#define CUSTOM_MEM_ALLOCATION_IMPL DEF_CUSTOM_MEM_ALLOCATION_IMPL \
void * operator new(size_t size, const char * /*lpszFileName*/, int /*nLine*/) \
{ \
return operator_new(size); \
} \
void * operator new[](size_t size, const char * /*lpszFileName*/, int /*nLine*/) \
{ \
return operator_new(size); \
} \
void operator delete(void * p, const char * /*lpszFileName*/, int /*nLine*/) \
{ \
operator_delete(p); \
} \
void operator delete[](void * p, const char * /*lpszFileName*/, int /*nLine*/) \
{ \
operator_delete(p); \
}
#else
#define CUSTOM_MEM_ALLOCATION_IMPL DEF_CUSTOM_MEM_ALLOCATION_IMPL
#endif // ifdef _DEBUG
#else
#define CUSTOM_MEM_ALLOCATION_IMPL
#endif // ifdef USE_DLMALLOC
#if defined(__cplusplus)
namespace nballoc
{
inline void destruct(char *) {}
inline void destruct(wchar_t *) {}
template <typename T>
inline void destruct(T * t) { t->~T(); }
} // namespace nballoc
template <typename T> struct custom_nballocator_t;
template <> struct custom_nballocator_t<void>
{
public:
typedef void * pointer;
typedef const void * const_pointer;
// reference to void members are impossible.
typedef void value_type;
template <class U>
struct rebind { typedef custom_nballocator_t<U> other; };
};
template <typename T>
struct custom_nballocator_t
{
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T * pointer;
typedef const T * const_pointer;
typedef T & reference;
typedef const T & const_reference;
typedef T value_type;
template <class U> struct rebind { typedef custom_nballocator_t<U> other; };
inline custom_nballocator_t() noexcept {}
inline custom_nballocator_t(const custom_nballocator_t &) noexcept {}
template <class U> custom_nballocator_t(const custom_nballocator_t<U> &) noexcept {}
~custom_nballocator_t() noexcept {}
pointer address(reference x) const { return &x; }
const_pointer address(const_reference x) const { return &x; }
pointer allocate(size_type s, void const * = 0)
{
if (0 == s)
return nullptr;
pointer temp = (pointer)nb_malloc(s * sizeof(T));
if (temp == nullptr)
throw std::bad_alloc();
return temp;
}
void deallocate(pointer p, size_type)
{
nb_free(p);
}
size_type max_size() const noexcept
{
// return std::numeric_limits<size_t>::max() / sizeof(T);
return size_t(-1) / sizeof(T);
}
void construct(pointer p, const T & val)
{
new((void *)p) T(val);
}
void destroy(pointer p)
{
nballoc::destruct(p);
}
};
template <typename T, typename U>
inline bool operator==(const custom_nballocator_t<T> &, const custom_nballocator_t<U> &)
{
return true;
}
template <typename T, typename U>
inline bool operator!=(const custom_nballocator_t<T> &, const custom_nballocator_t<U> &)
{
return false;
}
#endif // if defined(__cplusplus)

1609
src/main/headers/statreg.h Normal file
View File

File diff suppressed because it is too large Load Diff