int _tmain(int argc, _TCHAR* argv[])
{
	HANDLE hHeap = HeapCreate(HEAP_NO_SERIALIZE, PAGE_SIZE*10, PAGE_SIZE*100);

	int* pArr = (int* ) HeapAlloc(hHeap, 0, sizeof(int) * 30);
	
	for(int i = 0 ; i < 10 ; ++i)
	{
		if(i % 5 == 0)
			printf_s("\n");
		pArr[i] = (i + 1) * 100;
	}

	for(int i = 0 ; i < 30 ; ++i)
	{
		if(i % 5 == 0)
		printf_s("\n");
		printf_s("%d ", pArr[i]);
	}
	HeapFree(hHeap, 0, pArr);
	HeapDestroy(hHeap);
	
	getchar();

	return 0;
}

int main(int argc, char *argv[]){
	void *test;
	HGLOBAL hgtest;
	HLOCAL hltest;
	HANDLE heapcreate;
	LPVOID hptest;
	//LPVOID hvtest;

	test = malloc(100);
	memset(test,'a',100);
	zfree(test);

	hgtest = GlobalAlloc(GMEM_FIXED,100);
	memset(hgtest,'a',100);
	zGlobalFree(hgtest);

	hltest = LocalAlloc(LMEM_FIXED,100);
	memset(hltest,'a',100);
	zLocalFree(hltest);

	heapcreate = HeapCreate(0,100,100);
	hptest = HeapAlloc(heapcreate,HEAP_ZERO_MEMORY,100);
	memset(hptest,'a',100);
	zHeapFree(heapcreate,0,hptest);
	HeapDestroy(heapcreate);
	/* yet to implement 
	hvtest = VirtualAlloc(NULL,100,MEM_COMMIT,PAGE_READWRITE);
	memset(hvtest,'a',100);
	zVirtualFree(hvtest,100,MEM_RELEASE);
	return 0;
	*/
}

BOOL
LongBinary::SetBinarySize(DWORD sizeNew, void* lpDataCopy){
	if (m_hMemory == NULL){ // Allocate
		m_pBuffer = NULL;
		if (sizeNew == 0)
			return TRUE;
		m_hMemory = HeapCreate(0L, sizeNew, 0L);
		ASSERT(m_hMemory);
		m_pBuffer = HeapAlloc(m_hMemory, 0L, sizeNew);
		m_dwSize = sizeNew;
	}
	else{ // Reallocate
		if (sizeNew > m_dwSize){
			// Allocate or realocate memory . #####
			m_pBuffer = HeapReAlloc(m_hMemory, 0L, m_pBuffer, sizeNew);
			m_dwSize = sizeNew;
		}
		else
			if (sizeNew == 0){
				HeapFree(m_hMemory, 0L, m_pBuffer);
				HeapDestroy(m_hMemory);
				m_pBuffer = NULL;
				m_hMemory = NULL;
				m_dwSize = 0;
			}
		}

	if( lpDataCopy != NULL && m_hMemory ){
		memcpy(m_pBuffer, lpDataCopy, sizeNew);
		}
	return TRUE;
	}

BOOL CHeapAllocator::Initialize(SIZE_T dwInitSize)
{
    Unitialize();
    m_hHeap = HeapCreate(0,dwInitSize,0);


	// Jie JIAN changed @ 2007-12-28
	// use LFH if possible
	typedef BOOL (WINAPI *PFN_HEAPSETINFORMATION)(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T);
	
	HMODULE hKernel32 = LoadLibraryW( L"kernel32.dll" );
	if ( NULL != hKernel32 )
	{
		PFN_HEAPSETINFORMATION pfnHeapSetInformation = 
			reinterpret_cast<PFN_HEAPSETINFORMATION>(
			GetProcAddress(hKernel32, "HeapSetInformation")
			);

		if ( NULL != pfnHeapSetInformation )
		{
			ULONG ulHeapInformation = 2;
			(*pfnHeapSetInformation)( m_hHeap,
									  HeapCompatibilityInformation,
									  &ulHeapInformation,
									  sizeof(ULONG) );
		}

		FreeLibrary(hKernel32);
	}

    return TRUE;
}

