// // Copyright (c) Microsoft Corporation 1993-1995 // // mem.h // // Memory management functions. // // History: // 09-27-94 ScottH Partially taken from commctrl // 04-29-95 ScottH Taken from briefcase and cleaned up // #ifndef _MEM_H_ #define _MEM_H_ // // Memory routines // #ifdef WIN32 // // These macros are used in our controls, that in 32 bits we simply call // LocalAlloc as to have the memory associated with the process that created // it and as such will be cleaned up if the process goes away. // LPVOID PUBLIC MemAlloc(HANDLE hheap, DWORD cb); LPVOID PUBLIC MemReAlloc(HANDLE hheap, LPVOID pb, DWORD cb); BOOL PUBLIC MemFree(HANDLE hheap, LPVOID pb); DWORD PUBLIC MemSize(HANDLE hheap, LPVOID pb); #else // WIN32 // In 16 bit code we need the Allocs to go from our heap code as we do not // want to limit them to 64K of data. If we have some type of notification of // 16 bit application termination, We may want to see if we can // dedicate different heaps for different processes to cleanup... #define MemAlloc(hheap, cb) Alloc(cb) /* calls to verify heap exists */ #define MemReAlloc(hheap, pb, cb) ReAlloc(pb, cb) #define MemFree(hheap, pb) Free(pb) #define MemSize(hheap, pb) GetSize((LPCVOID)pb) #endif // WIN32 // Mem_Terminate() must be called before the app/dll is terminated. // void PUBLIC Mem_Terminate(); // // Non-shared memory allocation // // void * GAlloc(DWORD cbBytes) // // Alloc a chunk of memory. Initialize to zero. // #define GAlloc(cbBytes) GlobalAlloc(GPTR, cbBytes) // void * GReAlloc(void * pv, DWORD cbNewSize) // // Realloc memory. If pv is NULL, then this function will do // an alloc for you. Initializes new portion to zero. // #define GReAlloc(pv, cbNewSize) GlobalReAlloc(pv, cbNewSize, GMEM_MOVEABLE | GMEM_ZEROINIT) // void GFree(void *pv) // // Free pv if it is nonzero. // #define GFree(pv) ((pv) ? GlobalFree(pv) : (void)0) // DWORD GGetSize(void *pv) // // Get the size of a block allocated by GAlloc() // #define GGetSize(pv) GlobalSize(pv) // type * GAllocType(type) (macro) // // Alloc some memory the size of and return // pointer to . // #define GAllocType(type) (type *)GAlloc(sizeof(type)) // type * GAllocArray(type, DWORD cNum) (macro) // // Alloc an array of data the size of . Returns // a pointer to . // #define GAllocArray(type, cNum) (type *)GAlloc(sizeof(type) * (cNum)) // type * GReAllocArray(type, void * pb, DWORD cNum); // // Realloc an array of . Returns a pointer to // . The returned pointer may differ from the // given parameter. // #define GReAllocArray(type, pb, cNum) (type *)GReAlloc(pb, sizeof(type) * (cNum)) // (Re)allocates *ppszBuf and copies psz into *ppszBuf. If // *ppszBuf is NULL, this function allocates memory to hold // psz. If *ppszBuf is non-NULL, this function reallocates // memory to hold psz. If psz is NULL, this function frees // *ppszBuf. // // Returns TRUE if successful, FALSE if not. // BOOL PUBLIC GSetString(LPSTR * ppszBuf, LPCSTR psz); // This function is like GSetString except it concatentates // psz onto *ppszBuf. // BOOL PUBLIC GCatString(LPSTR * ppszBuf, LPCSTR psz); // // Shared memory allocation functions. // #ifndef NOSHAREDHEAP // PVOID SharedAlloc(DWORD cb); // // Alloc a chunk of memory. Initialize to zero. // PVOID PUBLIC SharedAlloc(DWORD cb); // PVOID SharedReAlloc(PVOID pv, DWORD cb); // // Realloc memory. If pv is NULL, then this function will do // an alloc for you. Initializes new portion to zero. // PVOID PUBLIC SharedReAlloc(PVOID pv, DWORD cb); // void SharedFree(PVOID pv); // // Free pv if it is nonzero. // void PUBLIC _SharedFree(PVOID pv); #define SharedFree(pv) ((pv) ? _SharedFree(pv) : (void)0) // DWORD SharedGetSize(PVOID pv); // // Get the size of a block allocated by SharedAlloc() // DWORD PUBLIC SharedGetSize(PVOID pv); // type * SharedAllocType(type); (macro) // // Alloc some memory the size of and return // pointer to . // #define SharedAllocType(type) (type *)SharedAlloc(sizeof(type)) // type * SharedAllocArray(type, DWORD cNum); (macro) // // Alloc an array of data the size of . Returns // a pointer to . // #define SharedAllocArray(type, cNum) (type *)SharedAlloc(sizeof(type) * (cNum)) // type * SharedReAllocArray(type, void * pb, DWORD cNum); // // Realloc an array of . Returns a pointer to // . The returned pointer may differ from the // given parameter. // #define SharedReAllocArray(type, pb, cNum) (type *)SharedReAlloc(pb, sizeof(type) * (cNum)) // (Re)allocates *ppszBuf and copies psz into *ppszBuf. If // *ppszBuf is NULL, this function allocates memory to hold // psz. If *ppszBuf is non-NULL, this function reallocates // memory to hold psz. If psz is NULL, this function frees // *ppszBuf. // // Returns TRUE if successful, FALSE if not. // BOOL PUBLIC SharedSetString(LPSTR * ppszBuf, LPCSTR psz); #else // NOSHAREDHEAP #define SharedAlloc(cbBytes) GAlloc(cbBytes) #define SharedReAlloc(pv, cb) GReAlloc(pv, cb) #define SharedFree(pv) GFree(pv) #define SharedGetSize(pv) GGetSize(pv) #define SharedAllocType(type) (type *)SharedAlloc(sizeof(type)) #define SharedAllocArray(type, cNum) (type *)SharedAlloc(sizeof(type) * (cNum)) #define SharedReAllocArray(type, pb, cNum) (type *)SharedReAlloc(pb, sizeof(type) * (cNum)) #define SharedSetString(ppszBuf, psz) GSetString(ppszBuf, psz) #endif // NOSHAREDHEAP #ifndef NODA // // Structure Array // #define SA_ERR ((DWORD)(-1)) #define SA_APPEND NULL typedef struct _SA FAR * HSA; typedef HSA * PHSA; BOOL PUBLIC SACreateEx(PHSA phsa, DWORD cbItem, DWORD cItemGrow, HANDLE hheap, DWORD dwFlags); #define SACreate(phsa, cbItem, cItemGrow) SACreateEx(phsa, cbItem, cItemGrow, NULL, SAF_DEFAULT) // Flags for SACreate #define SAF_DEFAULT 0x0000 #define SAF_SHARED 0x0001 #define SAF_HEAP 0x0002 typedef void (CALLBACK *PFNSAFREE)(LPVOID pv, LPARAM lParam); BOOL PUBLIC SADestroyEx(HSA hsa, PFNSAFREE pfnFree, LPARAM lParam); #define SADestroy(hsa) SADestroyEx(hsa, NULL, 0) BOOL PUBLIC SAGetItem(HSA hsa, DWORD iItem, LPVOID pitem); BOOL PUBLIC SAGetItemPtr(HSA hsa, DWORD iItem, LPVOID * ppv); BOOL PUBLIC SASetItem(HSA hsa, DWORD iItem, LPVOID pitem); BOOL PUBLIC SAInsertItem(HSA hsa, LPDWORD pindex, LPVOID pitem); BOOL PUBLIC SADeleteItem(HSA hsa, DWORD iItem); BOOL PUBLIC SADeleteAllItems(HSA hsa); #define SAGetCount(hsa) (*(DWORD FAR*)(hsa)) // // Pointer Array // #define PA_ERR ((DWORD)(-1)) #define PA_APPEND NULL typedef struct _PA FAR * HPA; typedef HPA * PHPA; BOOL PUBLIC PACreateEx(PHPA phpa, DWORD cItemGrow, HANDLE hheap, DWORD dwFlags); #define PACreate(phpa, cItemGrow) (PACreateEx(phpa, cItemGrow, NULL, PAF_DEFAULT)) // Flags for PACreate #define PAF_DEFAULT 0x0000 #define PAF_SHARED 0x0001 #define PAF_HEAP 0x0002 typedef void (CALLBACK *PFNPAFREE)(LPVOID pv, LPARAM lParam); BOOL PUBLIC PADestroyEx(HPA hpa, PFNPAFREE pfnFree, LPARAM lParam); #define PADestroy(hpa) PADestroyEx(hpa, NULL, 0) BOOL PUBLIC PAClone(PHPA phpa, HPA hpa); BOOL PUBLIC PAGetPtr(HPA hpa, DWORD i, LPVOID * ppv); BOOL PUBLIC PAGetPtrIndex(HPA hpa, LPVOID pv, LPDWORD pindex); BOOL PUBLIC PAGrow(HPA pdpa, DWORD cp); BOOL PUBLIC PASetPtr(HPA hpa, DWORD i, LPVOID p); BOOL PUBLIC PAInsertPtr(HPA hpa, LPDWORD pindex, LPVOID pv); LPVOID PUBLIC PADeletePtr(HPA hpa, DWORD i); BOOL PUBLIC PADeleteAllPtrsEx(HPA hpa, PFNPAFREE pfnFree, LPARAM lParam); #define PADeleteAllPtrs(hpa) PADeleteAllPtrsEx(hpa, NULL, 0) #define PAGetCount(hpa) (*(DWORD FAR*)(hpa)) #define PAGetPtrPtr(hpa) (*((LPVOID FAR* FAR*)((BYTE FAR*)(hpa) + 2*sizeof(DWORD)))) #define PAFastGetPtr(hpa, i) (PAGetPtrPtr(hpa)[i]) typedef int (CALLBACK *PFNPACOMPARE)(LPVOID p1, LPVOID p2, LPARAM lParam); BOOL PUBLIC PASort(HPA hpa, PFNPACOMPARE pfnCompare, LPARAM lParam); // Search array. If PAS_SORTED, then array is assumed to be sorted // according to pfnCompare, and binary search algorithm is used. // Otherwise, linear search is used. // // Searching starts at iStart (0 to start search at beginning). // // PAS_INSERTBEFORE/AFTER govern what happens if an exact match is not // found. If neither are specified, this function returns -1 if no exact // match is found. Otherwise, the index of the item before or after the // closest (including exact) match is returned. // // Search option flags // #define PAS_SORTED 0x0001 #define PAS_INSERTBEFORE 0x0002 #define PAS_INSERTAFTER 0x0004 DWORD PUBLIC PASearch(HPA hpa, LPVOID pFind, DWORD iStart, PFNPACOMPARE pfnCompare, LPARAM lParam, UINT options); #endif // NODA #endif // _MEM_H_