Changeset 482 for trunk/Common/alax.info


Ignore:
Timestamp:
Jul 2, 2015, 1:00:57 AM (7 years ago)
Author:
roman
Message:

Updated copyright notice

Location:
trunk/Common/alax.info
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/Common/alax.info/roatlcollections.h

    r466 r482  
    11////////////////////////////////////////////////////////////
     2// Template class library; extends Widnows SDK, ATL, WTL
     3//
    24// Copyright (C) Roman Ryltsov, 2006-2015
    35// Created by Roman Ryltsov roman@alax.info
    46//
    5 // A permission to use the source code is granted as long as reference to
    6 // source website http://alax.info is retained.
     7// A permission to re-use this source code is granted as long as copyright notice and
     8// reference to source website http://alax.info is retained.
    79
    810#pragma once
    911
    1012#include <atlcoll.h>
    11 
    12 #if !defined(_A)
    13         #define _A ATLASSERT
    14 #endif
    15 #if !defined(_W)
    16         #define _W ATLVERIFY
    17 #endif
    18 #if !defined(__D)
    19         #define __D ATLENSURE_THROW
    20 #endif
    2113
    2214////////////////////////////////////////////////////////////
  • trunk/Common/alax.info/roatlcom.h

    r321 r482  
    11////////////////////////////////////////////////////////////
    2 // Copyright (C) Roman Ryltsov, 2006-2014
     2// Template class library; extends Widnows SDK, ATL, WTL
     3//
     4// Copyright (C) Roman Ryltsov, 2006-2015
    35// Created by Roman Ryltsov roman@alax.info
    46//
    5 // A permission to use the source code is granted as long as reference to
    6 // source website http://alax.info is retained.
     7// A permission to re-use this source code is granted as long as copyright notice and
     8// reference to source website http://alax.info is retained.
    79
    810#pragma once
     
    1517#include "roatlcollections.h"
    1618
     19////////////////////////////////////////////////////////////
     20// Version
     21
    1722#if !defined(_WIN32_WINNT_WIN7)
    1823        #define _WIN32_WINNT_WIN7 0x0601
    1924#endif // !defined(_WIN32_WINNT_WIN7)
     25
     26#if !defined(_versionhelpers_H_INCLUDED_)
     27
     28inline bool IsWindowsVistaOrGreater()
     29{
     30        OSVERSIONINFOEX VersionInformation = { sizeof VersionInformation };
     31        GetVersionEx((OSVERSIONINFO*) &VersionInformation);
     32        return VersionInformation.dwMajorVersion >= 6; // Windows Vista, Windows Server 2008
     33}
     34
     35#endif // !defined(_versionhelpers_H_INCLUDED_)
    2036
    2137////////////////////////////////////////////////////////////
     
    367383public:
    368384// CObjectPtrT
    369         CLocalObjectPtr() throw()
     385        CLocalObjectPtr()
    370386        {
    371387                m_Instance.SetVoid(NULL);
    372388                m_Instance.InternalFinalConstructAddRef();
    373 #if _MSC_VER >= 1400
    374                 ATLVERIFY(SUCCEEDED(m_Instance._AtlInitialConstruct()));
    375 #endif // _MSC_VER >= 1400
     389                #if _MSC_VER >= 1400
     390                        ATLVERIFY(SUCCEEDED(m_Instance._AtlInitialConstruct()));
     391                #endif // _MSC_VER >= 1400
    376392                ATLVERIFY(SUCCEEDED(m_Instance.FinalConstruct()));
    377393                ATLVERIFY(SUCCEEDED(m_Instance._AtlFinalConstruct()));
     
    379395                m_Instance.InternalAddRef();
    380396        }
    381         ~CLocalObjectPtr() throw()
    382         {
    383         }
    384         operator const _Object* () const throw()
     397        ~CLocalObjectPtr()
     398        {
     399        }
     400        operator const _Object* () const
    385401        {
    386402                return &m_Instance;
    387403        }
    388         operator _Object* () throw()
     404        operator _Object* ()
    389405        {
    390406                return &m_Instance;
    391407        }
    392         _Object* operator -> () throw()
     408        _Object* operator -> ()
    393409        {
    394410                return &m_Instance;
     
    654670// CThreadT
    655671
    656 template <typename _Owner>
     672template <typename COwner>
    657673class ATL_NO_VTABLE CThreadT :
    658674        public CComObjectRootEx<CComMultiThreadModelNoCS>,
     
    660676{
    661677protected:
    662         typedef CThreadT<_Owner> CThread;
     678        typedef CThreadT<COwner> CThread;
    663679
    664680public:
     
    668684
    669685public:
    670         typedef DWORD (_Owner::*OWNERTHREADPROC)(CThread* pThread, CEvent& InitializationEvent, CEvent& TerminationEvent);
     686        typedef DWORD (COwner::*OWNERTHREADPROC)(CThread* pThread, CEvent& InitializationEvent, CEvent& TerminationEvent);
     687
     688        ////////////////////////////////////////////////////////
     689        // CMessageQueue
     690
     691        class CMessageQueue
     692        {
     693        public:
     694        // CMessageQueue
     695                CMessageQueue()
     696                {
     697                        MSG Message;
     698                        PeekMessage(&Message, NULL, WM_USER, WM_USER, PM_NOREMOVE);
     699                }
     700                BOOL Wait(DWORD nTimeoutTime = INFINITE)
     701                {
     702                        const DWORD nWaitResult = MsgWaitForMultipleObjects(0, NULL, FALSE, nTimeoutTime, QS_POSTMESSAGE);
     703                        _Z5_WAITRESULT(nWaitResult);
     704                        _A(nWaitResult == WAIT_OBJECT_0 || nWaitResult == WAIT_TIMEOUT && nTimeoutTime != INFINITE);
     705                        return nWaitResult == WAIT_OBJECT_0;
     706                }
     707                BOOL Peek(UINT& nMessage)
     708                {
     709                        MSG Message;
     710                        if(!PeekMessage(&Message, NULL, 0, 0, PM_REMOVE))
     711                                return FALSE;
     712                        nMessage = Message.message;
     713                        return TRUE;
     714                }
     715                static VOID Post(DWORD nIdentifier, UINT nMessage, WPARAM wParam = 0, LPARAM lParam = 0)
     716                {
     717                        _A(nIdentifier);
     718                        _W(PostThreadMessage(nIdentifier, nMessage, wParam, lParam));
     719                }
     720        };
    671721
    672722private:
    673         _Owner* m_pOwner;
     723        COwner* m_pOwner;
    674724        OWNERTHREADPROC m_pOwnerThreadProc;
    675725        CEvent m_InitializationEvent;
    676726        CEvent m_TerminationEvent;
    677         CHandle m_ThreadHandle;
    678         DWORD m_nThreadIdentifier;
    679         DWORD m_nThreadExitCode;
    680 
    681         DWORD ThreadProc() throw()
     727        CHandle m_Handle;
     728        DWORD m_nIdentifier;
     729
     730        DWORD ThreadProc()
    682731        {
    683732                DWORD nResult;
    684733                _ATLTRY
    685734                {
    686                         ATLTRACE(atlTraceGeneral, 3, _T("Thread %d (0x%x) has been started\n"), GetCurrentThreadId(), GetCurrentThreadId());
     735                        ATLTRACE(atlTraceGeneral, 3, _T("Starting thread %d (0x%X)\n"), GetCurrentThreadId(), GetCurrentThreadId());
    687736                        ATLASSERT(m_pOwner && m_pOwnerThreadProc);
    688737                        nResult = (m_pOwner->*m_pOwnerThreadProc)(this, m_InitializationEvent, m_TerminationEvent);
    689                         ATLTRACE(atlTraceGeneral, 3, _T("Thread %d (0x%x) is being completed with result %d\n"), GetCurrentThreadId(), GetCurrentThreadId(), nResult);
     738                        ATLTRACE(atlTraceGeneral, 3, _T("Stopping thread %d (0x%X), result %d (0x%X)\n"), GetCurrentThreadId(), GetCurrentThreadId(), nResult, nResult);
    690739                }
    691740                _ATLCATCH(Exception)
    692741                {
    693742                        //_Z_EXCEPTION();
    694                         ATLTRACE(atlTraceException, 1, _T("An exception 0x%08X has been caught in thread %d\n"), Exception.m_hr, GetCurrentThreadId());
    695                         nResult = Exception.m_hr;
     743                        ATLTRACE(atlTraceException, 1, _T("An exception 0x%08X has been caught in thread %d (0x%X)\n"), (HRESULT) Exception, GetCurrentThreadId(), GetCurrentThreadId());
     744                        nResult = (HRESULT) Exception;
    696745                }
    697746                _ATLCATCHALL()
    698747                {
    699748                        //_Z_EXCEPTION();
    700                         ATLTRACE(atlTraceException, 1, _T("An exception has been caught in thread %d\n"), GetCurrentThreadId());
     749                        ATLTRACE(atlTraceException, 1, _T("An exception has been caught in thread %d (0x%X)\n"), GetCurrentThreadId(), GetCurrentThreadId());
    701750                        nResult = E_FAIL;
    702751                }
    703752                return nResult;
    704753        }
    705         static DWORD WINAPI ThreadProc(CThreadT* pThread) throw()
     754        static DWORD WINAPI ThreadProc(CThreadT* pThread)
    706755        {
    707756                return pThread->ThreadProc();
     
    710759public:
    711760// CThreadT
    712         CThreadT() throw() :
     761        CThreadT() :
    713762                m_pOwner(NULL),
    714763                m_pOwnerThreadProc(NULL),
    715764                m_InitializationEvent(NULL, TRUE, FALSE, NULL),
    716765                m_TerminationEvent(NULL, TRUE, FALSE, NULL),
    717                 m_nThreadIdentifier(0),
    718                 m_nThreadExitCode(0)
     766                m_nIdentifier(0)
    719767        {
    720768                ATLTRACE(atlTraceRefcount, 4, _T("this 0x%p\n"), this);
    721769        }
    722         ~CThreadT() throw()
     770        ~CThreadT()
    723771        {
    724772                ATLTRACE(atlTraceRefcount, 4, _T("this 0x%p\n"), this);
    725773                Terminate();
    726774        }
    727         const CHandle& GetHandle() const throw()
    728         {
    729                 return m_ThreadHandle;
    730         }
    731         DWORD GetIdentifier() const throw()
    732         {
    733                 return m_nThreadIdentifier;
    734         }
    735         DWORD GetExitCode() const throw()
    736         {
    737                 // TODO: An option to wait for exit code
    738                 return m_nThreadExitCode;
    739         }
    740         VOID Initialize(_Owner* pOwner, OWNERTHREADPROC pOwnerThreadProc, CEvent** ppInitializationEvent)
     775        const CHandle& GetHandle() const
     776        {
     777                return m_Handle;
     778        }
     779        DWORD GetIdentifier() const
     780        {
     781                return m_nIdentifier;
     782        }
     783        BOOL GetExitCode(DWORD& nExitCode) const
     784        {
     785                return GetExitCodeThread(m_Handle, &nExitCode);
     786        }
     787        BOOL IsStillActive() const
     788        {
     789                if(!m_Handle)
     790                        return FALSE;
     791                DWORD nExitCode;
     792                __E(GetExitCode(nExitCode));
     793                return nExitCode == STILL_ACTIVE;
     794        }
     795        VOID Initialize(COwner* pOwner, OWNERTHREADPROC pOwnerThreadProc, CEvent** ppInitializationEvent)
    741796        {
    742797                ATLASSERT(!m_pOwner && pOwner);
     
    744799                m_pOwner = pOwner;
    745800                m_pOwnerThreadProc = pOwnerThreadProc;
    746                 m_nThreadExitCode = 0;
    747801                ATLASSERT(WaitForSingleObject(m_TerminationEvent, 0) == WAIT_TIMEOUT);
    748                 m_ThreadHandle.Attach(CreateThreadT<CThreadT>(NULL, 0, ThreadProc, this, CREATE_SUSPENDED, &m_nThreadIdentifier));
    749                 ATLWINCHECK(m_ThreadHandle);
    750                 ATLASSERT(m_nThreadIdentifier);
    751                 ATLTRACE(atlTraceGeneral, 3, _T("Thread %d (0x%x) has been started from thread %d\n"), m_nThreadIdentifier, m_nThreadIdentifier, GetCurrentThreadId());
    752                 ResumeThread(m_ThreadHandle);
     802                static const DWORD g_nFlags = 0; //CREATE_SUSPENDED;
     803                m_Handle.Attach(CreateThreadT<CThreadT>(NULL, 0, ThreadProc, this, g_nFlags, &m_nIdentifier));
     804                ATLWINCHECK(m_Handle);
     805                ATLASSERT(m_nIdentifier);
     806                ATLTRACE(atlTraceGeneral, 3, _T("Thread %d (0x%X) started from thread %d (0x%X)\n"), m_nIdentifier, m_nIdentifier, GetCurrentThreadId(), GetCurrentThreadId());
     807                //ResumeThread(m_Handle);
    753808                *ppInitializationEvent = &m_InitializationEvent;
    754809        }
    755         BOOL Initialize(_Owner* pOwner, OWNERTHREADPROC pOwnerThreadProc)
     810        BOOL Initialize(COwner* pOwner, OWNERTHREADPROC pOwnerThreadProc)
    756811        {
    757812                CEvent* pInitializationEvent;
    758813                Initialize(pOwner, pOwnerThreadProc, &pInitializationEvent);
    759814                ATLASSERT(pInitializationEvent == &m_InitializationEvent);
    760                 HANDLE phObjects[] = { m_ThreadHandle, m_InitializationEvent };
    761                 DWORD nWaitResult = WaitForMultipleObjects(_countof(phObjects), phObjects, FALSE, INFINITE);
     815                const HANDLE phObjects[] = { m_Handle, m_InitializationEvent };
     816                const DWORD nWaitResult = WaitForMultipleObjects(_countof(phObjects), phObjects, FALSE, INFINITE);
    762817                ATLASSERT((nWaitResult - WAIT_OBJECT_0) < _countof(phObjects));
    763818                if(nWaitResult == WAIT_OBJECT_0 + 0)
    764819                {
    765                         ATLVERIFY(GetExitCodeThread(m_ThreadHandle, &m_nThreadExitCode));
    766                         m_ThreadHandle.Close();
    767                         SetLastError(m_nThreadExitCode);
     820                        DWORD nExitCode;
     821                        ATLVERIFY(GetExitCodeThread(m_Handle, &nExitCode));
     822                        m_Handle.Close();
     823                        SetLastError(nExitCode);
    768824                        return FALSE;
    769825                }
    770826                return TRUE;
    771827        }
    772         BOOL Terminate(ULONG nTimeout = INFINITE, BOOL bForceTermination = TRUE) throw()
    773         {
    774                 if(!m_ThreadHandle)
     828        BOOL Terminate(ULONG nTimeout = INFINITE, BOOL bForce = TRUE)
     829        {
     830                if(!m_Handle)
    775831                        return FALSE;
    776                 ATLTRACE(atlTraceGeneral, 3, _T("Thread %d (0x%x) is being terminated from thread %d, nTimeout %d, bForceTermination %d\n"), m_nThreadIdentifier, m_nThreadIdentifier, GetCurrentThreadId(), nTimeout, bForceTermination);
     832                ATLTRACE(atlTraceGeneral, 3, _T("Thread %d (0x%X) is being terminated from thread %d (0x%X), nTimeout %d, bForce %d\n"), m_nIdentifier, m_nIdentifier, GetCurrentThreadId(), GetCurrentThreadId(), nTimeout, bForce);
    777833                ATLVERIFY(m_TerminationEvent.Set());
    778                 if(GetCurrentThreadId() != m_nThreadIdentifier)
    779                 {
    780                         const DWORD nWaitResult = WaitForSingleObject(m_ThreadHandle, nTimeout);
    781                         ATLTRACE(atlTraceGeneral, 4, _T("m_nThreadIdentifier %d, nWaitResult %d\n"), m_nThreadIdentifier, nWaitResult);
     834                if(GetCurrentThreadId() != m_nIdentifier)
     835                {
     836                        const DWORD nWaitResult = WaitForSingleObject(m_Handle, nTimeout);
     837                        ATLTRACE(atlTraceGeneral, 4, _T("m_nIdentifier %d (0x%X), nWaitResult 0x%X\n"), m_nIdentifier, m_nIdentifier, nWaitResult);
    782838                        ATLASSERT(nWaitResult == WAIT_OBJECT_0 || nWaitResult == WAIT_TIMEOUT && nTimeout != INFINITE);
    783839                        if(nWaitResult != WAIT_OBJECT_0)
    784840                        {
    785                                 if(!bForceTermination)
     841                                if(!bForce)
    786842                                        return FALSE;
    787                                 ATLTRACE(atlTraceGeneral, 2, _T("Thread %d (0x%x) is being forcefully terminated from thread %d\n"), m_nThreadIdentifier, m_nThreadIdentifier, GetCurrentThreadId());
    788                                 ATLVERIFY(TerminateThread(m_ThreadHandle, (DWORD) E_FAIL));
     843                                ATLTRACE(atlTraceGeneral, 2, _T("Thread %d (0x%X) is being forcefully terminated from thread %d (0x%X)\n"), m_nIdentifier, m_nIdentifier, GetCurrentThreadId(), GetCurrentThreadId());
     844                                ATLVERIFY(TerminateThread(m_Handle, (DWORD) HRESULT_FROM_WIN32(ERROR_TIMEOUT)));
    789845                        }
    790                         ATLTRACE(atlTraceGeneral, 3, _T("Thread %d (0x%x) has been terminated from thread %d\n"), m_nThreadIdentifier, m_nThreadIdentifier, GetCurrentThreadId());
     846                        ATLTRACE(atlTraceGeneral, 3, _T("Thread %d (0x%x) has been terminated from thread %d\n"), m_nIdentifier, m_nIdentifier, GetCurrentThreadId());
    791847                } else
    792                         ATLTRACE(atlTraceGeneral, 3, _T("Thread %d is self-terminated, no need to synchronize\n"), m_nThreadIdentifier);
    793                 m_ThreadHandle.Close();
     848                        ATLTRACE(atlTraceGeneral, 3, _T("Thread %d (0x%X) is self-terminated\n"), m_nIdentifier, m_nIdentifier);
     849                m_Handle.Close();
    794850                return TRUE;
    795851        }
    796         VOID AsynchronousTerminate() throw()
     852        VOID AsynchronousTerminate()
    797853        {
    798854                ATLVERIFY(m_TerminationEvent.Set());
     855        }
     856        VOID PostMessage(UINT nMessage, WPARAM wParam = 0, LPARAM lParam = 0)
     857        {
     858                _A(m_Handle);
     859                _W(PostThreadMessage(m_nIdentifier, nMessage, wParam, lParam));
    799860        }
    800861};
     
    802863////////////////////////////////////////////////////////
    803864// CTimedEventDaemon
     865
     866// TODO: Clean up tracing
     867#if _MSC_VER >= 1800 // Visual Studio 2013
     868        #if defined(_DEBUG)
     869                #define atlTraceTimedEvent 0 // Disabled for stock ATLTRACE
     870        #else
     871                #define atlTraceTimedEvent ((INT) -1) // Disabled for my ATLTRACE
     872        #endif
     873#else
     874        #define atlTraceTimedEvent atlTraceCore
     875#endif
    804876
    805877class ATL_NO_VTABLE CTimedEventDaemon :
     
    834906        public:
    835907        // CTimedEvent
    836                 CTimedEvent() throw()
    837                 {
    838                 }
    839                 CTimedEvent(ULONG nDelay, ULONG nResolution, TIMECALLBACK* pTimeProc, DWORD_PTR nUser, UINT nFlags) throw() :
     908                CTimedEvent()
     909                {
     910                }
     911                CTimedEvent(ULONG nDelay, ULONG nResolution, TIMECALLBACK* pTimeProc, DWORD_PTR nUser, UINT nFlags) :
    840912                        m_nDelay(nDelay),
    841913                        m_nResolution(nResolution),
     
    858930        public:
    859931        // CTimedEventList
    860                 BOOL IsValidPosition(POSITION Position) const throw()
     932                BOOL IsValidPosition(POSITION Position) const
    861933                {
    862934                        for(POSITION CurrentPosition = GetHeadPosition(); CurrentPosition; GetNext(CurrentPosition))
     
    865937                        return FALSE;
    866938                }
    867                 POSITION GetEarliestActivePosition() const throw()
     939                POSITION GetEarliestActivePosition() const
    868940                {
    869941                        POSITION BestPosition = NULL;
     
    888960        static BOOL g_bDefaultTimedEventDaemonTerminated;
    889961        static CTimedEventDaemon* g_pDefaultTimedEventDaemon;
    890 #if _DEVELOPMENT
    891         DWORD m_nSignature;
    892 #endif // _DEVELOPMENT
     962        #if _DEVELOPMENT
     963                DWORD m_nSignature;
     964        #endif // _DEVELOPMENT
    893965        mutable CComAutoCriticalSection m_DataCriticalSection;
    894966        CTimedEventList m_TimedEventList;
    895967        CEvent m_ListChangeEvent;
    896 #if defined(_WINDLL)
    897         CEvent m_ThreadPreTerminationEvent;
    898 #endif // defined(_WINDLL)
     968        #if defined(_WINDLL)
     969                CEvent m_ThreadPreTerminationEvent;
     970        #endif // defined(_WINDLL)
    899971        CObjectPtr<CThread> m_pThread;
    900972        CEvent m_IdlenessEvent;
    901973
    902         static VOID STDMETHODCALLTYPE DestroyDefaultTimedEventDaemon(DWORD_PTR nParameter) throw()
     974        static VOID STDMETHODCALLTYPE DestroyDefaultTimedEventDaemon(DWORD_PTR nParameter)
    903975        {
    904976                _ATLTRY
     
    911983                                if(g_pDefaultTimedEventDaemon)
    912984                                {
    913 #if defined(_DEBUG) || _TRACE
    914                                         // NOTE: Add a lock removed by timeSetEvent
    915                                         _pAtlModule->Lock();
    916 #endif // defined(_DEBUG) || _TRACE
     985                                        #if defined(_DEBUG) || _TRACE
     986                                                // NOTE: Add a lock removed by timeSetEvent
     987                                                _pAtlModule->Lock();
     988                                        #endif // defined(_DEBUG) || _TRACE
    917989                                        pTimedEventDaemon.Swap(&g_pDefaultTimedEventDaemon);
    918990                                }
     
    9411013                {
    9421014                        const DWORD nWaitResult = WaitForMultipleObjects(DIM(phObjects), phObjects, FALSE, INFINITE);
    943                         ATLTRACE(atlTraceSync, 5, _T("nWaitResult 0x%x\n"), nWaitResult);
     1015                        _Z5_WAITRESULT(nWaitResult);
    9441016                        _A((nWaitResult - WAIT_OBJECT_0) < DIM(phObjects));
    9451017                        if(nWaitResult != WAIT_OBJECT_0 + 1) // m_ListChangeEvent
     
    9531025                                        CurrentPosition = m_TimedEventList.GetEarliestActivePosition();
    9541026                                        _W(m_ListChangeEvent.Reset());
    955                                         ATLTRACE(atlTraceCore, 4, _T("%d timed events on the list\n"), m_TimedEventList.GetCount());
     1027                                        _Z4(atlTraceTimedEvent, 4, _T("%d timed events on the list\n"), m_TimedEventList.GetCount());
    9561028                                        if(!CurrentPosition)
    9571029                                        {
    958                                                 ATLTRACE(atlTraceCore, 4, _T("No more active timed events found\n"));
     1030                                                _Z4(atlTraceTimedEvent, 4, _T("No more active timed events found\n"));
    9591031                                                break;
    9601032                                        }
     
    9631035                                }
    9641036                                const DWORD nWaitResult = (nDelay > 0) ? WaitForMultipleObjects(DIM(phObjects), phObjects, FALSE, nDelay) : WAIT_TIMEOUT;
    965                                 ATLTRACE(atlTraceSync, 5, _T("nWaitResult 0x%x\n"), nWaitResult);
     1037                                _Z5_WAITRESULT(nWaitResult);
    9661038                                _A((nWaitResult - WAIT_OBJECT_0) < DIM(phObjects) || nWaitResult == WAIT_TIMEOUT);
    9671039                                if(nWaitResult == WAIT_OBJECT_0 + 0) // Termination
     
    9691041                                if(nWaitResult == WAIT_OBJECT_0 + 1) // m_ListChangeEvent
    9701042                                {
    971                                         ATLTRACE(atlTraceCore, 4, _T("Timed event list changed\n"));
     1043                                        _Z4(atlTraceTimedEvent, 4, _T("Timed event list changed\n"));
    9721044                                        continue;
    9731045                                }
     
    9781050                                        if(!m_TimedEventList.IsValidPosition(CurrentPosition))
    9791051                                                continue;
    980                                         ATLTRACE(atlTraceCore, 4, _T("Firing an event, CurrentPosition 0x%08X\n"), CurrentPosition);
     1052                                        _Z4(atlTraceTimedEvent, 4, _T("Firing an event, CurrentPosition 0x%p\n"), CurrentPosition);
    9811053                                        CTimedEvent& CurrentTimedEvent = m_TimedEventList.GetAt(CurrentPosition);
    9821054                                        CurrentTimedEvent.m_nTime = GetTickCount();
     
    10141086public:
    10151087// CTimedEventDaemon
    1016         static CObjectPtr<CTimedEventDaemon> GetDefaultTimedEventDaemon() throw()
     1088        static CObjectPtr<CTimedEventDaemon> GetDefaultTimedEventDaemon()
    10171089        {
    10181090                CObjectPtr<CTimedEventDaemon> pTimedEventDaemon;
     
    10281100                                        _pAtlModule->AddTermFunc(DestroyDefaultTimedEventDaemon, (DWORD_PTR) (CTimedEventDaemon*) pTimedEventDaemon);
    10291101                                        g_pDefaultTimedEventDaemon = pTimedEventDaemon.Detach();
    1030 #if defined(_DEBUG) || _TRACE
    1031                                         // NOTE: Exclude object's module lock so that it does not affect termination lock count report
    1032                                         _pAtlModule->Unlock();
    1033 #endif // defined(_DEBUG) || _TRACE
     1102                                        #if defined(_DEBUG) || _TRACE
     1103                                                // NOTE: Exclude object's module lock so that it does not affect termination lock count report
     1104                                                _pAtlModule->Unlock();
     1105                                        #endif // defined(_DEBUG) || _TRACE
    10341106                                }
    10351107                                _ATLCATCHALL()
     
    10421114                return pTimedEventDaemon;
    10431115        }
    1044         CTimedEventDaemon() throw() :
     1116        CTimedEventDaemon() :
    10451117                m_ListChangeEvent(TRUE, FALSE),
    10461118                m_IdlenessEvent(TRUE, TRUE)
    10471119        {
    1048                 ATLTRACE(atlTraceRefcount, 4, _T("this 0x%p\n"), this);
    1049 #if _DEVELOPMENT
    1050                 // WARN: CTimedEventDaemon has unresolved problems with late termination, so
    1051                 //       we mark used memory block to distinguish in head trace
    1052                 m_nSignature = 0x89674523;
    1053 #endif // _DEVELOPMENT
    1054         }
    1055         ~CTimedEventDaemon() throw()
    1056         {
    1057                 ATLTRACE(atlTraceRefcount, 4, _T("this 0x%p\n"), this);
     1120                _Z4_THIS();
     1121                #if _DEVELOPMENT
     1122                        // WARN: CTimedEventDaemon has unresolved problems with late termination, so
     1123                        //       we mark used memory block to distinguish in head trace
     1124                        m_nSignature = 0x89674523;
     1125                #endif // _DEVELOPMENT
     1126        }
     1127        ~CTimedEventDaemon()
     1128        {
     1129                _Z4_THIS();
    10581130                _A(!m_pThread);
    10591131        }
     
    10671139                __E(m_pThread.Construct()->Initialize(this, &CTimedEventDaemon::ThreadProc));
    10681140        }
    1069         VOID Terminate() throw()
     1141        VOID Terminate()
    10701142        {
    10711143                CObjectPtr<CThread> pThread;
     
    10871159                                        const HANDLE phObjects[] = { ThreadPreTerminationEvent, Thread };
    10881160                                        const DWORD nWaitResult = WaitForMultipleObjects(DIM(phObjects), phObjects, FALSE, INFINITE);
    1089                                         _Z5(atlTraceSync, 5, _T("nWaitResult 0x%x\n"), nWaitResult);
     1161                                        _Z5_WAITRESULT(nWaitResult);
    10901162                                        _A(nWaitResult - WAIT_OBJECT_0 < DIM(phObjects));
    10911163                                        return;
     
    10951167                }
    10961168        }
    1097         HRESULT SetEvent(ULONG nDelay, ULONG nResolution, TIMECALLBACK* pTimeProc, DWORD_PTR nUser, UINT nFlags, UINT_PTR* pnEvent) throw()
     1169        HRESULT SetEvent(ULONG nDelay, ULONG nResolution, TIMECALLBACK* pTimeProc, DWORD_PTR nUser, UINT nFlags, UINT_PTR* pnEvent)
    10981170        {
    10991171                _ATLTRY
     
    11051177                        _A(pnEvent);
    11061178                        *pnEvent = (UINT_PTR) Position;
    1107                         ATLTRACE(atlTraceCore, 4, _T("An event has been set, Position 0x%08X, nDelay %d, nFlags 0x%x, %d events on the list\n"), Position, nDelay, nFlags, m_TimedEventList.GetCount());
     1179                        _Z4(atlTraceTimedEvent, 4, _T("An event has been set, Position 0x%p, nDelay %d, nFlags 0x%X, %d events on the list\n"), Position, nDelay, nFlags, m_TimedEventList.GetCount());
    11081180                }
    11091181                _ATLCATCH(Exception)
     
    11131185                return S_OK;
    11141186        }
    1115         HRESULT KillEvent(UINT_PTR nEvent) throw()
     1187        HRESULT KillEvent(UINT_PTR nEvent)
    11161188        {
    11171189                BOOL bConcurrentlyActive = FALSE;
     
    11191191                        CComCritSecLock<CComAutoCriticalSection> DataLock(m_DataCriticalSection);
    11201192                        const POSITION Position = (POSITION) nEvent;
    1121                         ATLTRACE(atlTraceCore, 4, _T("An event is being killed, Position 0x%08X\n"), Position);
     1193                        _Z4(atlTraceTimedEvent, 4, _T("An event is being killed, Position 0x%p\n"), Position);
    11221194                        _D(m_TimedEventList.IsValidPosition(Position), E_INVALIDARG);
    11231195                        if(m_TimedEventList.GetAt(Position).m_bActive)
     
    11261198                        m_TimedEventList.RemoveAt(Position);
    11271199                        _W(m_ListChangeEvent.Set());
    1128                         ATLTRACE(atlTraceCore, 4, _T("An event has been killed, Position 0x%08X, %d more events on the list\n"), Position, m_TimedEventList.GetCount());
     1200                        _Z4(atlTraceTimedEvent, 4, _T("An event has been killed, Position 0x%p, %d more events on the list\n"), Position, m_TimedEventList.GetCount());
    11291201                }
    11301202                if(bConcurrentlyActive)
    11311203                {
    1132                         static const DWORD g_nTimeout = 5000;
    1133                         DWORD nWaitResult = WaitForSingleObject(m_IdlenessEvent, g_nTimeout);
     1204                        static const DWORD g_nTimeout = 5 * 1000; // 5 seconds
     1205                        const DWORD nWaitResult = WaitForSingleObject(m_IdlenessEvent, g_nTimeout);
     1206                        //_Z5_WAITRESULT(nWaitResult);
    11341207                        _A(nWaitResult == WAIT_OBJECT_0 || nWaitResult == WAIT_TIMEOUT);
    11351208                        if(nWaitResult != WAIT_OBJECT_0)
    1136                                 ATLTRACE(atlTraceGeneral, 2, _T("Worker thread failed to get idle within reasonable time, nWaitResult %d\n"), nWaitResult);
     1209                                _Z2(atlTraceTimedEvent, 2, _T("Worker thread failed to get idle within reasonable time, nWaitResult 0x%X\n"), nWaitResult);
    11371210                }
    11381211                return S_OK;
     
    11401213
    11411214// Standard API substitution
    1142         static MMRESULT timeSetEvent(UINT nDelay, UINT nResolution, TIMECALLBACK* pTimeProc, DWORD_PTR nUser, UINT nFlags) throw()
     1215        static MMRESULT timeSetEvent(UINT nDelay, UINT nResolution, TIMECALLBACK* pTimeProc, DWORD_PTR nUser, UINT nFlags)
    11431216        {
    11441217                _A(nFlags == (TIME_CALLBACK_FUNCTION | TIME_PERIODIC) || nFlags == (TIME_CALLBACK_FUNCTION | TIME_ONESHOT));
     
    11521225                return (MMRESULT) nEvent;
    11531226        }
    1154         static MMRESULT timeKillEvent(UINT uEvent) throw()
     1227        static MMRESULT timeKillEvent(UINT uEvent)
    11551228        {
    11561229                MMRESULT nResult = MMSYSERR_INVALPARAM;
     
    12171290                }
    12181291        }
    1219         static VOID CALLBACK TimedEventProc(UINT_PTR nEvent, UINT, DWORD_PTR nUser, DWORD_PTR, DWORD_PTR) throw()
     1292        static VOID CALLBACK TimedEventProc(UINT_PTR nEvent, UINT, DWORD_PTR nUser, DWORD_PTR, DWORD_PTR)
    12201293        {
    12211294                _ATLTRY
     
    12311304public:
    12321305// CTimedEventT
    1233         CTimedEventT() throw() :
     1306        CTimedEventT() :
    12341307                m_nEvent(0),
    12351308                m_IdlenessEvent(TRUE, TRUE)
     
    12401313#endif // defined(_DEBUG)
    12411314        }
    1242         ~CTimedEventT() throw()
     1315        ~CTimedEventT()
    12431316        {
    12441317                Destroy();
    12451318                static const DWORD g_nTimeout = 5 * 1000;
    12461319                const DWORD nWaitResult = WaitForSingleObject(m_IdlenessEvent, g_nTimeout);
    1247                 ATLTRACE(atlTraceSync, 5, _T("nWaitResult 0x%x\n"), nWaitResult);
     1320                _Z5_WAITRESULT(nWaitResult);
    12481321                _A(nWaitResult == WAIT_OBJECT_0 || nWaitResult == WAIT_TIMEOUT);
    12491322                if(nWaitResult != WAIT_OBJECT_0)
    12501323                        ATLTRACE(atlTraceGeneral, 2, _T("Worker thread failed to get idle within reasonable time, nWaitResult %d\n"), nWaitResult);
    12511324        }
    1252         VOID Initialize(CTimedEventDaemon* pTimedEventDaemon) throw()
     1325        VOID Initialize(CTimedEventDaemon* pTimedEventDaemon)
    12531326        {
    12541327                _A(pTimedEventDaemon);
     
    12571330                m_pTimedEventDaemon = pTimedEventDaemon;
    12581331        }
    1259         const _Parameter& GetParameter() const throw()
     1332        const _Parameter& GetParameter() const
    12601333        {
    12611334                return m_Parameter;
    12621335        }
    1263         VOID SetParameter(_Parameter Parameter) throw()
     1336        VOID SetParameter(_Parameter Parameter)
    12641337        {
    12651338                m_Parameter = Parameter;
    12661339        }
    1267         UINT_PTR GetEvent() const throw()
     1340        UINT_PTR GetEvent() const
    12681341        {
    12691342                CComCritSecLock<CComAutoCriticalSection> DataLock(m_DataCriticalSection);
    12701343                return m_nEvent;
    12711344        }
    1272         BOOL IsActive() const throw()
     1345        BOOL IsActive() const
    12731346        {
    12741347                CComCritSecLock<CComAutoCriticalSection> DataLock(m_DataCriticalSection);
     
    13041377                return Create(pOwner, pHandler, nDelay, nResolution, TRUE);
    13051378        }
    1306         VOID Destroy() throw()
     1379        VOID Destroy()
    13071380        {
    13081381                CObjectPtr<CTimedEventDaemon> pTimedEventDaemon;
     
    13311404public:
    13321405// CSimpleTimedEventT
    1333         CSimpleTimedEventT() throw()
     1406        CSimpleTimedEventT()
    13341407        {
    13351408                __super::Initialize(CTimedEventDaemon::GetDefaultTimedEventDaemon());
     
    13911464        public:
    13921465        // CCheck
    1393                 CCheck() throw() :
     1466                CCheck() :
    13941467                        m_nThreadIdentifier(0)
    13951468                {
    1396                         ATLTRACE(atlTraceRefcount, 5, _T("this 0x%p\n"), this);
    1397                 }
    1398                 ~CCheck() throw()
    1399                 {
    1400                         ATLTRACE(atlTraceRefcount, 5, _T("this 0x%p\n"), this);
     1469                        _Z5_THIS();
     1470                }
     1471                ~CCheck()
     1472                {
     1473                        _Z5_THIS();
    14011474                        _A(!m_TimeoutEvent.IsActive());
    14021475                }
     
    14251498public:
    14261499// CDebugTimeCheck
    1427         static ULONG GetDefaultTimeout() throw()
     1500        static ULONG GetDefaultTimeout()
    14281501        {
    14291502                static const ULONG g_nTimeout = 5000;
     
    14381511                m_pCheck.Construct()->Initialize(CString(pszDescription), nTimeout);
    14391512        }
    1440         ~CDebugTimeCheck() throw()
     1513        ~CDebugTimeCheck()
    14411514        {
    14421515                if(m_pCheck)
     
    15351608// CRoCriticalSection, CRoCriticalSectionLock
    15361609
    1537 #if defined(_M_IX86) && (defined(_DEBUG) || _TRACE)
     1610#if defined(_DEBUG) || _TRACE
    15381611
    15391612#pragma warning(disable: 4748) // warning C4748: /GS can not protect parameters and local variables from local buffer overrun because optimizations are disabled in function
     
    15591632        public:
    15601633        // CLockContext
    1561                 CLockContext(CRoCriticalSection* pCriticalSection, CONTEXT& ThreadContext, ULONG nTimeout) throw() :
     1634                CLockContext(CRoCriticalSection* pCriticalSection, CONTEXT& ThreadContext, ULONG nTimeout) :
    15621635                        m_CriticalSection(*pCriticalSection),
    15631636                        m_nThreadIdentifier(GetCurrentThreadId()),
     
    15871660                        CONTEXT LockingThreadContext = LockContext.m_ThreadContext;
    15881661                        CComCritSecLock<CComAutoCriticalSection> Lock(CDebugSymbols::GetGlobalCriticalSection());
    1589                         ATLCORETRACE3(LockedThreadContext)(atlTraceGeneral, 2, _T("Thread %d locked the critical section 0x%08X, lock time call stack follows:\n"), nLockThreadIdentifier, this);
    1590                         CDebugTraceCallStack::TraceCallStack(LockedThreadContext, 15, NULL);
     1662                        #if defined(_DEBUG)
     1663                                // NOTE: Debug builds don't have functions inlined so lock time stack is likely to be damaged anyway, let us just skip it
     1664                                LockedThreadContext.ContextFlags = 0;
     1665                        #endif // defined(_DEBUG)
     1666                        if(LockedThreadContext.ContextFlags)
     1667                        {
     1668                                ATLCORETRACE3(LockedThreadContext)(atlTraceGeneral, 2, _T("Thread %d locked the critical section 0x%p, lock time call stack follows:\n"), nLockThreadIdentifier, this);
     1669                                CDebugTraceCallStack::TraceCallStack(nLockThreadIdentifier, LockedThreadContext);
     1670                        } else
     1671                                ATLCORETRACE3(LockedThreadContext)(atlTraceGeneral, 2, _T("Thread %d locked the critical section 0x%p\n"), nLockThreadIdentifier, this);
    15911672                        ATLCORETRACE1(atlTraceGeneral, 2, _T("Thread %d current stack follows:\n"), nLockThreadIdentifier, this);
    1592                         CDebugTraceCallStack::TraceCallStack(nLockThreadIdentifier, 15);
    1593                         ATLCORETRACE3(LockingThreadContext)(atlTraceGeneral, 2, _T("Thread %d is trying to lock the critical section 0x%08X, call stack follows:\n"), LockContext.m_nThreadIdentifier, this);
    1594                         CDebugTraceCallStack::TraceCallStack(LockingThreadContext, 15, NULL);
     1673                        CDebugTraceCallStack::TraceCallStack(nLockThreadIdentifier);
     1674                        ATLCORETRACE3(LockingThreadContext)(atlTraceGeneral, 2, _T("Thread %d is trying to lock the critical section 0x%p, call stack follows:\n"), LockContext.m_nThreadIdentifier, this);
     1675                        CDebugTraceCallStack::TraceCallStack(LockContext.m_nThreadIdentifier, LockingThreadContext);
    15951676                        #pragma region MiniDump
    1596                         #if !defined(_WIN64)
    1597                                 #if !defined(_DEBUG) && defined(_TRACE) && _TRACE
     1677                        #if defined(_WINDLL) && !defined(_WIN64)
     1678                                #if !defined(_DEBUG) && _TRACE
    15981679                                        if(nTimeoutCount == 3)
    15991680                                        {
     
    16271708                                                }
    16281709                                        }
    1629                                 #endif // !defined(_DEBUG) && defined(_TRACE) && _TRACE
    1630                         #endif // defined(_WIN64)
     1710                                #endif // !defined(_DEBUG) && _TRACE
     1711                        #endif // defined(_WINDLL) && !defined(_WIN64)
    16311712                        #pragma endregion
    16321713                        #if defined(_DEBUG)
     
    16351716                }
    16361717        }
    1637         static VOID CALLBACK LockTimeout(UINT_PTR nEvent, UINT, DWORD_PTR nParameter, DWORD_PTR, DWORD_PTR) throw()
     1718        static VOID CALLBACK LockTimeout(UINT_PTR nEvent, UINT, DWORD_PTR nParameter, DWORD_PTR, DWORD_PTR)
    16381719        {
    16391720                CLockContext* pLockContext = (CLockContext*) nParameter;
     
    16531734public:
    16541735// CRoCriticalSection
    1655         CRoCriticalSection() throw()
     1736        CRoCriticalSection()
    16561737        {
    16571738                m_nLockThreadIdentifier = 0;
    16581739                ZeroMemory(&m_LockThreadContext, sizeof m_LockThreadContext);
    16591740        }
    1660         ~CRoCriticalSection() throw()
     1741        ~CRoCriticalSection()
    16611742        {
    16621743                _A(m_sec.LockCount < 0);
    16631744        }
    1664         HRESULT Lock() throw()
     1745        HRESULT Lock()
    16651746        {
    16661747                _ATLTRY
    16671748                {
    1668                         CONTEXT ThreadContext = { CONTEXT_FULL };
     1749                        CONTEXT ThreadContext;
    16691750                        if(!GetCurrentThreadContext(&ThreadContext))
    16701751                                ThreadContext.ContextFlags = 0;
     
    16841765                        if(nRecursionCount == (LONG) 1) // First lock
    16851766                        {
    1686                                 // NOTE: Stack walk out to step out of this function and lock helper class method
    1687                                 //       Number of required step out steps depends on compiler settings and
    1688                                 //       is 3 for debug builds to step out of this function, lock helper Lock and constructor
    1689                                 //       and is 1 for release builds with inline any suitable option
    1690                                 CDebugSymbols::GlobalStackWalk(NULL, ThreadContext);
    1691                                 #if defined(_DEBUG)
    1692                                         CDebugSymbols::GlobalStackWalk(NULL, ThreadContext);
    1693                                         CDebugSymbols::GlobalStackWalk(NULL, ThreadContext);
    1694                                 #endif // defined(_DEBUG)
    16951767                                CComCritSecLock<CComAutoCriticalSection> GlobalLock(g_CriticalSection);
    16961768                                m_nLockThreadIdentifier = GetCurrentThreadId();
     
    17071779                return S_OK;
    17081780        }
    1709         HRESULT Unlock() throw()
     1781        HRESULT Unlock()
    17101782        {
    17111783                {
     
    17161788                        {
    17171789                                m_nLockThreadIdentifier = 0;
    1718                                 ZeroMemory(&m_LockThreadContext, sizeof m_LockThreadContext);
     1790                                m_LockThreadContext.ContextFlags = 0; //ZeroMemory(&m_LockThreadContext, sizeof m_LockThreadContext);
    17191791                        }
    17201792                }
     
    17301802
    17311803#if !defined(_WIN64) && defined(_WINDLL)
    1732         #if !defined(_DEBUG) && defined(_TRACE) && _TRACE
     1804        #if !defined(_DEBUG) && _TRACE
    17331805
    17341806                #define AVAILABILITY_INTERNALWRITEMINIDUMP
     
    17371809
    17381810                //extern "C" // __declspec(dllexport)
    1739                 ATLINLINE HRESULT STDMETHODCALLTYPE InternalWriteMiniDump(HWND hParentWindow, HINSTANCE hInstance, LPSTR pszCommandLine, INT nShowCommand) throw()
     1811                ATLINLINE HRESULT STDMETHODCALLTYPE InternalWriteMiniDump(HWND hParentWindow, HINSTANCE hInstance, LPSTR pszCommandLine, INT nShowCommand)
    17401812                {
    17411813                        _ATLTRY
     
    17521824                                __E(Process);
    17531825                                TCHAR pszDirectory[MAX_PATH] = { 0 };
    1754                                 if(GetOsVersion() >= 0x00060000)
     1826                                if(IsWindowsVistaOrGreater())
    17551827                                {
    17561828                                        _W(SHGetSpecialFolderPath(NULL, pszDirectory, CSIDL_COMMON_APPDATA, TRUE));
     
    17861858                }
    17871859
    1788         #endif // !defined(_DEBUG) && defined(_TRACE) && _TRACE
     1860        #endif // !defined(_DEBUG) && _TRACE
    17891861#endif // !defined(_WIN64) && defined(_WINDLL)
    17901862
     1863#pragma optimize("", on)
     1864#pragma warning(default: 4748)
     1865
     1866#else
     1867
     1868typedef CComAutoCriticalSection CRoCriticalSection;
     1869
     1870#endif // defined(_DEBUG) || _TRACE
     1871
     1872typedef CComAutoCriticalSection CRoLightCriticalSection;
     1873
     1874#if TRUE
     1875
     1876template <typename CCriticalSection>
     1877inline BOOL TryLock(CCriticalSection& CriticalSection);
     1878
     1879#if _WIN32_WINNT >= 0x0400
     1880        template <>
     1881        inline BOOL TryLock<CComCriticalSection>(CComCriticalSection& CriticalSection)
     1882        {
     1883                return TryEnterCriticalSection(&CriticalSection.m_sec);
     1884        }
     1885        template <>
     1886        inline BOOL TryLock<CRoCriticalSection>(CRoCriticalSection& CriticalSection)
     1887        {
     1888                return TryEnterCriticalSection(&CriticalSection.m_sec);
     1889        }
     1890#endif // _WIN32_WINNT >= 0x0400
     1891
     1892template <typename CCriticalSection>
     1893class CRoCriticalSectionLockT
     1894{
     1895private:
     1896        CCriticalSection& m_CriticalSection;
     1897        BOOL m_bLocked;
     1898
     1899        CRoCriticalSectionLockT(const CRoCriticalSectionLockT&);
     1900        CRoCriticalSectionLockT& operator = (const CRoCriticalSectionLockT&);
     1901
     1902public:
     1903// CRoCriticalSectionLockT
     1904        CRoCriticalSectionLockT(CCriticalSection& CriticalSection, BOOL bInitialLock = TRUE) :
     1905                m_CriticalSection(CriticalSection),
     1906                m_bLocked(FALSE)
     1907        {
     1908                if(bInitialLock)
     1909                        Lock();
     1910        }
     1911        ~CRoCriticalSectionLockT()
     1912        {
     1913                if(m_bLocked)
     1914                        Unlock();
     1915        }
     1916        VOID Lock()
     1917        {
     1918                _A(!m_bLocked);
     1919                _V(m_CriticalSection.Lock());
     1920                m_bLocked = TRUE;
     1921        }
     1922        BOOL TryLock()
     1923        {
     1924                _A(!m_bLocked);
     1925                if(!::TryLock(m_CriticalSection))
     1926                        return FALSE;
     1927                m_bLocked = TRUE;
     1928                return TRUE;
     1929        }
     1930        VOID Unlock()
     1931        {
     1932                ATLASSUME(m_bLocked);
     1933                m_CriticalSection.Unlock();
     1934                m_bLocked = FALSE;
     1935        }
     1936        BOOL IsLocked() const
     1937        {
     1938                return m_bLocked;
     1939        }
     1940};
     1941
     1942typedef CRoCriticalSectionLockT<CRoCriticalSection> CRoCriticalSectionLock;
     1943
     1944#else
     1945
     1946typedef CComCritSecLock<CRoCriticalSection> CRoCriticalSectionLock;
     1947
     1948#endif
     1949
     1950typedef CComCritSecLock<CRoLightCriticalSection> CRoLightCriticalSectionLock;
     1951
     1952/////////////////////////////////////////////////////////////////////////////
     1953// DeadlockCriticalSectionT
     1954
    17911955template <typename _CriticalSection>
    1792 inline DWORD WINAPI DeadlockCriticalSectionThreadProcT(VOID* pvParameter) throw()
    1793 {
    1794         _CriticalSection& CriticalSection = *(reinterpret_cast<_CriticalSection*>(pvParameter));
    1795         CComCritSecLock<_CriticalSection> Lock(CriticalSection);
     1956inline DWORD WINAPI DeadlockCriticalSectionThreadProcT(_CriticalSection* pCriticalSection)
     1957{
     1958        CComCritSecLock<_CriticalSection> Lock(*pCriticalSection);
    17961959        _A(FALSE);
    17971960        return 0;
     
    17991962
    18001963template <typename _CriticalSection>
    1801 inline VOID DeadlockCriticalSectionT(_CriticalSection& CriticalSection) throw()
     1964inline VOID DeadlockCriticalSectionT(_CriticalSection& CriticalSection)
    18021965{
    18031966        CComCritSecLock<_CriticalSection> Lock(CriticalSection);
    1804         DWORD nThreadIdentifier = 0;
    1805         CHandle ThreadHandle(CreateThreadT<_CriticalSection>(NULL, 0, DeadlockCriticalSectionThreadProcT<_CriticalSection>, &CriticalSection, 0, &nThreadIdentifier));
     1967        // WARN: GetThreadId is WinVista+, so we have to use CreateThreadT instead of AtlCreateThread
     1968        DWORD nThreadIdentifier;
     1969        CHandle ThreadHandle;
     1970        ThreadHandle.Attach(CreateThreadT<_CriticalSection>(NULL, 0, DeadlockCriticalSectionThreadProcT<_CriticalSection>, &CriticalSection, 0, &nThreadIdentifier));
    18061971        ATLTRACE(atlTraceGeneral, 1, _T("Deadlocked in threads %d and %d (spawned)\n"), GetCurrentThreadId(), nThreadIdentifier);
    18071972        WaitForSingleObject(ThreadHandle, INFINITE);
     
    18091974}
    18101975
    1811 #pragma optimize("", on)
    1812 #pragma warning(default: 4748)
    1813 
    1814 #else
    1815 
    1816 typedef CComAutoCriticalSection CRoCriticalSection;
    1817 
    1818 #endif // defined(_M_IX86) && (defined(_DEBUG) || _TRACE)
    1819 
    1820 typedef CComAutoCriticalSection CRoLightCriticalSection;
    1821 
    1822 #if TRUE
    1823 
    1824 template <typename _CriticalSection>
    1825 class CRoCriticalSectionLockT
    1826 {
    1827 private:
    1828         _CriticalSection& m_CriticalSection;
    1829         BOOL m_bLocked;
    1830 
    1831         CRoCriticalSectionLockT(const CRoCriticalSectionLockT&) throw();
    1832         CRoCriticalSectionLockT& operator = (const CRoCriticalSectionLockT&) throw();
    1833 
    1834 public:
    1835 // CRoCriticalSectionLockT
    1836         CRoCriticalSectionLockT(_CriticalSection& CriticalSection, BOOL bInitialLock = TRUE) throw() :
    1837                 m_CriticalSection(CriticalSection),
    1838                 m_bLocked(FALSE)
    1839         {
    1840                 if(bInitialLock)
    1841                         Lock();
    1842         }
    1843         ~CRoCriticalSectionLockT() throw()
    1844         {
    1845                 if(m_bLocked)
    1846                         Unlock();
    1847         }
    1848         VOID Lock() throw()
    1849         {
    1850                 _A(!m_bLocked);
    1851                 _V(m_CriticalSection.Lock());
    1852                 m_bLocked = TRUE;
    1853         }
    1854         #if _WIN32_WINNT >= 0x0400
    1855                 BOOL TryLock() throw()
    1856                 {
    1857                         _A(!m_bLocked);
    1858                         // SUGG: Take advantage of m_CriticalSection's TryLock if available
    1859                         _A(sizeof m_CriticalSection >= sizeof (CRITICAL_SECTION));
    1860                         CRITICAL_SECTION* pInternalCriticalSection = reinterpret_cast<CRITICAL_SECTION*>(&m_CriticalSection);
    1861                         if(!TryEnterCriticalSection(pInternalCriticalSection))
    1862                                 return FALSE;
    1863                         m_bLocked = TRUE;
    1864                         return TRUE;
    1865                 }
    1866         #endif // _WIN32_WINNT >= 0x0400
    1867         VOID Unlock() throw()
    1868         {
    1869                 ATLASSUME(m_bLocked);
    1870                 m_CriticalSection.Unlock();
    1871                 m_bLocked = FALSE;
    1872         }
    1873 };
    1874 
    1875 typedef CRoCriticalSectionLockT<CRoCriticalSection> CRoCriticalSectionLock;
    1876 
    1877 #else
    1878 
    1879 typedef CComCritSecLock<CRoCriticalSection> CRoCriticalSectionLock;
    1880 
    1881 #endif
    1882 
    1883 typedef CComCritSecLock<CRoLightCriticalSection> CRoLightCriticalSectionLock;
    1884 
    18851976/////////////////////////////////////////////////////////////////////////////
    18861977// CComCritSecUnlock
    18871978
    1888 template <typename _CriticalSection>
     1979template <typename CCriticalSection>
    18891980class CComCritSecUnlock
    18901981{
    18911982private:
    1892         _CriticalSection& m_CriticalSection;
     1983        CCriticalSection& m_CriticalSection;
    18931984        BOOL m_bUnlocked;
    18941985
    1895         CComCritSecUnlock(const CComCritSecUnlock&) throw();
    1896         CComCritSecUnlock& operator = (const CComCritSecUnlock&) throw();
     1986        CComCritSecUnlock(const CComCritSecUnlock&);
     1987        CComCritSecUnlock& operator = (const CComCritSecUnlock&);
    18971988
    18981989public:
    18991990// CComCritSecUnlock
    1900         CComCritSecUnlock(_CriticalSection& CriticalSection, BOOL bInitialUnlock = TRUE) throw() :
     1991        CComCritSecUnlock(CCriticalSection& CriticalSection, BOOL bInitialUnlock = TRUE) :
    19011992                m_CriticalSection(CriticalSection),
    19021993                m_bUnlocked(FALSE)
     
    19051996                        Unlock();
    19061997        }
    1907         ~CComCritSecUnlock() throw()
     1998        ~CComCritSecUnlock()
    19081999        {
    19092000                if(m_bUnlocked)
    19102001                        Lock();
    19112002        }
    1912         VOID Unlock() throw()
     2003        VOID Unlock()
    19132004        {
    19142005                _A(!m_bUnlocked);
     
    19162007                m_bUnlocked = TRUE;
    19172008        }
    1918         VOID Lock() throw()
     2009        VOID Lock()
    19192010        {
    19202011                _A(m_bUnlocked);
     
    19222013                m_bUnlocked = FALSE;
    19232014        }
    1924 #if _WIN32_WINNT >= 0x0400
    1925         BOOL TryLock() throw()
     2015        BOOL TryLock()
    19262016        {
    19272017                _A(m_bUnlocked);
    1928                 // SUGG: Take advantage of m_CriticalSection's TryLock if available
    1929                 _A(sizeof m_CriticalSection == sizeof (CRITICAL_SECTION));
    1930                 CRITICAL_SECTION* pInternalCriticalSection = reinterpret_cast<CRITICAL_SECTION*>(&m_CriticalSection);
    1931                 if(!TryEnterCriticalSection(pInternalCriticalSection))
     2018                if(!::TryLock(m_CriticalSection))
    19322019                        return FALSE;
    19332020                m_bUnlocked = FALSE;
    19342021                return TRUE;
    19352022        }
    1936 #endif // _WIN32_WINNT >= 0x0400
     2023        BOOL IsLocked() const
     2024        {
     2025                return m_bLocked;
     2026        }
    19372027};
    19382028
     
    19462036// NOTE: Requires Windows Vista or Windows Server 2008
    19472037
     2038#if _WIN32_WINNT >= 0x0600
     2039
    19482040class CApiComReleaseReaderWriterLock
    19492041{
     
    19532045public:
    19542046// CApiComReleaseReaderWriterLock
    1955         CApiComReleaseReaderWriterLock() throw()
     2047        CApiComReleaseReaderWriterLock()
    19562048        {
    19572049                memset(&m_Lock, 0, sizeof m_Lock);
    19582050        }
    1959         ~CApiComReleaseReaderWriterLock() throw()
    1960         {
    1961         }
    1962         VOID Initialize() throw()
     2051        ~CApiComReleaseReaderWriterLock()
     2052        {
     2053        }
     2054        VOID Initialize()
    19632055        {
    19642056                InitializeSRWLock(&m_Lock);
    19652057        }
    1966         VOID Terminate() throw()
    1967         {
    1968         }
    1969         BOOL VerifyAcquiredExclusive() const throw()
     2058        VOID Terminate()
     2059        {
     2060        }
     2061        BOOL VerifyAcquiredExclusive() const
    19702062        {
    19712063                return TRUE; // No way to verify
    19722064        }
    1973         VOID AcquireExclusive() throw()
     2065        VOID AcquireExclusive()
    19742066        {
    19752067                AcquireSRWLockExclusive(&m_Lock);
    19762068        }
    1977 #if _WIN32_WINNT >= _WIN32_WINNT_WIN7
    1978         BOOLEAN TryAcquireExclusive() throw()
     2069        #if _WIN32_WINNT >= _WIN32_WINNT_WIN7
     2070                BOOLEAN TryAcquireExclusive()
    19792071        {
    19802072                return TryAcquireSRWLockExclusive(&m_Lock);
    19812073        }
    1982 #endif // _WIN32_WINNT >= _WIN32_WINNT_WIN7
    1983         VOID ReleaseExclusive() throw()
     2074        #endif // _WIN32_WINNT >= _WIN32_WINNT_WIN7
     2075        VOID ReleaseExclusive()
    19842076        {
    19852077                ReleaseSRWLockExclusive(&m_Lock);
    19862078        }
    1987         BOOL VerifyAcquiredShared() const throw()
     2079        BOOL VerifyAcquiredShared() const
    19882080        {
    19892081                return TRUE; // No way to verify
    19902082        }
    1991         VOID AcquireShared() throw()
     2083        VOID AcquireShared()
    19922084        {
    19932085                AcquireSRWLockShared(&m_Lock);
    19942086        }
    1995 #if _WIN32_WINNT >= _WIN32_WINNT_WIN7
    1996         BOOLEAN TryAcquireShared() throw()
     2087        #if _WIN32_WINNT >= _WIN32_WINNT_WIN7
     2088                BOOLEAN TryAcquireShared()
    19972089        {
    19982090                return TryAcquireSRWLockShared(&m_Lock);
    19992091        }
    2000 #endif // _WIN32_WINNT >= _WIN32_WINNT_WIN7
    2001         VOID ReleaseShared() throw()
     2092        #endif // _WIN32_WINNT >= _WIN32_WINNT_WIN7
     2093        VOID ReleaseShared()
    20022094        {
    20032095                ReleaseSRWLockShared(&m_Lock);
    20042096        }
    20052097};
     2098
     2099#endif // _WIN32_WINNT >= 0x0600
    20062100
    20072101////////////////////////////////////////////////////////////
     
    20162110public:
    20172111// CNativeComReleaseReaderWriterLockT
    2018         CNativeComReleaseReaderWriterLockT() throw() :
     2112        CNativeComReleaseReaderWriterLockT() :
    20192113                m_nLock(0)
    20202114        {
    20212115        }
    2022         ~CNativeComReleaseReaderWriterLockT() throw()
    2023         {
    2024         }
    2025         VOID Initialize() throw()
     2116        ~CNativeComReleaseReaderWriterLockT()
     2117        {
     2118        }
     2119        VOID Initialize()
    20262120        {
    20272121                m_nLock = 0;
    20282122        }
    2029         VOID Terminate() throw()
    2030         {
    2031         }
    2032         BOOL VerifyAcquiredExclusive() const throw()
     2123        VOID Terminate()
     2124        {
     2125        }
     2126        BOOL VerifyAcquiredExclusive() const
    20332127        {
    20342128                return TRUE; // No way to reliably verify
    20352129        }
    2036         VOID AcquireExclusiveNoSpin() throw()
     2130        VOID AcquireExclusiveNoSpin()
    20372131        {
    20382132                for(; ; )
     
    20442138                }
    20452139        }
    2046         VOID AcquireExclusiveSpin(UINT nSpinCount) throw()
     2140        VOID AcquireExclusiveSpin(UINT nSpinCount)
    20472141        {
    20482142                for(UINT nSpinIndex = 0; ; nSpinIndex++)
     
    20572151                }
    20582152        }
    2059         VOID AcquireExclusive() throw()
     2153        VOID AcquireExclusive()
    20602154        {
    20612155                (t_nDefaultSpinCount > 0) ? AcquireExclusiveSpin(t_nDefaultSpinCount) : AcquireExclusiveNoSpin();
    20622156        }
    2063         BOOLEAN TryAcquireExclusive() throw()
     2157        BOOLEAN TryAcquireExclusive()
    20642158        {
    20652159                if(m_nLock.ExchangeAdd(-0x10000) == 0)
     
    20682162                return FALSE;
    20692163        }
    2070         VOID ReleaseExclusive() throw()
     2164        VOID ReleaseExclusive()
    20712165        {
    20722166                _A(m_nLock < -0x10000 / 2);
    20732167                m_nLock.ExchangeAdd(+0x10000);
    20742168        }
    2075         BOOL VerifyAcquiredShared() const throw()
     2169        BOOL VerifyAcquiredShared() const
    20762170        {
    20772171                return TRUE; // No way to reliably verify
    20782172        }
    2079         VOID AcquireSharedNoSpin() throw()
     2173        VOID AcquireSharedNoSpin()
    20802174        {
    20812175                for(; ; )
     
    20872181                }
    20882182        }
    2089         VOID AcquireSharedSpin(UINT nSpinCount) throw()
     2183        VOID AcquireSharedSpin(UINT nSpinCount)
    20902184        {
    20912185                for(UINT nSpinIndex = 0; ; nSpinIndex++)
     
    21002194                }
    21012195        }
    2102         VOID AcquireShared() throw()
     2196        VOID AcquireShared()
    21032197        {
    21042198                (t_nDefaultSpinCount > 0) ? AcquireSharedSpin(t_nDefaultSpinCount) : AcquireSharedNoSpin();
    21052199        }
    2106         BOOLEAN TryAcquireShared() throw()
     2200        BOOLEAN TryAcquireShared()
    21072201        {
    21082202                if(m_nLock.Increment() > 0)
     
    21112205                return FALSE;
    21122206        }
    2113         VOID ReleaseShared() throw()
     2207        VOID ReleaseShared()
    21142208        {
    21152209                m_nLock.Decrement();
     
    21432237        public:
    21442238        // CAcquirement
    2145                 static BOOL IsEqualThreadIdentifier(const CAcquirement& Acquirement, DWORD nThreadIdentifier) throw()
     2239                static BOOL IsEqualThreadIdentifier(const CAcquirement& Acquirement, DWORD nThreadIdentifier)
    21462240                {
    21472241                        return Acquirement.m_nThreadIdentifier == nThreadIdentifier;
    21482242                }
    2149                 CAcquirement() throw()
    2150                 {
    2151                 }
    2152                 CAcquirement(DWORD nThreadIdentifier, BOOL bExclusive) throw() :
     2243                CAcquirement()
     2244                {
     2245                }
     2246                CAcquirement(DWORD nThreadIdentifier, BOOL bExclusive) :
    21532247                        m_nThreadIdentifier(nThreadIdentifier),
    21542248                        m_bExclusive(bExclusive)
     
    21682262        public:
    21692263        // CAcquirementList
    2170                 BOOL IsEmpty() const throw()
     2264                BOOL IsEmpty() const
    21712265                {
    21722266                        m_DataReaderWriterLock.AcquireShared();
     
    21752269                        return bResult;
    21762270                }
    2177                 BOOL Find(DWORD nThreadIdentifier = GetCurrentThreadId()) const throw()
     2271                BOOL Find(DWORD nThreadIdentifier = GetCurrentThreadId()) const
    21782272                {
    21792273                        POSITION Position = NULL;
     
    21832277                        return Position != NULL;
    21842278                }
    2185                 BOOL Find(BOOL& bExclusive, DWORD nThreadIdentifier = GetCurrentThreadId()) const throw()
     2279                BOOL Find(BOOL& bExclusive, DWORD nThreadIdentifier = GetCurrentThreadId()) const
    21862280                {
    21872281                        POSITION Position = NULL;
     
    21932287                        return Position != NULL;
    21942288                }
    2195                 VOID Add(BOOL bExclusive, DWORD nThreadIdentifier = GetCurrentThreadId()) throw()
     2289                VOID Add(BOOL bExclusive, DWORD nThreadIdentifier = GetCurrentThreadId())
    21962290                {
    21972291                        m_DataReaderWriterLock.AcquireExclusive();
     
    21992293                        m_DataReaderWriterLock.ReleaseExclusive();
    22002294                }
    2201                 BOOL RemoveLast(DWORD nThreadIdentifier = GetCurrentThreadId()) throw()
     2295                BOOL RemoveLast(DWORD nThreadIdentifier = GetCurrentThreadId())
    22022296                {
    22032297                        POSITION Position;
     
    22152309public:
    22162310// CComDebugReaderWriterLock
    2217         CComDebugReaderWriterLock() throw()
    2218         {
    2219         }
    2220         ~CComDebugReaderWriterLock() throw()
    2221         {
    2222         }
    2223         VOID Initialize() throw()
     2311        CComDebugReaderWriterLock()
     2312        {
     2313        }
     2314        ~CComDebugReaderWriterLock()
     2315        {
     2316        }
     2317        VOID Initialize()
    22242318        {
    22252319                __super::Initialize();
    22262320                _A(m_AcquirementList.IsEmpty());
    22272321        }
    2228         VOID Terminate() throw()
     2322        VOID Terminate()
    22292323        {
    22302324                _A(m_AcquirementList.IsEmpty());
    22312325        }
    2232         BOOL VerifyAcquiredExclusive() const throw()
     2326        BOOL VerifyAcquiredExclusive() const
    22332327        {
    22342328                BOOL bExclusive;
     
    22372331                return bExclusive;
    22382332        }
    2239         VOID AcquireExclusive() throw()
     2333        VOID AcquireExclusive()
    22402334        {
    22412335                _A(!m_AcquirementList.Find());
     
    22432337                m_AcquirementList.Add(TRUE);
    22442338        }
    2245         BOOLEAN TryAcquireExclusive() throw()
     2339        BOOLEAN TryAcquireExclusive()
    22462340        {
    22472341                _A(!m_AcquirementList.Find());
     
    22512345                return TRUE;
    22522346        }
    2253         VOID ReleaseExclusive() throw()
     2347        VOID ReleaseExclusive()
    22542348        {
    22552349                _W(m_AcquirementList.RemoveLast());
     
    22572351                _A(!m_AcquirementList.Find());
    22582352        }
    2259         BOOL VerifyAcquiredShared() const throw()
     2353        BOOL VerifyAcquiredShared() const
    22602354        {
    22612355                BOOL bExclusive;
     
    22642358                return !bExclusive;
    22652359        }
    2266         VOID AcquireShared() throw()
     2360        VOID AcquireShared()
    22672361        {
    22682362                _A(!m_AcquirementList.Find());
     
    22702364                m_AcquirementList.Add(FALSE);
    22712365        }
    2272         BOOLEAN TryAcquireShared() throw()
     2366        BOOLEAN TryAcquireShared()
    22732367        {
    22742368                _A(!m_AcquirementList.Find());
     
    22782372                return TRUE;
    22792373        }
    2280         VOID ReleaseShared() throw()
     2374        VOID ReleaseShared()
    22812375        {
    22822376                _W(m_AcquirementList.RemoveLast());
     
    23032397public:
    23042398// CComAutoReaderWriterLock
    2305         CComAutoReaderWriterLock() throw()
     2399        CComAutoReaderWriterLock()
    23062400        {
    23072401                __super::Initialize();
    23082402        }
    2309         ~CComAutoReaderWriterLock() throw()
     2403        ~CComAutoReaderWriterLock()
    23102404        {
    23112405                __super::Terminate();
     
    23222416        BOOL m_bLocked;
    23232417
    2324         CComReaderWriterLockExclusiveLockT(const CComReaderWriterLockExclusiveLockT&) throw();
    2325         CComReaderWriterLockExclusiveLockT& operator = (const CComReaderWriterLockExclusiveLockT&) throw();
     2418        CComReaderWriterLockExclusiveLockT(const CComReaderWriterLockExclusiveLockT&);
     2419        CComReaderWriterLockExclusiveLockT& operator = (const CComReaderWriterLockExclusiveLockT&);
    23262420
    23272421public:
    23282422// CComReaderWriterLockExclusiveLockT
    2329         CComReaderWriterLockExclusiveLockT(_ReaderWriterLock& ReaderWriterLock, BOOL bInitialLock = TRUE) throw() :
     2423        CComReaderWriterLockExclusiveLockT(_ReaderWriterLock& ReaderWriterLock, BOOL bInitialLock = TRUE) :
    23302424                m_Lock(ReaderWriterLock),
    23312425                m_bLocked(FALSE)
     
    23342428                        Lock();
    23352429        }
    2336         ~CComReaderWriterLockExclusiveLockT() throw()
     2430        ~CComReaderWriterLockExclusiveLockT()
    23372431        {
    23382432                if(m_bLocked)
    23392433                        Unlock();
    23402434        }
    2341         VOID Lock() throw()
     2435        VOID Lock()
    23422436        {
    23432437                _A(!m_bLocked);
     
    23462440        }
    23472441//#if _WIN32_WINNT >= _WIN32_WINNT_WIN7
    2348         BOOL TryLock() throw()
     2442        BOOL TryLock()
    23492443        {
    23502444                _A(!m_bLocked);
     
    23552449        }
    23562450//#endif // _WIN32_WINNT >= _WIN32_WINNT_WIN7
    2357         VOID Unlock() throw()
     2451        VOID Unlock()
    23582452        {
    23592453                ATLASSUME(m_bLocked);
     
    23702464        BOOL m_bUnlocked;
    23712465
    2372         CComReaderWriterLockExclusiveUnlockT(const CComReaderWriterLockExclusiveUnlockT&) throw();
    2373         CComReaderWriterLockExclusiveUnlockT& operator = (const CComReaderWriterLockExclusiveUnlockT&) throw();
     2466        CComReaderWriterLockExclusiveUnlockT(const CComReaderWriterLockExclusiveUnlockT&);
     2467        CComReaderWriterLockExclusiveUnlockT& operator = (const CComReaderWriterLockExclusiveUnlockT&);
    23742468
    23752469public:
    23762470// CComReaderWriterLockExclusiveUnlockT
    2377         CComReaderWriterLockExclusiveUnlockT(_ReaderWriterLock& ReaderWriterLock, BOOL bInitialUnlock = TRUE) throw() :
     2471        CComReaderWriterLockExclusiveUnlockT(_ReaderWriterLock& ReaderWriterLock, BOOL bInitialUnlock = TRUE) :
    23782472                m_Lock(ReaderWriterLock),
    23792473                m_bUnlocked(FALSE)
     
    23822476                        Unlock();
    23832477        }
    2384         ~CComReaderWriterLockExclusiveUnlockT() throw()
     2478        ~CComReaderWriterLockExclusiveUnlockT()
    23852479        {
    23862480                if(m_bUnlocked)
    23872481                        Lock();
    23882482        }
    2389         VOID Unlock() throw()
     2483        VOID Unlock()
    23902484        {
    23912485                _A(!m_bUnlocked);
     
    23932487                m_bUnlocked = TRUE;
    23942488        }
    2395         VOID Lock() throw()
     2489        VOID Lock()
    23962490        {
    23972491                ATLASSUME(m_bUnlocked);
     
    24002494        }
    24012495//#if _WIN32_WINNT >= _WIN32_WINNT_WIN7
    2402         BOOL TryLock() throw()
     2496        BOOL TryLock()
    24032497        {
    24042498                _A(!m_bLocked);
     
    24182512        BOOL m_bLocked;
    24192513
    2420         CComReaderWriterLockSharedLockT(const CComReaderWriterLockSharedLockT&) throw();
    2421         CComReaderWriterLockSharedLockT& operator = (const CComReaderWriterLockSharedLockT&) throw();
     2514        CComReaderWriterLockSharedLockT(const CComReaderWriterLockSharedLockT&);
     2515        CComReaderWriterLockSharedLockT& operator = (const CComReaderWriterLockSharedLockT&);
    24222516
    24232517public:
    24242518// CComReaderWriterLockSharedLockT
    2425         CComReaderWriterLockSharedLockT(_ReaderWriterLock& ReaderWriterLock, BOOL bInitialLock = TRUE) throw() :
     2519        CComReaderWriterLockSharedLockT(_ReaderWriterLock& ReaderWriterLock, BOOL bInitialLock = TRUE) :
    24262520                m_Lock(ReaderWriterLock),
    24272521                m_bLocked(FALSE)
     
    24302524                        Lock();
    24312525        }
    2432         ~CComReaderWriterLockSharedLockT() throw()
     2526        ~CComReaderWriterLockSharedLockT()
    24332527        {
    24342528                if(m_bLocked)
    24352529                        Unlock();
    24362530        }
    2437         VOID Lock() throw()
     2531        VOID Lock()
    24382532        {
    24392533                _A(!m_bLocked);
     
    24422536        }
    24432537//#if _WIN32_WINNT >= _WIN32_WINNT_WIN7
    2444         BOOL TryLock() throw()
     2538        BOOL TryLock()
    24452539        {
    24462540                _A(!m_bLocked);
     
    24512545        }
    24522546//#endif // _WIN32_WINNT >= _WIN32_WINNT_WIN7
    2453         VOID Unlock() throw()
     2547        VOID Unlock()
    24542548        {
    24552549                ATLASSUME(m_bLocked);
     
    24662560        BOOL m_bUnlocked;
    24672561
    2468         CComReaderWriterLockSharedUnlockT(const CComReaderWriterLockSharedUnlockT&) throw();
    2469         CComReaderWriterLockSharedUnlockT& operator = (const CComReaderWriterLockSharedUnlockT&) throw();
     2562        CComReaderWriterLockSharedUnlockT(const CComReaderWriterLockSharedUnlockT&);
     2563        CComReaderWriterLockSharedUnlockT& operator = (const CComReaderWriterLockSharedUnlockT&);
    24702564
    24712565public:
    24722566// CComReaderWriterLockSharedUnlockT
    2473         CComReaderWriterLockSharedUnlockT(_ReaderWriterLock& ReaderWriterLock, BOOL bInitialUnlock = TRUE) throw() :
     2567        CComReaderWriterLockSharedUnlockT(_ReaderWriterLock& ReaderWriterLock, BOOL bInitialUnlock = TRUE) :
    24742568                m_Lock(ReaderWriterLock),
    24752569                m_bUnlocked(FALSE)
     
    24782572                        Unlock();
    24792573        }
    2480         ~CComReaderWriterLockSharedUnlockT() throw()
     2574        ~CComReaderWriterLockSharedUnlockT()
    24812575        {
    24822576                if(m_bUnlocked)
    24832577                        Lock();
    24842578        }
    2485         VOID Unlock() throw()
     2579        VOID Unlock()
    24862580        {
    24872581                _A(!m_bUnlocked);
     
    24892583                m_bUnlocked = TRUE;
    24902584        }
    2491         VOID Lock() throw()
     2585        VOID Lock()
    24922586        {
    24932587                ATLASSUME(m_bUnlocked);
     
    24962590        }
    24972591//#if _WIN32_WINNT >= _WIN32_WINNT_WIN7
    2498         BOOL TryLock() throw()
     2592        BOOL TryLock()
    24992593        {
    25002594                _A(!m_bLocked);
  • trunk/Common/alax.info/rowindows.h

    r77 r482  
    11////////////////////////////////////////////////////////////
    2 // Copyright (C) Roman Ryltsov, 2006-2012
     2// Template class library; extends Widnows SDK, ATL, WTL
     3//
     4// Copyright (C) Roman Ryltsov, 2006-2015
    35// Created by Roman Ryltsov roman@alax.info
    4 //
    5 // $Id$
    66//
    7 // A permission to use the source code is granted as long as reference to
    8 // source website http://alax.info is retained.
     7// A permission to re-use this source code is granted as long as copyright notice and
     8// reference to source website http://alax.info is retained.
    99
    1010#pragma once
     
    359359        static HWND GetParentWindow() throw()
    360360        {
    361 #if WINVER >= 0x0500
    362                 OSVERSIONINFO VersionInformation = { sizeof VersionInformation };
    363                 ATLVERIFY(GetVersionEx(&VersionInformation));
    364                 if(VersionInformation.dwPlatformId == VER_PLATFORM_WIN32_NT && VersionInformation.dwMajorVersion >= 5)
    365                         return HWND_MESSAGE;
    366 #endif // WINVER >= 0x0500
    367                 return NULL;
     361                return HWND_MESSAGE; // Windows 2000+
    368362        }
    369363        HWND Create(HWND hParentWindow = GetParentWindow(), _U_RECT Position = NULL, LPCTSTR pszWindowName = NULL, DWORD nStyle = 0, DWORD nExStyle = 0, _U_MENUorID Menu = 0U, VOID* pvCreateParameter = NULL)
     
    393387        {
    394388                CRoCriticalSectionLock DataLock(m_DataCriticalSection);
    395                 UINT_PTR nCookie = ++m_nCounter;
     389                const UINT_PTR nCookie = ++m_nCounter;
    396390                _A(!m_ParameterMap.Lookup((UINT) nCookie));
    397                 m_ParameterMap[(UINT) nCookie] = pParameter;
     391                m_ParameterMap[nCookie] = pParameter;
    398392                return nCookie;
    399393        }
     
    406400        CAutoPtr<_Parameter> RemoveParameter(UINT_PTR nCookie) throw()
    407401        {
     402                CRoCriticalSectionLock DataLock(m_DataCriticalSection);
     403                const POSITION Position = m_ParameterMap.Lookup(nCookie);
    408404                CAutoPtr<_Parameter> pParameter;
     405                if(!Position)
     406                        return pParameter; // Nothing
     407                pParameter = m_ParameterMap.GetValueAt(Position);
     408                m_ParameterMap.RemoveAtPos(Position);
     409                return pParameter;
     410        }
     411        SIZE_T RemoveAllParameters() throw()
     412        {
    409413                CRoCriticalSectionLock DataLock(m_DataCriticalSection);
    410                 POSITION Position = m_ParameterMap.Lookup((UINT) nCookie);
    411                 if(Position)
    412                 {
    413                         pParameter = m_ParameterMap.GetValueAt(Position);
    414                         m_ParameterMap.RemoveAtPos(Position);
    415                 }
    416                 return pParameter;
    417         }
    418         VOID RemoveAllParameters() throw()
    419         {
    420                 CRoCriticalSectionLock DataLock(m_DataCriticalSection);
     414                const SIZE_T nCount = m_ParameterMap.GetCount();
    421415                m_ParameterMap.RemoveAll();
     416                return nCount;
    422417        }
    423418};
     
    484479        SIZE_T DispatchPrivateMessages() throw()
    485480        {
    486                 return RemovePrivateMessages(DispatchPrivateMessage);
     481                return RemovePrivateMessages(&T::DispatchPrivateMessage);
    487482        }
    488483        LRESULT HandlePostedPrivateMessage(WPARAM wParam, LPARAM lParam) throw()
     
    499494        }
    500495};
     496
     497inline SSIZE_T WaitForMultipleObjectsDispatchingMessages(SIZE_T nObjectCount, const HANDLE* phObjects, BOOL bWaitAllObjects = FALSE, ULONG nTimeoutTime = INFINITE, DWORD nWakeMask = QS_ALLINPUT | QS_ALLPOSTMESSAGE)
     498{
     499        _A(phObjects && nObjectCount);
     500        const ULONG nReturnTime = GetTickCount() + nTimeoutTime;
     501        DWORD nWaitResult;
     502        for(; ; )
     503        {
     504                ULONG nCurrentTimeoutTime;
     505                if(nTimeoutTime != INFINITE)
     506                {
     507                        nCurrentTimeoutTime = nReturnTime - GetTickCount();
     508                        if((LONG) nCurrentTimeoutTime <= 0)
     509                                return WAIT_TIMEOUT;
     510                } else
     511                        nCurrentTimeoutTime = INFINITE;
     512                nWaitResult = MsgWaitForMultipleObjects((DWORD) nObjectCount, phObjects, bWaitAllObjects, nCurrentTimeoutTime, nWakeMask);
     513                _Z5_WAITRESULT(nWaitResult);
     514                _A(nWaitResult - WAIT_OBJECT_0 <= nObjectCount || nWaitResult == WAIT_TIMEOUT && nCurrentTimeoutTime != INFINITE);
     515                if(nWaitResult - WAIT_OBJECT_0 != nObjectCount)
     516                        break;
     517                MSG Message;
     518                while(PeekMessage(&Message, NULL, WM_NULL, WM_NULL, PM_REMOVE))
     519                {
     520                        TranslateMessage(&Message);
     521                        DispatchMessage(&Message);
     522                }
     523        }
     524        return nWaitResult;
     525}
    501526
    502527////////////////////////////////////////////////////////////
     
    836861};
    837862
     863////////////////////////////////////////////////////////////
     864// CThreadHookData
     865
     866class CThreadHookData
     867{
     868public:
     869        DWORD m_nThreadIdentifier;
     870        HHOOK m_hHook;
     871
     872public:
     873// CThreadHookData
     874        CThreadHookData() :
     875                m_hHook(NULL)
     876        {
     877        }
     878};
     879       
     880////////////////////////////////////////////////////////////
     881// CThreadGetMessageHookTraits
     882
     883class CThreadGetMessageHookTraits
     884{
     885public:
     886        typedef MSG CMessageData;
     887
     888public:
     889// CThreadPreMessageHookTraits
     890        static INT GetHookIdentifier()
     891        {
     892                return WH_GETMESSAGE;
     893        }
     894};
     895
     896////////////////////////////////////////////////////////////
     897// CThreadPreMessageHookTraits
     898
     899class CThreadPreMessageHookTraits
     900{
     901public:
     902        typedef CWPSTRUCT CMessageData;
     903
     904public:
     905// CThreadPreMessageHookTraits
     906        static INT GetHookIdentifier()
     907        {
     908                return WH_CALLWNDPROC;
     909        }
     910};
     911       
     912////////////////////////////////////////////////////////////
     913// CThreadPostMessageHookTraits
     914
     915class CThreadPostMessageHookTraits
     916{
     917public:
     918        typedef CWPRETSTRUCT CMessageData;
     919
     920public:
     921// CThreadPostMessageHookTraits
     922        static INT GetHookIdentifier()
     923        {
     924                return WH_CALLWNDPROCRET;
     925        }
     926};
     927       
     928////////////////////////////////////////////////////////////
     929// CThreadMessageHookT
     930       
     931template <typename T, typename CTraits, typename CHookData = CThreadHookData>
     932class CThreadMessageHookT
     933{
     934private:
     935        static CRoListT<CHookData>* g_pHookDataList;
     936        CHookData* m_pHookData;
     937
     938        static BOOL FindHook(POSITION& Position, DWORD nThreadIdentifier = GetCurrentThreadId())
     939        {
     940                _A(_pAtlModule);
     941                CComCritSecLock<CComCriticalSection> DataLock(_pAtlModule->m_csStaticDataInitAndTypeInfo);
     942                if(g_pHookDataList)
     943                        for(POSITION CurrentPosition = g_pHookDataList->GetTailPosition(); CurrentPosition; g_pHookDataList->GetPrev(CurrentPosition))
     944                        {
     945                                const CHookData& HookData = g_pHookDataList->GetAt(CurrentPosition);
     946                                if(HookData.m_nThreadIdentifier != nThreadIdentifier)
     947                                        continue;
     948                                Position = CurrentPosition;
     949                                return TRUE;
     950                        }
     951                return FALSE;
     952        }
     953        static BOOL FindHook(HHOOK& hHook, DWORD nThreadIdentifier = GetCurrentThreadId())
     954        {
     955                _A(_pAtlModule);
     956                CComCritSecLock<CComCriticalSection> DataLock(_pAtlModule->m_csStaticDataInitAndTypeInfo);
     957                POSITION Position;
     958                if(!FindHook(Position, nThreadIdentifier))
     959                        return FALSE;
     960                _A(g_pHookDataList);
     961                hHook = g_pHookDataList->GetAt(Position).m_hHook;
     962                return TRUE;
     963        }
     964        static LRESULT CALLBACK HookProc(INT nCode, WPARAM wParam, LPARAM lParam)
     965        {
     966                HHOOK hHook;
     967                if(!FindHook(hHook))
     968                        return 0;
     969                if(nCode == HC_ACTION)
     970                        T::HandleMessage(wParam, *((CTraits::CMessageData*) lParam));
     971                return CallNextHookEx(hHook, nCode, wParam, lParam);
     972        }
     973
     974protected:
     975        static BOOL CheckClassName(HWND hWindow, LPCTSTR pszClassName)
     976        {
     977                TCHAR pszWindowClassName[64] = { 0 };
     978                _W(GetClassName(hWindow, pszWindowClassName, _countof(pszWindowClassName)));
     979                return _tcscmp(pszWindowClassName, pszClassName) == 0;
     980        }
     981        static CString GetWindowText(HWND hWindow)
     982        {
     983                CString sWindowText;
     984                CWindow(hWindow).GetWindowText(sWindowText);
     985                return sWindowText;
     986        }
     987        static BOOL FindHookData(CHookData*& pHookData, DWORD nThreadIdentifier = GetCurrentThreadId())
     988        {
     989                _A(_pAtlModule);
     990                _A(VerifyCriticalSectionLocked(_pAtlModule->m_csStaticDataInitAndTypeInfo));
     991                POSITION Position;
     992                if(!FindHook(Position, nThreadIdentifier))
     993                        return FALSE;
     994                _A(g_pHookDataList);
     995                pHookData = &g_pHookDataList->GetAt(Position);
     996                return TRUE;
     997        }
     998        static BOOL FindHookData(CHookData& HookData, DWORD nThreadIdentifier = GetCurrentThreadId())
     999        {
     1000                _A(_pAtlModule);
     1001                CComCritSecLock<CComCriticalSection> DataLock(_pAtlModule->m_csStaticDataInitAndTypeInfo);
     1002                POSITION Position;
     1003                if(!FindHook(Position, nThreadIdentifier))
     1004                        return FALSE;
     1005                _A(g_pHookDataList);
     1006                HookData = g_pHookDataList->GetAt(Position);
     1007                return TRUE;
     1008        }
     1009        CHookData* GetHookData() const
     1010        {
     1011                return m_pHookData;
     1012        }
     1013        static VOID HandleMessage(WPARAM, typename CTraits::CMessageData&);
     1014
     1015public:
     1016// CThreadMessageHookT
     1017        CThreadMessageHookT() :
     1018                m_pHookData(NULL)
     1019        {
     1020        }
     1021        ~CThreadMessageHookT()
     1022        {
     1023                Terminate();
     1024        }
     1025        VOID Initialize()
     1026        {
     1027                _A(!m_pHookData);
     1028                const HINSTANCE hInstance = NULL; //_AtlBaseModule.GetModuleInstance()
     1029                const DWORD nThreadIdentifier = GetCurrentThreadId();
     1030                const HHOOK hHook = SetWindowsHookEx(CTraits::GetHookIdentifier(), HookProc, hInstance, nThreadIdentifier);
     1031                __E(hHook);
     1032                _A(_pAtlModule);
     1033                CComCritSecLock<CComCriticalSection> DataLock(_pAtlModule->m_csStaticDataInitAndTypeInfo);
     1034                if(!g_pHookDataList)
     1035                        g_pHookDataList = new CRoListT<CHookData>;
     1036                const POSITION Position = g_pHookDataList->AddTail();
     1037                CHookData& HookData = g_pHookDataList->GetAt(Position);
     1038                HookData.m_nThreadIdentifier = nThreadIdentifier;
     1039                HookData.m_hHook = hHook;
     1040                m_pHookData = &HookData;
     1041        }
     1042        VOID Terminate()
     1043        {
     1044                if(m_pHookData)
     1045                {
     1046                        HHOOK hHook = NULL;
     1047                        {
     1048                                _A(_pAtlModule);
     1049                                CComCritSecLock<CComCriticalSection> DataLock(_pAtlModule->m_csStaticDataInitAndTypeInfo);
     1050                                POSITION Position = NULL;
     1051                                if(FindHook(Position))
     1052                                {
     1053                                        _A(m_pHookData == &g_pHookDataList->GetAt(Position));
     1054                                        hHook = g_pHookDataList->GetAt(Position).m_hHook;
     1055                                        g_pHookDataList->RemoveAt(Position);
     1056                                        if(g_pHookDataList->IsEmpty())
     1057                                        {
     1058                                                delete g_pHookDataList;
     1059                                                g_pHookDataList = NULL;
     1060                                        }
     1061                                } else
     1062                                        _A(FALSE);
     1063                                m_pHookData = NULL;
     1064                        }
     1065                        if(hHook)
     1066                                _W(UnhookWindowsHookEx(hHook));
     1067                }
     1068        }
     1069};
     1070
     1071template <typename T, typename CTraits, typename CHookData>
     1072__declspec(selectany) CRoListT<CHookData>* CThreadMessageHookT<T, CTraits, CHookData>::g_pHookDataList = NULL;
     1073
  • trunk/Common/alax.info/rowtlapp.h

    r77 r482  
    11////////////////////////////////////////////////////////////
    2 // Copyright (C) Roman Ryltsov, 2006-2012
     2// Template class library; extends Widnows SDK, ATL, WTL
     3//
     4// Copyright (C) Roman Ryltsov, 2006-2015
    35// Created by Roman Ryltsov roman@alax.info
    4 //
    5 // $Id$
    66//
    7 // A permission to use the source code is granted as long as reference to
    8 // source website http://alax.info is retained.
     7// A permission to re-use this source code is granted as long as copyright notice and
     8// reference to source website http://alax.info is retained.
    99
    1010#pragma once
  • trunk/Common/alax.info/rowtlcrack.h

    r77 r482  
    11////////////////////////////////////////////////////////////
    2 // Copyright (C) Roman Ryltsov, 2006-2012
     2// Template class library; extends Widnows SDK, ATL, WTL
     3//
     4// Copyright (C) Roman Ryltsov, 2006-2015
    35// Created by Roman Ryltsov roman@alax.info
    4 //
    5 // $Id$
    66//
    7 // A permission to use the source code is granted as long as reference to
    8 // source website http://alax.info is retained.
     7// A permission to re-use this source code is granted as long as copyright notice and
     8// reference to source website http://alax.info is retained.
    99
    1010#pragma once
Note: See TracChangeset for help on using the changeset viewer.