Filter Library

Camera

Interface Physics

QAFDebug.cpp

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////////
//
//  QAFDebug critical error log
//
//  Copyright (c) 2000-2004
//  Andrew Schetinin
//
//  This software is provided "as is" without express or implied warranty, 
//  and with no claim as to its suitability for any purpose.
//
//  Permission to use or copy this software for any purpose is hereby granted 
//  without fee, provided the above notices are retained on all copies.
//  Permission to modify the code and to distribute modified code is granted,
//  provided the above notices are retained, and a notice that the code was
//  modified is included with the above copyright notice.
//
//  This software accompanies the article "Code that debugs itself"
//  located at http://www.codeproject.com/debug/qafdebug.asp
//
//  You are welcomed to report bugs, send comments and post code modifications 
//  to aschetinin@hotmail.com 
//
/////////////////////////////////////////////////////////////////////////////////

///
/// @file       QAFDebug.cpp "../Src/QAFDebug.cpp"
/// @brief      Implementation of functions for reporting critical errors.
///         
///                     This is the implementation of the "QAFDebug.h" macros. 
///

#include "stdafx.h"

#include "QAFDebug.h"

#include <malloc.h>
#include <shlobj.h>

// Only if reporting is not disabled
#ifndef QAF_DISABLED

////////////////////////////////////////////////////////////////////////////////////
// Defines and constants
////////////////////////////////////////////////////////////////////////////////////

/// Size of the shared flags stored in the memory-mapped-file 
const DWORD QDEBUG_SHMEMSIZE = sizeof(DWORD);

/// Buffer length for HRESULT formatting
const DWORD QAFDEBUG_FMT_HRESULT_LEN = 20;

/// Format string for HRESULT formatting
const LPCTSTR QAFDEBUG_FMT_HRESULT = _T("FAILED(0x%08X)");

/// Buffer length for ERROR_SUCCESS formatting
const DWORD QAFDEBUG_FMT_ERROR_SUCCESS_LEN = 30;

/// Format string for ERROR_SUCCESS formatting
const LPCTSTR QAFDEBUG_FMT_ERROR_SUCCESS = _T("(ERROR_SUCCESS != 0x%08X)");

// DebugOutString() for saving to file:
//
// C:\SharedUnits\Dev\QMSOColl\QMSOColl.cpp(137) : Assertion raised
//         time:        2003-12-07 15:48:07:507 
//         process:     0x00000E24 
//         thread:      0x00000E2C 
//         application: C:\Program Files\Microsoft Office\Office10\WINWORD.EXE <1.4.6.7> 
//         module:      C:\SharedUnits\Dev\QMSOColl\Debug\QMSOColl.dll <1.4.6.7> 
//         last error:  6, The handle is invalid. 
//         expression:  DuplicateHandle( NULL, NULL, NULL, NULL, 0, FALSE, 0 ) 

// IMPORTANT:
//            I limit here format string output to be safe in the buffer of 2048 characters.
//            Otherwise the buffer may be overrun.

/// Maximum size of the debug record.
const size_t MAX_BUF_SIZE = 2048;

/// 3 parameters
/// "filename(line) : error message" 
#define QAFDEBUG_FMT_SPOS _T("%.250s(%d) : %.600s")

/// End of line + tab
#define QAFDEBUG_FMT_PREFIX _T("\r\n\t")

/// 7 parameters - formatting date and time
/// "        time:        2003-12-07 15:48:07:507"          
#define QAFDEBUG_FMT_DATE QAFDEBUG_FMT_PREFIX _T("time:        ") _T("%04d-%02d-%02d %02d:%02d:%02d:%03d")

/// 1 parameter - formatting process info
/// "        process:     0x00000E24" 
#define QAFDEBUG_FMT_PROC QAFDEBUG_FMT_PREFIX _T("process:     ") _T("0x%08X")

/// 1 parameter - formatting thread info
/// "        thread:      0x00000E2C" 
#define QAFDEBUG_FMT_THRE QAFDEBUG_FMT_PREFIX _T("thread:      ") _T("0x%08X")

/// 1 parameter - formatting application info
/// "        application: C:\Program Files\Microsoft Office\Office10\WINWORD.EXE <1.4.6.7>" 
#define QAFDEBUG_FMT_APPL QAFDEBUG_FMT_PREFIX _T("application: ") _T("%.250s")

/// 1 parameter - formatting module info
/// "        module:      C:\SharedUnits\Dev\QMSOColl\Debug\QMSOColl.dll <1.4.6.7>" 
#define QAFDEBUG_FMT_MODU QAFDEBUG_FMT_PREFIX _T("module:      ") _T("%.250s")

/// 1 parameter - formatting last error info
/// "        last error:  6, The handle is invalid." 
#define QAFDEBUG_FMT_LERR QAFDEBUG_FMT_PREFIX _T("last error:  ") _T("%.250s")

/// 1 parameter - formatting expression info
/// "        expression:  DuplicateHandle( NULL, NULL, NULL, NULL, 0, FALSE, 0 )" 
#define QAFDEBUG_FMT_EXPR QAFDEBUG_FMT_PREFIX _T("expression:  ") _T("%.250s")