// TODO: I should probably move all initalization inside the thread
// We should minimize the amount of work done in DLL_PROCESS_ATTACH as per
// http://blogs.msdn.com/b/oleglv/archive/2003/10/24/56141.aspx
static BOOL ProcessAttach()
{
    lf("memtrace.dll: ProcessAttach()");
    if (!OpenPipe()) {
        lf("memtrace.dll: couldn't open pipe");
        return FALSE;
    } else {
        lf("memtrace.dll: opened pipe");
    }

    gHeap = HeapCreate(0, 0, 0);
    if (!gHeap) {
        lf("memtrace.dll: failed to create heap");
        return FALSE;
    }

    InitializeCriticalSection(&gMemMutex);
    gSendThreadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    if (!gSendThreadEvent) {
        lf("memtrace.dll: couldn't create gSendThreadEvent");
        return FALSE;
    }
    gSendThread = CreateThread(NULL, 0, DataSendThreadProc, NULL, 0, 0);
    if (!gSendThread) {
        lf("memtrace.dll: couldn't create gSendThread");
        return FALSE;
    }
    InstallHooks();
    return TRUE;
}

/* //////////////////////////////////////////////////////////////////////////////////////
 * implementation
 */
tb_bool_t tb_native_memory_init()
{   
    // enter
    tb_spinlock_enter_without_profiler(&g_lock);

    // done
    tb_bool_t ok = tb_false;
    do
    {
        // have been inited?
        tb_check_break_state(!g_heap, ok, tb_true);

        // make heap
        g_heap = (tb_handle_t)HeapCreate(0, 0, 0);
        tb_check_break(g_heap);

        // ok
        ok = tb_true;

    } while (0);

    // leave
    tb_spinlock_leave(&g_lock);

    // ok?
    return ok;
}

inline static void _win32_initHeap( void )
{
    g_privateHeap = HeapCreate( 0, 0, 0 );

    unsigned int info = 0;
    HeapSetInformation( g_privateHeap, HeapCompatibilityInformation, &info, sizeof(info) );
}

void PatchMW2_StringList()
{
	slHashMap.set_empty_key("*DUMMYDUMMY*");
	slHashMap.set_deleted_key("*DUMMYDUMM*");

	call(0x4D2280, SL_Init, PATCH_JUMP);
	call(0x436B40, SL_GetStringOfSize, PATCH_JUMP);
	call(0x4EC1D0, SL_ConvertToString_, PATCH_JUMP);
	call(0x61BCB0, FindStringOfSize, PATCH_JUMP);
	call(0x469D80, SL_ConvertFromString, PATCH_JUMP);
	call(0x4D9B00, SL_AddRefToString, PATCH_JUMP);
	call(0x4F1500, SL_RemoveRefToStringOfSize, PATCH_JUMP);
	call(0x47CD70, SL_RemoveRefToString, PATCH_JUMP);
	call(0x417730, Scr_SetString, PATCH_JUMP);
	call(0x4401E0, SL_GetStringLen, PATCH_JUMP);
	call(0x40C050, SL_TransferRefToUser, PATCH_JUMP);
	call(0x4B4310, SL_AddUser, PATCH_JUMP);
	call(0x430510, SL_ConvertToLowercase, PATCH_JUMP);
	call(0x4F46D0, SL_ShutdownSystem, PATCH_JUMP);
	call(0x4A44A0, SL_TransferSystem, PATCH_JUMP);

	stringHeap = HeapCreate(0, 1024 * 1024, 0);

	// path_node_constant_t marking function; has some terrible string references
	*(BYTE*)0x4F74B0 = 0xC3;
}

/*! This function has to be called before using any other
    function of hpgs. It defines the path, where additional
    files such as the truetype files for HPGL files or plugins
    are stored.

    Truetype fonts are searched in the path <prefix>/share/hpgs

    The path is internally duplicated using \c strdup.
*/
void hpgs_init(const char *path)
{
  int l;

  hpgs_reader_prefix = strdup(path);

  if (!hpgs_reader_prefix) return;

  // strip off trailing directory separators.  
  l = strlen(hpgs_reader_prefix);

  if (l && hpgs_reader_prefix[l-1] == HPGS_PATH_SEPARATOR)
    hpgs_reader_prefix[l-1] = '\0';

#ifdef WIN32
  hHeap = HeapCreate(0,4096,128*1024);
  tls_handle = TlsAlloc();
#else
  pthread_key_create (&key,free);
#endif
#ifdef HPGS_HAVE_GETTEXT
  hpgs_i18n_init();
#endif
  hpgs_font_init();
}

