Include enum name in enum values, move AllocationRangeIterator implementations to cpp

slurmlord · slurmlord · commit bcb86fe8d8e2 · 2025-12-01T18:20:48.000+01:00
diff --git a/Core/GameEngine/Include/Common/GameMemory.h b/Core/GameEngine/Include/Common/GameMemory.h
@@ -509,57 +509,31 @@ class AllocationRangeIterator
 
 public:
 
+	AllocationRangeIterator();
 	AllocationRangeIterator(const MemoryPoolFactory* factory);
-	AllocationRangeIterator(MemoryPool& pool, MemoryPoolBlob& blob)
-	{
-		m_currentPool = &pool;
-		m_currentBlobInPool = &blob;
-		m_factory = NULL;
-		m_range = MemoryPoolAllocatedRange();
-	};
-
-	AllocationRangeIterator(MemoryPool* pool, MemoryPoolBlob* blob)
-	{
-		m_currentPool = pool;
-		m_currentBlobInPool = blob;
-		m_factory = NULL;
-		m_range = MemoryPoolAllocatedRange();
-	};
-
-	AllocationRangeIterator()
-	{
-		m_currentPool = NULL;
-		m_currentBlobInPool = NULL;
-		m_factory = NULL;
-		m_range = MemoryPoolAllocatedRange();
-	};
+	AllocationRangeIterator(MemoryPool& pool, MemoryPoolBlob& blob);
+	AllocationRangeIterator(MemoryPool* pool, MemoryPoolBlob* blob);
 
-	reference operator*() { UpdateRange(); return m_range; }
-	pointer operator->() { UpdateRange(); return &m_range; }
+	reference operator*() { return m_range; }
+	pointer operator->() { return &m_range; }
 
 	// Prefix increment
-	AllocationRangeIterator& operator++() { MoveToNextBlob(); return *this; }
+	AllocationRangeIterator& operator++();
 
 	// Postfix increment
-	AllocationRangeIterator operator++(int) { AllocationRangeIterator tmp = *this; ++(*this); return tmp; }
+	AllocationRangeIterator operator++(int);
 
-	friend const bool operator== (const AllocationRangeIterator& a, const AllocationRangeIterator& b)
-	{
-		return a.m_currentBlobInPool == b.m_currentBlobInPool;
-	};
-
-	friend const bool operator!= (const AllocationRangeIterator& a, const AllocationRangeIterator& b)
-	{
-		return a.m_currentBlobInPool != b.m_currentBlobInPool;
-	};
+	friend const bool operator== (const AllocationRangeIterator& a, const AllocationRangeIterator& b);
+	friend const bool operator!= (const AllocationRangeIterator& a, const AllocationRangeIterator& b);
 
 private:
+
+	void updateRange();
+	void moveToNextBlob();
 	const MemoryPoolFactory* m_factory;
 	MemoryPool* m_currentPool;
 	MemoryPoolBlob* m_currentBlobInPool;
 	MemoryPoolAllocatedRange m_range;
-	void UpdateRange();
-	void MoveToNextBlob();
 };
 #endif
 
