KSG-Framework/main.h

#ifndef main_H
#define main_H

#ifdef _DEBUG
#include <iostream>
#include <sstream>
#include <vector>
#ifndef _LTMDB
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#define DEBUG_CLIENTBLOCK   new( _CLIENT_BLOCK, __FILE__, __LINE__)
#define new DEBUG_CLIENTBLOCK
#define _LTMDB
#endif
#endif
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#pragma warning( push )
#pragma warning( disable : 4091 )
#include <DbgHelp.h>
#pragma warning( pop )

#define KSGStart __stdcall
#include "Globals.h"

namespace Framework
{
	//! Speichert die dem Programm vom Betriebssystem beim Start übergebenen Parameter
	struct Startparam
	{
		HINSTANCE hinst, hpinst;
		LPSTR cmd;
		int show;
	};

	//! Überschreibe diese Funktion. Sie wird vom Framework automatisch beim Start des Programmes aufgerufen
	//! \param p Die Parameter, die dem Programm beim Start vom Betriebssystem übergeben wurden
	int KSGStart Start(Startparam p);
}

typedef BOOL(__stdcall* MINIDUMPWRITEDUMP)(HANDLE hProcess, DWORD dwPid, HANDLE hFile, MINIDUMP_TYPE DumpType, CONST PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam, CONST PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam, CONST PMINIDUMP_CALLBACK_INFORMATION CallbackParam);

void createMinidump(struct _EXCEPTION_POINTERS* apExceptionInfo)
{
	HMODULE mhLib = ::LoadLibrary("dbghelp.dll");
	MINIDUMPWRITEDUMP pDump = mhLib ? (MINIDUMPWRITEDUMP)::GetProcAddress(mhLib, "MiniDumpWriteDump") : 0;

	HANDLE  hFile = ::CreateFile("error_core_memory_dump.dmp", GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS,
		FILE_ATTRIBUTE_NORMAL, NULL);

	_MINIDUMP_EXCEPTION_INFORMATION ExInfo;
	ExInfo.ThreadId = ::GetCurrentThreadId();
	ExInfo.ExceptionPointers = apExceptionInfo;
	ExInfo.ClientPointers = FALSE;

	if (pDump)
		pDump(GetCurrentProcess(), GetCurrentProcessId(), hFile, MiniDumpNormal, &ExInfo, NULL, NULL);
	::CloseHandle(hFile);
}

LONG WINAPI unhandledHandler(struct _EXCEPTION_POINTERS* apExceptionInfo)
{
	createMinidump(apExceptionInfo);
	return EXCEPTION_CONTINUE_SEARCH;
}

#ifdef _DEBUG
template<typename TChar, typename TTraits>
class OutputDebugStringBuf : public std::basic_stringbuf<TChar, TTraits>
{
public:
	explicit OutputDebugStringBuf() : _buffer(1)
	{
		__super::setg(nullptr, nullptr, nullptr);
		__super::setp(_buffer.data(), _buffer.data(), _buffer.data() + _buffer.size());
	}

	~OutputDebugStringBuf()
	{}

	static_assert(std::is_same<TChar, char>::value || std::is_same<TChar, wchar_t>::value, "OutputDebugStringBuf only supports char and wchar_t types");

	int sync() try
	{
		MessageOutputer<TChar, TTraits>()(__super::pbase(), __super::pptr());
		__super::setp(_buffer.data(), _buffer.data(), _buffer.data() + _buffer.size());
		return 0;
	}
	catch (...)
	{
		return -1;
	}

	int overflow(int c = TTraits::eof())
	{
		auto syncRet = sync();
		if (c != TTraits::eof())
		{
			_buffer[0] = c;
			__super::setp(_buffer.data(), _buffer.data() + 1, _buffer.data() + _buffer.size());
		}
		return syncRet == -1 ? TTraits::eof() : 0;
	}


private:
	std::vector<TChar>		_buffer;

	template<typename TChar, typename TTraits>
	struct MessageOutputer;

	template<>
	struct MessageOutputer<char, std::char_traits<char>>
	{
		template<typename TIterator>
		void operator()(TIterator begin, TIterator end) const
		{
			std::string s(begin, end);
			OutputDebugStringA(s.c_str());
		}
	};

	template<>
	struct MessageOutputer<wchar_t, std::char_traits<wchar_t>>
	{
		template<typename TIterator>
		void operator()(TIterator begin, TIterator end) const
		{
			std::wstring s(begin, end);
			OutputDebugStringW(s.c_str());
		}
	};
};
#endif

#ifndef NO_MAIN
int WINAPI WinMain(_In_ HINSTANCE hinst, _In_opt_ HINSTANCE hpinst, _In_ LPSTR cmd, int _In_ show)
{
#ifdef _DEBUG
	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
	OutputDebugStringBuf<char, std::char_traits<char>> charDebugOutput;
	std::streambuf* buf = std::cout.rdbuf();
	std::cout.rdbuf(&charDebugOutput);
#endif
	SetUnhandledExceptionFilter(unhandledHandler);
	Framework::initFramework(hinst);
	Framework::Startparam stp;
	stp.hinst = hinst;
	stp.hpinst = hpinst;
	stp.cmd = cmd;
	stp.show = show;
	int ret = Framework::Start(stp);
	Framework::releaseFramework();
#ifdef _DEBUG
	std::cout.rdbuf(buf);
#endif
	return ret;
}
#endif

#endif