CLrpHeap::CLrpHeap() : m_heap(HeapCreate(0, 0, 0))
{
	if (nullptr == m_heap)
	{
		throw runtime_error("Couldn't create a new memory heap");
	}
}

//-------------------------------------------------------------------------
MH_STATUS WINAPI MH_Initialize(VOID)
{
    MH_STATUS status = MH_OK;

    EnterSpinLock();

    if (g_hHeap == NULL)
    {
        g_hHeap = HeapCreate(0, 0, 0);
        if (g_hHeap != NULL)
        {
            // Initialize the internal function buffer.
            InitializeBuffer();
        }
        else
        {
            status = MH_ERROR_MEMORY_ALLOC;
        }
    }
    else
    {
        status = MH_ERROR_ALREADY_INITIALIZED;
    }

    LeaveSpinLock();

    return status;
}

HANDLE get_tls_heap()
{
	if (local_heap_tls == 0)
	{
		local_heap_tls = TlsAlloc();
		if (local_heap_tls == 0)
		{
			return (NULL);
		}
	}

	void* tls_val = TlsGetValue(local_heap_tls);

	if (tls_val == NULL)
	{
		HANDLE heap = HeapCreate(HEAP_NO_SERIALIZE, 0, 0);
		if (heap == 0)
		{
			return (NULL);
		}
		tls_val = (void*)heap;
		TlsSetValue(local_heap_tls, tls_val);
	}

	return (HANDLE)tls_val;
}

int InitModuleNames(void)
{
	struct DBModuleName *dbmn;
	DWORD ofsThis;
	int nameLen;
	char *mod;

	hModHeap=HeapCreate(0,0,0);
	lMods.sortFunc=ModCompare;
	lMods.increment=50;
	lOfs.sortFunc=OfsCompare;
	lOfs.increment=50;

	ofsThis=dbHeader.ofsFirstModuleName;
	dbmn=(struct DBModuleName*)DBRead(ofsThis,sizeof(struct DBModuleName),NULL);
	while(ofsThis) {
		if(dbmn->signature!=DBMODULENAME_SIGNATURE) DatabaseCorruption(NULL);

		nameLen=dbmn->cbName;

		mod = (char*)HeapAlloc(hModHeap,0,nameLen+1);
		CopyMemory(mod,DBRead(ofsThis+offsetof(struct DBModuleName,name),nameLen,NULL),nameLen);
		mod[nameLen] = 0;

		AddToList(mod, nameLen, ofsThis);

		ofsThis=dbmn->ofsNext;
		dbmn=(struct DBModuleName*)DBRead(ofsThis,sizeof(struct DBModuleName),NULL);
	}
	CreateServiceFunction(MS_DB_MODULES_ENUM,EnumModuleNames);
	return 0;
}

BOOL WinAPIOverride32Init(HINSTANCE hInst) {
	TCHAR psz[MAX_PATH+32];
	TCHAR pszPID[32];
	SYSTEM_INFO siSysInfo;

	DisableThreadLibraryCalls(hInst);

	dwCurrentProcessID = GetCurrentProcessId();

	wsprintf(pszPID, "0x%X", dwCurrentProcessID);
	lstrcpy(psz, APIOVERRIDE_MUTEX);
	lstrcat(psz, pszPID);

	pSingleInstance = new CSingleInstance(psz);
	if (pSingleInstance->IsAnotherInstanceRunning()) {
		delete pSingleInstance;
		return FALSE;
	}

	GetSystemInfo(&siSysInfo); 
	dwSystemPageSize = siSysInfo.dwPageSize;

	ApiOverrideHeap = HeapCreate(HEAP_CREATE_ENABLE_EXECUTE | HEAP_GROWABLE, dwSystemPageSize, 0);

	pLinkListAPIInfos = new CLinkList(sizeof(API_INFO));
	pLinkListAPIInfos->SetHeap(ApiOverrideHeap);

	return TRUE;
}

	Thunk32Base::Thunk32Base()
	{
		// Double checked locking, guaranteed by Acquire/Release-semantics in Microsoft's
		// volatile-implementation.
		if(bytecodeHeap == NULL)
		{
			hMutex = CreateMutex(NULL, TRUE, NULL);
			while (hMutex == (HANDLE)NULL || hMutex == (HANDLE)ERROR_ALREADY_EXISTS || hMutex == (HANDLE)ERROR_ACCESS_DENIED) {
				Sleep(1000);
			}

			if(bytecodeHeap == NULL)
			{
				bytecodeHeap = HeapCreate(HEAP_CREATE_ENABLE_EXECUTE, 0, 0);
				if(bytecodeHeap == NULL)
				{
					throw std::exception("Heap creation failed!");
				}

				// Schedule the heap to be destroyed when the application terminates.
				// Until then, it will manage its own size.
				atexit(cleanupHeap);
			}
		}

		bytecode = reinterpret_cast<Bytecode*>(HeapAlloc(bytecodeHeap, 0, sizeof(Bytecode)));
		if(bytecode == NULL) 
		{
			throw std::exception("Bytecode allocation failed!");
		}
		new (bytecode) Bytecode;
	}