diff --git a/Core/GameEngine/Include/Common/MiniDumper.h b/Core/GameEngine/Include/Common/MiniDumper.h
@@ -24,29 +24,29 @@
 enum DumpType CPP_11(: Char)
 {
 	// Smallest dump type with call stacks and some supporting variables
-	DUMP_TYPE_MINIMAL = 'M',
-	// Large dump including all memory regions allocated by the GameMemory implementaion
-	DUMP_TYPE_GAMEMEMORY = 'X',
+	DumpType_Minimal = 'M',
+	// Large dump including all memory regions allocated by the GameMemory implementation
+	DumpType_Gamememory = 'X',
 	// Largest dump size including complete memory contents of the process
-	DUMP_TYPE_FULL = 'F',
+	DumpType_Full = 'F',
 };
 
 class MiniDumper
 {
 	enum MiniDumperExitCode CPP_11(: Int)
 	{
-		DUMPER_EXIT_SUCCESS = 0x0,
-		DUMPER_EXIT_FAILURE_WAIT = 0x37DA1040,
-		DUMPER_EXIT_FAILURE_PARAM = 0x4EA527BB,
-		DUMPER_EXIT_FORCED_TERMINATE = 0x158B1154,
+		MiniDumperExitCode_Success = 0x0,
+		MiniDumperExitCode_FailureWait = 0x37DA1040,
+		MiniDumperExitCode_FailureParam = 0x4EA527BB,
+		MiniDumperExitCode_ForcedTerminate = 0x158B1154,
 	};
 
 	enum DumpObjectsState CPP_11(: Int)
 	{
 		DumpObjectsState_Begin,
-		DumpObjectsState_Memory_Pools,
-		DumpObjectsState_Memory_Pool_Allocations,
-		DumpObjectsState_DMA_Allocations,
+		DumpObjectsState_MemoryPools,
+		DumpObjectsState_MemoryPoolAllocations,
+		DumpObjectsState_DMAAllocations,
 		DumpObjectsState_Completed
 	};
 
diff --git a/Core/GameEngine/Source/Common/System/Debug.cpp b/Core/GameEngine/Source/Common/System/Debug.cpp
@@ -737,8 +737,8 @@ static void TriggerMiniDump()
 	if (TheMiniDumper && TheMiniDumper->IsInitialized())
 	{
 		// Do dumps both with and without extended info
-		TheMiniDumper->TriggerMiniDump(DUMP_TYPE_MINIMAL);
-		TheMiniDumper->TriggerMiniDump(DUMP_TYPE_GAMEMEMORY);
+		TheMiniDumper->TriggerMiniDump(DumpType_Minimal);
+		TheMiniDumper->TriggerMiniDump(DumpType_Gamememory);
 	}
 
 	MiniDumper::shutdownMiniDumper();
diff --git a/Core/GameEngine/Source/Common/System/GameMemory.cpp b/Core/GameEngine/Source/Common/System/GameMemory.cpp
@@ -2606,6 +2606,7 @@ void DynamicMemoryAllocator::fillAllocationRangeForRawBlock(const MemoryPoolSing
 	allocationRange.allocationAddr = reinterpret_cast<const char*>(block);
 	allocationRange.allocationSize = block->calcRawBlockSize(block->debugGetLogicalSize());
 }
+
 #endif
 
 //-----------------------------------------------------------------------------
@@ -3273,21 +3274,70 @@ MemoryPool* MemoryPoolFactory::getFirstMemoryPool() const
 	return m_firstPoolInFactory;
 }
 
+//-----------------------------------------------------------------------------
+// METHODS for AllocationRangeIterator
+//-----------------------------------------------------------------------------
+
+AllocationRangeIterator::AllocationRangeIterator()
+{
+	m_currentPool = NULL;
+	m_currentBlobInPool = NULL;
+	m_factory = NULL;
+	m_range = MemoryPoolAllocatedRange();
+}
+
 AllocationRangeIterator::AllocationRangeIterator(const MemoryPoolFactory* factory)
 {
 	m_factory = factory;
-	m_currentPool = factory->m_firstPoolInFactory;
-	m_currentBlobInPool = m_currentPool->m_firstBlob;
+	if (factory)
+	{
+		m_currentPool = factory->m_firstPoolInFactory;
+		m_currentBlobInPool = m_currentPool ? m_currentPool->m_firstBlob : NULL;
+	}
+	else
+	{
+		m_currentPool = NULL;
+		m_currentBlobInPool = NULL;
+	}
+
 	m_range = MemoryPoolAllocatedRange();
 }
 
-void AllocationRangeIterator::UpdateRange()
+AllocationRangeIterator::AllocationRangeIterator(MemoryPool& pool, MemoryPoolBlob& blob)
 {
+	m_currentPool = &pool;
+	m_currentBlobInPool = &blob;
+	m_factory = NULL;
+	m_range = MemoryPoolAllocatedRange();
+}
+
+AllocationRangeIterator::AllocationRangeIterator(MemoryPool* pool, MemoryPoolBlob* blob)
+{
+	m_currentPool = pool;
+	m_currentBlobInPool = blob;
+	m_factory = NULL;
+	m_range = MemoryPoolAllocatedRange();
+}
+
+void AllocationRangeIterator::updateRange()
+{
+	if (m_currentBlobInPool == NULL)
+	{
+		m_range.allocationAddr = nullptr;
+		m_range.allocationSize = 0;
+		return;
+	}
+
 	m_currentBlobInPool->fillAllocatedRange(m_range);
 }
 
