cpp/jacob/include/atlalloc.h

@@ -0,0 +1,764 @@
+// 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 <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(T* ptResult, T tLeft, T tRight)
+{
+	if(::ATL::AtlLimits<T>::_Max-tLeft < tRight)
+	{
+		return E_INVALIDARG;
+	}
+	*ptResult= tLeft + tRight;
+	return S_OK;
+}
+
+/* generic but compariatively slow version */
+template<typename T>
+inline HRESULT AtlMultiply(T* ptResult,	T tLeft, T tRight)
+{
+	/* avoid divide 0 */
+	if(tLeft==0)
+	{
+		*ptResult=0;
+		return S_OK;
+	}
+	if(::ATL::AtlLimits<T>::_Max/tLeft < tRight)
+	{
+		return E_INVALIDARG;
+	}
+	*ptResult= tLeft * tRight;
+	return S_OK;
+}
+
+/* fast	version	for	32 bit integers	*/
+template<>
+inline HRESULT AtlMultiply(int _ATL_W64	*piResult, int _ATL_W64	iLeft, int _ATL_W64 iRight)
+{
+	__int64 i64Result=static_cast<__int64>(iLeft) * static_cast<__int64>(iRight);
+	if(i64Result>INT_MAX || i64Result < INT_MIN)
+	{
+		return E_INVALIDARG;
+	}
+	*piResult=static_cast<int _ATL_W64>(i64Result);
+	return S_OK;
+}
+
+template<>
+inline HRESULT AtlMultiply(unsigned int	_ATL_W64 *piResult, unsigned int _ATL_W64 iLeft, unsigned int _ATL_W64 iRight)
+{
+	unsigned __int64 i64Result=static_cast<unsigned __int64>(iLeft) * static_cast<unsigned __int64>(iRight);
+	if(i64Result>UINT_MAX)
+	{
+		return E_INVALIDARG;
+	}
+	*piResult=static_cast<unsigned int _ATL_W64>(i64Result);
+	return S_OK;
+}
+
+template<>
+inline HRESULT AtlMultiply(long	_ATL_W64 *piResult, long _ATL_W64 iLeft, long _ATL_W64 iRight)
+{
+	__int64 i64Result=static_cast<__int64>(iLeft) * static_cast<__int64>(iRight);
+	if(i64Result>LONG_MAX || i64Result < LONG_MIN)
+	{
+		return E_INVALIDARG;
+	}
+	*piResult=static_cast<long _ATL_W64>(i64Result);
+	return S_OK;
+}
+
+template<>
+inline HRESULT AtlMultiply(unsigned long _ATL_W64 *piResult, unsigned long _ATL_W64 iLeft, unsigned long _ATL_W64 iRight)
+{
+	unsigned __int64 i64Result=static_cast<unsigned __int64>(iLeft) * static_cast<unsigned __int64>(iRight);
+	if(i64Result>ULONG_MAX)
+	{
+		return E_INVALIDARG;
+	}
+	*piResult=static_cast<unsigned long _ATL_W64>(i64Result);
+	return S_OK;
+}
+
+template <typename T>
+inline T AtlMultiplyThrow(T tLeft, T tRight)
+{
+	T tResult;
+	HRESULT hr=AtlMultiply(&tResult, tLeft, tRight);
+	if(FAILED(hr))
+	{
+		AtlThrow(hr);
+	}
+	return tResult;
+}
+
+template <typename T>
+inline T AtlAddThrow(T tLeft, T	tRight)
+{
+	T tResult;
+	HRESULT hr=AtlAdd(&tResult, tLeft, tRight);
+	if(FAILED(hr))
+	{
+		AtlThrow(hr);
+	}
+	return tResult;
+}
+
+inline LPVOID AtlCoTaskMemCAlloc(ULONG nCount, ULONG nSize)
+{
+	HRESULT hr;
+	ULONG nBytes=0;
+	if( FAILED(hr=::ATL::AtlMultiply(&nBytes, nCount, nSize)))
+	{
+		return NULL;
+	}
+	return ::CoTaskMemAlloc(nBytes);
+}
+
+inline LPVOID AtlCoTaskMemRecalloc(void	*pvMemory, ULONG nCount, 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_bcount_part(s1max,n) void *s1, __in size_t s1max, __in_bcount(n) const void *s2, __in size_t n);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Allocation helpers
+
+class CCRTAllocator 
+{
+public:
+	static void* Reallocate(void* p, size_t nBytes) throw()
+	{
+		return realloc(p, nBytes);
+	}
+
+	static void* Allocate(size_t nBytes) throw()
+	{
+		return malloc(nBytes);
+	}
+
+	static void Free(void* p) throw()
+	{
+		free(p);
+	}
+};
+
+class CLocalAllocator
+{
+public:
+	static void* Allocate(size_t nBytes) throw()
+	{
+		return ::LocalAlloc(LMEM_FIXED, nBytes);
+	}
+	static void* Reallocate(void* p, 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(void* p) throw()
+	{
+		::LocalFree(p);
+	}
+};
+
+class CGlobalAllocator
+{
+public:
+	static void* Allocate(size_t nBytes) throw()
+	{
+		return ::GlobalAlloc(GMEM_FIXED, nBytes);
+	}
+	static void* Reallocate(void* p, 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(void* p) throw()
+	{
+		::GlobalFree(p);
+	}
+};
+
+template <class T, class Allocator = CCRTAllocator>
+class CHeapPtrBase
+{
+protected:
+	CHeapPtrBase() throw() :
+		m_pData(NULL)
+	{
+	}
+	CHeapPtrBase(CHeapPtrBase<T, Allocator>& p) throw()
+	{
+		m_pData = p.Detach();  // Transfer ownership
+	}
+	explicit CHeapPtrBase(T* pData) throw() :
+		m_pData(pData)
+	{
+	}
+
+public:
+	~CHeapPtrBase() throw()
+	{
+		Free();
+	}
+
+protected:
+	CHeapPtrBase<T, Allocator>& operator=(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()
+	{
+#if defined(ATLASSUME)
+		ATLASSUME(m_pData == NULL);
+#endif
+		return &m_pData;
+	}
+
+	// Allocate a buffer with the given number of bytes
+	bool AllocateBytes(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(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(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(CHeapPtr<T, Allocator>& p) throw() :
+		CHeapPtrBase<T, Allocator>(p)
+	{
+	}
+	explicit CHeapPtr(T* p) throw() :
+		CHeapPtrBase<T, Allocator>(p)
+	{
+	}
+
+	CHeapPtr<T, Allocator>& operator=(CHeapPtr<T, Allocator>& p) throw()
+	{
+		CHeapPtrBase<T, Allocator>::operator=(p);
+
+		return *this;
+	}
+
+	// Allocate a buffer with the given number of elements
+	bool Allocate(size_t nElements = 1) throw()
+	{
+		size_t nBytes=0;
+		if(FAILED(::ATL::AtlMultiply(&nBytes, nElements, sizeof(T))))
+		{
+			return false;
+		}
+		return AllocateBytes(nBytes);
+	}
+
+	// Reallocate the buffer to hold a given number of elements
+	bool Reallocate(size_t nElements) throw()
+	{
+		size_t nBytes=0;
+		if(FAILED(::ATL::AtlMultiply(&nBytes, nElements, sizeof(T))))
+		{
+			return false;
+		}
+		return ReallocateBytes(nBytes);
+	}
+};
+
+template< typename T, int t_nFixedBytes = 128, class Allocator = CCRTAllocator >
+class CTempBuffer
+{
+public:
+	CTempBuffer() throw() :
+		m_p( NULL )
+	{
+	}
+	CTempBuffer( 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 );
+	}
+
+	T* Allocate( size_t nElements ) throw( ... )
+	{
+		return( AllocateBytes( ::ATL::AtlMultiplyThrow(nElements,sizeof( T )) ) );
+	}
+
+	T* Reallocate( size_t nElements ) throw( ... )
+	{
+		ATLENSURE(nElements < size_t(-1)/sizeof(T) );		
+		size_t nNewSize = nElements*sizeof( T ) ;
+				
+		if (m_p == NULL)
+			return 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
+		{
+			m_p = reinterpret_cast< T* >( m_abFixedBuffer );
+		}
+
+		return m_p;
+	}
+
+	T* AllocateBytes( 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:
+	ATL_NOINLINE void AllocateHeap( size_t nBytes )
+	{
+		T* p = static_cast< T* >( Allocator::Allocate( nBytes ) );
+		if( p == NULL )
+		{
+			AtlThrow( E_OUTOFMEMORY );
+		}
+		m_p = p;
+	}
+ 
+	ATL_NOINLINE void ReAllocateHeap( size_t nNewSize)
+	{
+		T* p = static_cast< T* >( Allocator::Reallocate(m_p, nNewSize) );
+		if ( p == NULL )
+		{
+			AtlThrow( E_OUTOFMEMORY );
+		}
+		m_p = p;
+	}
+
+	ATL_NOINLINE 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).
+//The use of __try/__except preverts inlining in this case.
+#if (_ATL_VER > 0x0301)
+inline bool _AtlVerifyStackAvailable(SIZE_T Size)
+{
+    bool bStackAvailable = true;
+
+    __try
+    {
+		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);
+			if (p)
+			{
+				(p);
+			}
+		}
+    }
+    __except ((EXCEPTION_STACK_OVERFLOW == GetExceptionCode()) ?
+                   EXCEPTION_EXECUTE_HANDLER :
+                   EXCEPTION_CONTINUE_SEARCH)
+    {
+        bStackAvailable = false;
+        _resetstkoflw();
+    }
+    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) {};
+	void* Allocate(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);
+		}
+	}
+};
+#endif
+
+}	// 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.
+
+#if (_ATL_VER > 0x0301)
+
+// 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
+#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))
+#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
+
+#if (_ATL_VER <= 0x0301) // from atlbase.h
+
+class CComAllocator 
+{
+public:
+	static void* Reallocate(void* p, size_t nBytes) throw()
+	{
+#ifdef _WIN64
+		if( nBytes > INT_MAX )
+		{
+			return( NULL );
+		}
+#endif
+		return ::CoTaskMemRealloc(p, ULONG(nBytes));
+	}
+	static void* Allocate(size_t nBytes) throw()
+	{
+#ifdef _WIN64
+		if( nBytes > INT_MAX )
+		{
+			return( NULL );
+		}
+#endif
+		return ::CoTaskMemAlloc(ULONG(nBytes));
+	}
+	static void Free(void* p) throw()
+	{
+		::CoTaskMemFree(p);
+	}
+};
+
+template <typename T>
+class CComHeapPtr :
+	public CHeapPtr<T, CComAllocator>
+{
+public:
+	CComHeapPtr() throw()
+	{
+	}
+
+	explicit CComHeapPtr(T* pData) throw() :
+		CHeapPtr<T, CComAllocator>(pData)
+	{
+	}
+};
+
+#endif
+