/// The resulting format strings
/// 16 parameters
#define QAFDEBUG_STD_FORMAT \
                        QAFDEBUG_FMT_SPOS \
                        QAFDEBUG_FMT_DATE \
                        QAFDEBUG_FMT_PROC \
                        QAFDEBUG_FMT_THRE \
                        QAFDEBUG_FMT_APPL \
                        QAFDEBUG_FMT_MODU \
                        QAFDEBUG_FMT_LERR \
                        QAFDEBUG_FMT_EXPR

// Fixed error messages for faults in the debug engine
#define QAFDEBUG_ERROR_MUTEX_CREATE       QAFDEBUG_ERROR_PREFIX _T("Mutex is not created\r\n")
#define QAFDEBUG_ERROR_MAP_FILE_CREATE    QAFDEBUG_ERROR_PREFIX _T("Mapped-memory file is not created\r\n")
#define QAFDEBUG_ERROR_LOG_FILE_PATH      QAFDEBUG_ERROR_PREFIX _T("Path to the error log file cannot be retrieved\r\n")
#define QAFDEBUG_ERROR_POINTER_NOT_MAPPED QAFDEBUG_ERROR_PREFIX _T("Memory pointer is not mapped to the Mapped-memory file\r\n")
#define QAFDEBUG_ERROR_NULL               QAFDEBUG_ERROR_PREFIX _T("qafOutputDebugString() got an empty error message.\r\n")
#define QAFDEBUG_ERROR_STD_NULL           QAFDEBUG_ERROR_PREFIX _T("QAFDebug::std pointer is not initialized.\r\n")
#define QAFDEBUG_ERROR_OPEN_LOG_FILE      QAFDEBUG_ERROR_PREFIX _T("Debug log file cannot be opened.\r\n")
#define QAFDEBUG_ERROR_ALLOCATE_BUFFER    QAFDEBUG_ERROR_PREFIX _T("Cannot allocate memory for formatting the error message.\r\n")
#define QAFDEBUG_ERROR_NULL_ARGS          QAFDEBUG_ERROR_PREFIX _T("NULL input parameters for formatting the error message.\r\n")
#define QAFDEBUG_ERROR_FORMAT             QAFDEBUG_ERROR_PREFIX _T("Cannot format the error message.\r\n")
#define QAFDEBUG_ERROR_CLOSE_FILE         QAFDEBUG_ERROR_PREFIX _T("Cannot close the debug log file\r\n")
#define QAFDEBUG_ERROR_BACKUP             QAFDEBUG_ERROR_PREFIX _T("Cannot create a backup copy of the debug log file\r\n")

////////////////////////////////////////////////////////////////////////////////////
// Service Functions
////////////////////////////////////////////////////////////////////////////////////

#pragma warning( push )
#pragma warning( disable : 4100 )       // (possibly) unreferenced formal parameter

///
/// @fn ODS
/// @brief Replacement for OutputDebugString() with checking that it is enabled.
///
inline void ODS( LPCTSTR szMessage )
{
        #ifndef QAF_OUTPUTDEBUGSTRING_DISABLED
                OutputDebugString( szMessage );
        #endif
}

#pragma warning( pop )

////////////////////////////////////////////////////////////////////////////////////
// Classes
////////////////////////////////////////////////////////////////////////////////////

/// A simple synchronization class, designed to be used as an automatic variable.
/// Once its instance is instanciated, it locks its visibility scope. 
class CSync
{
public:
        
        /// Flag that the critical section object must be constructed or destroyed
        enum CSOP { CS_NOP = 0, CS_CREATE = 1, CS_DESTROY = 2 };
        
        /// Constructor creates and enters the critical section
        CSync( CRITICAL_SECTION * pcs, const CSOP csop = CS_NOP )
        {
                m_pcs = pcs;
                m_csop = csop;
                if( CS_CREATE == m_csop )
                        InitializeCriticalSection( m_pcs ); 
                EnterCriticalSection( m_pcs ); 
        }
        
        /// Destructor leaves and destroys the critical section
        ~CSync() 
        {
                LeaveCriticalSection( m_pcs ); 
                if( CS_DESTROY == m_csop )
                        DeleteCriticalSection( m_pcs ); 
        }

private:
        
        /// Critical section is used for synchronization
        CRITICAL_SECTION * m_pcs;
        
        /// Flag that the critical section object must be constructed or destroyed
        CSOP m_csop;
        
};

///
/// @class CQAFDebug
/// @brief Class to generate debug log
///
class CQAFDebug
{
private:

        #ifndef QAF_UNITTEST_DISABLED
        /// This is a named mutex that regulates access to the memory-mapped-file.
        HANDLE m_hMutex;

        /// Pointer to the shared memory that contains the shared flags.
        LPVOID m_pMem; 

        /// Handle of the shared memory-mapped-file.
        HANDLE m_hMapObject;  
        #endif

        /// Name of the log file, it is initialized by the constructor
        #ifndef QAF_LOGFILE_DISABLED
        TCHAR m_szLogFileName[MAX_PATH];
        #endif

        /// Critical section is used for synchronization the class methods
        CRITICAL_SECTION m_cs;

        /// Application name
        TCHAR m_szApplicationName[MAX_PATH];

protected:
        
        #ifndef QAF_UNITTEST_DISABLED
        /// Set the shared flag in the memory mapped file
        bool SetSharedFlag( const DWORD dwFlag ) 
        { 
                if( ! tryLock() )
                        return false;
                
                memcpy( m_pMem, &dwFlag, sizeof(dwFlag) );
                
                unLock();
                
                return true;
        } 
        