-void AllocationRangeIterator::MoveToNextBlob()
+void AllocationRangeIterator::moveToNextBlob()
 {
+	if (m_currentBlobInPool == NULL)
+	{
+		return;
+	}
+
 	// Advances to the next blob, advancing to the next MemoryPool if needed.
 	m_currentBlobInPool = m_currentBlobInPool->getNextInList();
 	if (m_currentBlobInPool != NULL)
@@ -3308,6 +3358,22 @@ void AllocationRangeIterator::MoveToNextBlob()
 		m_currentBlobInPool = NULL;
 	}
 }
+
+// Prefix increment
+AllocationRangeIterator& AllocationRangeIterator::operator++() { moveToNextBlob(); updateRange(); return *this; }
+
+// Postfix increment
+AllocationRangeIterator AllocationRangeIterator::operator++(int) { AllocationRangeIterator tmp = *this; ++(*this); return tmp; }
+
+const bool operator== (const AllocationRangeIterator& a, const AllocationRangeIterator& b)
+{
+	return a.m_currentBlobInPool == b.m_currentBlobInPool;
+}
+
+const bool operator!= (const AllocationRangeIterator& a, const AllocationRangeIterator& b)
+{
+	return a.m_currentBlobInPool != b.m_currentBlobInPool;
+}
 #endif
 
 //-----------------------------------------------------------------------------
diff --git a/Core/GameEngine/Source/Common/System/MiniDumper.cpp b/Core/GameEngine/Source/Common/System/MiniDumper.cpp
@@ -63,7 +63,7 @@ MiniDumper::MiniDumper()
 {
 	m_miniDumpInitialized = false;
 	m_loadedDbgHelp = false;
-	m_requestedDumpType = DUMP_TYPE_MINIMAL;
+	m_requestedDumpType = DumpType_Minimal;
 	m_dumpRequested = NULL;
 	m_dumpComplete = NULL;
 	m_quitting = NULL;
@@ -234,9 +234,9 @@ Bool MiniDumper::InitializeDumpDirectory(const AsciiString& userDirPath)
 	}
 
 	// Clean up old files (we keep a maximum of 10 small, 2 extended and 2 full)
-	KeepNewestFiles(m_dumpDir, DUMP_TYPE_GAMEMEMORY, MaxExtendedFileCount);
-	KeepNewestFiles(m_dumpDir, DUMP_TYPE_FULL, MaxFullFileCount);
-	KeepNewestFiles(m_dumpDir, DUMP_TYPE_MINIMAL, MaxMiniFileCount);
+	KeepNewestFiles(m_dumpDir, DumpType_Gamememory, MaxExtendedFileCount);
+	KeepNewestFiles(m_dumpDir, DumpType_Full, MaxFullFileCount);
+	KeepNewestFiles(m_dumpDir, DumpType_Minimal, MaxMiniFileCount);
 
 	return true;
 }
@@ -256,7 +256,7 @@ void MiniDumper::ShutdownDumpThread()
 			break;
 		case WAIT_TIMEOUT:
 			DEBUG_LOG(("MiniDumper::ShutdownDumpThread: Waiting for dumping thread to exit timed out, killing thread", waitRet));
-			::TerminateThread(m_dumpThread, DUMPER_EXIT_FORCED_TERMINATE);
+			::TerminateThread(m_dumpThread, MiniDumperExitCode_ForcedTerminate);
 			break;
 		case WAIT_FAILED:
 			DEBUG_LOG(("MiniDumper::ShutdownDumpThread: Waiting for minidump triggering failed: status=%u, error=%u", waitRet, ::GetLastError()));
@@ -323,13 +323,13 @@ DWORD MiniDumper::ThreadProcInternal()
 			break;
 		case WAIT_OBJECT_0 + 1:
 			// Quit (m_quitting)
