UINT _ValidateLocalMem(HLOCAL hMem, LPARAM lParam, LPCSTR pszText)
{
UINT uByte = 0;
if (hMem)
{
UINT uSize = LocalSize(hMem);
if (uSize)
{
LPARAM lParamStored;
uByte = *(UINT*)HMEM2PTR(hMem, uSize-sizeof(UINT));
AssertMsg(uByte+CBALLOCEXTRA <= uSize,
"cm ASSERT! Bogus uByte %d (%s for %x)",
uByte, pszText, hMem);
lParamStored = *(LPARAM*)HMEM2PTR(hMem, uByte);
AssertMsg(lParamStored==lParam, "cm ASSERT! Bad Signiture %x (%s for %x)",
lParamStored, pszText, hMem);
}
else
{
AssertMsg(0, "cm ASSERT! LocalSize is zero (%s for %x)",
pszText, hMem);
}
}
return uByte;
}
void _StoreSigniture(HLOCAL hMem, UINT uByte, LPARAM lParam)
{
if (hMem)
{
UINT uSize = LocalSize(hMem);
Assert(uSize>=uByte+CBALLOCEXTRA);
*(UINT*)HMEM2PTR(hMem, uSize-sizeof(UINT)) = uByte;
*(LPARAM*)HMEM2PTR(hMem, uByte) = lParam;
}
}
void* GUI_ALLOC_h2p (GUI_HMEM hMem) {
#if GUI_DEBUG_LEVEL>0
if (!hMem) {
GUI_DEBUG_ERROROUT("\n"__FILE__ " GUI_ALLOC_h2p: illegal argument (0 handle)");
return 0;
}
#endif
return HMEM2PTR(hMem);
}
/*********************************************************************
*
* GUI_ALLOC_h2p
*/
void* GUI_ALLOC_h2p(GUI_HMEM hMem) {
GUI_ASSERT_LOCK();
#if GUI_DEBUG_LEVEL > 0
if (!hMem) {
GUI_DEBUG_ERROROUT("\n"__FILE__ " GUI_ALLOC_h2p: illegal argument (0 handle)");
return 0;
}
if (aBlock[hMem].Size == 0) {
GUI_DEBUG_ERROROUT("Dereferencing free block");
}
#endif
return HMEM2PTR(hMem);
}
static GUI_HMEM _Alloc(int size) {
GUI_HMEM hMemNew, hMemIns;
CheckInit();
size = Size2LegalSize(size);
/* Check if memory is available at all ...*/
if (size > GUI_ALLOC.NumFreeBytes) {
GUI_DEBUG_WARN1("GUI_ALLOC_Alloc: Insufficient memory configured (Trying to alloc % bytes)", size);
return 0;
}
/* Locate free handle */
if ((hMemNew = FindFreeHandle()) == 0)
return 0;
/* Locate or Create hole of sufficient size */
hMemIns = FindHole(size);
#if GUI_ALLOC_AUTDEFRAG
if (hMemIns == -1) {
hMemIns = CreateHole(size);
}
#endif
/* Occupy hole */
if (hMemIns==-1) {
GUI_DEBUG_ERROROUT1("GUI_ALLOC_Alloc: Could not allocate %d bytes",size);
return 0;
}
{
int Off = aBlock[hMemIns].Off+aBlock[hMemIns].Size;
int Next = aBlock[hMemIns].Next;
aBlock[hMemNew].Size = size;
aBlock[hMemNew].Off = Off;
if ((aBlock[hMemNew].Next = Next) >0) {
aBlock[Next].Prev = hMemNew;
}
aBlock[hMemNew].Prev = hMemIns;
aBlock[hMemIns].Next = hMemNew;
}
/* Keep track of number of blocks and av. memory */
GUI_ALLOC.NumUsedBlocks++;
GUI_ALLOC.NumFreeBlocks--;
if (GUI_ALLOC.NumFreeBlocksMin > GUI_ALLOC.NumFreeBlocks) {
GUI_ALLOC.NumFreeBlocksMin = GUI_ALLOC.NumFreeBlocks;
}
GUI_ALLOC.NumUsedBytes += size;
GUI_ALLOC.NumFreeBytes -= size;
if (GUI_ALLOC.NumFreeBytesMin > GUI_ALLOC.NumFreeBytes) {
GUI_ALLOC.NumFreeBytesMin = GUI_ALLOC.NumFreeBytes;
}
/* In order to be on the safe side, zeroinit ! */
memset(HMEM2PTR(hMemNew), 0, size);
return hMemNew;
}