        /// Get the shared flag from the memory mapped file
        void CQAFDebug::GetSharedFlag( const LPDWORD pdwFlag ) 
        { 
                if( (NULL != pdwFlag) && tryLock() )
                {
                        memcpy( pdwFlag, m_pMem, sizeof(*pdwFlag) );
                        unLock();
                }
        }
        
        /// Try to lock the memory mapped file.
        bool tryLock()
        {
                return (WaitForSingleObject( m_hMutex, 50 ) == WAIT_OBJECT_0);
        }
        
        /// Unlock the locked memory mapped file.
        void unLock()
        {
                ReleaseMutex( m_hMutex );
        }
        #endif
        
        /// Generate the file name and directory (check that the file is here).
        /// Get the buffer and the buffer length in TCHAR characters including tailing 0x00(00).
        /// Returns the length of the written string or 0 if the file name cannot be generated.
        /// The file name is constructed from the:
        /// 1. Try get the folder path from the environment variable QAFDEBUG_LOG_ENV_VAR
        /// 2. Try CSIDL_APPDATA (C:\Documents and Settings\username\Application Data) + QAFDEBUG_LOG_SUBFOLDER
        /// 3. Try CSIDL_COMMON_APPDATA (C:\Documents and Settings\All Users\Application Data) + QAFDEBUG_LOG_SUBFOLDER
        /// 4. Return 0
        /// If the folders are missing on the disk, they are created.
        static DWORD qafGetLogFileName( LPTSTR szFilenameBuf, const DWORD dwMaxLen );
        
        /// Get the shared instance of the log class
        static CQAFDebug & instance( void )
        {
                // Initialize the static instance (it will be a global variable)
                static CQAFDebug std_err;
                // Return the instance
                return std_err;
        }
        
public:

        /// Constructor. It does some complex initialization of memory shared files and instance pointers.
        CQAFDebug()
                #ifndef QAF_UNITTEST_DISABLED
                : m_hMutex(NULL), m_hMapObject(NULL), m_pMem(NULL)
                #endif
        {
                CSync sync( &m_cs, CSync::CS_CREATE );
        
                if( 0 == SetLogModule( NULL, m_szApplicationName, MAX_PATH ) )
                        m_szApplicationName[0] = 0;

                #ifndef QAF_LOGFILE_DISABLED
                // Initialize the file name
                if( 0 == qafGetLogFileName( m_szLogFileName, MAX_PATH ) )
                        m_szLogFileName[0] = 0;
                #endif

                #ifndef QAF_UNITTEST_DISABLED
                m_hMutex = CreateMutex( NULL, false, QAFDEBUG_SILENCE_MUTEX );
                if( NULL == m_hMutex )
                        ODS( QAFDEBUG_ERROR_MUTEX_CREATE );
                
                m_hMapObject = CreateFileMapping( 
                        INVALID_HANDLE_VALUE, // use paging file
                        NULL,                 // default security attributes
                        PAGE_READWRITE,       // read/write access
                        0,                    // size: high 32-bits
                        QDEBUG_SHMEMSIZE,     // size: low 32-bits
                        QDEBUG_SHMEMFILE );   // name of map object
                if( NULL == m_hMapObject ) 
                        ODS( QAFDEBUG_ERROR_MAP_FILE_CREATE ); 
                
                // The first process to attach initializes memory.
                bool fInit = (GetLastError() != ERROR_ALREADY_EXISTS); 
                
                // Get a pointer to the file-mapped shared memory.
                m_pMem = MapViewOfFile( 
                        m_hMapObject,     // object to map view of
                        FILE_MAP_WRITE, // read/write access
                        0,              // high offset:  map from
                        0,              // low offset:   beginning
                        0 );            // default: map entire file
                if( NULL == m_pMem ) 
                        ODS( QAFDEBUG_ERROR_POINTER_NOT_MAPPED ); 
                
                if( fInit )
                        SetSharedFlag( TRUE );
                #endif
        }
        
        /// Destructor. It deinitializes the shared flags.
        ~CQAFDebug()
        {
                CSync sync( &m_cs, CSync::CS_DESTROY );
                
                #ifndef QAF_UNITTEST_DISABLED
                unLock();
                #endif

                #ifndef QAF_LOGFILE_DISABLED
                m_szLogFileName[0] = 0;
                #endif
                
                #ifndef QAF_UNITTEST_DISABLED
                if( NULL != m_pMem )
                {
                        UnmapViewOfFile( m_pMem );
                        m_pMem = NULL;
                }
                
                if( NULL != m_hMapObject )
                {
                        CloseHandle( m_hMapObject );
                        m_hMapObject = NULL;
                }
                
                if( NULL != m_hMutex )
                {
                        CloseHandle( m_hMutex );
                        m_hMutex = NULL;
                }
                #endif
        }
        
