//////////////////////////////////////////////////////////////////////////////// // // Visual Leak Detector - CRT and MFC IAT Patch Functions Header // Copyright (c) 2009 Dan Moulding // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA // // See COPYING.txt for the full terms of the GNU Lesser General Public License. // //////////////////////////////////////////////////////////////////////////////// #pragma once #ifndef VLDBUILD #error \ "This header should only be included by Visual Leak Detector when building it from source. \ Applications should never include this header." #endif #include "vldint.h" extern __declspec(dllexport) VisualLeakDetector vld; #define TEMPLATE_HEADER \ template #define TEMPLATE_ARGS \ crtddll, mfcddll, mfcuddll,\ crtd_vector_new_name, crtd_vector_new_dbg_name,\ crtd_scalar_new_name, crtd_scalar_new_dbg_name,\ mfcd_vector_new_ordinal, mfcd_vector_new_dbg_4p_ordinal, mfcd_vector_new_dbg_3p_ordinal,\ mfcd_scalar_new_ordinal, mfcd_scalar_new_dbg_4p_ordinal, mfcd_scalar_new_dbg_3p_ordinal,\ mfcud_vector_new_ordinal, mfcud_vector_new_dbg_4p_ordinal, mfcud_vector_new_dbg_3p_ordinal,\ mfcud_scalar_new_ordinal, mfcud_scalar_new_dbg_4p_ordinal, mfcud_scalar_new_dbg_3p_ordinal TEMPLATE_HEADER class CrtMfcPatch { public: static void* __cdecl crtd__calloc_dbg (size_t num, size_t size, int type, char const *file, int line); static void* __cdecl crtd__malloc_dbg (size_t size, int type, const char *file, int line); static void* __cdecl crtd__realloc_dbg (void *mem, size_t size, int type, char const *file, int line); static void* __cdecl crtd__scalar_new_dbg (size_t size, int type, char const *file, int line); static void* __cdecl crtd__vector_new_dbg (size_t size, int type, char const *file, int line); static void* __cdecl crtd_calloc (size_t num, size_t size); static void* __cdecl crtd_malloc (size_t size); static void* __cdecl crtd_realloc (void *mem, size_t size); static void* __cdecl crtd_scalar_new (size_t size); static void* __cdecl crtd_vector_new (size_t size); template static void* __cdecl crtd_new_dbg (SIZE_T fp, size_t size, int type, char const *file, int line); template static void* __cdecl crtd_new (SIZE_T fp, size_t size); static void* __cdecl mfcd_vector_new (size_t size); static void* __cdecl mfcd__vector_new_dbg_4p (size_t size, int type, char const *file, int line); static void* __cdecl mfcd__vector_new_dbg_3p (size_t size, char const *file, int line); static void* __cdecl mfcd_scalar_new (size_t size); static void* __cdecl mfcd__scalar_new_dbg_4p (size_t size, int type, char const *file, int line); static void* __cdecl mfcd__scalar_new_dbg_3p (size_t size, char const *file, int line); static void* __cdecl mfcud_vector_new (size_t size); static void* __cdecl mfcud__vector_new_dbg_4p (size_t size, int type, char const *file, int line); static void* __cdecl mfcud__vector_new_dbg_3p (size_t size, char const *file, int line); static void* __cdecl mfcud_scalar_new (size_t size); static void* __cdecl mfcud__scalar_new_dbg_4p (size_t size, int type, char const *file, int line); static void* __cdecl mfcud__scalar_new_dbg_3p (size_t size, char const *file, int line); template static void* __cdecl mfcd_new_dbg (SIZE_T fp, size_t size, int type, char const *file, int line); template static void* __cdecl mfcd_new_dbg (SIZE_T fp, size_t size, char const *file, int line); template static void* __cdecl mfcd_new (SIZE_T fp, size_t size); }; //////////////////////////////////////////////////////////////////////////////// // // Visual Studio DLLs // //////////////////////////////////////////////////////////////////////////////// // crtd__calloc_dbg - Calls to _calloc_dbg from msvcrXXd.dll are patched // through to this function. // // - mem (IN): Pointer to the memory block to be reallocated. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // - type (IN): The CRT "use type" of the block to be allocated. // // - file (IN): The name of the file from which this function is being called. // // - line (IN): The line number, in the above file, at which this function is // being called. // // Return Value: // // Returns the value returned by _calloc_dbg. // TEMPLATE_HEADER void* CrtMfcPatch::crtd__calloc_dbg (size_t num, size_t size, int type, char const *file, int line) { static _calloc_dbg_t pcrtxxd__calloc_dbg = NULL; SIZE_T fp; HMODULE msvcrxxd; FRAMEPOINTER(fp); if (pcrtxxd__calloc_dbg == NULL) { // This is the first call to this function. Link to the real // _calloc_dbg. msvcrxxd = GetModuleHandle(crtddll); pcrtxxd__calloc_dbg = (_calloc_dbg_t)GetProcAddress(msvcrxxd, "_calloc_dbg"); } return vld.__calloc_dbg(pcrtxxd__calloc_dbg, fp, num, size, type, file, line); } // crtd__malloc_dbg - Calls to _malloc_dbg from msvcrXXd.dll are patched // through to this function. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // - type (IN): The CRT "use type" of the block to be allocated. // // - file (IN): The name of the file from which this function is being called. // // - line (IN): The line number, in the above file, at which this function is // being called. // // Return Value: // // Returns the value returned by _malloc_dbg. // TEMPLATE_HEADER void* CrtMfcPatch::crtd__malloc_dbg (size_t size, int type, char const *file, int line) { static _malloc_dbg_t pcrtxxd__malloc_dbg = NULL; SIZE_T fp; HMODULE msvcrxxd; FRAMEPOINTER(fp); if (pcrtxxd__malloc_dbg == NULL) { // This is the first call to this function. Link to the real // _malloc_dbg. msvcrxxd = GetModuleHandle(crtddll); pcrtxxd__malloc_dbg = (_malloc_dbg_t)GetProcAddress(msvcrxxd, "_malloc_dbg"); } return vld.__malloc_dbg(pcrtxxd__malloc_dbg, fp, size, type, file, line); } // crtd__realloc_dbg - Calls to _realloc_dbg from msvcrXXd.dll are patched // through to this function. // // - mem (IN): Pointer to the memory block to be reallocated. // // - size (IN): The size of the memory block to reallocate. // // - type (IN): The CRT "use type" of the block to be reallocated. // // - file (IN): The name of the file from which this function is being called. // // - line (IN): The line number, in the above file, at which this function is // being called. // // Return Value: // // Returns the value returned by _realloc_dbg. // TEMPLATE_HEADER void* CrtMfcPatch::crtd__realloc_dbg (void *mem, size_t size, int type, char const *file, int line) { static _realloc_dbg_t pcrtxxd__realloc_dbg = NULL; SIZE_T fp; HMODULE msvcrxxd; FRAMEPOINTER(fp); if (pcrtxxd__realloc_dbg == NULL) { // This is the first call to this function. Link to the real // _realloc_dbg. msvcrxxd = GetModuleHandle(crtddll); pcrtxxd__realloc_dbg = (_realloc_dbg_t)GetProcAddress(msvcrxxd, "_realloc_dbg"); } return vld.__realloc_dbg(pcrtxxd__realloc_dbg, fp, mem, size, type, file, line); } // crtd__scalar_new_dbg - Calls to the CRT's debug scalar new operator from // msvcrXXd.dll are patched through to this function. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // - type (IN): The CRT "use type" of the block to be allocated. // // - file (IN): The name of the file from which this function is being called. // // - line (IN): The line number, in the above file, at which this function is // being called. // // Return Value: // // Returns the value returned by the CRT debug scalar new operator. // TEMPLATE_HEADER void* CrtMfcPatch::crtd__scalar_new_dbg (size_t size, int type, char const *file, int line) { SIZE_T fp; FRAMEPOINTER(fp); return crtd_new_dbg(fp, size, type, file, line); } // crtd__vector_new_dbg - Calls to the CRT's debug vector new operator from // msvcrXXd.dll are patched through to this function. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // - type (IN): The CRT "use type" of the block to be allocated. // // - file (IN): The name of the file from which this function is being called. // // - line (IN): The line number, in the above file, at which this function is // being called. // // Return Value: // // Returns the value returned by the CRT debug vector new operator. // TEMPLATE_HEADER void* CrtMfcPatch::crtd__vector_new_dbg (size_t size, int type, char const *file, int line) { SIZE_T fp; FRAMEPOINTER(fp); return crtd_new_dbg(fp, size, type, file, line); } // crtd_calloc - Calls to calloc from msvcrXXd.dll are patched through to // this function. // // - dll (IN): The name of the dll // // - num (IN): The number of blocks, of size 'size', to be allocated. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // Return Value: // // Returns the valued returned from calloc. // TEMPLATE_HEADER void* CrtMfcPatch::crtd_calloc (size_t num, size_t size) { static calloc_t pcrtxxd_calloc = NULL; SIZE_T fp; HMODULE msvcrxxd; FRAMEPOINTER(fp); if (pcrtxxd_calloc == NULL) { // This is the first call to this function. Link to the real malloc. msvcrxxd = GetModuleHandle(crtddll); pcrtxxd_calloc = (calloc_t)GetProcAddress(msvcrxxd, "calloc"); } return vld._calloc(pcrtxxd_calloc, fp, num, size); } // crtd_malloc - Calls to malloc from msvcrXXd.dll are patched through to // this function. // // - dll (IN): The name of the dll // // - size (IN): The size, in bytes, of the memory block to be allocated. // // Return Value: // // Returns the valued returned from malloc. // TEMPLATE_HEADER void* CrtMfcPatch::crtd_malloc (size_t size) { static malloc_t pcrtxxd_malloc = NULL; SIZE_T fp; HMODULE msvcrxxd; FRAMEPOINTER(fp); if (pcrtxxd_malloc == NULL) { // This is the first call to this function. Link to the real malloc. msvcrxxd = GetModuleHandle(crtddll); pcrtxxd_malloc = (malloc_t)GetProcAddress(msvcrxxd, "malloc"); } return vld._malloc(pcrtxxd_malloc, fp, size); } // crtd_realloc - Calls to realloc from msvcrXXd.dll are patched through to // this function. // // - dll (IN): The name of the dll // // - mem (IN): Pointer to the memory block to reallocate. // // - size (IN): Size of the memory block to reallocate. // // Return Value: // // Returns the value returned from realloc. // TEMPLATE_HEADER void* CrtMfcPatch::crtd_realloc (void *mem, size_t size) { static realloc_t pcrtxxd_realloc = NULL; SIZE_T fp; HMODULE msvcrxxd; FRAMEPOINTER(fp); if (pcrtxxd_realloc == NULL) { // This is the first call to this function. Link to the real realloc. msvcrxxd = GetModuleHandle(crtddll); pcrtxxd_realloc = (realloc_t)GetProcAddress(msvcrxxd, "realloc"); } return vld._realloc(pcrtxxd_realloc, fp, mem, size); } // crtd_scalar_new - Calls to the CRT's scalar new operator from msvcrXXd.dll // are patched through to this function. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // Return Value: // // Returns the value returned by the CRT scalar new operator. // TEMPLATE_HEADER void* CrtMfcPatch::crtd_scalar_new (size_t size) { SIZE_T fp; FRAMEPOINTER(fp); return crtd_new(fp, size); } // crtd_vector_new - Calls to the CRT's vector new operator from msvcrXXd.dll // are patched through to this function. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // Return Value: // // Returns the value returned by the CRT vector new operator. // TEMPLATE_HEADER void* CrtMfcPatch::crtd_vector_new (size_t size) { SIZE_T fp; FRAMEPOINTER(fp); return crtd_new(fp, size); } // crtd_new_dbg - A template function for implementation of patch functions to // the CRT's debug new operator from msvcrXXd.dll // // - procname (IN): The debug new operator's name // // - fp (IN): Frame pointer from the call that initiated this allocation. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // - type (IN): The CRT "use type" of the block to be allocated. // // - file (IN): The name of the file from which this function is being called. // // - line (IN): The line number, in the above file, at which this function is // being called. // // Return Value: // // Returns the value returned by the CRT debug new operator. // TEMPLATE_HEADER template void* CrtMfcPatch::crtd_new_dbg (SIZE_T fp, size_t size, int type, char const *file, int line) { static new_dbg_crt_t pcrtxxd_new_dbg = NULL; HMODULE msvcrxxd; if (pcrtxxd_new_dbg == NULL) { // This is the first call to this function. Link to the real CRT debug // new operator. msvcrxxd = GetModuleHandle(crtddll); pcrtxxd_new_dbg = (new_dbg_crt_t)GetProcAddress(msvcrxxd, procname); } return vld.new_dbg_crt(pcrtxxd_new_dbg, fp, size, type, file, line); } // crt_new - A template function for implementing patch functions to the // CRT's new operator from msvcrXXd.dll // // - dll (IN): The name of the dll // // - procname (IN): The debug new operator's name // // - size (IN): The size, in bytes, of the memory block to be allocated. // // Return Value: // // Returns the value returned by the CRT new operator. // TEMPLATE_HEADER template void* CrtMfcPatch::crtd_new (SIZE_T fp, size_t size) { static new_t pcrtxxd_scalar_new = NULL; HMODULE msvcrxxd; if (pcrtxxd_scalar_new == NULL) { // This is the first call to this function. Link to the real CRT new // operator. msvcrxxd = GetModuleHandle(crtddll); pcrtxxd_scalar_new = (new_t)GetProcAddress(msvcrxxd, procname); } return vld._new(pcrtxxd_scalar_new, fp, size); } //////////////////////////////////////////////////////////////////////////////// // // MFC DLLs // //////////////////////////////////////////////////////////////////////////////// // mfcd__scalar_new_dbg_3p - Calls to the MFC debug scalar new operator from // mfcXXd.dll are patched through to this function. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // - type (IN): The "use type" of the block to be allocated. // // - file (IN): The name of the file from which this function is being called. // // - line (IN): The line number, in the above file, at which this function is // being called. // // Return Value: // // Returns the value returned by the MFC debug scalar new operator. // TEMPLATE_HEADER void* CrtMfcPatch::mfcd__scalar_new_dbg_4p (size_t size, int type, char const *file, int line) { SIZE_T fp; FRAMEPOINTER(fp); return mfcd_new_dbg (fp, size, type, file, line); } // mfcd__scalar_new_dbg_3p - Calls to the MFC debug scalar new operator from // mfcXXd.dll are patched through to this function. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // - file (IN): The name of the file from which this function is being called. // // - line (IN): The line number, in the above file, at which this function is // being called. // // Return Value: // // Returns the value returned by the MFC debug scalar new operator. // TEMPLATE_HEADER void* CrtMfcPatch::mfcd__scalar_new_dbg_3p (size_t size, char const *file, int line) { SIZE_T fp; FRAMEPOINTER(fp); return mfcd_new_dbg (fp, size, file, line); } // mfcd__vector_new_dbg_4p - Calls to the MFC debug vector new operator from // mfcXXd.dll are patched through to this function. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // - type (IN): The "use type" of the block to be allocated. // // - file (IN): The name of the file from which this function is being called. // // - line (IN): The line number, in the above file, at which this function is // being called. // // Return Value: // // Returns the value returned by the MFC debug vector new operator. // TEMPLATE_HEADER void* CrtMfcPatch::mfcd__vector_new_dbg_4p (size_t size, int type, char const *file, int line) { SIZE_T fp; FRAMEPOINTER(fp); return mfcd_new_dbg (fp, size, type, file, line); } // mfcd__vector_new_dbg_3p - Calls to the MFC debug vector new operator from // mfcXXd.dll are patched through to this function. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // - file (IN): The name of the file from which this function is being called. // // - line (IN): The line number, in the above file, at which this function is // being called. // // Return Value: // // Returns the value returned by the MFC debug vector new operator. // TEMPLATE_HEADER void* CrtMfcPatch::mfcd__vector_new_dbg_3p (size_t size, char const *file, int line) { SIZE_T fp; FRAMEPOINTER(fp); return mfcd_new_dbg (fp, size, file, line); } // mfcd_scalar_new - Calls to the MFC scalar new operator from mfcXXd.dll are // patched through to this function. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // Return Value: // // Returns the value returned by the MFC scalar new operator. // TEMPLATE_HEADER void* CrtMfcPatch::mfcd_scalar_new (size_t size) { SIZE_T fp; FRAMEPOINTER(fp); return mfcd_new(fp, size); } // mfcd_vector_new - Calls to the MFC vector new operator from mfcXXd.dll are // patched through to this function. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // Return Value: // // Returns the value returned by the MFC vector new operator. // TEMPLATE_HEADER void* CrtMfcPatch::mfcd_vector_new (size_t size) { SIZE_T fp; FRAMEPOINTER(fp); return mfcd_new(fp, size); } // mfcud__scalar_new_dbg_4p - Calls to the MFC debug scalar new operator from // mfcXXud.dll are patched through to this function. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // - type (IN): The "use type" of the block to be allocated. // // - file (IN): The name of the file from which this function is being called. // // - line (IN): The line number, in the above file, at which this function is // being called. // // Return Value: // // Returns the value returned by the MFC debug scalar new operator. // TEMPLATE_HEADER void* CrtMfcPatch::mfcud__scalar_new_dbg_4p (size_t size, int type, char const *file, int line) { SIZE_T fp; FRAMEPOINTER(fp); return mfcd_new_dbg (fp, size, type, file, line); } // mfcud__scalar_new_dbg_3p - Calls to the MFC debug scalar new operator from // mfcXXud.dll are patched through to this function. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // - file (IN): The name of the file from which this function is being called. // // - line (IN): The line number, in the above file, at which this function is // being called. // // Return Value: // // Returns the value returned by the MFC debug scalar new operator. // TEMPLATE_HEADER void* CrtMfcPatch::mfcud__scalar_new_dbg_3p (size_t size, char const *file, int line) { SIZE_T fp; FRAMEPOINTER(fp); return mfcd_new_dbg (fp, size, file, line); } // mfcud__vector_new_dbg_4p - Calls to the MFC debug vector new operator from // mfcXXud.dll are patched through to this function. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // - type (IN): The "use type" of the block to be allocated. // // - file (IN): The name of the file from which this function is being called. // // - line (IN): The line number, in the above file, at which this function is // being called. // // Return Value: // // Returns the value returned by the MFC debug vector new operator. // TEMPLATE_HEADER void* CrtMfcPatch::mfcud__vector_new_dbg_4p (size_t size, int type, char const *file, int line) { SIZE_T fp; FRAMEPOINTER(fp); return mfcd_new_dbg (fp, size, type, file, line); } // mfcud__vector_new_dbg_3p - Calls to the MFC debug vector new operator from // mfcXXud.dll are patched through to this function. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // - file (IN): The name of the file from which this function is being called. // // - line (IN): The line number, in the above file, at which this function is // being called. // // Return Value: // // Returns the value returned by the MFC debug vector new operator. // TEMPLATE_HEADER void* CrtMfcPatch::mfcud__vector_new_dbg_3p (size_t size, char const *file, int line) { SIZE_T fp; FRAMEPOINTER(fp); return mfcd_new_dbg (fp, size, file, line); } // mfcud_scalar_new - Calls to the MFC scalar new operator from mfcXXud.dll are // patched through to this function. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // Return Value: // // Returns the value returned by the MFC scalar new operator. // TEMPLATE_HEADER void* CrtMfcPatch::mfcud_scalar_new (size_t size) { SIZE_T fp; FRAMEPOINTER(fp); return mfcd_new(fp, size); } // mfcud_vector_new - Calls to the MFC vector new operator from mfcXXud.dll are // patched through to this function. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // Return Value: // // Returns the value returned by the MFC vector new operator. // TEMPLATE_HEADER void* CrtMfcPatch::mfcud_vector_new (size_t size) { SIZE_T fp; FRAMEPOINTER(fp); return mfcd_new(fp, size); } // mfcd_new_dbg - A generic function for implementing patch functions to the MFC // debug new operators: // void* __cdecl operator new[](size_t size, int type, char const *file, int line) // void* __cdecl operator new(size_t size, int type, char const *file, int line) // // - mfcdll (IN): The name of the MFC DLL // // - ordinal (IN): The debug new operator's ordinal value // // - type (IN): The "use type" of the block to be allocated. // // - size (IN): The size, in bytes, of the memory block to be allocated. // // - file (IN): The name of the file from which this function is being called. // // - line (IN): The line number, in the above file, at which this function is // being called. // // Return Value: // // Returns the value returned by the MFC debug new operator. // TEMPLATE_HEADER template void* CrtMfcPatch::mfcd_new_dbg (SIZE_T fp, size_t size, int type, char const *file, int line) { static new_dbg_crt_t pmfcxxd__new_dbg = NULL; HMODULE mfcxxd; if (pmfcxxd__new_dbg == NULL) { // This is the first call to this function. Link to the real MFC debug // new operator. mfcxxd = GetModuleHandle(mfcdll); pmfcxxd__new_dbg = (new_dbg_crt_t)GetProcAddress(mfcxxd, (LPCSTR)ordinal); } return vld.new_dbg_mfc(pmfcxxd__new_dbg, fp, size, type, file, line); } // mfcd_new_dbg - A generic function for implementing patch functions to the MFC // debug new operators: // void* __cdecl operator new[](size_t size, char const *file, int line) // void* __cdecl operator new(size_t size, char const *file, int line) // // - mfcdll (IN): The name of the MFC DLL // // - ordinal (IN): The debug new operator's ordinal value // // - size (IN): The size, in bytes, of the memory block to be allocated. // // - file (IN): The name of the file from which this function is being called. // // - line (IN): The line number, in the above file, at which this function is // being called. // // Return Value: // // Returns the value returned by the MFC debug new operator. // TEMPLATE_HEADER template void* CrtMfcPatch::mfcd_new_dbg (SIZE_T fp, size_t size, char const *file, int line) { static new_dbg_mfc_t pmfcxxd__new_dbg = NULL; HMODULE mfcxxd; if (pmfcxxd__new_dbg == NULL) { // This is the first call to this function. Link to the real MFC debug // new operator. mfcxxd = GetModuleHandle(mfcdll); pmfcxxd__new_dbg = (new_dbg_mfc_t)GetProcAddress(mfcxxd, (LPCSTR)ordinal); } return vld.new_dbg_mfc(pmfcxxd__new_dbg, fp, size, file, line); } // mfcd_new - A generic function for implementing patch functions to the MFC new // operators. // // - mfcdll (IN): The name of the MFC DLL // // - ordinal (IN): The new operator's ordinal value // // - size (IN): The size, in bytes, of the memory block to be allocated. // // Return Value: // // Returns the value returned by the MFC new operator. // TEMPLATE_HEADER template void* CrtMfcPatch::mfcd_new (SIZE_T fp, size_t size) { static new_t pmfcxxd_new = NULL; HMODULE mfcxxd; if (pmfcxxd_new == NULL) { // This is the first call to this function. Link to the real CRT new // operator. mfcxxd = GetModuleHandle(mfcdll); pmfcxxd_new = (new_t)GetProcAddress(mfcxxd, (LPCSTR)ordinal); } return vld._new(pmfcxxd_new, fp, size); } #undef TEMPLATE_HEADER #undef TEMPLATE_ARGS const extern char scalar_new_dbg_name[] = "??2@YAPAXIHPBDH@Z"; const extern char vector_new_dbg_name[] = "??_U@YAPAXIHPBDH@Z"; const extern char scalar_new_name[] = "??2@YAPAXI@Z"; const extern char vector_new_name[] = "??_U@YAPAXI@Z"; const extern wchar_t msvcrtd_dll[] = L"msvcrtd.dll"; const extern wchar_t mfc42d_dll[] = L"mfc42d.dll"; const extern wchar_t mfc42ud_dll[] = L"mfc42ud.dll"; const extern wchar_t msvcr70d_dll[] = L"msvcr70d.dll"; const extern wchar_t mfc70d_dll[] = L"mfc70d.dll"; const extern wchar_t mfc70ud_dll[] = L"mfc70ud.dll"; const extern wchar_t msvcr71d_dll[] = L"msvcr71d.dll"; const extern wchar_t mfc71d_dll[] = L"mfc71d.dll"; const extern wchar_t mfc71ud_dll[] = L"mfc71ud.dll"; const extern wchar_t msvcr80d_dll[] = L"msvcr80d.dll"; const extern wchar_t mfc80d_dll[] = L"mfc80d.dll"; const extern wchar_t mfc80ud_dll[] = L"mfc80ud.dll"; const extern wchar_t msvcr90d_dll[] = L"msvcr90d.dll"; const extern wchar_t mfc90d_dll[] = L"mfc90d.dll"; const extern wchar_t mfc90ud_dll[] = L"mfc90ud.dll"; const extern wchar_t msvcr100d_dll[] = L"msvcr100d.dll"; const extern wchar_t mfc100d_dll[] = L"mfc100d.dll"; const extern wchar_t mfc100ud_dll[] = L"mfc100ud.dll"; // Visual Studio 6.0 typedef CrtMfcPatch VS60; // Visual Studio .NET 2002 typedef CrtMfcPatch VS70; // Visual Studio .NET 2003 typedef CrtMfcPatch VS71; // Visual Studio 2005 typedef CrtMfcPatch VS80; // Visual Studio 2008 typedef CrtMfcPatch VS90; // Visual Studio 2010 typedef CrtMfcPatch VS100;