/* Copyright (c) 1999-2000 Microsoft Corporation.  All rights reserved. */
#include <windows.h>
#include <coredll.h>
#include "heap.h"
#include <celogcoredll.h>

#ifdef MEMTRACKING
DWORD dwHeapMemType;
#endif

DWORD pagemask;
heap ProcessHeap;
CRITICAL_SECTION hcs;

BOOL WINAPI LMemInit(void){
	pagemask = UserKInfo[KINX_PAGESIZE] - 1;
    DEBUGMSG(DBGLMEM, (L"LMemInit\r\n"));
    InitializeCriticalSection(&hcs);
    ProcessHeap.pNextHeap	  = NULL;
    ProcessHeap.pGrowthHeap	  = NULL;
	ProcessHeap.pVallocs	  = NULL;
	ProcessHeap.flOptions     = HEAP_IS_PROC_HEAP;
    ProcessHeap.dwMaximumSize = CE_FIXED_HEAP_MAXSIZE;
    ProcessHeap.pMem          = NULL;
    ProcessHeap.pHigh         = NULL;
    ProcessHeap.pCur          = NULL;
    ProcessHeap.dwCommitted   = 0;
    ProcessHeap.dwFree        = 0;
    ProcessHeap.dwLastCompact = 0;
    ProcessHeap.dwMaxLeft     = 0;
#ifdef MEMTRACKING
    ProcessHeap.dwMemType     = RegisterTrackedItem(L"Local Memory");
    dwHeapMemType = RegisterTrackedItem(L"Heaps");
#endif

    CELOG_HeapCreate(HEAP_IS_PROC_HEAP, 0, CE_FIXED_HEAP_MAXSIZE, (HANDLE)&ProcessHeap);

    DEBUGMSG(DBGLMEM, (L"   LMemInit ==> TRUE\r\n"));
    return TRUE;
}

#if defined(MEMTRACKING) && defined(MEM_ACCOUNT)
void TrackerCallback (DWORD dwFlags, DWORD dwType, HANDLE hItem, DWORD dwProc, BOOL fDeleted,
	DWORD dwSize, DWORD dw1, DWORD dw2) {
	PBYTE p = (PBYTE)hItem;
	if (!fDeleted && *(int*)p == 0x8482906) {
		NKDbgPrintfW (L"%a %i", p+4, *(int*)(p+20));
		if (!memcmp (p+4, "String", 7))
			NKDbgPrintfW (L"  :\"%s\"", p+24);
	}
	NKDbgPrintfW (L"\r\n");
}
#define TCB TrackerCallback
#else
#define TCB NULL
#endif

/*
	@doc BOTH EXTERNAL
	
	@func HLOCAL | LocalAlloc | Allocates a block of memory from the local heap
    @parm UINT | uFlags | flags for alloc operation
    @parm UINT | uBytes | desired size of block

	@comm Only fixed memory is supported, thus LMEM_MOVEABLE is invalid.
*/
HLOCAL WINAPI LocalAlloc(UINT uFlags, UINT uBytes) {
    LPVOID p;
    DEBUGMSG(DBGLMEM, (L"LocalAlloc %8.8lx %8.8lx\r\n",uBytes,uFlags));
    if(uFlags & ~LMEM_VALID_FLAGS) {
	    DEBUGMSG(DBGLMEM, (L"   LocalAlloc %8.8lx %8.8lx ==> %8.8lx\r\n",uBytes,uFlags,0));
		SetLastError(ERROR_INVALID_PARAMETER);
		return NULL;
    }
    p = HeapAlloc(&ProcessHeap,(uFlags & LMEM_ZEROINIT) ? HEAP_ZERO_MEMORY : 0,uBytes);
	DEBUGMSG(DBGLMEM, (L"   LocalAlloc %8.8lx %8.8lx ==> %8.8lx [%8.8lx]\r\n",uBytes,uFlags,p,FixedHeapSize(&ProcessHeap,p)));
    return (HLOCAL)p;
}