cpp/jacob/include/atlbase.inl

@@ -0,0 +1,428 @@
+// 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(IUnknown* pUnkCP, IUnknown* pUnk, const IID& iid, 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(IUnknown* pUnkCP, const IID& iid, 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(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;
+}
+
+ATLINLINE ATLAPI AtlMarshalPtrInProc(IUnknown* pUnk, const IID& iid, 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;
+}
+
+ATLINLINE ATLAPI AtlUnmarshalPtr(IStream* pStream, const IID& iid, 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
+
+ATLINLINE ATLAPI AtlComModuleGetClassObject(_ATL_COM_MODULE* pComModule, REFCLSID rclsid, REFIID riid, LPVOID* ppv)
+{
+	ATLASSERT(pComModule != NULL);
+	if (pComModule == NULL)
+		return E_INVALIDARG;
+	if (pComModule->cbSize == 0)  // Module hasn't been initialized
+		return E_UNEXPECTED;
+
+	if (ppv == NULL)
+		return E_POINTER;
+	*ppv = NULL;
+
+	HRESULT hr = S_OK;
+
+	for (_ATL_OBJMAP_ENTRY** ppEntry = pComModule->m_ppAutoObjMapFirst; ppEntry < pComModule->m_ppAutoObjMapLast; ppEntry++)
+	{
+		if (*ppEntry != NULL)
+		{
+			_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))
+					{
+						ATLTRACE(atlTraceCOM, 0, _T("ERROR : Unable to lock critical section in AtlComModuleGetClassObject\n"));
+						ATLASSERT(0);
+						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;
+}
+
+ATLINLINE ATLAPI AtlComModuleRegisterClassObjects(_ATL_COM_MODULE* pComModule, DWORD dwClsContext, 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(_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(HANDLE hEvent)
+{
+	DWORD dwRet;
+	MSG msg;
+
+	while(1)
+	{
+		dwRet = MsgWaitForMultipleObjects(1, &hEvent, FALSE, INFINITE, QS_ALLINPUT);
+
+		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
+
+ATLINLINE ATLAPI AtlInternalQueryInterface(void* pThis,
+	const _ATL_INTMAP_ENTRY* pEntries, REFIID iid, 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;
+}
+
+ATLINLINE ATLAPI_(DWORD) AtlGetVersion(void* /* pReserved */)
+{
+	return _ATL_VER;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Windowing
+
+ATLINLINE ATLAPI_(void) AtlWinModuleAddCreateWndData(_ATL_WIN_MODULE* pWinModule, _AtlCreateWndData* pData, 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()))
+	{
+		ATLTRACE(atlTraceWindowing, 0, _T("ERROR : Unable to lock critical section in AtlWinModuleAddCreateWndData\n"));
+		ATLASSERT(0);
+		return;
+	}
+	pData->m_pNext = pWinModule->m_pCreateWndList;
+	pWinModule->m_pCreateWndList = pData;
+}
+
+ATLINLINE ATLAPI_(void*) AtlWinModuleExtractCreateWndData(_ATL_WIN_MODULE* pWinModule)
+{
+	if (pWinModule == NULL)
+		return NULL;
+
+	void* pv = NULL;
+	CComCritSecLock<CComCriticalSection> lock(pWinModule->m_csWindowCreate, false);
+	if (FAILED(lock.Lock()))
+	{
+		ATLTRACE(atlTraceWindowing, 0, _T("ERROR : Unable to lock critical section in AtlWinModuleExtractCreateWndData\n"));
+		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(_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))
+	{
+		ATLTRACE(atlTraceWindowing, 0, _T("ERROR : Unable to initialize critical section in AtlWinModuleInit\n"));
+		ATLASSERT(0);
+	}
+	return hr;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Module
+
+ATLINLINE ATLAPI AtlModuleAddTermFunc(_ATL_MODULE* pModule, _ATL_TERMFUNC* pFunc, 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;
+			ATLTRACE(atlTraceGeneral, 0, _T("ERROR : Unable to lock critical section in AtlModuleAddTermFunc\n"));
+			ATLASSERT(0);
+		}
+	}
+	return hr;
+}
+
+ATLINLINE ATLAPI_(void) AtlCallTermFunc(_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__
+

cpp/jacob/include/atlchecked.h

@@ -0,0 +1,605 @@
+// 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 warning(push)
+#pragma warning(disable:4127)
+
+#pragma pack(push,_ATL_PACKING)
+namespace ATL
+{
+
+inline errno_t AtlCrtErrorCheck(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
+{
+
+#if _SECURE_ATL
+
+#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_bcount_part(_S1max,_N)  void *_S1, __in size_t _S1max, __in_bcount(_N) const void *_S2, __in size_t _N)
+{
+	ATLMFC_CRT_ERRORCHECK(::memcpy_s(_S1, _S1max, _S2, _N));
+}
+
+inline void __cdecl wmemcpy_s(__out_ecount_part(_N1,_N) wchar_t *_S1, __in size_t _N1, __in_ecount(_N) const wchar_t *_S2, __in size_t _N)
+{
+	ATLMFC_CRT_ERRORCHECK(::wmemcpy_s(_S1, _N1, _S2, _N));
+}
+
+inline void __cdecl memmove_s(__out_bcount_part(_S1max,_N) void *_S1, __in size_t _S1max, __in_bcount(_N) const void *_S2, size_t _N)
+{
+	ATLMFC_CRT_ERRORCHECK(::memmove_s(_S1, _S1max, _S2, _N));
+}
+
+inline void __cdecl strcpy_s(__out_ecount(_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_ecount(_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_ecount(_SizeInChars) TCHAR * _Dst, __in size_t _SizeInChars, __in_z const TCHAR * _Src)
+{
+#ifndef _ATL_MIN_CRT
+	ATLMFC_CRT_ERRORCHECK(::_tcscpy_s(_Dst, _SizeInChars, _Src));
+#else
+#ifdef UNICODE
+	ATLMFC_CRT_ERRORCHECK(::wcscpy_s(_Dst, _SizeInChars, _Src));
+#else
+	ATLMFC_CRT_ERRORCHECK(::strcpy_s(_Dst, _SizeInChars, _Src));
+#endif
+#endif
+}
+
+inline errno_t __cdecl strncpy_s(__out_ecount(_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_ecount(_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_ecount(_SizeInChars) TCHAR *_Dest, __in size_t _SizeInChars, __in_z const TCHAR *_Source, __in size_t _Count)
+{
+#ifndef _ATL_MIN_CRT
+	return ATLMFC_CRT_ERRORCHECK(::_tcsncpy_s(_Dest, _SizeInChars, _Source,_Count));	
+#else
+#ifdef UNICODE
+	return ATLMFC_CRT_ERRORCHECK(::wcsncpy_s(_Dest, _SizeInChars, _Source,_Count));	
+#else
+	return ATLMFC_CRT_ERRORCHECK(::strncpy_s(_Dest, _SizeInChars, _Source,_Count));	
+#endif
+#endif
+}
+
+inline void __cdecl strcat_s(__inout_ecount_z(_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_ecount_z(_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_ecount_z(_SizeInChars) TCHAR * _Dst, __in size_t _SizeInChars, __in_z const TCHAR * _Src)
+{
+#ifndef _ATL_MIN_CRT
+	ATLMFC_CRT_ERRORCHECK(::_tcscat_s(_Dst, _SizeInChars, _Src));
+#else
+#ifdef UNICODE
+	ATLMFC_CRT_ERRORCHECK(::wcscat_s(_Dst, _SizeInChars, _Src));
+#else
+	ATLMFC_CRT_ERRORCHECK(::strcat_s(_Dst, _SizeInChars, _Src));
+#endif
+#endif
+}
+
+inline void __cdecl strlwr_s(__inout_ecount_z(_SizeInChars) char * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_strlwr_s(_Str, _SizeInChars));	
+}
+
+inline void __cdecl wcslwr_s(__inout_ecount_z(_SizeInChars) wchar_t * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_wcslwr_s(_Str, _SizeInChars));	
+}
+
+#if !defined(_MANAGED)
+inline void __cdecl mbslwr_s(__inout_bcount_z(_SizeInChars) unsigned char * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_mbslwr_s(_Str, _SizeInChars));	
+}
+#endif
+
+inline void __cdecl tcslwr_s(__inout_ecount_z(_SizeInChars) TCHAR * _Str, __in size_t _SizeInChars)
+{
+#ifndef _ATL_MIN_CRT
+	ATLMFC_CRT_ERRORCHECK(::_tcslwr_s(_Str, _SizeInChars));	
+#else
+#ifdef UNICODE
+	ATLMFC_CRT_ERRORCHECK(::_wcslwr_s(_Str, _SizeInChars));	
+#else
+	ATLMFC_CRT_ERRORCHECK(::_strlwr_s(_Str, _SizeInChars));	
+#endif
+#endif
+}
+
+inline void __cdecl strupr_s(__inout_ecount_z(_SizeInChars) char * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_strupr_s(_Str, _SizeInChars));	
+}
+
+inline void __cdecl wcsupr_s(__inout_ecount_z(_SizeInChars) wchar_t * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_wcsupr_s(_Str, _SizeInChars));	
+}
+
+#if !defined(_MANAGED)
+inline void __cdecl mbsupr_s(__inout_bcount_z(_SizeInChars) unsigned char * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_mbsupr_s(_Str, _SizeInChars));	
+}
+#endif
+
+inline void __cdecl tcsupr_s(__inout_ecount_z(_SizeInChars) TCHAR * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_tcsupr_s(_Str, _SizeInChars));	
+}
+
+inline void __cdecl itoa_s(__in int _Val, __out_ecount_z(_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_ecount_z(_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_ecount_z(_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_ecount_z(_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_ecount_z(_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_ecount_z(_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_ecount_z(_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_ecount_z(_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_ecount_z(_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_ecount_z(_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_ecount_z(_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_ecount_z(_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_ecount_z_opt(_Drive_len) TCHAR *_Drive, __in size_t _Drive_len, 
+	__out_ecount_z_opt(_Dir_len) TCHAR *_Dir, __in size_t _Dir_len, 
+	__out_ecount_z_opt(_Fname_len) TCHAR *_Fname, __in size_t _Fname_len, 
+	__out_ecount_z_opt(_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_ecount_z(_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_ecount(_Maxsize) const char *_Str, __in size_t _Maxsize)
+{
+	return ::strnlen(_Str, _Maxsize);
+}
+
+inline size_t __cdecl wcsnlen(__in_ecount(_Maxsize) const wchar_t *_Wcs, __in size_t _Maxsize)
+{
+	return ::wcsnlen(_Wcs, _Maxsize);
+}
+
+inline size_t __cdecl tcsnlen(__in_ecount(_Maxsize) const TCHAR *_Str, __in size_t _Maxsize)
+{
+	return ::_tcsnlen(_Str, _Maxsize);
+}
+
+inline int get_errno()
+{
+	int nErrNo;
+	ATLMFC_CRT_ERRORCHECK(::_get_errno(&nErrNo));
+	return nErrNo;
+}
+
+inline void set_errno(__in int _Value)
+{
+	ATLMFC_CRT_ERRORCHECK(::_set_errno(_Value));
+}
+
+#else // !_SECURE_ATL
+
+#define ATLMFC_CRT_ERRORCHECK(expr) do { expr; } while (0)
+
+inline void __cdecl memcpy_s(__out_bcount(_S1max) void *_S1, __in size_t _S1max, __in_bcount(_N) const void *_S2, size_t _N)
+{
+	(_S1max);
+	memcpy(_S1, _S2, _N);
+}
+
+inline void __cdecl wmemcpy_s(__out_ecount(_N1) wchar_t *_S1, __in size_t _N1, __in_ecount(_N) const wchar_t *_S2, __in size_t _N)
+{
+	(_N1);
+	::wmemcpy(_S1, _S2, _N);
+}
+
+inline void __cdecl memmove_s(__out_bcount(_S1max) void *_S1, __in size_t _S1max, __in_bcount(_N) const void *_S2, __in size_t _N)
+{
+	(_S1max);
+	memmove(_S1, _S2, _N);
+}
+
+inline void __cdecl strcpy_s(__out_ecount_z(_S1max) char *_S1, __in size_t _S1max, __in_z const char *_S2)
+{
+	(_S1max);
+	::strcpy(_S1, _S2);
+}
+
+inline void __cdecl wcscpy_s(__out_ecount_z(_S1max) wchar_t *_S1, __in size_t _S1max, __in_z const wchar_t *_S2)
+{
+	(_S1max);
+	::wcscpy(_S1, _S2);
+}
+
+inline void __cdecl tcscpy_s(__out_ecount_z(_SizeInChars) TCHAR * _Dst, __in size_t _SizeInChars, __in_z const TCHAR * _Src)
+{
+	(_SizeInChars);
+#ifndef _ATL_MIN_CRT
+	::_tcscpy(_Dst, _Src);
+#else
+#ifdef UNICODE
+	::wcscpy(_Dst, _Src);
+#else
+	::strcpy(_Dst, _Src);
+#endif
+#endif
+}
+
+/* ensure that strncpy_s null-terminate the dest string */
+inline errno_t __cdecl strncpy_s(__out_ecount_z(_SizeInChars) char *_Dest, __in size_t _SizeInChars, __in_z const char *_Source,__in size_t _Count)
+{
+	if (_Count == _TRUNCATE)
+	{
+		_Count = _SizeInChars - 1;
+	}
+	while (_Count > 0 && *_Source != 0)
+	{
+		*_Dest++ = *_Source++;
+		--_Count;
+	}
+	*_Dest = 0;
+
+	return (*_Source!=0) ? STRUNCATE : 0;
+}
+
+inline errno_t __cdecl wcsncpy_s(__out_ecount_z(_SizeInChars) wchar_t *_Dest, __in size_t _SizeInChars, __in_z const wchar_t *_Source, __in size_t _Count)
+{
+	if (_Count == _TRUNCATE)
+	{
+		_Count = _SizeInChars - 1;
+	}
+	while (_Count > 0 && *_Source != 0)
+	{
+		*_Dest++ = *_Source++;
+		--_Count;
+	}
+	*_Dest = 0;
+
+	return (*_Source!=0) ? STRUNCATE : 0;
+}
+
+inline errno_t __cdecl tcsncpy_s(__out_ecount_z(_SizeInChars) TCHAR *_Dest, __in size_t _SizeInChars, __in_z const TCHAR *_Source,__in size_t _Count)
+{
+	if (_Count == _TRUNCATE)
+	{
+		if(_SizeInChars>0)
+		{
+			_Count = _SizeInChars - 1;
+		}
+		else
+		{
+			_Count =0;
+		}
+	}
+
+#ifndef _ATL_MIN_CRT
+#pragma warning(push)
+#pragma warning(disable: 6535)
+	::_tcsncpy(_Dest,_Source,_Count);
+#pragma warning(pop)
+	if(_SizeInChars>0)
+	{
+		size_t nulCount = __min(_SizeInChars-1, _Count);
+		_Dest[nulCount] = 0;
+	}
+#else
+	while (_Count > 0 && *_Source != 0)
+	{
+		*_Dest++ = *_Source++;
+		--_Count;
+	}
+	*_Dest = 0;
+#endif
+
+	return (*_Source!=0) ? STRUNCATE : 0;
+}
+
+inline void __cdecl strcat_s(__inout_ecount_z(_SizeInChars) char * _Dst, __in size_t _SizeInChars, __in_z const char * _Src)
+{
+	(_SizeInChars);
+	::strcat(_Dst, _Src);
+}
+
+inline void __cdecl wcscat_s(__inout_ecount_z(_SizeInChars) wchar_t * _Dst, __in size_t _SizeInChars, __in_z const wchar_t * _Src)
+{
+	(_SizeInChars);
+	::wcscat(_Dst, _Src);
+}
+
+inline void __cdecl tcscat_s(__inout_ecount_z(_SizeInChars) TCHAR * _Dst, __in size_t _SizeInChars, __in_z const TCHAR * _Src)
+{
+	(_SizeInChars);
+#ifndef _ATL_MIN_CRT
+	::_tcscat(_Dst, _Src);
+#else
+#ifdef UNICODE
+	::wcscat(_Dst, _Src);
+#else
+	::strcat(_Dst, _Src);
+#endif
+#endif
+}
+
+inline void __cdecl strlwr_s(__inout_ecount_z(_SizeInChars) char * _Str, size_t _SizeInChars)
+{
+	(_SizeInChars);
+	::_strlwr(_Str);	
+}
+
+inline void __cdecl wcslwr_s(__inout_ecount_z(_SizeInChars) wchar_t * _Str, size_t _SizeInChars)
+{
+	(_SizeInChars);
+	::_wcslwr(_Str);	
+}
+
+inline void __cdecl mbslwr_s(__inout_bcount_z(_SizeInChars) unsigned char * _Str, size_t _SizeInChars)
+{
+	(_SizeInChars);
+	::_mbslwr(_Str);
+}
+
+inline void __cdecl tcslwr_s(__inout_ecount_z(_SizeInChars) TCHAR * _Str, size_t _SizeInChars)
+{
+	(_SizeInChars);
+#ifndef _ATL_MIN_CRT
+	::_tcslwr(_Str);
+#else
+#ifdef UNICODE
+	::_wcslwr(_Str);
+#else
+	::_strlwr(_Str);
+#endif
+#endif
+}
+
+inline void __cdecl itoa_s(__in int _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_itoa_s(_Val, _Buf, _SizeInChars, _Radix);
+}
+
+inline void __cdecl itot_s(__in int _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_itot(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ltoa_s(__in long _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ltoa(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ltot_s(__in long _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ltot(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ultoa_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ultoa(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ultow_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ultow(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ultot_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ultot(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl i64toa_s(__in __int64 _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_i64toa(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl i64tow_s(__in __int64 _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_i64tow(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ui64toa_s(__in unsigned __int64 _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ui64toa(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ui64tow_s(__in unsigned __int64 _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ui64tow(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl gcvt_s(__out_ecount_z(_SizeInChars) char *_Buffer, __in size_t _SizeInChars, __in double _Value, __in int _Ndec)
+{
+	(_SizeInChars);
+	::_gcvt(_Value, _Ndec, _Buffer);
+}
+
+inline void __cdecl tsplitpath_s(__in_z const TCHAR *_Path, __out_ecount_z_opt(_Drive_len) TCHAR *_Drive, __in size_t _Drive_len, 
+	__out_ecount_z_opt(_Dir_len) TCHAR *_Dir, __in size_t _Dir_len, 
+	__out_ecount_z_opt(_Fname_ext) TCHAR *_Fname, __in size_t _Fname_len, 
+	__out_ecount_z_opt(_Ext_len) TCHAR *_Ext, __in size_t _Ext_len)
+{
+	(_Drive_len, _Dir_len, _Fname_len, _Ext_len);
+	::_tsplitpath(_Path, _Drive, _Dir, _Fname, _Ext);
+}
+
+inline void __cdecl tmakepath_s(__out_ecount_z(_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)
+{
+	(_SizeInChars);
+	::_tmakepath(_Path, _Drive, _Dir, _Fname, _Ext);
+}
+
+inline size_t __cdecl strnlen(__in_ecount(_Maxsize) const char *_Str, __in size_t _Maxsize)
+{
+	(_Maxsize);
+	return ::strlen(_Str);
+}
+
+inline size_t __cdecl wcsnlen(__in_ecount(_Maxsize) const wchar_t *_Wcs, __in size_t _Maxsize)
+{
+	(_Maxsize);
+	return ::wcslen(_Wcs);
+}
+
+inline size_t __cdecl tcsnlen(__in_ecount(_Maxsize) const TCHAR *_Str, __in size_t _Maxsize)
+{
+	(_Maxsize);
+	return ::_tcslen(_Str);
+}
+
+inline int get_errno()
+{
+	return errno;
+}
+
+inline void set_errno(__in int _Value)
+{
+	errno = _Value;
+}
+
+#endif // _SECURE_ATL
+
+} // namespace Checked
+
+} // namespace ATL
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // __ATLCHECKED_H__
+
+/////////////////////////////////////////////////////////////////////////////
+

cpp/jacob/include/atlcore.h

@@ -0,0 +1,554 @@
+// 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>
+
+#pragma pack(push,_ATL_PACKING)
+namespace ATL
+{
+/////////////////////////////////////////////////////////////////////////////
+// Verify that a null-terminated string points to valid memory
+inline BOOL AtlIsValidString(LPCWSTR psz, size_t nMaxLength = INT_MAX)
+{
+	(nMaxLength);
+	return (psz != NULL);
+}
+
+// Verify that a null-terminated string points to valid memory
+inline BOOL AtlIsValidString(LPCSTR psz, size_t nMaxLength = UINT_MAX)
+{
+	(nMaxLength);
+	return (psz != NULL);
+}
+
+// Verify that a pointer points to valid memory
+inline BOOL AtlIsValidAddress(const void* p, size_t nBytes,
+	BOOL bReadWrite = TRUE)
+{
+	(bReadWrite);
+	(nBytes);
+	return (p != NULL);
+}
+
+template<typename T>
+inline void AtlAssertValidObject(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 = E_FAIL;
+		__try
+		{
+			InitializeCriticalSection(&m_sec);
+			hRes = S_OK;
+		}
+		// structured exception may be raised in low memory situations
+		__except(STATUS_NO_MEMORY == GetExceptionCode())
+		{			
+			hRes = E_OUTOFMEMORY;		
+		}
+		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;
+	bool m_bNT5orWin98;
+	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(HINSTANCE hInst) throw()
+	{
+		return static_cast< HINSTANCE >(InterlockedExchangePointer((void**)&m_hInstResource, hInst));
+	}
+
+	bool AddResourceInstance(HINSTANCE hInst) throw();
+	bool RemoveResourceInstance(HINSTANCE hInst) throw();
+	HINSTANCE GetHInstanceAt(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;
+		__field_ecount(nLength) WCHAR achString[];
+	};
+#pragma warning(pop)	// C4200
+
+inline const ATLSTRINGRESOURCEIMAGE* _AtlGetStringResourceImage( HINSTANCE hInstance, HRSRC hResource, 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( HINSTANCE hInstance, UINT id ) throw()
+{
+	HRSRC hResource;
+
+	hResource = ::FindResource( hInstance, MAKEINTRESOURCE( ((id>>4)+1) ), RT_STRING );
+	if( hResource == NULL )
+	{
+		return( NULL );
+	}
+
+	return _AtlGetStringResourceImage( hInstance, hResource, id );
+}
+
+inline const ATLSTRINGRESOURCEIMAGE* AtlGetStringResourceImage( HINSTANCE hInstance, UINT id, WORD wLanguage ) throw()
+{
+	HRSRC hResource;
+
+	hResource = ::FindResourceEx( hInstance, RT_STRING, MAKEINTRESOURCE( ((id>>4)+1) ), wLanguage );
+	if( hResource == NULL )
+	{
+		return( NULL );
+	}
+
+	return _AtlGetStringResourceImage( hInstance, hResource, id );
+}
+
+inline const ATLSTRINGRESOURCEIMAGE* AtlGetStringResourceImage( 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( UINT id, 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_ecount_part_z(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(LPCTSTR lpName, LPCTSTR lpType, 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(UINT nID, LPCTSTR lpType, WORD wLanguage = 0) throw()
+{
+	return AtlFindResourceInstance(MAKEINTRESOURCE(nID), lpType, wLanguage);
+}
+
+inline HINSTANCE AtlFindStringResourceInstance(UINT nID, 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
+(
+    SAFEARRAY *psaArray,
+    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(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>(const wchar_t* p) throw()
+{
+	return const_cast< wchar_t* >( p+1 );
+}
+template<typename CharType>
+inline const CharType* AtlstrchrT(const CharType* p, 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(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(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)
+
+#pragma warning(push)
+#pragma warning(disable : 4068 28110)
+
+inline BOOL AtlConvertSystemTimeToVariantTime(const SYSTEMTIME& systimeSrc,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;
+}
+#pragma warning(pop)
+
+/////////////////////////////////////////////////////////////////////////////
+
+}	// namespace ATL
+#pragma pack(pop)
+
+#ifdef _ATL_ALL_WARNINGS
+#pragma warning( pop )
+#endif
+
+#endif	// __ATLCORE_H__
+

cpp/jacob/include/atldef.h

@@ -0,0 +1,668 @@
+
+// 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>
+
+#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
+
+#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
+
+#ifndef AtlThrow
+#ifndef _ATL_CUSTOM_THROW
+#define AtlThrow ATL::AtlThrowImpl
+#endif
+#endif // AtlThrow
+
+#ifndef ATLASSERT
+#define ATLASSERT(expr) _ASSERTE(expr)
+#endif // ATLASSERT
+
+/* 
+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 // ATLASSERT
+
+#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);            \
+	ATLASSERT(__atl_condVal);              \
+	if(!(__atl_condVal)) AtlThrow(hr);     \
+} while (0)
+#endif // ATLENSURE
+
+#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
+
+/* Used inside COM methods that do not want to throw */
+#ifndef ATLENSURE_RETURN_HR
+#define ATLENSURE_RETURN_HR(expr, hr)          \
+do {                                           \
+	int __atl_condVal=!!(expr);                \
+	ATLASSERT(__atl_condVal);                  \
+	if(!(__atl_condVal)) return hr;            \
+} while (0) 
+#endif 
+
+/* Used inside COM methods that do not want to throw */
+#ifndef ATLENSURE_RETURN
+#define ATLENSURE_RETURN(expr) ATLENSURE_RETURN_HR(expr, E_FAIL)
+#endif
+
+/* generic version that returns 2nd expr if 1st is false; no implication of HRESULT */
+#ifndef ATLENSURE_RETURN_VAL
+#define ATLENSURE_RETURN_VAL ATLENSURE_RETURN_HR
+#endif
+
+#if defined(_SECURE_ATL)
+#error Do not define _SECURE_ATL.
+#undef _SECURE_ATL
+#endif
+#define _SECURE_ATL 1
+
+#if _SECURE_ATL
+
+#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
+
+#else // !_SECURE_ATL
+
+#define ATL_CRT_ERRORCHECK(expr) do { expr; } while (0)
+#define ATL_CRT_ERRORCHECK_SPRINTF(expr) do { expr; } while (0)
+
+#endif // _SECURE_ATL
+
+///////////////////////////////////////////////////////////////////////////////
+// __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
+
+#if defined(_ATL_DISABLE_DEPRECATED) || (defined(_PREFAST_) && (_MSC_VER < 1400))
+#define ATL_DEPRECATED(_Message)
+#else
+#define ATL_DEPRECATED(_Message) __declspec( deprecated(_Message) )
+#endif
+
+// If ATL80.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 ATL80.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 0x0800 // Active Template Library version 8.00
+
+/////////////////////////////////////////////////////////////////////////////
+// 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
+
+#define ATLAXWIN_CLASS	"AtlAxWin80"
+#define ATLAXWINLIC_CLASS "AtlAxWinLic80"
+
+// _ATL_INSECURE_DEPRECATE define
+#ifndef _ATL_INSECURE_DEPRECATE
+#if defined(_ATL_SECURE_NO_DEPRECATE) || (defined(_PREFAST_) && (_MSC_VER < 1400))
+#define _ATL_INSECURE_DEPRECATE(_Message)
+#else
+#define _ATL_INSECURE_DEPRECATE(_Message) __declspec(deprecated(_Message))
+#endif // _ATL_SECURE_NO_DEPRECATE
+#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
+#define PTM_WARNING_DISABLE \
+	__pragma(warning( push )) \
+	__pragma(warning( disable : 4867 ))
+#define PTM_WARNING_RESTORE \
+	__pragma(warning( pop ))
+#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)
+#if(WINVER >= 0x0400)
+#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)
+#endif /* WINVER >= 0x0400 */
+#define ATL_RT_HTML         ATL_MAKEINTRESOURCE(23)
+#ifdef RC_INVOKED
+#define ATL_RT_MANIFEST                        24
+#define ATL_CREATEPROCESS_MANIFEST_RESOURCE_ID  1
+#define ATL_ISOLATIONAWARE_MANIFEST_RESOURCE_ID 2
+#define ATL_ISOLATIONAWARE_NOSTATICIMPORT_MANIFEST_RESOURCE_ID 3
+#define ATL_MINIMUM_RESERVED_MANIFEST_RESOURCE_ID 1   /* inclusive */
+#define ATL_MAXIMUM_RESERVED_MANIFEST_RESOURCE_ID 16  /* inclusive */
+#else  /* RC_INVOKED */
+#define ATL_RT_MANIFEST                        ATL_MAKEINTRESOURCE(24)
+#define ATL_CREATEPROCESS_MANIFEST_RESOURCE_ID ATL_MAKEINTRESOURCE( 1)
+#define ATL_ISOLATIONAWARE_MANIFEST_RESOURCE_ID ATL_MAKEINTRESOURCE(2)
+#define ATL_ISOLATIONAWARE_NOSTATICIMPORT_MANIFEST_RESOURCE_ID ATL_MAKEINTRESOURCE(3)
+#define ATL_MINIMUM_RESERVED_MANIFEST_RESOURCE_ID ATL_MAKEINTRESOURCE( 1 /*inclusive*/)
+#define ATL_MAXIMUM_RESERVED_MANIFEST_RESOURCE_ID ATL_MAKEINTRESOURCE(16 /*inclusive*/)
+#endif /* RC_INVOKED */
+
+/* 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
+
+#endif // __ATLDEF_H__
+
+/////////////////////////////////////////////////////////////////////////////
+

cpp/jacob/include/atlexcept.h

@@ -0,0 +1,123 @@
+// 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
+
+#include <atldef.h>
+#include <atltrace.h>
+
+
+#pragma pack(push,_ATL_PACKING)
+namespace ATL
+{
+
+/////////////////////////////////////////////////////////////////////////////
+// Exception raise (for functions that cannot return an error code)
+
+inline void __declspec(noreturn) _AtlRaiseException( DWORD dwExceptionCode, DWORD dwExceptionFlags = EXCEPTION_NONCONTINUABLE )
+{
+	RaiseException( dwExceptionCode, dwExceptionFlags, 0, NULL );
+}
+
+class CAtlException
+{
+public:
+	CAtlException() throw() :
+		m_hr( E_FAIL )
+	{
+	}
+
+	CAtlException( HRESULT hr ) throw() :
+		m_hr( hr )
+	{
+	}
+
+	operator HRESULT() const throw()
+	{
+		return( m_hr );
+	}
+
+public:
+	HRESULT m_hr;
+};
+
+#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( HRESULT hr )
+{
+	ATLTRACE(atlTraceException, 0, _T("AtlThrow: hr = 0x%x\n"), hr );
+#ifdef _AFX
+	if( hr == E_OUTOFMEMORY )
+	{
+		AfxThrowMemoryException();
+	}
+	else
+	{
+		AfxThrowOleException( hr );
+	}
+#else
+	throw CAtlException( hr );
+#endif
+};
+#endif
+
+// Throw a CAtlException corresponding to the result of ::GetLastError
+ATL_NOINLINE __declspec(noreturn) inline void WINAPI AtlThrowLastWin32()
+{
+	DWORD dwError = ::GetLastError();
+	AtlThrow( HRESULT_FROM_WIN32( dwError ) );
+}
+
+#else  // no exception handling
+
+// Throw a CAtlException with the given HRESULT
+#if !defined( _ATL_CUSTOM_THROW )  // You can define your own AtlThrow
+
+ATL_NOINLINE inline void WINAPI AtlThrowImpl( HRESULT hr )
+{
+	ATLTRACE(atlTraceException, 0, _T("AtlThrow: hr = 0x%x\n"), hr );
+	ATLASSERT( false );
+	DWORD dwExceptionCode;
+	switch(hr)
+	{
+	case E_OUTOFMEMORY:
+		dwExceptionCode = DWORD(STATUS_NO_MEMORY);
+		break;
+	default:
+		dwExceptionCode = DWORD(EXCEPTION_ILLEGAL_INSTRUCTION);
+		break;
+	}
+	_AtlRaiseException(dwExceptionCode);
+}
+#endif
+
+// Throw a CAtlException corresponding to the result of ::GetLastError
+ATL_NOINLINE inline void WINAPI AtlThrowLastWin32()
+{
+	DWORD dwError = ::GetLastError();
+	AtlThrow( HRESULT_FROM_WIN32( dwError ) );
+}
+
+#endif  // no exception handling
+
+};  // namespace ATL
+#pragma pack(pop)
+
+#endif  // __ATLEXCEPT_H__
+

cpp/jacob/include/atlrc.h

@@ -0,0 +1,28 @@
+// 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__
+

cpp/jacob/include/atlsimpcoll.h

@@ -0,0 +1,489 @@
+// 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>
+
+#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(const T& t1, const T& t2)
+	{
+		return (t1 == t2);
+	}
+};
+
+template <class T>
+class CSimpleArrayEqualHelperFalse
+{
+public:
+	static bool IsEqual(const T&, const T&)
+	{
+		ATLASSERT(false);
+		return false;
+	}
+};
+
+template <class TKey, class TVal>
+class CSimpleMapEqualHelper
+{
+public:
+	static bool IsEqualKey(const TKey& k1, const TKey& k2)
+	{
+		return CSimpleArrayEqualHelper<TKey>::IsEqual(k1, k2);
+	}
+
+	static bool IsEqualValue(const TVal& v1, const TVal& v2)
+	{
+		return CSimpleArrayEqualHelper<TVal>::IsEqual(v1, v2);
+	}
+};
+
+template <class TKey, class TVal>
+class CSimpleMapEqualHelperFalse
+{
+public:
+	static bool IsEqualKey(const TKey& k1, const TKey& k2)
+	{
+		return CSimpleArrayEqualHelper<TKey>::IsEqual(k1, k2);
+	}
+
+	static bool IsEqualValue(const TVal&, 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(const CSimpleArray< T, TEqual >& src) : m_aT(NULL), m_nSize(0), m_nAllocSize(0)
+	{
+        if (src.GetSize())
+        {
+			m_aT = (T*)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=(const CSimpleArray< T, TEqual >& src)
+	{
+		if (GetSize() != src.GetSize())
+		{
+			RemoveAll();
+			m_aT = (T*)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(const T& t)
+		{
+			if(m_nSize == 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(const T& t)
+	{
+		int nIndex = Find(t);
+		if(nIndex == -1)
+			return FALSE;
+		return RemoveAt(nIndex);
+	}
+	BOOL RemoveAt(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();
+			free(m_aT);
+			m_aT = NULL;
+		}
+		m_nSize = 0;
+		m_nAllocSize = 0;
+    }   
+	const T& operator[] (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[] (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(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(int nIndex, const T& t)
+	{
+		if (nIndex < 0 || nIndex >= m_nSize)
+			return FALSE;
+		InternalSetAtIndex(nIndex, t);
+		return TRUE;
+	}
+
+// Implementation
+	class Wrapper
+	{
+	public:
+		Wrapper(const T& _t) : t(_t)
+		{
+		}
+		template <class _Ty>
+		void * __cdecl operator new(size_t, _Ty* p)
+		{
+			return p;
+		}
+		template <class _Ty>
+		void __cdecl operator delete(void* /* pv */, _Ty* /* p */)
+		{
+		}
+		T t;
+	};
+
+// Implementation
+	void InternalSetAtIndex(int nIndex, 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(const TKey& key, 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(const TKey& key)
+	{
+		int nIndex = FindKey(key);
+		if(nIndex == -1)
+			return FALSE;
+		return RemoveAt(nIndex);
+	}
+	BOOL RemoveAt(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();
+			}
+			free(m_aKey);
+			m_aKey = NULL;
+		}
+		if(m_aVal != NULL)
+		{
+			free(m_aVal);
+			m_aVal = NULL;
+		}
+
+		m_nSize = 0;
+	}
+	BOOL SetAt(const TKey& key, 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(const TKey& key) const
+	{
+		int nIndex = FindKey(key);
+		if(nIndex == -1)
+			return NULL;    // must be able to convert
+		return GetValueAt(nIndex);
+	}
+	TKey ReverseLookup(const TVal& val) const
+	{
+		int nIndex = FindVal(val);
+		if(nIndex == -1)
+			return NULL;    // must be able to convert
+		return GetKeyAt(nIndex);
+	}
+	TKey& GetKeyAt(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(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(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(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(int nIndex, const TKey& key, 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(const T& _t) : t(_t)
+		{
+		}
+		template <class _Ty>
+		void *operator new(size_t, _Ty* p)
+		{
+			return p;
+		}
+		template <class _Ty>
+		void operator delete(void* /* pv */, _Ty* /* p */)
+		{
+		}
+		T t;
+	};
+	void InternalSetAtIndex(int nIndex, const TKey& key, 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__
+

cpp/jacob/include/atltrace.h

@@ -0,0 +1,450 @@
+// 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>
+
+#ifdef _DEBUG
+#include <stdio.h>
+#include <stdarg.h>
+#endif
+
+#ifdef _DEBUG
+#include <atldebugapi.h>
+
+extern "C" IMAGE_DOS_HEADER __ImageBase;
+#endif  // _DEBUG
+ 
+
+#pragma pack(push,_ATL_PACKING)
+namespace ATL
+{
+
+// Declare a global instance of this class to automatically register a custom trace category at startup
+class CTraceCategory
+{
+public:
+	explicit CTraceCategory( LPCTSTR pszCategoryName, UINT nStartingLevel = 0 ) throw();
+
+#ifdef _DEBUG
+	UINT GetLevel() const throw();
+	void SetLevel( UINT nLevel ) throw();
+	ATLTRACESTATUS GetStatus() const throw();
+	void SetStatus( ATLTRACESTATUS eStatus) throw();
+#endif
+
+	operator DWORD_PTR() const throw();
+
+public:
+#ifdef _DEBUG
+	DWORD_PTR m_dwCategory;
+#endif
+};
+
+#ifdef _DEBUG
+
+class CTrace
+{
+public:
+	typedef int (__cdecl *fnCrtDbgReport_t)(int,const char *,int,const char *,const char *,...);
+
+private:
+	CTrace(
+#ifdef _ATL_NO_DEBUG_CRT
+		fnCrtDbgReport_t pfnCrtDbgReport = NULL)
+#else
+		fnCrtDbgReport_t pfnCrtDbgReport = _CrtDbgReport)
+#endif
+		: m_hInst(reinterpret_cast<HINSTANCE>(&__ImageBase)),
+			m_dwModule( 0 )
+	{
+		m_dwModule = AtlTraceRegister(m_hInst, pfnCrtDbgReport);
+	}
+
+	~CTrace()
+	{
+		AtlTraceUnregister(m_dwModule);
+	}
+
+public:
+	bool ChangeCategory(DWORD_PTR dwCategory, UINT nLevel, ATLTRACESTATUS eStatus)
+	{
+		return 0 !=
+			AtlTraceModifyCategory(0, dwCategory, nLevel, eStatus);
+	}
+
+	bool GetCategory(DWORD_PTR dwCategory, UINT *pnLevel, ATLTRACESTATUS *peStatus)
+	{
+		ATLASSERT(pnLevel && peStatus);
+		return 0 != AtlTraceGetCategory(0, dwCategory, pnLevel, peStatus);
+	}
+	UINT GetLevel()
+	{
+		ATLTRACESTATUS eStatus;
+		UINT nLevel;
+		AtlTraceGetModule(0, m_dwModule, &nLevel, &eStatus);
+
+		return nLevel;
+	}
+	void SetLevel(UINT nLevel)
+	{
+		AtlTraceModifyModule(0, m_dwModule, nLevel, ATLTRACESTATUS_ENABLED);
+	}
+	ATLTRACESTATUS GetStatus()
+	{
+		ATLTRACESTATUS eStatus;
+		UINT nLevel;
+		AtlTraceGetModule(0, m_dwModule, &nLevel, &eStatus);
+
+		return eStatus;
+	}
+	void SetStatus(ATLTRACESTATUS eStatus)
+	{
+		ATLTRACESTATUS eOldStatus;
+		UINT nLevel;
+		AtlTraceGetModule(0, m_dwModule, &nLevel, &eOldStatus);
+		AtlTraceModifyModule(0, m_dwModule, nLevel, eStatus);
+	}
+	void __cdecl TraceV(const char *pszFileName, int nLine,
+		DWORD_PTR dwCategory, UINT nLevel, LPCSTR pszFmt, va_list args) const;
+	void __cdecl TraceV(const char *pszFileName, int nLine,
+		DWORD_PTR dwCategory, UINT nLevel, LPCWSTR pszFmt, va_list args) const;
+
+	DWORD_PTR RegisterCategory(LPCSTR pszCategory)
+		{return(AtlTraceRegisterCategoryA(m_dwModule, pszCategory));}
+#ifdef _UNICODE
+	DWORD_PTR RegisterCategory(LPCWSTR pszCategory)
+		{return(AtlTraceRegisterCategoryU(m_dwModule, pszCategory));}
+#endif
+
+	bool LoadSettings(LPCTSTR pszFileName = NULL) const
+		{return 0 != AtlTraceLoadSettings(pszFileName);}
+	void SaveSettings(LPCTSTR pszFileName = NULL) const
+		{AtlTraceSaveSettings(pszFileName);}
+
+public:
+	static CTrace s_trace;
+
+protected:
+	HINSTANCE m_hInst;
+	DWORD_PTR m_dwModule;
+};
+
+    inline void __cdecl CTrace::TraceV(const char *pszFileName, int nLine,
+		DWORD_PTR dwCategory, UINT nLevel, LPCSTR pszFmt, va_list args) const
+	{
+		AtlTraceVA(m_dwModule, pszFileName, nLine, dwCategory, nLevel, pszFmt, args);
+	}
+	inline void __cdecl CTrace::TraceV(const char *pszFileName, int nLine,
+		DWORD_PTR dwCategory, UINT nLevel, LPCWSTR pszFmt, va_list args) const
+	{
+		AtlTraceVU(m_dwModule, pszFileName, nLine, dwCategory, nLevel, pszFmt, args);
+	}
+
+extern CTraceCategory atlTraceGeneral;
+
+class CTraceFileAndLineInfo
+{
+public:
+	CTraceFileAndLineInfo(const char *pszFileName, int nLineNo)
+		: m_pszFileName(pszFileName), m_nLineNo(nLineNo)
+	{}
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+	void __cdecl operator()(DWORD_PTR dwCategory, UINT nLevel, const char *pszFmt, ...) const
+	{
+		va_list ptr; va_start(ptr, pszFmt);
+		ATL::CTrace::s_trace.TraceV(m_pszFileName, m_nLineNo, dwCategory, nLevel, pszFmt, ptr);
+		va_end(ptr);
+	}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+	void __cdecl operator()(DWORD_PTR dwCategory, UINT nLevel, const wchar_t *pszFmt, ...) const
+	{
+		va_list ptr; va_start(ptr, pszFmt);
+		ATL::CTrace::s_trace.TraceV(m_pszFileName, m_nLineNo, dwCategory, nLevel, pszFmt, ptr);
+		va_end(ptr);
+	}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+	void __cdecl operator()(const char *pszFmt, ...) const
+	{
+		va_list ptr; va_start(ptr, pszFmt);
+		ATL::CTrace::s_trace.TraceV(m_pszFileName, m_nLineNo, atlTraceGeneral, 0, pszFmt, ptr);
+		va_end(ptr);
+	}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+	void __cdecl operator()(const wchar_t *pszFmt, ...) const
+	{
+		va_list ptr; va_start(ptr, pszFmt);
+		ATL::CTrace::s_trace.TraceV(m_pszFileName, m_nLineNo, atlTraceGeneral, 0, pszFmt, ptr);
+		va_end(ptr);
+	}
+#pragma warning(pop)
+
+private:
+	/* unimplemented */
+	CTraceFileAndLineInfo &__cdecl operator=(const CTraceFileAndLineInfo &right);
+
+	const char *const m_pszFileName;
+	const int m_nLineNo;
+};
+
+#endif  // _DEBUG
+
+#ifdef _DEBUG
+
+inline CTraceCategory::CTraceCategory( LPCTSTR pszCategoryName, UINT nStartingLevel ) throw() :
+	m_dwCategory( 0 )
+{
+	m_dwCategory = ATL::CTrace::s_trace.RegisterCategory( pszCategoryName );
+	ATL::CTrace::s_trace.ChangeCategory( m_dwCategory, nStartingLevel, ATLTRACESTATUS_INHERIT);
+}
+
+inline CTraceCategory::operator DWORD_PTR() const throw()
+{
+	return( m_dwCategory );
+}
+
+inline UINT CTraceCategory::GetLevel() const throw()
+{
+	UINT nLevel;
+	ATLTRACESTATUS eStatus;
+	ATL::CTrace::s_trace.GetCategory( m_dwCategory, &nLevel, &eStatus );
+
+	return( nLevel );
+}
+
+inline void CTraceCategory::SetLevel( UINT nLevel ) throw()
+{
+	ATL::CTrace::s_trace.ChangeCategory( m_dwCategory, nLevel, ATLTRACESTATUS_ENABLED );
+}
+
+inline ATLTRACESTATUS CTraceCategory::GetStatus() const throw()
+{
+	UINT nLevel;
+	ATLTRACESTATUS eStatus;
+	ATL::CTrace::s_trace.GetCategory( m_dwCategory, &nLevel, &eStatus );
+
+	return( eStatus );
+}
+
+inline void CTraceCategory::SetStatus( ATLTRACESTATUS eStatus ) throw()
+{
+	UINT nLevel;
+	ATLTRACESTATUS eOldStatus;
+	ATL::CTrace::s_trace.GetCategory( m_dwCategory, &nLevel, &eOldStatus );
+	ATL::CTrace::s_trace.ChangeCategory( m_dwCategory, nLevel, eStatus );
+}
+
+#else  // !_DEBUG
+
+inline CTraceCategory::CTraceCategory( LPCTSTR pszCategoryName, UINT nStartingLevel ) throw()
+{
+	(void)pszCategoryName;
+	(void)nStartingLevel;
+}
+
+inline CTraceCategory::operator DWORD_PTR() const throw()
+{
+	return( 0 );
+}
+
+#endif  // _DEBUG
+
+}  // namespace ATL
+ 
+namespace ATL
+{
+
+#ifdef _DEBUG
+#define DECLARE_TRACE_CATEGORY( name ) extern ATL::CTraceCategory name;
+#else
+#define DECLARE_TRACE_CATEGORY( name ) const DWORD_PTR name = 0;
+#endif
+
+DECLARE_TRACE_CATEGORY( atlTraceGeneral )
+DECLARE_TRACE_CATEGORY( atlTraceCOM )  
+DECLARE_TRACE_CATEGORY( atlTraceQI )	
+DECLARE_TRACE_CATEGORY( atlTraceRegistrar )
+DECLARE_TRACE_CATEGORY( atlTraceRefcount )
+DECLARE_TRACE_CATEGORY( atlTraceWindowing )
+DECLARE_TRACE_CATEGORY( atlTraceControls )
+DECLARE_TRACE_CATEGORY( atlTraceHosting ) 
+DECLARE_TRACE_CATEGORY( atlTraceDBClient )  
+DECLARE_TRACE_CATEGORY( atlTraceDBProvider )
+DECLARE_TRACE_CATEGORY( atlTraceSnapin )
+DECLARE_TRACE_CATEGORY( atlTraceNotImpl )   
+DECLARE_TRACE_CATEGORY( atlTraceAllocation )
+DECLARE_TRACE_CATEGORY( atlTraceException )
+DECLARE_TRACE_CATEGORY( atlTraceTime )
+DECLARE_TRACE_CATEGORY( atlTraceCache )		
+DECLARE_TRACE_CATEGORY( atlTraceStencil )
+DECLARE_TRACE_CATEGORY( atlTraceString )
+DECLARE_TRACE_CATEGORY( atlTraceMap )	
+DECLARE_TRACE_CATEGORY( atlTraceUtil )		
+DECLARE_TRACE_CATEGORY( atlTraceSecurity )
+DECLARE_TRACE_CATEGORY( atlTraceSync )
+DECLARE_TRACE_CATEGORY( atlTraceISAPI )		
+
+// atlTraceUser categories are no longer needed.  Just declare your own trace category using CTraceCategory.
+DECLARE_TRACE_CATEGORY( atlTraceUser )
+DECLARE_TRACE_CATEGORY( atlTraceUser2 )
+DECLARE_TRACE_CATEGORY( atlTraceUser3 )
+DECLARE_TRACE_CATEGORY( atlTraceUser4 )
+
+#pragma deprecated( atlTraceUser )
+#pragma deprecated( atlTraceUser2 )
+#pragma deprecated( atlTraceUser3 )
+#pragma deprecated( atlTraceUser4 )
+
+#ifdef _DEBUG
+
+#ifndef _ATL_NO_DEBUG_CRT
+class CNoUIAssertHook
+{
+public:
+	CNoUIAssertHook()
+	{
+		ATLASSERT( s_pfnPrevHook == NULL );
+		s_pfnPrevHook = _CrtSetReportHook(CrtHookProc);
+	}
+	~CNoUIAssertHook()
+	{
+		_CrtSetReportHook(s_pfnPrevHook);
+		s_pfnPrevHook = NULL;
+	}
+
+private:
+	static int __cdecl CrtHookProc(__in int eReportType, __in_z char* pszMessage, __out int* pnRetVal)
+	{
+		
+		if (eReportType == _CRT_ASSERT)
+		{
+			::OutputDebugStringA( "ASSERTION FAILED\n" );
+			::OutputDebugStringA( pszMessage );
+			//If caller doesn't want retVal, so be it.
+			if (pnRetVal != NULL)
+			{
+				*pnRetVal = 1;
+			}
+			return TRUE;
+		}
+
+		if (s_pfnPrevHook != NULL)
+		{
+			return s_pfnPrevHook(eReportType, pszMessage, pnRetVal);
+		}
+		else
+		{
+			return FALSE;
+		}
+	}
+
+private:
+	static _CRT_REPORT_HOOK s_pfnPrevHook;
+};
+
+__declspec( selectany ) _CRT_REPORT_HOOK CNoUIAssertHook::s_pfnPrevHook = NULL;
+
+#define DECLARE_NOUIASSERT() ATL::CNoUIAssertHook _g_NoUIAssertHook;
+
+#endif  // _ATL_NO_DEBUG_CRT
+
+#ifndef ATLTRACE
+#define ATLTRACE ATL::CTraceFileAndLineInfo(__FILE__, __LINE__)
+#define ATLTRACE2 ATLTRACE
+#endif
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+inline void __cdecl AtlTrace(LPCSTR pszFormat, ...)
+{
+	va_list ptr;
+	va_start(ptr, pszFormat);
+	ATL::CTrace::s_trace.TraceV(NULL, -1, atlTraceGeneral, 0, pszFormat, ptr);
+	va_end(ptr);
+}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+inline void __cdecl AtlTrace(LPCWSTR pszFormat, ...)
+{
+	va_list ptr;
+	va_start(ptr, pszFormat);
+	ATL::CTrace::s_trace.TraceV(NULL, -1, atlTraceGeneral, 0, pszFormat, ptr);
+	va_end(ptr);
+}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+inline void __cdecl AtlTrace2(DWORD_PTR dwCategory, UINT nLevel, LPCSTR pszFormat, ...)
+{
+	va_list ptr;
+	va_start(ptr, pszFormat);
+	ATL::CTrace::s_trace.TraceV(NULL, -1, dwCategory, nLevel, pszFormat, ptr);
+	va_end(ptr);
+}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+inline void __cdecl AtlTrace2(DWORD_PTR dwCategory, UINT nLevel, LPCWSTR pszFormat, ...)
+{
+	va_list ptr;
+	va_start(ptr, pszFormat);
+	ATL::CTrace::s_trace.TraceV(NULL, -1, dwCategory, nLevel, pszFormat, ptr);
+	va_end(ptr);
+}
+#pragma warning(pop)
+
+#define ATLTRACENOTIMPL(funcname)  do { ATLTRACE(ATL::atlTraceNotImpl, 0, _T("ATL: %s not implemented.\n"), funcname); return E_NOTIMPL; } while(0)
+
+#else // !DEBUG
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+inline void __cdecl AtlTraceNull(...){}
+inline void __cdecl AtlTrace(LPCSTR , ...){}
+inline void __cdecl AtlTrace2(DWORD_PTR, UINT, LPCSTR , ...){}
+inline void __cdecl AtlTrace(LPCWSTR , ...){}
+inline void __cdecl AtlTrace2(DWORD_PTR, UINT, LPCWSTR , ...){}
+#pragma warning(pop)
+
+#ifndef ATLTRACE
+
+#define ATLTRACE            __noop
+#define ATLTRACE2           __noop
+#endif //ATLTRACE
+#define ATLTRACENOTIMPL(funcname)   return E_NOTIMPL
+#define DECLARE_NOUIASSERT()
+
+#endif //!_DEBUG
+
+};  // namespace ATL
+#pragma pack(pop)
+
+#endif  // __ATLTRACE_H__
+