        #ifndef QAF_LOGFILE_DISABLED
        /// try open the log file, testing its size and moving it to the same log file if needed.
        static HANDLE tryOpenLogFile( void )
        {
                CSync sync( &instance().m_cs );
                LPTSTR szFilename = instance().m_szLogFileName;
                bool bAlreadyTried = false;
                HANDLE h = INVALID_HANDLE_VALUE;
                while( true )
                {
                        h = CreateFile( szFilename, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_ARCHIVE, NULL );
                        if( INVALID_HANDLE_VALUE == h )
                        {
                                ODS( QAFDEBUG_ERROR_OPEN_LOG_FILE );
                                return INVALID_HANDLE_VALUE;
                        }
                        if( bAlreadyTried || ((QAFDEBUG_LOG_FILE_MAX_SIZE / 2) > GetFileSize( h, NULL )) )
                                break;
                        if( ! CloseHandle(h) )
                        {
                                ODS( QAFDEBUG_ERROR_CLOSE_FILE );
                                return INVALID_HANDLE_VALUE;
                        }
                        TCHAR szCopyFilename[MAX_PATH] = { 0 };
                        _tcscpy( szCopyFilename, szFilename );
                        LPTSTR szPos = _tcsrchr( szCopyFilename, _T('\\') );
                        szPos[1] = 0;
                        _tcscat( szPos, QAFDEBUG_LOG_OLD_FILE_NAME );
                        DeleteFile( szCopyFilename ); // ignore the error if the file does not exist
                        if( !MoveFile( szFilename, szCopyFilename ) )
                        { // report about the error but not exit - continue using the current file
                                ODS( QAFDEBUG_ERROR_BACKUP );
                        }
                        bAlreadyTried = true;
                }
                return h;
        }
        #endif

        /// try to enable the log
        static bool tryEnable( void )
        {
                #ifdef QAF_UNITTEST_DISABLED
                return true;
                #else
                CSync sync( &instance().m_cs );
                return instance().SetSharedFlag( TRUE );
                #endif
        }
        
        /// try to disable the log
        static bool tryDisable( void )
        {
                #ifdef QAF_UNITTEST_DISABLED
                return true;
                #else
                CSync sync( &instance().m_cs );
                return instance().SetSharedFlag( FALSE );
                #endif
        }

        /// Check if the debug log is enabled in the memory mapped file
        static bool isEnabled( void )
        {
                #ifdef QAF_UNITTEST_DISABLED
                        return true;
                #else
                        CSync sync( &instance().m_cs );
                        DWORD dwTemp = FALSE;
                        instance().GetSharedFlag( &dwTemp );
                        return (dwTemp == TRUE);
                #endif
        }
        
        /// Return a pointer to a null-terminated string with the application name and version.
        static LPCTSTR GetApplication()
        {
                return instance().m_szApplicationName;
        }
        
        /// Get the full path and version number of the given module and record them in 
        /// the output buffer.
        /// The function returns the number of characters in the output buffer 
        /// or 0 in a case of any error.
        static DWORD SetLogModule( HMODULE hModule, LPTSTR szOutputBuffer, DWORD dwBufSize )
        {
                if( (NULL == szOutputBuffer) || (dwBufSize < 2) )
                        return 0;
                szOutputBuffer[0] = 0;
                DWORD dwRet = GetModuleFileName( hModule, szOutputBuffer, dwBufSize - 1 );
                if( (0 == dwRet) || (dwRet > (dwBufSize - 2)) )
                        return 0;
                DWORD dwModuleFileNameLen = dwRet;
                DWORD dwReserved = 0;
                dwRet = GetFileVersionInfoSize( szOutputBuffer, &dwReserved );
                if( 0 == dwRet )
                        return dwModuleFileNameLen;
                void * pVerInfo = malloc( dwRet );
                if( NULL == pVerInfo )
                        return dwModuleFileNameLen;
                memset( pVerInfo, 0, dwRet );
                BOOL bRet = GetFileVersionInfo( szOutputBuffer, dwReserved, dwRet, pVerInfo );
                if( !bRet )
                {
                        free( pVerInfo );
                        return dwModuleFileNameLen;
                }
                UINT uiSize = 0;
                VS_FIXEDFILEINFO * pFixedVerInfo = NULL;
                bRet = VerQueryValue( pVerInfo, _T("\\"), (LPVOID *)(&pFixedVerInfo), &uiSize );
                if( !bRet || (NULL == pFixedVerInfo) || (sizeof(VS_FIXEDFILEINFO) != uiSize) )
                {
                        free( pVerInfo );
                        return dwModuleFileNameLen;
                }
                const int MAX_TEMP_BUF = 26;
                TCHAR szBuf[MAX_TEMP_BUF] = { 0 };
                _sntprintf( szBuf, 25, _T(" <%d.%d.%d.%d>"),  
                        HIWORD(pFixedVerInfo->dwFileVersionMS), LOWORD(pFixedVerInfo->dwFileVersionMS),
                        HIWORD(pFixedVerInfo->dwFileVersionLS), LOWORD(pFixedVerInfo->dwFileVersionLS) );
                szBuf[MAX_TEMP_BUF - 1] = 0;
                free( pVerInfo );
                if( (dwModuleFileNameLen + MAX_TEMP_BUF + 1) < dwBufSize )
                {
                        _tcscpy( szOutputBuffer + dwModuleFileNameLen, szBuf );
                        dwModuleFileNameLen += _tcslen( szBuf );
                }
                return dwModuleFileNameLen;
        }
        
};

////////////////////////////////////////////////////////////////////////////////////
// Implementation
////////////////////////////////////////////////////////////////////////////////////