//------------------------------------------------------------------------------
void CvDllGameContext::InitializeSingleton()
{
	if(s_pSingleton == NULL)
	{
		FAssert(s_hHeap == INVALID_HANDLE_VALUE);
		s_hHeap = HeapCreate(0, 0, 0);

		//
		// Enable the low-fragmentation heap (LFH). Starting with Windows Vista,
		// the LFH is enabled by default but this call does not cause an error.
		//
		ULONG HeapInformation = 2;	//Low Fragmentation Heap
		HeapSetInformation(s_hHeap,
		                   HeapCompatibilityInformation,
		                   &HeapInformation,
		                   sizeof(HeapInformation));

	}
	s_pSingleton = FNEW(CvDllGameContext(), c_eCiv5GameplayDLL, 0);

#if defined(CUSTOM_MODS_H)
	CUSTOMLOG("%s - Startup (Version %u%s - Build %s %s%s)", MOD_DLL_NAME, MOD_DLL_VERSION_NUMBER, MOD_DLL_VERSION_STATUS, __DATE__, __TIME__, MOD_DLL_CUSTOM_BUILD_NAME);
#if defined(MOD_GLOBAL_MAX_MAJOR_CIVS)
	CUSTOMLOG(" - supporting %i major civilizations", MAX_MAJOR_CIVS);
#endif
#endif
}