/*
	@doc BOTH EXTERNAL
	
	@func HLOCAL | LocalRealloc | Realloc's a LocalAlloc'ed block of memory
    @parm HLOCAL | hMem | handle of local memory object to realloc
    @parm UINT | uBytes | desired new size of block
    @parm UINT | uFlags | flags for realloc operation

	@comm Follows the Win32 reference description without restrictions
    or modifications. 
*/
HLOCAL WINAPI LocalReAlloc(HLOCAL hMem, UINT uBytes, UINT uFlags) {
	LPVOID retval;
	UINT newflags;
    DEBUGMSG(DBGLMEM, (L"LocalRealloc %8.8lx %8.8lx %8.8lx\r\n",hMem,uBytes,uFlags));
    if((uFlags & ~(LMEM_VALID_FLAGS | LMEM_MODIFY )) ||
		((uFlags & LMEM_DISCARDABLE) && !(uFlags & LMEM_MODIFY))) {
	    DEBUGMSG(DBGLMEM, (L"   LocalRealloc %8.8lx %8.8lx %8.8lx ==> %8.8lx\r\n",hMem,uBytes,uFlags,0));
		SetLastError(ERROR_INVALID_PARAMETER);
		return(NULL);
    }
    newflags = ((uFlags & LMEM_ZEROINIT) ? HEAP_ZERO_MEMORY : 0) | ((uFlags & LMEM_MOVEABLE) ? 0 : HEAP_REALLOC_IN_PLACE_ONLY);
	retval = HeapReAlloc(&ProcessHeap, newflags, hMem, uBytes);    
    DEBUGMSG(DBGLMEM, (L"   LocalRealloc %8.8lx %8.8lx %8.8lx ==> %8.8lx [%8.8lx]\r\n",hMem,uBytes,uFlags,retval,FixedHeapSize(&ProcessHeap,retval)));
    return (HLOCAL)retval;
}

/*
	@doc BOTH EXTERNAL
	
	@func UINT | LocalSize | Returns the size of a LocalAlloc'ed block of memory
    @parm HLOCAL | hMem | handle of local memory object to get size of

	@comm Follows the Win32 reference description without restrictions 
    or modifications. 
*/
UINT WINAPI LocalSize(HLOCAL hMem) {
	UINT retval;
    DEBUGMSG(DBGLMEM, (L"LocalSize %8.8lx\r\n",hMem));
    if ((retval = HeapSize(&ProcessHeap,0,hMem)) == (DWORD)-1)
    	retval = 0;
    DEBUGMSG(DBGLMEM, (L"   LocalSize %8.8lx ==> %8.8lx\r\n",hMem,retval));
	return retval;
}

/*
	@doc BOTH EXTERNAL
	
	@func HLOCAL | LocalFree | Frees a LocalAlloc'ed block of memory
    @parm HLOCAL | hMem | handle of local memory object to free

	@comm Follows the Win32 reference description without restrictions 
    or modifications. 
*/
HLOCAL WINAPI LocalFree(HLOCAL hMem) {
	HLOCAL retval;
    DEBUGMSG(DBGLMEM, (L"LocalFree %8.8lx\r\n",hMem));
	if (retval = (!hMem || HeapFree(&ProcessHeap,0,(LPVOID)hMem)) ? NULL : hMem)
		SetLastError(ERROR_INVALID_PARAMETER);
    DEBUGMSG(DBGLMEM, (L"   LocalFree %8.8lx ==> %8.8lx\r\n",hMem,retval));
    return retval;
}

/*
    @doc BOTH EXTERNAL
	
	@func HANDLE | HeapCreate    | Creates a new local heap
    @parm DWORD  | flOptions     | no flags supported
    @parm DWORD  | dwInitialSize | Initial committed heap size
    @parm DWORD  | dwMaximumSize | Maximum heap size
*/
HANDLE WINAPI HeapCreate(DWORD flOptions, DWORD dwInitialSize, DWORD dwMaximumSize) {
    pheap pHeap;
#ifdef MEMTRACKING
	WCHAR Name[14];
#endif
    DEBUGMSG(DBGLMEM, (L"HeapCreate %8.8lx %8.8lx %8.8lx\r\n", flOptions, dwInitialSize, dwMaximumSize));
    if (flOptions & ~HEAP_NO_SERIALIZE) {
	    DEBUGMSG(DBGLMEM, (L"   HeapCreate: Invalid parameter\r\n"));
	    SetLastError(ERROR_INVALID_PARAMETER);
		return 0;
    }
    EnterCriticalSection(&hcs);
    pHeap = (pheap)FixedHeapAlloc(&ProcessHeap,sizeof(heap),0);
    LeaveCriticalSection(&hcs);
    if (!pHeap) {
		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
		return(NULL);
    }
#ifdef MEMTRACKING
    AddTrackedItem(dwHeapMemType,pHeap,NULL,GetCurrentProcessId(),sizeof(heap),0,0);
#endif
    pHeap->flOptions     = 0;
	pHeap->pVallocs		 = 0;
    pHeap->dwMaximumSize = CE_FIXED_HEAP_MAXSIZE;
    pHeap->pMem          = NULL;
    pHeap->pHigh         = NULL;
    pHeap->pCur          = NULL;
    pHeap->dwCommitted   = 0;
    pHeap->dwFree        = 0;
    pHeap->dwLastCompact = 0;
	pHeap->dwMaxLeft     = 0;
#ifdef MEMTRACKING
	swprintf(Name, L"Heap %08X", pHeap);
	pHeap->dwMemType     = RegisterTrackedItem(Name);
#endif
    EnterCriticalSection(&hcs);
    pHeap->pGrowthHeap = NULL;
    pHeap->pNextHeap = ProcessHeap.pNextHeap;
    ProcessHeap.pNextHeap = pHeap;
    LeaveCriticalSection(&hcs);
    DEBUGMSG(DBGLMEM, (L"   HeapCreate %8.8lx %8.8lx %8.8lx ==> %8.8lx\r\n", flOptions, dwInitialSize, dwMaximumSize, pHeap));
    CELOG_HeapCreate(flOptions, dwInitialSize, dwMaximumSize, (HANDLE)pHeap);
    return (HANDLE)pHeap;
}