// This is taken from MSDN, there is no such constant in VC++ 6.0 header files
#if !defined(INVALID_FILE_ATTRIBUTES)
        const DWORD INVALID_FILE_ATTRIBUTES = 0xFFFFFFFF;
#endif

/// Return true if the directory exists.
bool DirExists0( LPCTSTR dirName )
{
        DWORD dwAttr = GetFileAttributes( dirName );
        
        if( dwAttr == INVALID_FILE_ATTRIBUTES )
                return false;
        
        return ((dwAttr & FILE_ATTRIBUTE_DIRECTORY) != 0);
}

/// Create the full folder path recursively. 
/// Must get the folder full path without tailing '\'.
bool CreateSubFolders0( LPCTSTR szFolderName )
{
        // Prepare variables
        DWORD dwLen = _tcslen(szFolderName); 
        if( dwLen <= 0 )
                return false;
        // Copy the input string with removing the trailing '\'
        LPTSTR szTemp = (LPTSTR) malloc( (dwLen + 1) * sizeof(TCHAR) );
        if( NULL == szTemp )
                return false;
        _tcscpy( szTemp, szFolderName );
        if( szTemp[dwLen - 1] == _T('\\') )
                dwLen--;
        szTemp[dwLen] = _T('\0');
        // If the directory exists, that's it!
        bool bRet = DirExists0( szTemp );
        // If the directory does not exists, check its parent
        if( ! bRet )
        {
                LPTSTR szPos = _tcsrchr( szTemp, _T('\\') );
                if( NULL != szPos )
                {
                        (*szPos) = _T('\0');
                        // Call the function recursively
                        if( CreateSubFolders0( szTemp ) )
                        {
                                // Now try to create the subfolder and exit
                                (*szPos) = _T('\\');
                                bRet = (TRUE == CreateDirectory( szTemp, NULL ));
                        }
                } 
        }
        free( szTemp );
        return bRet;
}

// Taken from the platform SDK
#if !defined(CSIDL_COMMON_APPDATA)
        // All Users\Application Data
        #define CSIDL_COMMON_APPDATA 0x0023 
#endif
#if !defined(CSIDL_FLAG_CREATE)
        // new for Win2K, to force creation of the folder
        #define CSIDL_FLAG_CREATE 0x8000 
#endif

// This part is excluded for Windows CE
#ifndef _WIN32_WCE

/// Count of the libraries with the SHGetFolderPath function
const int LIBRARY_COUNT = 2;

/// The first DLL that is checked for the SHGetFolderPathA(W) function
const LPCTSTR LIBRARY_DLL[LIBRARY_COUNT] = { _T("shell32.dll"), _T("shfolder.dll") };

/// The name of the function (it differs for ASCII and UNICODE builds) 
#ifdef _UNICODE
        const LPCSTR SHGetFolderPathFuncName = "SHGetFolderPathW";
#else
        const LPCSTR SHGetFolderPathFuncName = "SHGetFolderPathA";
#endif

/// The folder search function definition (taken from MSDN)
typedef HRESULT (__stdcall* PSHGetFolderPath)  
        ( HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPTSTR szPath );

/// My wrapper function that tries to load first shell32.dll and then shfolder.dll
HRESULT SHGetSpecialFolderPathCustom( HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPTSTR szPath ) 
{
        HRESULT hr = E_FAIL;
        for( int i = 0; i < LIBRARY_COUNT; i++ )
        {
                HMODULE hModule = LoadLibrary( LIBRARY_DLL[i] );
                if( NULL != hModule )
                {
                        PSHGetFolderPath pFunc = (PSHGetFolderPath) GetProcAddress( hModule, SHGetFolderPathFuncName );
                        if( NULL != pFunc )
                                hr = pFunc( hwndOwner, nFolder, hToken, dwFlags, szPath );
                        FreeLibrary( hModule );
                }
                if( S_OK == hr ) // I cannot test for SUCCEEDED because it may return S_FALSE on error (look in MSDN)
                        break;
        }
        return hr;
}

#endif // This part is excluded for Windows CE

/// This is an enumeration from MSDN for newer versions of SHxxx functions.
/// Renamed to be ported easily between VC 6 and VC 7
typedef enum {
        Q_SHGFP_TYPE_CURRENT  = 0,   ///< current value for user, verify it exists
        Q_SHGFP_TYPE_DEFAULT  = 1,   ///< default value, may not exist
} Q_SHGFP_TYPE;

/// Generate the file name and directory (check that the file is here).
/// Get the buffer and the buffer length in TCHAR characters including tailing 0x00(00).
/// Returns the length of the written string or 0 if the file name cannot be generated.
/// The file name is constructed from the:
/// 1. Try get the folder path from the environment variable QAFDEBUG_LOG_ENV_VAR
/// 2. Try CSIDL_APPDATA (C:\Documents and Settings\username\Application Data) + QAFDEBUG_LOG_SUBFOLDER
/// 3. Try CSIDL_COMMON_APPDATA (C:\Documents and Settings\All Users\Application Data) + QAFDEBUG_LOG_SUBFOLDER
/// 4. Return 0
/// If the folders are missing on the disk, they are created.
DWORD CQAFDebug::qafGetLogFileName( LPTSTR szFilenameBuf, const DWORD dwMaxLen )
{
        DWORD dwRet = QAFDebug::GetLogDir( szFilenameBuf, dwMaxLen );
        if( 0 == dwRet )
                return 0;
        // If the directory is created, it is o'key and we can continue with the file name
        _tcscat( szFilenameBuf, QAFDEBUG_LOG_FILE_NAME );
        return _tcslen(szFilenameBuf);
}


