//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1996 - 1997.
//
//  File:       mydebug.hxx
//
//  Contents:   Functions to manage the debug heap
//
//  Classes:    ( none )
//
//  Functions:  void* operator new( size_t )
//              void* operator new( size_t, const char*, int )
//              void* my_new( size_t, const char*, int )
//              void operator delete( void* )
//
//  Coupling:
//
//  Notes:      To enable the debug version, include this header file, use the
//              NEW macro instead of the new keyword, and include the following
//              line in your sources file:
//                  DEBUG_CRTS=1
//
//  History:    10-20-1996   ericne   Created
//
//----------------------------------------------------------------------------

#ifndef _MYDEBUG_

    #define _MYDEBUG_

    #ifdef NEW
        #undef NEW  // Redefined later
    #endif

    #include <crtdbg.h>

    #ifdef _DEBUG_BLDCRT

        #include <malloc.h>
        #include <new.h>

        // If this is a multi-threaded application
        #ifdef _MT
        static class CDebugCriticalSection
        {
            CRITICAL_SECTION m_crit_sect;

            public:
                CDebugCriticalSection()
                {
                    InitializeCriticalSection( &m_crit_sect );
                }
                ~CDebugCriticalSection()
                {
                    DeleteCriticalSection( &m_crit_sect );
                }
                void Enter()
                {
                    EnterCriticalSection( &m_crit_sect );
                }
                void Leave()
                {
                    LeaveCriticalSection( &m_crit_sect );
                }

        } g_NewCriticalSection;
        #endif

        //+--------------------------------------------------------------------
        //
        //  Function:   my_new
        //
        //  Synopsis:   performs an allocation on the debug heap.  Calls the
        //              new handler if necessary.
        //
        //  Arguments:  [size] -- the number of bytes to allocate
        //              [file] -- the name of the file which made the call
        //              [line] -- the line number of the call
        //
        //  Returns:    NULL if it fails, a valid pointer otherwise
        //
        //  History:    10-20-1996   ericne   Created
        //
        //  Notes:
        //
        //---------------------------------------------------------------------

        inline void * __cdecl my_new( size_t size, const char* file, int line )
        {

            void *pvoid             = NULL;
            _PNH old_new_handler    = NULL;

            #ifdef _MT
            __try
            {
                g_NewCriticalSection.Enter();
            #endif
                do
                {
                    // Call _malloc_dbg to allocate space on the debug heap
                    pvoid = _malloc_dbg( size, _NORMAL_BLOCK, file, line );

                    // if the allocation succeeded, break
                    if( NULL != pvoid )
                        break;

                    // if new_mode is 1, then malloc calls the new handler upon
                    // failure -- it souldn't be called again.
                    if( 1 == _query_new_mode( ) )
                        break;

                    // If there is no new handler, break
                    if( NULL == ( old_new_handler = _query_new_handler( ) ) )
                        break;

                    #ifdef _MT
                    // Getting ready to call the new handler
                    // -- leave the critical section
                    g_NewCriticalSection.Leave( );
                    #endif

                    // If the new handler returns 0, don't retry
                    if( 0 == (*old_new_handler)( size ) )
                    {
                        #ifdef _MT
                        g_NewCriticalSection.Enter( );
                        #endif
                        break;
                    }

                    #ifdef _MT
                    // Re-enter the critical section
                    g_NewCriticalSection.Enter( );
                    #endif

                } while( 1 );

            #ifdef _MT
            }
            __finally
            {
                g_NewCriticalSection.Leave( );
            }
            #endif

            // Return the pointer
            return( pvoid );

        } // my_new

        //+--------------------------------------------------------------------
        //
        //  Function:   new
        //
        //  Synopsis:   Calls my_new.  This function is needed to shadow the
        //              default global new operator
        //
        //  Arguments:  [size] -- The size of the memory to be allocated
        //
        //  Returns:    void *
        //
        //  History:    10-20-1996   ericne   Created
        //
        //  Notes:
        //
        //---------------------------------------------------------------------

        inline void * __cdecl operator new( size_t size )
        {

            return( my_new( size, NULL, 0 ) );

        } // new

        //+--------------------------------------------------------------------
        //
        //  Function:   new
        //
        //  Synopsis:   Calls my_new.
        //
        //  Arguments:  [size] -- Size of the user's memory block
        //              [file] -- name of source file requesting the allocation
        //              [line] -- line in source file of allocation request
        //
        //  Returns:
        //
        //  History:    10-20-1996   ericne   Created
        //
        //  Notes:      If you use the NEW macro, this function will be called
        //              with __FILE__ and __LINE__ as the 2nd and 3rd params
        //
        //---------------------------------------------------------------------

        inline void * __cdecl operator new( size_t size,
                                             const char* file,
                                             int line )
        {

            return( my_new( size, file, line ) );

        } // new

        //+--------------------------------------------------------------------
        //
        //  Function:   delete
        //
        //  Synopsis:   calls _free_dbg to clean up the debug heap
        //
        //  Arguments:  [pMemory] -- pointer to the users memory
        //
        //  Returns:    void
        //
        //  History:    10-20-1996   ericne   Created
        //
        //  Notes:
        //
        //---------------------------------------------------------------------

        inline void __cdecl operator delete( void *pMemory )
        {

            // free the memory
            _free_dbg( pMemory, _NORMAL_BLOCK );

        } // delete

        #define NEW new( __FILE__, __LINE__ )

        #define DEBUG_INIT( )                                                  \
            _CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_FILE );                 \
            _CrtSetReportFile( _CRT_WARN, _CRTDBG_FILE_STDOUT );               \
            _CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE );                \
            _CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDOUT )

        #define SET_CRT_DEBUG_FIELD( field )                                   \
            _CrtSetDbgFlag( (field) | _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG ) )

        #define CLEAR_CRT_DEBUG_FIELD( field )                                 \
            _CrtSetDbgFlag( ~(field) & _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG ) )

        // This object ensures that the debug settings are set even before
        // main begins
        static class DebugInit
        {
            public:
                DebugInit()
                {
                    // Initialize the debug session
                    DEBUG_INIT();

                    // Memory check at termination
                    SET_CRT_DEBUG_FIELD( _CRTDBG_LEAK_CHECK_DF );
                }
        } g_Debug_Is_Initialized;

    #else

        #define NEW new

        #define DEBUG_INIT( )                  ( (void) 0 )

        #define SET_CRT_DEBUG_FIELD( field )   ( (void) 0 )

        #define CLEAR_CRT_DEBUG_FIELD( field ) ( (void) 0 )

    #endif

#endif