-			return DUMPER_EXIT_SUCCESS;
+			return MiniDumperExitCode_Success;
 		case WAIT_FAILED:
 			DEBUG_LOG(("MiniDumper::ThreadProcInternal: Waiting for events failed: status=%u, error=%u", event, ::GetLastError()));
-			return DUMPER_EXIT_FAILURE_WAIT;
+			return MiniDumperExitCode_FailureWait;
 		default:
 			DEBUG_LOG(("MiniDumper::ThreadProcInternal: Waiting for events failed: status=%u", event));
-			return DUMPER_EXIT_FAILURE_WAIT;
+			return MiniDumperExitCode_FailureWait;
 		}
 	}
 }
@@ -339,7 +339,7 @@ DWORD WINAPI MiniDumper::MiniDumpThreadProc(LPVOID lpParam)
 	if (lpParam == NULL)
 	{
 		DEBUG_LOG(("MiniDumper::MiniDumpThreadProc: The provided parameter was NULL, exiting thread."));
-		return DUMPER_EXIT_FAILURE_PARAM;
+		return MiniDumperExitCode_FailureParam;
 	}
 
 	MiniDumper* dumper = static_cast<MiniDumper *>(lpParam);
@@ -387,7 +387,7 @@ void MiniDumper::CreateMiniDump(DumpType dumpType)
 
 	PMINIDUMP_CALLBACK_INFORMATION callbackInfoPtr = NULL;
 	MINIDUMP_CALLBACK_INFORMATION callBackInfo = { 0 };