/////////////////////////////////////////////////////////////////////////////////////////////////
/// Small class that preserves the last error code
/////////////////////////////////////////////////////////////////////////////////////////////////
class CPreserveLastError
{
public:

        /// Constructor saves the last error code or inherits the error code from a chained 
        /// instance of this class.
        CPreserveLastError( const LPDWORD pdwLastError ) 
        { 
                m_bPreserveLastError = (NULL == pdwLastError);
                if( m_bPreserveLastError )
                        m_dwLastError = GetLastError();
                else
                        m_dwLastError = (*pdwLastError);
        }

        /// Destructor restores the saved last error code if it is a self-enough instance.
        ~CPreserveLastError() 
        { 
                if( m_bPreserveLastError && (GetLastError() != m_dwLastError) ) 
                        SetLastError( m_dwLastError ); 
        }

        /// Return the last saved error code.
        DWORD GetSavedLastError( void )
        {
                return m_dwLastError;
        }

        /// Return a pointer to the last saved error code 
        operator LPDWORD()
        {
                return &m_dwLastError;
        }

private:

        /// Saved last error code
        DWORD m_dwLastError;

        /// Flag that indicates that the instance is active.
        bool m_bPreserveLastError;

};

/////////////////////////////////////////////////////////////////////////////////////////////////
// QAFDebug namespace
/////////////////////////////////////////////////////////////////////////////////////////////////

/// The current module name - internal variable.
TCHAR szCurrentModuleName[MAX_PATH] = { 0 }; 

/// Set the current module name (not NULL module name will enable the version logging).
void QAFDebug::SetModule( LPCTSTR szModuleName )
{
        szCurrentModuleName[0] = 0;
        if( (NULL != szModuleName) && (0 != szModuleName[0]) )
        {
                HMODULE hModule = GetModuleHandle( szModuleName );
                if( NULL == hModule )
                        return;
                CQAFDebug::SetLogModule( hModule, szCurrentModuleName, MAX_PATH );
        }
}

bool QAFDebug::tryEnable(void)
{
        return CQAFDebug::tryEnable();
}

bool QAFDebug::tryDisable(void)
{
        return CQAFDebug::tryDisable();
}

/// Return true if the character is \n or \r
inline bool isRN( const TCHAR ch )
{
        return (_T('\r') == ch) || (_T('\n') == ch);
}

#pragma warning( push )
#pragma warning( disable : 4189 )       // local variable is initialized but not referenced

