Return to NewHandler.cpp CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / elwix / tools / oldlzma / SRC / Common

Annotation of elwix/tools/oldlzma/SRC/Common/NewHandler.cpp, revision 1.1

1.1     ! misho       1: // NewHandler.cpp
        !             2:  
        !             3: #include "StdAfx.h"
        !             4: 
        !             5: #include "NewHandler.h"
        !             6: 
        !             7: // #define DEBUG_MEMORY_LEAK
        !             8: 
        !             9: #ifndef DEBUG_MEMORY_LEAK
        !            10: 
        !            11: #include <stdlib.h>
        !            12: 
        !            13: void * __cdecl operator new(size_t size)
        !            14: {
        !            15:   // void *p = ::HeapAlloc(::GetProcessHeap(), 0, size);
        !            16:   void *p = ::malloc(size);
        !            17:   if (p == 0)
        !            18:     throw CNewException();
        !            19:   return p;
        !            20: }
        !            21: 
        !            22: void __cdecl operator delete(void *p)
        !            23: {
        !            24:   /*
        !            25:   if (p == 0)
        !            26:     return;
        !            27:   ::HeapFree(::GetProcessHeap(), 0, p);
        !            28:   */
        !            29:   ::free(p);
        !            30: }
        !            31: 
        !            32: #else
        !            33: 
        !            34: #pragma init_seg(lib)
        !            35: const int kDebugSize = 1000000;
        !            36: static void *a[kDebugSize];
        !            37: static int index = 0;
        !            38: 
        !            39: static int numAllocs = 0;
        !            40: void * __cdecl operator new(size_t size)
        !            41: {
        !            42:   numAllocs++;
        !            43:   void *p = HeapAlloc(GetProcessHeap(), 0, size);
        !            44:   if (index == 40)
        !            45:   {
        !            46:     int t = 1;
        !            47:   }
        !            48:   if (index < kDebugSize)
        !            49:   {
        !            50:     a[index] = p;
        !            51:     index++;
        !            52:   }
        !            53:   if (p == 0)
        !            54:     throw CNewException();
        !            55:   printf("Alloc %6d, size = %8d\n", numAllocs, size);
        !            56:   return p;
        !            57: }
        !            58: 
        !            59: class CC
        !            60: {
        !            61: public:
        !            62:   CC()
        !            63:   {
        !            64:     for (int i = 0; i < kDebugSize; i++)
        !            65:       a[i] = 0;
        !            66:   }
        !            67:   ~CC()
        !            68:   {
        !            69:     for (int i = 0; i < kDebugSize; i++)
        !            70:       if (a[i] != 0)
        !            71:         return;
        !            72:   }
        !            73: } g_CC;
        !            74: 
        !            75: 
        !            76: void __cdecl operator delete(void *p)
        !            77: {
        !            78:   if (p == 0)
        !            79:     return;
        !            80:   /*
        !            81:   for (int i = 0; i < index; i++)
        !            82:     if (a[i] == p)
        !            83:       a[i] = 0;
        !            84:   */
        !            85:   HeapFree(GetProcessHeap(), 0, p);
        !            86:   numAllocs--;
        !            87:   printf("Free %d\n", numAllocs);
        !            88: }
        !            89: 
        !            90: #endif
        !            91: 
        !            92: /*
        !            93: int MemErrorVC(size_t)
        !            94: {
        !            95:   throw CNewException();
        !            96:   // return 1;
        !            97: }
        !            98: CNewHandlerSetter::CNewHandlerSetter()
        !            99: {
        !           100:   // MemErrorOldVCFunction = _set_new_handler(MemErrorVC);
        !           101: }
        !           102: CNewHandlerSetter::~CNewHandlerSetter()
        !           103: {
        !           104:   // _set_new_handler(MemErrorOldVCFunction);
        !           105: }
        !           106: */