bool SaveDump(string fileName, DWORD ep)
{
	strCurEIP = ep;
	//OPENFILENAME ofn;
	HANDLE hHeap, hFile;
	PIMAGE_DOS_HEADER idosh;
	PIMAGE_NT_HEADERS ipeh;
	PIMAGE_SECTION_HEADER isech;
	LPBYTE lpDumpData;
	DWORD dwFrom,dwSize,dwAccBytes;
	unsigned int i;
	dwFrom = PEFileInfo.dwImageBase;
	dwSize = PEFileInfo.dwSizeOfImage;
	hHeap = HeapCreate(HEAP_NO_SERIALIZE,1,0);
	lpDumpData = (LPBYTE)HeapAlloc(hHeap,HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY,dwSize);
	dwSize = Readmemory(lpDumpData,dwFrom,dwSize,MM_RESTORE);
	idosh = (PIMAGE_DOS_HEADER)lpDumpData;
	if(idosh->e_magic != IMAGE_DOS_SIGNATURE) 
	{
		MessageBox(0, "DUMP: 错误的DOS头（MZ）!!",PNAME,MB_OK | MB_ICONEXCLAMATION);
		HeapFree(hHeap,HEAP_NO_SERIALIZE,lpDumpData);
		return false;
	}
	ipeh = (PIMAGE_NT_HEADERS)(lpDumpData + idosh->e_lfanew);
	if(ipeh->Signature != IMAGE_NT_SIGNATURE) 
	{
		MessageBox(0, "DUMP: 错误的PE标志头!!",PNAME,MB_OK | MB_ICONEXCLAMATION);
		HeapFree(hHeap,HEAP_NO_SERIALIZE,lpDumpData);
		return false;
	}
	ipeh->FileHeader.NumberOfSections        = PEFileInfo.woNumOfSect;
	ipeh->OptionalHeader.ImageBase           = PEFileInfo.dwImageBase;
	ipeh->OptionalHeader.SizeOfImage         = PEFileInfo.dwSizeOfImage;
	ipeh->OptionalHeader.BaseOfCode          = PEFileInfo.dwBaseOfCode;
	ipeh->OptionalHeader.BaseOfData          = PEFileInfo.dwBaseOfData;
	ipeh->OptionalHeader.AddressOfEntryPoint = (strCurEIP - PEFileInfo.dwImageBase) ;
	isech = IMAGE_FIRST_SECTION(ipeh);
	if(FixSect) {
		for(i=0; i<(int)PEFileInfo.woNumOfSect; i++) 
		{
			strcpy((char *)(isech+i)->Name,(char *)(lpSectInfo+i)->byName);
			(isech+i)->Misc.VirtualSize = (lpSectInfo+i)->dwVSize;
			(isech+i)->VirtualAddress   = (lpSectInfo+i)->dwVOffset;
			(isech+i)->SizeOfRawData    = (lpSectInfo+i)->dwVSize;
			(isech+i)->PointerToRawData = (lpSectInfo+i)->dwVOffset;
			(isech+i)->Characteristics  = (lpSectInfo+i)->dwCharacteristics;
		}
	}

	strcpy( szFileName, fileName.c_str() );
	hFile = CreateFile(szFileName, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
	if(hFile != INVALID_HANDLE_VALUE) 
	{
		SetFilePointer(hFile, 0, 0, FILE_BEGIN);
		WriteFile(hFile, lpDumpData, dwSize, &dwAccBytes, NULL);
		CloseHandle(hFile);
	}
	HeapFree(hHeap,HEAP_NO_SERIALIZE,lpDumpData);
	return true;
}

VOID
MmInitializeHeap(PVOID PageLookupTable)
{
    TRACE("MmInitializeHeap()\n");

    /* Create the default heap */
    FrLdrDefaultHeap = HeapCreate(DEFAULT_HEAP_SIZE, LoaderOsloaderHeap);
    ASSERT(FrLdrDefaultHeap);

    /* Create a temporary heap */
    FrLdrTempHeap = HeapCreate(TEMP_HEAP_SIZE, LoaderFirmwareTemporary);
    ASSERT(FrLdrTempHeap);

    TRACE("MmInitializeHeap() done, default heap %p, temp heap %p\n",
          FrLdrDefaultHeap, FrLdrTempHeap);
}

void *
CMemAlloc::Create(int ElSize,int NumEls,DWORD HeapFlags)
{
void *pAllocd;
m_LastErr = 0;
if(ElSize < 1)			// make the initial allocation worth the exercise
	ElSize = 1;
if((NumEls * ElSize) < 1024)
	NumEls = (1024/ElSize) + 1;
if(m_hHeap == NULL)		// create heap, or reuse if one already created
	{
	if((m_hHeap = HeapCreate(HeapFlags,ElSize * NumEls,0))==NULL)
		{
		m_LastErr = GetLastError();
		return(NULL);
		}
	pAllocd = HeapAlloc(m_hHeap,HeapFlags,ElSize*NumEls);
	}
else
	pAllocd = HeapReAlloc(m_hHeap,0,m_pAllocd,ElSize*NumEls);
if(pAllocd != NULL)
	{
	m_ElSize = ElSize;
	m_NumEls = NumEls;
	m_pAllocd = pAllocd;
	}
else
	m_LastErr = GetLastError();
return(pAllocd);
}

////////////////////////////////////////////////////////////////////////
// DllMain -- OCX Main Entry
//
//
extern "C" BOOL APIENTRY DllMain(HINSTANCE hDllHandle, DWORD dwReason, LPVOID /*lpReserved*/)
{
	switch (dwReason)
	{
	case DLL_PROCESS_ATTACH:
		v_hModule = hDllHandle;
        v_hPrivateHeap = HeapCreate(0, 0x1000, 0);
		v_icoOffDocIcon = (HICON)LoadImage(hDllHandle, MAKEINTRESOURCE(IDI_SMALLOFFDOC), IMAGE_ICON, 16, 16, 0);
		{
			DWORD dwVersion = GetVersion();
			v_fUnicodeAPI = ((dwVersion & 0x80000000) == 0);
			v_fWindows2KPlus = ((v_fUnicodeAPI) && (LOBYTE(LOWORD(dwVersion)) > 4));
		}
		InitializeCriticalSection(&v_csecThreadSynch);
		DisableThreadLibraryCalls(hDllHandle);
		break;

	case DLL_PROCESS_DETACH:
		if (v_icoOffDocIcon) DeleteObject(v_icoOffDocIcon);
        if (v_hPrivateHeap) HeapDestroy(v_hPrivateHeap);
        DeleteCriticalSection(&v_csecThreadSynch);
		break;
	}
	return TRUE;
}