/*
    @doc BOTH EXTERNAL
	
	@func LPVOID | HeapReAlloc | Realloc's a HeapAlloc'ed block of memory
	@parm HANDLE | hHeap     | Handle returned from CreateHeap()
    @parm DWORD  | dwFlags   | HEAP_NO_SERIALIZE, HEAP_REALLOC_IN_PLACE_ONLY and HEAP_ZERO_MEM supported
    @parm LPVOID | lpMem     | pointer to memory to realloc
    @parm DWORD  | dwBytes   | Desired size of block
*/
LPVOID WINAPI HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, DWORD dwBytes) {
    LPVOID p;
    DEBUGMSG(DBGLMEM, (L"HeapReAlloc %8.8lx %8.8lx %8.8lx %8.8lx\r\n", hHeap,dwFlags,lpMem,dwBytes));
    if(dwFlags & ~(HEAP_GENERATE_EXCEPTIONS | HEAP_NO_SERIALIZE | HEAP_REALLOC_IN_PLACE_ONLY | HEAP_ZERO_MEMORY)) {
	    DEBUGMSG(DBGLMEM, (L"   HeapReAlloc %8.8lx %8.8lx %8.8lx %8.8lx ==> %8.8lx\r\n", hHeap,dwFlags,lpMem,dwBytes,0));
		SetLastError(ERROR_INVALID_PARAMETER);
		return NULL;
    }
    if(dwFlags & HEAP_GENERATE_EXCEPTIONS) {
	    DEBUGMSG(DBGLMEM, (L"   HeapReAlloc %8.8lx %8.8lx %8.8lx %8.8lx ==> %8.8lx\r\n", hHeap,dwFlags,lpMem,dwBytes,0));
		SetLastError(ERROR_NOT_SUPPORTED);
		return NULL;
    }
    if(!hHeap || !lpMem) {
		SetLastError(ERROR_INVALID_PARAMETER);
	    DEBUGMSG(DBGLMEM, (L"   HeapReAlloc %8.8lx %8.8lx %8.8lx %8.8lx ==> %8.8lx\r\n", hHeap,dwFlags,lpMem,dwBytes,0));
		return NULL;
    }
    EnterCriticalSection(&hcs);
    if (!(p=FixedHeapReAlloc((pheap)hHeap,lpMem,dwBytes,(dwFlags & HEAP_ZERO_MEMORY?1:0),
		(dwFlags & HEAP_REALLOC_IN_PLACE_ONLY ? 0 : 1))))
		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
#ifdef MEMTRACKING
    if (p) {
		DeleteTrackedItem(((pheap)hHeap)->dwMemType, lpMem);
		AddTrackedItem(((pheap)hHeap)->dwMemType, p, TCB, GetCurrentProcessId(), 
	       FixedHeapSize((pheap)hHeap,p), 0, 0);
    }
#endif
    DEBUGMSG(DBGLMEM, (L"   HeapReAlloc %8.8lx %8.8lx %8.8lx %8.8lx ==> %8.8lx\r\n", hHeap,dwFlags,lpMem,dwBytes,p));
    DEBUGCHK(!p || ((FixedHeapSize((pheap)hHeap,p) >= dwBytes) && (FixedHeapSize((pheap)hHeap,p) != (DWORD)-1)));
    LeaveCriticalSection(&hcs);
    CELOG_HeapRealloc(hHeap, dwFlags, dwBytes, (DWORD)lpMem, (DWORD)p);
    return p;
}

/*
    @doc BOTH EXTERNAL
	
	@func LPVOID | HeapAlloc | Allocates a block of memory from specified heap
    @parm HANDLE | hHeap     | Handle returned from CreateHeap()