void QAFDebug::OutputDebugStringEx( LPCTSTR szFilename, const int iLine, 
        LPCTSTR szExpression, LPCTSTR szErrorMessage, const LPDWORD pdwLastError )
{
        // Restore the last error upon exit
        CPreserveLastError LastError( pdwLastError );
        
        // Check if the log is disabled by unit tests, in this case skip reporting
        if( !CQAFDebug::isEnabled() )
                return;
        
        // test input parameters
        if( NULL == szFilename )
                szFilename = _T("");
        if( NULL == szExpression )
                szExpression = _T("");
        if( NULL == szErrorMessage )
                szErrorMessage = _T("");

        // C:\SharedUnits\Dev\QMSOColl\QMSOColl.cpp(137) : Assertion raised
        //         time:        2003-12-07 15:48:07:507 
        //         process:     0x00000E24 
        //         thread:      0x00000E2C 
        //         application: C:\Program Files\Microsoft Office\Office10\WINWORD.EXE <1.4.6.7> 
        //         module:      C:\SharedUnits\Dev\QMSOColl\Debug\QMSOColl.dll <1.4.6.7> 
        //         last error:  6, The handle is invalid. 
        //         expression:  DuplicateHandle( NULL, NULL, NULL, NULL, 0, FALSE, 0 ) 
        
        // Prepare parameters for the complete error message
        SYSTEMTIME st;
        GetLocalTime( &st );
        DWORD dwProcess = GetCurrentProcessId(), dwThread = GetCurrentThreadId();
        
        // Decode the last error if needed
        TCHAR szLastError[MAX_PATH] = _T("0"); 
        if( 0 != LastError.GetSavedLastError() )
        {
                _itot( LastError.GetSavedLastError(), szLastError, 10 );
                LPTSTR szPos = szLastError + _tcslen( szLastError );
                _tcscpy( szPos, _T(", ") );
                szPos += 2;
                DWORD dwRet = FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                        NULL, LastError.GetSavedLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), 
                        szPos, MAX_PATH - (szPos - szLastError), NULL );
                szPos[dwRet] = 0;
                while( dwRet-- && _tcschr( _T("\n\r"), szPos[dwRet] ) ) // first compare to 0 and then decrement dwRet!
                        szPos[dwRet] = 0;
        }
        
        LPTSTR szFmtStr = QAFDEBUG_STD_FORMAT; // Format string, its length should be enough for decimal values too
        size_t nBufSize = _tcslen( szFmtStr ) + _tcslen( szFilename ) + _tcslen( szExpression )
                + _tcslen( szErrorMessage ) + _tcslen( szLastError ) 
                + _tcslen( CQAFDebug::GetApplication() ) + _tcslen( szCurrentModuleName ); // In TCHAR characters!
        if( nBufSize > MAX_BUF_SIZE )
                nBufSize = MAX_BUF_SIZE;
        LPTSTR szBuffer = (LPTSTR) malloc( nBufSize * sizeof(TCHAR) );
        if( NULL == szBuffer ) // if the memory cannot be allocated, the function fails
        {
                ODS( QAFDEBUG_ERROR_ALLOCATE_BUFFER );
                return; 
        }
        
        // Format the complete error message 
        int iRes = _sntprintf( szBuffer, nBufSize, szFmtStr,
                szFilename, iLine, szErrorMessage,
                st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, st.wMilliseconds,
                dwProcess, 
                dwThread, 
                CQAFDebug::GetApplication(), 
                szCurrentModuleName,
                szLastError,
                szExpression );
        DWORD dw = GetLastError();
        if( 0 > iRes )
        {
                ODS( QAFDEBUG_ERROR_FORMAT );
                free( szBuffer );
                return;
        }

        // Fix redundant \r\n
        if( (0 != szBuffer[0]) && (0 != szBuffer[1]) )
        {
                for( TCHAR * szPos = szBuffer; 0 != szPos[2]; ++szPos  )
                {
                        if( isRN( szPos[0] ) && isRN( szPos[2] ) )
                                szPos[0] = _T(' ');
                }
        }

        // Add the last \r\n
        DWORD dwBufferSize = _tcslen( szBuffer );
        if( (szBuffer[dwBufferSize - 1] != _T('\r')) && (szBuffer[dwBufferSize - 1] != _T('\n')) )
        {
                _tcscat( szBuffer, _T("\r\n") );
                dwBufferSize += 2;
        }

        // Output the complete error message to the Visual Studio IDE
        ODS( szBuffer );
        
        // If the log file is enabled
        #ifndef QAF_LOGFILE_DISABLED

        // Add another \r\n for an additional empty line (that simplifies reading)
        _tcscat( szBuffer, _T("\r\n") );
        dwBufferSize += 2;

        // If requested, encode the error message to UTF8. This define must be set only in UNICODE builds!
        #ifdef QAF_SAVE_UNICODE_AS_UTF8
                DWORD dwUtf8BufSize = (dwBufferSize + 1) * sizeof(TCHAR);
                LPSTR szUTF8 = (LPSTR) malloc( dwUtf8BufSize );
                if( NULL != szUTF8 ) // in case of memory overflow the UNICODE string will be written to file
                {
                        int nRet = WideCharToMultiByte( CP_UTF8, 0, szBuffer, dwBufferSize, szUTF8, 
                                dwUtf8BufSize, NULL, NULL );
                        if( nRet > 0 ) // in case of any error the UNICODE string will be written to file
                        {
                                free( szBuffer );
                                szBuffer = (LPTSTR) szUTF8; // I can do this because this string is used as a plain buffer
                                dwBufferSize = nRet; // count of returned bytes - does not include the trailing sero
                                // despite the fact that in MSDN it is written that this function return value counts 
                                // the trailing zero, actually it even does not terminate the output string with \0.
                        }
                }
        #else
                dwBufferSize *= sizeof(TCHAR); // I must recalculate here the buffer size because it was in characters 
        #endif
        
        // Output the complete error message to file
        // Try to write to the file during 200 msec (5 times with sleeps within)
        HANDLE h = INVALID_HANDLE_VALUE;
        for( int i = 0; i < 5; i++ )
        {
                h = CQAFDebug::tryOpenLogFile();
                #ifdef _DEBUG 
                        DWORD dw = GetLastError(); // for my debug purposes
                #endif
                if( h != INVALID_HANDLE_VALUE )
                {
                        SetFilePointer( h, 0, NULL, FILE_END ); // I cannot check the return value
                        #ifdef _DEBUG 
                                dw = GetLastError(); // for my debug purposes
                        #endif
                        if( ! WriteFile( h, szBuffer, dwBufferSize, &dwBufferSize, NULL ) ) // and I need it in bytes
                                #ifdef _DEBUG 
                                        dw = GetLastError(); // for my debug purposes
                                #else
                                        dw = 0; // to disable the compiler warning
                                #endif
                        
                        CloseHandle( h );

                        break;
                }
                Sleep( 40 );
        }

        // If the log file is enabled
        #endif

        free( szBuffer );
}

#pragma warning( pop )

HRESULT QAFDebug::qafReportComError( HRESULT hrStatus, LPCTSTR szFile, const int iLine )
{
        if( SUCCEEDED(hrStatus) )
                return hrStatus;

        CPreserveLastError LastError( NULL );

    if( FACILITY_WINDOWS == HRESULT_FACILITY(hrStatus) )
        hrStatus = HRESULT_CODE(hrStatus);
        
        LPTSTR szErrMsg = NULL;
        int iFreeErrMsg = FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, 
                NULL, hrStatus, MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), (LPTSTR)&szErrMsg, 0, NULL );
        if( (0 == iFreeErrMsg) || (NULL == szErrMsg) )
                szErrMsg = QAFDEBUG_ERROR_NO_MESSAGE;
        
        TCHAR szBuf[QAFDEBUG_FMT_HRESULT_LEN];
        if( 0 >= wsprintf( szBuf, QAFDEBUG_FMT_HRESULT, hrStatus ) )
                szBuf[0] = 0;
        
        QAFDebug::OutputDebugStringEx( szFile, iLine, szBuf, szErrMsg, static_cast<LPDWORD>(LastError) );
        
        if( iFreeErrMsg != 0 )
        LocalFree( szErrMsg );

        return hrStatus;
}