-	if (dumpType == DUMP_TYPE_GAMEMEMORY)
+	if (dumpType == DumpType_Gamememory)
 	{
 		callBackInfo.CallbackRoutine = MiniDumpCallback;
 		callBackInfo.CallbackParam = this;
@@ -397,13 +397,13 @@ void MiniDumper::CreateMiniDump(DumpType dumpType)
 	int dumpTypeFlags = MiniDumpNormal;
 	switch (dumpType)
 	{
-	case DUMP_TYPE_FULL:
+	case DumpType_Full:
 		dumpTypeFlags |= MiniDumpWithFullMemory;
 		FALLTHROUGH;
-	case DUMP_TYPE_GAMEMEMORY:
+	case DumpType_Gamememory:
 		dumpTypeFlags |= MiniDumpWithDataSegs | MiniDumpWithHandleData | MiniDumpWithThreadInfo | MiniDumpWithFullMemoryInfo | MiniDumpWithPrivateReadWriteMemory;
 		FALLTHROUGH;
-	case DUMP_TYPE_MINIMAL:
+	case DumpType_Minimal:
 		dumpTypeFlags |= MiniDumpWithIndirectlyReferencedMemory | MiniDumpScanMemory;
 		break;
 	}
@@ -525,7 +525,7 @@ void MiniDumper::DumpMemoryObjects(ULONG64& memoryBase, ULONG& memorySize)
 		switch (m_dumpObjectsState)
 		{
 		case DumpObjectsState_Begin:
-			m_dumpObjectsState = DumpObjectsState_Memory_Pools;
+			m_dumpObjectsState = DumpObjectsState_MemoryPools;
 			if (TheMemoryPoolFactory)
 			{
 				m_currentPool = TheMemoryPoolFactory->getFirstMemoryPool();
@@ -535,13 +535,13 @@ void MiniDumper::DumpMemoryObjects(ULONG64& memoryBase, ULONG& memorySize)
 					m_currentSingleBlock = m_currentAllocator->getFirstRawBlock();
 			}
 			break;
-		case DumpObjectsState_Memory_Pools:
+		case DumpObjectsState_MemoryPools:
 		{
 			// Dump all the MemoryPool instances in TheMemoryPoolFactory
 			// This only dumps the metadata, not the actual MemoryPool contents (done in the next phase).
 			if (m_currentPool == NULL)
 			{
-				m_dumpObjectsState = DumpObjectsState_Memory_Pool_Allocations;
+				m_dumpObjectsState = DumpObjectsState_MemoryPoolAllocations;
 				break;
 			}
 
@@ -550,13 +550,13 @@ void MiniDumper::DumpMemoryObjects(ULONG64& memoryBase, ULONG& memorySize)
 			m_currentPool = m_currentPool->getNextPoolInList();
 			break;
 		}
-		case DumpObjectsState_Memory_Pool_Allocations:
+		case DumpObjectsState_MemoryPoolAllocations:
 		{
 			// Iterate through all the allocations of memory pools and containing blobs that has been done via the memory pool factory
 			// and include all of the storage space allocated for objects
 			if (!TheMemoryPoolFactory || m_rangeIter == TheMemoryPoolFactory->cend())
 			{
-				m_dumpObjectsState = DumpObjectsState_DMA_Allocations;
+				m_dumpObjectsState = DumpObjectsState_DMAAllocations;
 				break;
 			}
 
@@ -565,7 +565,7 @@ void MiniDumper::DumpMemoryObjects(ULONG64& memoryBase, ULONG& memorySize)
 			++m_rangeIter;
 			break;
 		}
-		case DumpObjectsState_DMA_Allocations:
+		case DumpObjectsState_DMAAllocations:
 		{
 			// Iterate through all the direct allocations ("raw blocks") done by DMAs, as these are done outside of the
 			// memory pool factory allocations dumped in the previous phase.
@@ -575,7 +575,7 @@ void MiniDumper::DumpMemoryObjects(ULONG64& memoryBase, ULONG& memorySize)
 				break;
 			}
 
-			MemoryPoolAllocatedRange rawBlockRange = { 0 };
+			MemoryPoolAllocatedRange rawBlockRange;
 			m_currentAllocator->fillAllocationRangeForRawBlock(m_currentSingleBlock, rawBlockRange);
 			memoryBase = reinterpret_cast<ULONG64>(rawBlockRange.allocationAddr);
 			memorySize = rawBlockRange.allocationSize;
diff --git a/Core/Libraries/Source/WWVegas/WWLib/DbgHelpLoader.h b/Core/Libraries/Source/WWVegas/WWLib/DbgHelpLoader.h
@@ -126,16 +126,6 @@ class DbgHelpLoader
 private:
 
 	static void freeResources();
-#ifdef RTS_ENABLE_CRASHDUMP
-	typedef BOOL(WINAPI* MiniDumpWriteDump_t)(
-		HANDLE hProcess,
-		DWORD ProcessId,
-		HANDLE hFile,
-		MINIDUMP_TYPE DumpType,
-		PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
-		PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
-		PMINIDUMP_CALLBACK_INFORMATION CallbackParam);
-#endif
 
 	typedef BOOL (WINAPI *SymInitialize_t) (
 		HANDLE hProcess,
diff --git a/Generals/Code/Main/WinMain.cpp b/Generals/Code/Main/WinMain.cpp
@@ -748,8 +748,8 @@ static LONG WINAPI UnHandledExceptionFilter( struct _EXCEPTION_POINTERS* e_info
 	if (TheMiniDumper && TheMiniDumper->IsInitialized())
 	{
 		// Do dumps both with and without extended info
-		TheMiniDumper->TriggerMiniDumpForException(e_info, DUMP_TYPE_MINIMAL);
-		TheMiniDumper->TriggerMiniDumpForException(e_info, DUMP_TYPE_GAMEMEMORY);
+		TheMiniDumper->TriggerMiniDumpForException(e_info, DumpType_Minimal);
+		TheMiniDumper->TriggerMiniDumpForException(e_info, DumpType_Gamememory);
 	}
 
 	MiniDumper::shutdownMiniDumper();
diff --git a/GeneralsMD/Code/Main/WinMain.cpp b/GeneralsMD/Code/Main/WinMain.cpp
diff --git a/cmake/config-memory.cmake b/cmake/config-memory.cmake

Original file line number	Diff line number	Diff line change
`@@ -737,8 +737,8 @@ static void TriggerMiniDump()`
`737`	`737`	`if (TheMiniDumper && TheMiniDumper->IsInitialized())`
`738`	`738`	`{`
`739`	`739`	`// Do dumps both with and without extended info`
`740`		`- TheMiniDumper->TriggerMiniDump(DUMP_TYPE_MINIMAL);`
`741`		`- TheMiniDumper->TriggerMiniDump(DUMP_TYPE_GAMEMEMORY);`
	`740`	`+ TheMiniDumper->TriggerMiniDump(DumpType_Minimal);`
	`741`	`+ TheMiniDumper->TriggerMiniDump(DumpType_Gamememory);`
`742`	`742`	`}`
`743`	`743`
`744`	`744`	`MiniDumper::shutdownMiniDumper();`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ MiniDumper::MiniDumper()`
`63`	`63`	`{`
`64`	`64`	`m_miniDumpInitialized = false;`
`65`	`65`	`m_loadedDbgHelp = false;`
`66`		`- m_requestedDumpType = DUMP_TYPE_MINIMAL;`
	`66`	`+ m_requestedDumpType = DumpType_Minimal;`
`67`	`67`	`m_dumpRequested = NULL;`
`68`	`68`	`m_dumpComplete = NULL;`
`69`	`69`	`m_quitting = NULL;`
`@@ -234,9 +234,9 @@ Bool MiniDumper::InitializeDumpDirectory(const AsciiString& userDirPath)`
`234`	`234`	`}`
`235`	`235`
`236`	`236`	`// Clean up old files (we keep a maximum of 10 small, 2 extended and 2 full)`
`237`		`- KeepNewestFiles(m_dumpDir, DUMP_TYPE_GAMEMEMORY, MaxExtendedFileCount);`
`238`		`- KeepNewestFiles(m_dumpDir, DUMP_TYPE_FULL, MaxFullFileCount);`
`239`		`- KeepNewestFiles(m_dumpDir, DUMP_TYPE_MINIMAL, MaxMiniFileCount);`
	`237`	`+ KeepNewestFiles(m_dumpDir, DumpType_Gamememory, MaxExtendedFileCount);`
	`238`	`+ KeepNewestFiles(m_dumpDir, DumpType_Full, MaxFullFileCount);`
	`239`	`+ KeepNewestFiles(m_dumpDir, DumpType_Minimal, MaxMiniFileCount);`
`240`	`240`
`241`	`241`	`return true;`
`242`	`242`	`}`
`@@ -256,7 +256,7 @@ void MiniDumper::ShutdownDumpThread()`
`256`	`256`	`break;`
`257`	`257`	`case WAIT_TIMEOUT:`
`258`	`258`	`DEBUG_LOG(("MiniDumper::ShutdownDumpThread: Waiting for dumping thread to exit timed out, killing thread", waitRet));`
`259`		`- ::TerminateThread(m_dumpThread, DUMPER_EXIT_FORCED_TERMINATE);`
	`259`	`+ ::TerminateThread(m_dumpThread, MiniDumperExitCode_ForcedTerminate);`
`260`	`260`	`break;`
`261`	`261`	`case WAIT_FAILED:`
`262`	`262`	`DEBUG_LOG(("MiniDumper::ShutdownDumpThread: Waiting for minidump triggering failed: status=%u, error=%u", waitRet, ::GetLastError()));`
`@@ -323,13 +323,13 @@ DWORD MiniDumper::ThreadProcInternal()`
`323`	`323`	`break;`
`324`	`324`	`case WAIT_OBJECT_0 + 1:`
`325`	`325`	`// Quit (m_quitting)`
`326`		`- return DUMPER_EXIT_SUCCESS;`
	`326`	`+ return MiniDumperExitCode_Success;`
`327`	`327`	`case WAIT_FAILED:`
`328`	`328`	`DEBUG_LOG(("MiniDumper::ThreadProcInternal: Waiting for events failed: status=%u, error=%u", event, ::GetLastError()));`
`329`		`- return DUMPER_EXIT_FAILURE_WAIT;`
	`329`	`+ return MiniDumperExitCode_FailureWait;`
`330`	`330`	`default:`
`331`	`331`	`DEBUG_LOG(("MiniDumper::ThreadProcInternal: Waiting for events failed: status=%u", event));`
`332`		`- return DUMPER_EXIT_FAILURE_WAIT;`
	`332`	`+ return MiniDumperExitCode_FailureWait;`
`333`	`333`	`}`
`334`	`334`	`}`
`335`	`335`	`}`
`@@ -339,7 +339,7 @@ DWORD WINAPI MiniDumper::MiniDumpThreadProc(LPVOID lpParam)`
`339`	`339`	`if (lpParam == NULL)`
`340`	`340`	`{`
`341`	`341`	`DEBUG_LOG(("MiniDumper::MiniDumpThreadProc: The provided parameter was NULL, exiting thread."));`
`342`		`- return DUMPER_EXIT_FAILURE_PARAM;`
	`342`	`+ return MiniDumperExitCode_FailureParam;`
`343`	`343`	`}`
`344`	`344`
`345`	`345`	`MiniDumper* dumper = static_cast<MiniDumper *>(lpParam);`
`@@ -387,7 +387,7 @@ void MiniDumper::CreateMiniDump(DumpType dumpType)`
`387`	`387`
`388`	`388`	`PMINIDUMP_CALLBACK_INFORMATION callbackInfoPtr = NULL;`
`389`	`389`	`MINIDUMP_CALLBACK_INFORMATION callBackInfo = { 0 };`
`390`		`- if (dumpType == DUMP_TYPE_GAMEMEMORY)`
	`390`	`+ if (dumpType == DumpType_Gamememory)`
`391`	`391`	`{`
`392`	`392`	`callBackInfo.CallbackRoutine = MiniDumpCallback;`
`393`	`393`	`callBackInfo.CallbackParam = this;`
`@@ -397,13 +397,13 @@ void MiniDumper::CreateMiniDump(DumpType dumpType)`
`397`	`397`	`int dumpTypeFlags = MiniDumpNormal;`
`398`	`398`	`switch (dumpType)`
`399`	`399`	`{`
`400`		`- case DUMP_TYPE_FULL:`
	`400`	`+ case DumpType_Full:`
`401`	`401`	`dumpTypeFlags \|= MiniDumpWithFullMemory;`
`402`	`402`	`FALLTHROUGH;`
`403`		`- case DUMP_TYPE_GAMEMEMORY:`
	`403`	`+ case DumpType_Gamememory:`
`404`	`404`	`dumpTypeFlags \|= MiniDumpWithDataSegs \| MiniDumpWithHandleData \| MiniDumpWithThreadInfo \| MiniDumpWithFullMemoryInfo \| MiniDumpWithPrivateReadWriteMemory;`
`405`	`405`	`FALLTHROUGH;`
`406`		`- case DUMP_TYPE_MINIMAL:`
	`406`	`+ case DumpType_Minimal:`
`407`	`407`	`dumpTypeFlags \|= MiniDumpWithIndirectlyReferencedMemory \| MiniDumpScanMemory;`
`408`	`408`	`break;`
`409`	`409`	`}`
`@@ -525,7 +525,7 @@ void MiniDumper::DumpMemoryObjects(ULONG64& memoryBase, ULONG& memorySize)`
`525`	`525`	`switch (m_dumpObjectsState)`
`526`	`526`	`{`
`527`	`527`	`case DumpObjectsState_Begin:`
`528`		`- m_dumpObjectsState = DumpObjectsState_Memory_Pools;`
	`528`	`+ m_dumpObjectsState = DumpObjectsState_MemoryPools;`
`529`	`529`	`if (TheMemoryPoolFactory)`
`530`	`530`	`{`
`531`	`531`	`m_currentPool = TheMemoryPoolFactory->getFirstMemoryPool();`
`@@ -535,13 +535,13 @@ void MiniDumper::DumpMemoryObjects(ULONG64& memoryBase, ULONG& memorySize)`
`535`	`535`	`m_currentSingleBlock = m_currentAllocator->getFirstRawBlock();`
`536`	`536`	`}`
`537`	`537`	`break;`
`538`		`- case DumpObjectsState_Memory_Pools:`
	`538`	`+ case DumpObjectsState_MemoryPools:`
`539`	`539`	`{`
`540`	`540`	`// Dump all the MemoryPool instances in TheMemoryPoolFactory`
`541`	`541`	`// This only dumps the metadata, not the actual MemoryPool contents (done in the next phase).`
`542`	`542`	`if (m_currentPool == NULL)`
`543`	`543`	`{`
`544`		`- m_dumpObjectsState = DumpObjectsState_Memory_Pool_Allocations;`
	`544`	`+ m_dumpObjectsState = DumpObjectsState_MemoryPoolAllocations;`
`545`	`545`	`break;`
`546`	`546`	`}`
`547`	`547`
`@@ -550,13 +550,13 @@ void MiniDumper::DumpMemoryObjects(ULONG64& memoryBase, ULONG& memorySize)`
`550`	`550`	`m_currentPool = m_currentPool->getNextPoolInList();`
`551`	`551`	`break;`
`552`	`552`	`}`
`553`		`- case DumpObjectsState_Memory_Pool_Allocations:`
	`553`	`+ case DumpObjectsState_MemoryPoolAllocations:`
`554`	`554`	`{`
`555`	`555`	`// Iterate through all the allocations of memory pools and containing blobs that has been done via the memory pool factory`
`556`	`556`	`// and include all of the storage space allocated for objects`
`557`	`557`	`if (!TheMemoryPoolFactory \|\| m_rangeIter == TheMemoryPoolFactory->cend())`
`558`	`558`	`{`
`559`		`- m_dumpObjectsState = DumpObjectsState_DMA_Allocations;`
	`559`	`+ m_dumpObjectsState = DumpObjectsState_DMAAllocations;`
`560`	`560`	`break;`
`561`	`561`	`}`
`562`	`562`
`@@ -565,7 +565,7 @@ void MiniDumper::DumpMemoryObjects(ULONG64& memoryBase, ULONG& memorySize)`
`565`	`565`	`++m_rangeIter;`
`566`	`566`	`break;`
`567`	`567`	`}`
`568`		`- case DumpObjectsState_DMA_Allocations:`
	`568`	`+ case DumpObjectsState_DMAAllocations:`
`569`	`569`	`{`
`570`	`570`	`// Iterate through all the direct allocations ("raw blocks") done by DMAs, as these are done outside of the`
`571`	`571`	`// memory pool factory allocations dumped in the previous phase.`
`@@ -575,7 +575,7 @@ void MiniDumper::DumpMemoryObjects(ULONG64& memoryBase, ULONG& memorySize)`
`575`	`575`	`break;`
`576`	`576`	`}`
`577`	`577`
`578`		`- MemoryPoolAllocatedRange rawBlockRange = { 0 };`
	`578`	`+ MemoryPoolAllocatedRange rawBlockRange;`
`579`	`579`	`m_currentAllocator->fillAllocationRangeForRawBlock(m_currentSingleBlock, rawBlockRange);`
`580`	`580`	`memoryBase = reinterpret_cast<ULONG64>(rawBlockRange.allocationAddr);`
`581`	`581`	`memorySize = rawBlockRange.allocationSize;`
Original file line number	Diff line number	Diff line change
`@@ -748,8 +748,8 @@ static LONG WINAPI UnHandledExceptionFilter( struct _EXCEPTION_POINTERS* e_info`
`748`	`748`	`if (TheMiniDumper && TheMiniDumper->IsInitialized())`
`749`	`749`	`{`
`750`	`750`	`// Do dumps both with and without extended info`
`751`		`- TheMiniDumper->TriggerMiniDumpForException(e_info, DUMP_TYPE_MINIMAL);`
`752`		`- TheMiniDumper->TriggerMiniDumpForException(e_info, DUMP_TYPE_GAMEMEMORY);`
	`751`	`+ TheMiniDumper->TriggerMiniDumpForException(e_info, DumpType_Minimal);`
	`752`	`+ TheMiniDumper->TriggerMiniDumpForException(e_info, DumpType_Gamememory);`
`753`	`753`	`}`
`754`	`754`
`755`	`755`	`MiniDumper::shutdownMiniDumper();`