DWORD QAFDebug::ReportWinError( const DWORD dwError, LPCTSTR szFile, const int iLine )
{
        if( ERROR_SUCCESS == dwError )
                return dwError;

        CPreserveLastError LastError( NULL );

        LPTSTR szErrMsg = NULL;
        int iFreeErrMsg = FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, 
                NULL, dwError, MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), (LPTSTR)&szErrMsg, 0, NULL );
        if( (0 == iFreeErrMsg) || (NULL == szErrMsg) )
                szErrMsg = QAFDEBUG_ERROR_NO_MESSAGE;
        
        TCHAR szBuf[QAFDEBUG_FMT_ERROR_SUCCESS_LEN];
        if( 0 >= wsprintf( szBuf, QAFDEBUG_FMT_ERROR_SUCCESS, dwError ) )
                szBuf[0] = 0;
        
        QAFDebug::OutputDebugStringEx( szFile, iLine, szBuf, szErrMsg, static_cast<LPDWORD>(LastError) );
        
        if( iFreeErrMsg != 0 )
        LocalFree( szErrMsg );
        
        return dwError;
}

DWORD QAFDebug::GetLogDir( LPTSTR szDirBuf, const DWORD dwMaxLen )
{

// This part is excluded for Windows CE
#ifndef _WIN32_WCE
        
        // Test three different folders, one set from outside, second for regular applications 
        // and third for service applications
        for( int i = 1; i <= 3; i++ )
        {
                if( 1 == i ) 
                {
                        // 1. Try get the folder path from the environment variable QAFDEBUG_LOG_ENV_VAR 
                        DWORD dwRet = GetEnvironmentVariable( QAFDEBUG_LOG_ENV_VAR, szDirBuf, dwMaxLen );
                        if( (dwRet <= 0) || (dwRet >= dwMaxLen) )
                                continue; // try the second
                }
                else
                {
                        if( 2 == i )
                        {
                                // 2. Try CSIDL_APPDATA (C:\Documents and Settings\username\Application Data) + QAFDEBUG_LOG_SUBFOLDER
                                if( S_OK != SHGetSpecialFolderPathCustom( NULL, CSIDL_APPDATA | CSIDL_FLAG_CREATE, NULL, Q_SHGFP_TYPE_CURRENT, szDirBuf ) )
                                        continue; // try the third
                        }
                        else
                        {
                                // 3. Try CSIDL_COMMON_APPDATA (C:\Documents and Settings\All Users\Application Data) + QAFDEBUG_LOG_SUBFOLDER
                                if( S_OK != SHGetSpecialFolderPathCustom( NULL, CSIDL_COMMON_APPDATA | CSIDL_FLAG_CREATE, NULL, Q_SHGFP_TYPE_CURRENT, szDirBuf ) )
                                        return 0; // FAILED!!!
                        }
                        // Add the relative path 
                        DWORD dwSize = _tcslen(szDirBuf); 
                        if( dwSize > 0 )
                        {
                                if( szDirBuf[dwSize - 1] != _T('\\') )
                                        _tcscat( szDirBuf, _T("\\") );
                                _tcscat( szDirBuf, QAFDEBUG_LOG_SUBFOLDER );
                        }
                }
                // Test the resulting string 
                DWORD dwSizeBuf = _tcslen(szDirBuf);
                if( 0 == dwSizeBuf )
                        continue; // This trial failed

                // Add final '\'
                if( szDirBuf[dwSizeBuf - 1] != _T('\\') )
                        _tcscat( szDirBuf, _T("\\") );
                // Check that the directory exists and create missing subdirectories
                if( ! CreateSubFolders0(szDirBuf) )
                        continue; // This trial failed
                // Return the result
                return _tcslen(szDirBuf);
        } 

#else // This part is specific for Windows CE

        // This function always return FALSE, even if successful.
        SHGetSpecialFolderPath(NULL, szDirBuf, CSIDL_PERSONAL, FALSE);
        // Add the relative path 
        DWORD dwSize = _tcslen(szDirBuf); 
        if( dwSize > 0 )
        {
                if( szDirBuf[dwSize - 1] != _T('\\') )
                        _tcscat( szDirBuf, _T("\\") );
                _tcscat( szDirBuf, QAFDEBUG_LOG_SUBFOLDER );
        }
        // Test the resulting string 
        DWORD dwSizeBuf = _tcslen(szDirBuf);
        if( 0 == dwSizeBuf )
                return 0;

        // Add final '\'
        if( szDirBuf[dwSizeBuf - 1] != _T('\\') )
                _tcscat( szDirBuf, _T("\\") );
        // Check that the directory exists and create missing subdirectories
        if( ! CreateSubFolders0(szDirBuf) )
                return 0;

        // Return the result
        return _tcslen(szDirBuf);

#endif // This part is specific for Windows CE

        // FAILED !!!
        return 0;
}

///////////////////////////////////////////////
// END OF FILE
///////////////////////////////////////////////
#endif

---