- Updated dbghelp.dll

- Added dbghelpplug.c souce code made HPM compatible.

Signed-off-by: Xgear <matiassw@gmail.com>

2 files changed, 1816 insertions, 0 deletions

diff --git a/dbghelp.dll b/dbghelp.dll
index 660d9207d..9f52a5d41 100644
--- a/dbghelp.dll
+++ b/dbghelp.dll
diff --git a/src/plugins/dbghelpplug.c b/src/plugins/dbghelpplug.c
new file mode 100644
index 000000000..32b30d69a
--- /dev/null
+++ b/src/plugins/dbghelpplug.c
@@ -0,0 +1,1816 @@
+// Copyright (c) Hercules Dev Team, licensed under GNU GPL.
+// Ported from eAthena Dev Team's version @ http://eathena-project.googlecode.com/svn/trunk/src/plugins/dbghelpplug.c
+// See the LICENSE file
+// dbghelpplug.dll Hercules Plugin
+
+#include <stdio.h>
+#include <string.h>
+#include "../common/HPMi.h"
+
+HPExport struct hplugin_info pinfo = {
+	"DBGHelpPlug",		// Plugin name
+	SERVER_TYPE_MAP,// Which server types this plugin works with?
+	"0.3",			// Plugin version
+	HPM_VERSION,	// HPM Version (don't change, macro is automatically updated)
+};
+
+#ifdef _WIN32
+
+/////////////////////////////////////////////////////////////////////
+// Include files 
+//
+#include <assert.h>
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+#define _NO_CVCONST_H
+#include <dbghelp.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+/////////////////////////////////////////////////////////////////////
+// Types from Cvconst.h (DIA SDK) 
+//
+
+#ifdef _NO_CVCONST_H
+
+typedef enum _BasicType
+{ 
+   btNoType   = 0,
+   btVoid     = 1,
+   btChar     = 2,
+   btWChar    = 3,
+   btInt      = 6,
+   btUInt     = 7,
+   btFloat    = 8,
+   btBCD      = 9,
+   btBool     = 10,
+   btLong     = 13,
+   btULong    = 14,
+   btCurrency = 25,
+   btDate     = 26,
+   btVariant  = 27,
+   btComplex  = 28,
+   btBit      = 29,
+   btBSTR     = 30,
+   btHresult  = 31
+} BasicType;
+
+typedef enum _UdtKind
+{
+    UdtStruct,
+    UdtClass,
+    UdtUnion
+} UdtKind;
+/*
+typedef enum _SymTag { 
+   SymTagNull             = 0,
+   SymTagExe              = 1,
+   SymTagCompiland        = 2,
+   SymTagCompilandDetails = 3,
+   SymTagCompilandEnv     = 4,
+   SymTagFunction         = 5,
+   SymTagBlock            = 6,
+   SymTagData             = 7,
+   SymTagAnnotation       = 8,
+   SymTagLabel            = 9,
+   SymTagPublicSymbol     = 10,
+   SymTagUDT              = 11,
+   SymTagEnum             = 12,
+   SymTagFunctionType     = 13,
+   SymTagPointerType      = 14,
+   SymTagArrayType        = 15,
+   SymTagBaseType         = 16,
+   SymTagTypedef          = 17,
+   SymTagBaseClass        = 18,
+   SymTagFriend           = 19,
+   SymTagFunctionArgType  = 20,
+   SymTagFuncDebugStart   = 21,
+   SymTagFuncDebugEnd     = 22,
+   SymTagUsingNamespace   = 23,
+   SymTagVTableShape      = 24,
+   SymTagVTable           = 25,
+   SymTagCustom           = 26,
+   SymTagThunk            = 27,
+   SymTagCustomType       = 28,
+   SymTagManagedType      = 29,
+   SymTagDimension        = 30
+} SymTag;
+*/
+#endif /* _NO_CVCONST_H */
+
+
+/////////////////////////////////////////////////////////////////////
+// dbghelp function prototypes
+//
+
+typedef BOOL (WINAPI *MINIDUMPWRITEDUMP)(
+	HANDLE hProcess,
+	DWORD ProcessId,
+	HANDLE hFile,
+	MINIDUMP_TYPE DumpType,
+	CONST PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
+	CONST PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
+	CONST PMINIDUMP_CALLBACK_INFORMATION CallbackParam
+);
+typedef BOOL (WINAPI *SYMINITIALIZE)(
+	HANDLE  hProcess,
+	PSTR    UserSearchPath,
+	BOOL    fInvadeProcess
+);
+typedef DWORD (WINAPI *SYMSETOPTIONS)(
+	DWORD   SymOptions
+);
+typedef DWORD (WINAPI *SYMGETOPTIONS)(
+	VOID
+);
+typedef BOOL (WINAPI *SYMCLEANUP)(
+	HANDLE  hProcess
+);
+typedef BOOL (WINAPI *SYMGETTYPEINFO)(
+	HANDLE                      hProcess,
+	DWORD64                     ModBase,
+	ULONG                       TypeId,
+	IMAGEHLP_SYMBOL_TYPE_INFO   GetType,
+	PVOID                       pInfo
+);
+typedef BOOL (WINAPI *SYMGETLINEFROMADDR)(
+	HANDLE          hProcess,
+	DWORD           dwAddr,
+	PDWORD          pdwDisplacement,
+	PIMAGEHLP_LINE  Line
+);
+typedef BOOL (WINAPI *SYMENUMSYMBOLS)(
+	HANDLE                          hProcess,
+	ULONG64                         BaseOfDll,
+	PCSTR                           Mask,
+	PSYM_ENUMERATESYMBOLS_CALLBACK  EnumSymbolsCallback,
+	PVOID                           UserContext
+);
+typedef BOOL (WINAPI *SYMSETCONTEXT)(
+	HANDLE                  hProcess,
+	PIMAGEHLP_STACK_FRAME   StackFrame,
+	PIMAGEHLP_CONTEXT       Context
+);
+typedef BOOL (WINAPI *SYMFROMADDR)(
+	HANDLE          hProcess,
+	DWORD64         Address,
+	PDWORD64        Displacement,
+	PSYMBOL_INFO    Symbol
+);
+typedef BOOL (WINAPI *STACKWALK)(
+	DWORD                           MachineType,
+	HANDLE                          hProcess,
+	HANDLE                          hThread,
+	LPSTACKFRAME                    StackFrame,
+	PVOID                           ContextRecord,
+	PREAD_PROCESS_MEMORY_ROUTINE    ReadMemoryRoutine,
+	PFUNCTION_TABLE_ACCESS_ROUTINE  FunctionTableAccessRoutine,
+	PGET_MODULE_BASE_ROUTINE        GetModuleBaseRoutine,
+	PTRANSLATE_ADDRESS_ROUTINE      TranslateAddress
+);
+typedef PVOID (WINAPI *SYMFUNCTIONTABLEACCESS)(
+	HANDLE  hProcess,
+	DWORD   AddrBase
+);
+typedef DWORD (WINAPI *SYMGETMODULEBASE)(
+	HANDLE  hProcess,
+	DWORD   dwAddr
+);
+
+/////////////////////////////////////////////////////////////////////
+// Custom info
+
+/// Internal structure used to pass some data around
+typedef struct _InternalData {
+	// PrintStacktrace
+	FILE* log_file;
+	STACKFRAME* pStackframe;
+	HANDLE hProcess;
+	DWORD nr_of_frame;
+
+	// PrintFunctionDetail
+	BOOL as_arg_list;
+	BOOL log_params;
+	BOOL log_locals;
+	BOOL log_globals;
+	DWORD nr_of_var;
+
+	// PrintDataInfo
+	ULONG64 modBase;
+} InterData;
+
+/// dbghelp dll filename
+#define DBGHELP_DLL "dbghelp.dll"
+
+// Default report filename, used when the module path is unavailable
+#define DBG_DEFAULT_FILENAME "hercules"
+
+// Extended information printed in the console
+#define DBG_EXTENDED_INFORMATION \
+		"Please report the crash in the bug tracker:\n" \
+		"http://hercules.ws/board/tracker/\n"
+
+/////////////////////////////////////////////////////////////////////
+// Global variables
+
+HANDLE dbghelp_dll = INVALID_HANDLE_VALUE;
+MINIDUMPWRITEDUMP MiniDumpWriteDump_ = NULL;
+SYMINITIALIZE SymInitialize_ = NULL;
+SYMSETOPTIONS SymSetOptions_ = NULL;
+SYMGETOPTIONS SymGetOptions_ = NULL;
+SYMCLEANUP SymCleanup_ = NULL;
+SYMGETTYPEINFO SymGetTypeInfo_ = NULL;
+SYMGETLINEFROMADDR SymGetLineFromAddr_ = NULL;
+SYMENUMSYMBOLS SymEnumSymbols_ = NULL;
+SYMSETCONTEXT SymSetContext_ = NULL;
+SYMFROMADDR SymFromAddr_ = NULL;
+STACKWALK StackWalk_ = NULL;
+SYMFUNCTIONTABLEACCESS SymFunctionTableAccess_ = NULL;
+SYMGETMODULEBASE SymGetModuleBase_ = NULL;
+
+/////////////////////////////////////////////////////////////////////
+// Code
+
+/// Writes the minidump to file. The callback function will at the 
+/// same time write the list of modules to the log file.
+///
+/// @param file Filename of the minidump
+/// @param ptrs Exception info
+/// @param module_callback Callback for MiniDumpWriteDump
+/// @param log_file Log file
+static VOID
+Dhp__WriteMinidumpFile(
+	const char*                 file,
+	PEXCEPTION_POINTERS         ptrs,
+	MINIDUMP_CALLBACK_ROUTINE   module_callback,
+	FILE*                       log_file)
+{
+	// open minidump file
+	HANDLE minidump_file = CreateFileA(
+		file,
+		GENERIC_WRITE,
+		0,
+		NULL,
+		CREATE_ALWAYS,
+		FILE_ATTRIBUTE_NORMAL,
+		NULL
+	);
+
+	if( minidump_file != INVALID_HANDLE_VALUE )
+	{
+		MINIDUMP_EXCEPTION_INFORMATION expt_info;
+		MINIDUMP_CALLBACK_INFORMATION dump_cb_info;
+
+		expt_info.ThreadId = GetCurrentThreadId();
+		expt_info.ExceptionPointers = ptrs;
+		expt_info.ClientPointers = FALSE;
+
+		dump_cb_info.CallbackRoutine = module_callback;
+		dump_cb_info.CallbackParam = (void*)log_file;
+
+		if( module_callback != NULL && log_file != NULL )
+			fprintf(log_file, "\n\nLoaded modules:\n");
+
+		MiniDumpWriteDump_(
+			GetCurrentProcess(),
+			GetCurrentProcessId(),
+			minidump_file,
+			MiniDumpNormal,
+			ptrs ? &expt_info : NULL,
+			NULL,
+			&dump_cb_info
+		);
+
+		CloseHandle(minidump_file);
+	}
+}
+
+/// Prints module information to the log file.
+/// Used as a callback to MiniDumpWriteDump.
+///
+/// @param data Log file
+/// @param callback_input
+/// @param callback_output
+/// @return
+static BOOL CALLBACK
+Dhp__PrintModuleInfoCallback(
+	void*                           data,
+	CONST PMINIDUMP_CALLBACK_INPUT  callback_input,
+	PMINIDUMP_CALLBACK_OUTPUT       callback_output)
+{
+	if( data != NULL &&
+		callback_input != NULL &&
+		callback_input->CallbackType == ModuleCallback)
+	{
+		FILE* log_file = (FILE*)data;
+		MINIDUMP_MODULE_CALLBACK module = callback_input->Module;
+
+		fprintf(log_file, "0x%p", module.BaseOfImage);
+
+		fprintf(log_file, "  %ws", module.FullPath, log_file);
+
+		fprintf(log_file, "  (%d.%d.%d.%d, %d bytes)\n",
+			HIWORD(module.VersionInfo.dwFileVersionMS),
+			LOWORD(module.VersionInfo.dwFileVersionMS),
+			HIWORD(module.VersionInfo.dwFileVersionLS),
+			LOWORD(module.VersionInfo.dwFileVersionLS),
+			module.SizeOfImage);
+	}
+
+	return TRUE;
+}
+
+/// Prints details about the current process, platform and exception 
+/// information to the log file.
+///
+/// @param exception Exception info
+/// @param context Exception context
+/// @param log_file Log file
+static VOID
+Dhp__PrintProcessInfo(
+	EXCEPTION_RECORD*   exception,
+	CONTEXT*            context,
+	FILE*               log_file)
+{
+	OSVERSIONINFOA oi;
+	LPSTR cmd_line;
+
+	fprintf(log_file,
+		"\nProcess info:\n");
+
+	// print the command line
+	cmd_line = GetCommandLineA();
+	if( cmd_line )
+	fprintf(log_file,
+		"Cmd line: %s\n",
+		cmd_line);
+
+	// print information about the OS
+	oi.dwOSVersionInfoSize = sizeof(oi);
+	GetVersionExA(&oi);
+	fprintf(log_file,
+		"Platform: Windows OS version %d.%d build %d %s\n",
+		oi.dwMajorVersion, oi.dwMinorVersion, oi.dwBuildNumber, oi.szCSDVersion);
+
+	// print the exception code
+	if( exception )
+	{
+		fprintf(log_file,
+			"\nException:\n"
+			"0x%x",
+			exception->ExceptionCode);
+		switch( exception->ExceptionCode )
+		{
+#define PRINT(x) case x: fprintf(log_file, " "#x); break
+		PRINT(EXCEPTION_ACCESS_VIOLATION);
+		PRINT(EXCEPTION_DATATYPE_MISALIGNMENT);
+		PRINT(EXCEPTION_BREAKPOINT);
+		PRINT(EXCEPTION_SINGLE_STEP);
+		PRINT(EXCEPTION_ARRAY_BOUNDS_EXCEEDED);
+		PRINT(EXCEPTION_FLT_DENORMAL_OPERAND);
+		PRINT(EXCEPTION_FLT_DIVIDE_BY_ZERO);
+		PRINT(EXCEPTION_FLT_INEXACT_RESULT);
+		PRINT(EXCEPTION_FLT_INVALID_OPERATION);
+		PRINT(EXCEPTION_FLT_OVERFLOW);
+		PRINT(EXCEPTION_FLT_STACK_CHECK);
+		PRINT(EXCEPTION_FLT_UNDERFLOW);
+		PRINT(EXCEPTION_INT_DIVIDE_BY_ZERO);
+		PRINT(EXCEPTION_INT_OVERFLOW);
+		PRINT(EXCEPTION_PRIV_INSTRUCTION);
+		PRINT(EXCEPTION_IN_PAGE_ERROR);
+		PRINT(EXCEPTION_ILLEGAL_INSTRUCTION);
+		PRINT(EXCEPTION_NONCONTINUABLE_EXCEPTION);
+		PRINT(EXCEPTION_STACK_OVERFLOW);
+		PRINT(EXCEPTION_INVALID_DISPOSITION);
+		PRINT(EXCEPTION_GUARD_PAGE);
+		PRINT(EXCEPTION_INVALID_HANDLE);
+#undef PRINT
+		}
+
+		// print where the fault occured
+		fprintf(log_file, " at location 0x%p", exception->ExceptionAddress);
+
+		// if the exception was an access violation, print additional information
+		if( exception->ExceptionCode == EXCEPTION_ACCESS_VIOLATION && exception->NumberParameters >= 2 )
+			fprintf(log_file, " %s location 0x%p", exception->ExceptionInformation[0] ? "writing to" : "reading from", exception->ExceptionInformation[1]);
+
+		fprintf(log_file, "\n");
+	}
+
+	// print the register info
+	if( context )
+	{
+#if defined(_M_IX86)
+		fprintf(log_file,
+			"\nRegisters:\n");
+		if( context->ContextFlags & CONTEXT_INTEGER )
+		{
+			fprintf(log_file,
+				"eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x\n",
+				context->Eax, context->Ebx, context->Ecx,
+				context->Edx, context->Esi, context->Edi);
+		}
+		if( context->ContextFlags & CONTEXT_CONTROL )
+		{
+			fprintf(log_file,
+				"eip=%08x esp=%08x ebp=%08x iopl=%1x %s %s %s %s %s %s %s %s %s %s\n",
+				context->Eip, context->Esp, context->Ebp, 
+				(context->EFlags >> 12) & 3,	//  IOPL level value
+				context->EFlags & 0x00100000 ? "vip" : "   ",	//  VIP (virtual interrupt pending)
+				context->EFlags & 0x00080000 ? "vif" : "   ",	//  VIF (virtual interrupt flag)
+				context->EFlags & 0x00000800 ? "ov"  : "nv",	//  VIF (virtual interrupt flag)
+				context->EFlags & 0x00000400 ? "dn"  : "up",	//  OF (overflow flag)
+				context->EFlags & 0x00000200 ? "ei"  : "di",	//  IF (interrupt enable flag)
+				context->EFlags & 0x00000080 ? "ng"  : "pl",	//  SF (sign flag)
+				context->EFlags & 0x00000040 ? "zr"  : "nz",	//  ZF (zero flag)
+				context->EFlags & 0x00000010 ? "ac"  : "na",	//  AF (aux carry flag)
+				context->EFlags & 0x00000004 ? "po"  : "pe",	//  PF (parity flag)
+				context->EFlags & 0x00000001 ? "cy"  : "nc");	//  CF (carry flag)
+		}
+		if( context->ContextFlags & CONTEXT_SEGMENTS )
+		{
+			fprintf(log_file,
+				"cs=%04x  ss=%04x  ds=%04x  es=%04x  fs=%04x  gs=%04x",
+				context->SegCs,
+				context->SegSs,
+				context->SegDs,
+				context->SegEs,
+				context->SegFs,
+				context->SegGs,
+				context->EFlags);
+			if( context->ContextFlags & CONTEXT_CONTROL )
+				fprintf(log_file,
+					"             efl=%08x",
+					context->EFlags);
+			fprintf(log_file, "\n");
+		}
+		else if( context->ContextFlags & CONTEXT_CONTROL )
+			fprintf(log_file,
+					"                                                                       efl=%08x\n",
+					context->EFlags);
+#else /* defined(_M_IX86) */
+		//TODO add more processors
+#endif
+	}
+}
+
+/// Prints the typename of the symbol.
+///
+/// @param typeIndex Type index of the symbol
+/// @param symtag Symbol tag
+/// @param withParens If brackets are printed around the typename
+/// @param interData Inter data
+static VOID
+Dhp__PrintTypeName(
+	DWORD       typeIndex,
+	DWORD       symtag,
+	BOOL        withParens,
+	InterData*  interData)
+{
+	// inter data
+	FILE* log_file;
+	HANDLE hProcess;
+	ULONG64 modBase;
+	//
+	assert( interData != NULL );
+	log_file = interData->log_file;
+	hProcess = interData->hProcess;
+	modBase  = interData->modBase;
+
+	if( withParens )
+		fprintf(log_file, "(");
+
+	switch( symtag )
+	{
+	case SymTagEnum:
+		{			
+			WCHAR* pwszTypeName;
+
+			if( SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_GET_SYMNAME, &pwszTypeName) )
+			{
+				fprintf(log_file, "enum %ls", pwszTypeName);
+				LocalFree(pwszTypeName);
+			}
+			else
+				fprintf(log_file, "enum <symname not found>");
+		}
+		break;
+	case SymTagBaseType:
+		{
+			DWORD basetype;
+			ULONG64 length = 0;
+
+			SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_GET_LENGTH, &length);
+			if( !SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_GET_BASETYPE, &basetype) )
+			{
+				fprintf(log_file, "<basetype not found>");
+				break;
+			}
+			switch( basetype )
+			{
+			case btVoid: fprintf(log_file, "void"); break;
+			case btChar: fprintf(log_file, "char"); break;
+			case btWChar: fprintf(log_file, "wchar"); break;
+			case btULong: fprintf(log_file, "unsigned ");	// next
+			case btLong: fprintf(log_file, "long"); break;
+			case btUInt: fprintf(log_file, "unsigned ");	// next
+			case btInt:
+				if( length == sizeof(char) ) fprintf(log_file, "char");
+				else if( length == sizeof(short) ) fprintf(log_file, "short");
+				else if( length == sizeof(int) ) fprintf(log_file, "int");
+				else if( length == sizeof(long long) ) fprintf(log_file, "long long");
+				else fprintf(log_file, "<int%d>", length*8);
+				break;
+			case btFloat:
+				if( length == sizeof(float) ) fprintf(log_file, "float");
+				else if( length == sizeof(double) ) fprintf(log_file, "double");
+				else if( length == sizeof(long double) ) fprintf(log_file, "long double");
+				else fprintf(log_file, "<float%d>", length*8);
+				break;
+			default: fprintf(log_file, "<TODO name of basetype %d %d>", basetype, length); break;
+			}
+		}
+		break;
+	case SymTagPointerType:
+		{
+			DWORD subtype;
+			DWORD subtag;
+
+			if( !SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_GET_TYPE, &subtype) )
+				fprintf(log_file, "<type not found>*");
+			else if( !SymGetTypeInfo_(hProcess, modBase, subtype, TI_GET_SYMTAG, &subtag) )
+				fprintf(log_file, "<symtag not found>*");
+			else
+			{
+				Dhp__PrintTypeName(subtype, subtag, FALSE, interData);
+				fprintf(log_file, "*");
+			}
+		}
+		break;
+	case SymTagArrayType:
+		{
+			DWORD childTypeIndex;
+			DWORD childSymtag;
+
+			// print root type
+			childTypeIndex = typeIndex;
+			childSymtag = symtag;
+			for( ; ; )
+			{
+				if( !SymGetTypeInfo_( hProcess, modBase, childTypeIndex, TI_GET_TYPE, &childTypeIndex) )
+				{
+					fprintf(log_file, "<child type not found>");
+					break;
+				}
+				if( !SymGetTypeInfo_( hProcess, modBase, childTypeIndex, TI_GET_SYMTAG, &childSymtag) )
+				{
+					fprintf(log_file, "<child symtag not found>");
+					break;
+				}
+				if( childSymtag != SymTagArrayType )
+				{
+					Dhp__PrintTypeName(childTypeIndex, childSymtag, FALSE, interData);
+					break;
+				}
+				// next dimension
+			}
+			// print dimensions
+			childTypeIndex = typeIndex;
+			childSymtag = symtag;
+			for( ; childSymtag == SymTagArrayType ; )
+			{
+				DWORD childCount;
+				if( !SymGetTypeInfo_( hProcess, modBase, childTypeIndex, TI_GET_COUNT, &childCount) )
+					fprintf(log_file, "[<count not found>]");
+				else
+					fprintf(log_file, "[%u]", childCount);
+				if( !SymGetTypeInfo_( hProcess, modBase, childTypeIndex, TI_GET_TYPE, &childTypeIndex) )
+				{
+					fprintf(log_file, "<child type not found>");
+					break;
+				}
+				if( !SymGetTypeInfo_( hProcess, modBase, childTypeIndex, TI_GET_SYMTAG, &childSymtag) )
+				{
+					fprintf(log_file, "<child symtag not found>");
+					break;
+				}
+				// next dimension
+			}
+		}
+		break;
+	default:
+		{
+			WCHAR* pSymname;
+			DWORD udtkind;
+
+			if( SymGetTypeInfo_( hProcess, modBase, typeIndex, TI_GET_UDTKIND, &udtkind) )
+			{
+				switch( (UdtKind)udtkind )
+				{
+				case UdtStruct: fprintf(log_file, "struct "); break;
+				case UdtClass: fprintf(log_file, "class "); break;
+				case UdtUnion: fprintf(log_file, "union "); break;
+				default: fprintf(log_file, "<unknown udtkind %d> ", udtkind); break;
+				}
+			}
+			if( SymGetTypeInfo_( hProcess, modBase, typeIndex, TI_GET_SYMNAME, &pSymname ) )
+			{
+				fprintf(log_file, "%ls", pSymname);
+				LocalFree( pSymname );
+			}
+			else
+				fprintf(log_file, "<TODO typename of symtag %d>", symtag); break;
+		}
+		break;
+	}
+
+	if( withParens )
+		fprintf(log_file, ")");
+}
+
+/// Prints the bytes in the target location.
+///
+/// @param log_file Log file
+/// @param p Pointer to the data
+/// @param length Length of the data in bytes
+static VOID
+Dhp__PrintValueBytes(
+	FILE*   log_file,
+	BYTE*   p,
+	ULONG64 length)
+{
+	ULONG64 i;
+
+	fprintf(log_file, "<bytes:");
+	for( i = 0; i < length; ++i )
+	{
+		fprintf(log_file, "%02X", p[i]);
+	}
+	fprintf(log_file, ">");
+}
+
+/// Prints a wide string/char value.
+///
+/// @param log_file Log file
+/// @param p Pointer to the value
+/// @param length Length of the value in bytes
+static VOID
+Dhp__PrintValueWideChars(
+	FILE*   log_file,
+	WCHAR*  wstr,
+	ULONG64 length,
+	BOOL    isString)
+{
+	ULONG64 i;
+	char* buf;
+	char delim;
+
+	length /= sizeof(WCHAR);
+	delim = ( isString || length > 1 ? '\"' : '\'' );
+	fprintf(log_file, "%c", delim);
+	buf = (char *)LocalAlloc(LMEM_FIXED, MB_CUR_MAX+1);
+	buf[MB_CUR_MAX] = '\0';
+	for( i = 0; i < length; ++i )
+	{
+		int n;
+		switch( wstr[i] )
+		{
+		case L'\"': fprintf(log_file, "\\\""); break;
+		case L'\'': fprintf(log_file, "\\\'"); break;
+		case L'\\': fprintf(log_file, "\\\\"); break;
+		case L'\a': fprintf(log_file, "\\a"); break;
+		case L'\b': fprintf(log_file, "\\b"); break;
+		case L'\f': fprintf(log_file, "\\f"); break;
+		case L'\n': fprintf(log_file, "\\n"); break;
+		case L'\r': fprintf(log_file, "\\r"); break;
+		case L'\t': fprintf(log_file, "\\t"); break;
+		case L'\v': fprintf(log_file, "\\v"); break;
+		default:
+			if( iswprint(wstr[i]) && (n=wctomb(buf, wstr[i])) > 0 )
+			{
+				buf[n] = '\0';
+				fprintf(log_file, "%s", buf);
+			}
+			else fprintf(log_file, "\\u%04X", wstr[i]);
+			break;
+		}
+	}
+	LocalFree(buf);
+	fprintf(log_file, "%c", delim);
+}
+
+/// Prints a string/char value.
+///
+/// @param log_file Log file
+/// @param p Pointer to the value
+/// @param length Length of the value in bytes
+static VOID
+Dhp__PrintValueChars(
+	FILE*   log_file,
+	char*   str,
+	ULONG64 length,
+	BOOL    isString)
+{
+	ULONG64 i;
+	char delim;
+
+	length /= sizeof(char);
+	delim = ( isString || length > 1 ? '\"' : '\'' );
+	fprintf(log_file, "%c", delim);
+	for( i = 0; i < length; ++i )
+	{
+		switch( str[i] )
+		{
+		case '\"': fprintf(log_file, "\\\""); break;
+		case '\'': fprintf(log_file, "\\\'"); break;
+		case '\\': fprintf(log_file, "\\\\"); break;
+		case '\a': fprintf(log_file, "\\a"); break;
+		case '\b': fprintf(log_file, "\\b"); break;
+		case '\f': fprintf(log_file, "\\f"); break;
+		case '\n': fprintf(log_file, "\\n"); break;
+		case '\r': fprintf(log_file, "\\r"); break;
+		case '\t': fprintf(log_file, "\\t"); break;
+		case '\v': fprintf(log_file, "\\v"); break;
+		default:
+			if( isprint((unsigned char)str[i]) ) fprintf(log_file, "%c", str[i]);
+			else fprintf(log_file, "\\x%02X", (unsigned char)str[i]);
+			break;
+		}
+	}
+	fprintf(log_file, "%c", delim);
+}
+
+/// Prints a float value.
+///
+/// @param log_file Log file
+/// @param p Pointer to the value
+/// @param length Length of the value in bytes
+static VOID
+Dhp__PrintValueFloat(
+	FILE*   log_file,
+	VOID*   p,
+	ULONG64 length)
+{
+	if( length == sizeof(float) ) fprintf(log_file, "%f", *(float*)p);
+	else if( length == sizeof(double) ) fprintf(log_file, "%lf", *(double*)p);
+	else if( length == sizeof(long double) ) fprintf(log_file, "%Lf", *(long double*)p);
+	else
+	{
+		fprintf(log_file, "<unexpected length %I64u>", length);
+		Dhp__PrintValueBytes(log_file, (BYTE*)p, length);
+	}
+}
+
+/// Prints a hex value.
+///
+/// @param log_file Log file
+/// @param p Pointer to the value
+/// @param length Length of the value in bytes
+static VOID
+Dhp__PrintValueHex(
+	FILE*   log_file,
+	VOID*   p,
+	ULONG64 length)
+{
+	if( length == sizeof(UINT32) ) fprintf(log_file, "0x%I32X", *(UINT32*)p);
+	else if( length == sizeof(UINT64) ) fprintf(log_file, "0x%I64X", *(UINT64*)p);
+	else if( length == sizeof(char) ) fprintf(log_file, "0x%X", *(unsigned char*)p);
+	else if( length == sizeof(short) ) fprintf(log_file, "0x%X", *(unsigned short*)p);
+	else if( length == sizeof(int) ) fprintf(log_file, "0x%x", *(unsigned int*)p);
+	else if( length == sizeof(long) ) fprintf(log_file, "0x%lX", *(unsigned long*)p);
+	else if( length == sizeof(long long) ) fprintf(log_file, "0x%llX", *(unsigned long long*)p);
+	else
+	{
+		fprintf(log_file, "<unexpected length %I64u>", length);
+		Dhp__PrintValueBytes(log_file, (BYTE*)p, length);
+	}
+}
+
+/// Prints an unsigned integer value.
+///
+/// @param log_file Log file
+/// @param p Pointer to the value
+/// @param length Length of the value in bytes
+static VOID
+Dhp__PrintValueUnsigned(
+	FILE*   log_file,
+	VOID*   p,
+	ULONG64 length)
+{
+	if( length == sizeof(INT32) ) fprintf(log_file, "%I32u", *(INT32*)p);
+	else if( length == sizeof(INT64) ) fprintf(log_file, "%I64u", *(INT64*)p);
+	else if( length == sizeof(char) ) fprintf(log_file, "%u", *(unsigned char*)p);
+	else if( length == sizeof(short) ) fprintf(log_file, "%u", *(unsigned short*)p);
+	else if( length == sizeof(int) ) fprintf(log_file, "%u", *(unsigned int*)p);
+	else if( length == sizeof(long) ) fprintf(log_file, "%lu", *(unsigned long*)p);
+	else if( length == sizeof(long long) ) fprintf(log_file, "%llu", *(unsigned long long*)p);
+	else
+	{
+		fprintf(log_file, "<unexpected length %I64u>", length);
+		Dhp__PrintValueBytes(log_file, (BYTE*)p, length);
+	}
+}
+
+/// Prints a signed integer value.
+///
+/// @param log_file Log file
+/// @param p Pointer to the value
+/// @param length Length of the value in bytes
+static VOID
+Dhp__PrintValueSigned(
+	FILE*   log_file,
+	VOID*   p,
+	ULONG64 length)
+{
+	if( length == sizeof(INT32) ) fprintf(log_file, "%I32d", *(INT32*)p);
+	else if( length == sizeof(INT64) ) fprintf(log_file, "%I64d", *(INT64*)p);
+	else if( length == sizeof(char) ) fprintf(log_file, "%d", *(signed char*)p);
+	else if( length == sizeof(short) ) fprintf(log_file, "%d", *(signed short*)p);
+	else if( length == sizeof(int) ) fprintf(log_file, "%d", *(signed int*)p);
+	else if( length == sizeof(long) ) fprintf(log_file, "%ld", *(signed long*)p);
+	else if( length == sizeof(long long) ) fprintf(log_file, "%lld", *(signed long long*)p);
+	else
+	{
+		fprintf(log_file, "<unexpected length %I64u>", length);
+		Dhp__PrintValueBytes(log_file, (BYTE*)p, length);
+	}
+}
+
+/// Prints a nul-terminated wide string value.
+/// Checks if the memory can be read from.
+///
+/// @param log_file Log file
+/// @param str Target string
+static VOID
+Dhp__PrintValueCWideString(
+	FILE*   log_file,
+	WCHAR*   str)
+{
+	ULONG64 length = 0;
+
+	// check if memory is readable
+	__try
+	{
+		while( str[length] != L'\0' )
+			++length;
+	}
+	__except( EXCEPTION_EXECUTE_HANDLER )
+	{
+		if( length ) Dhp__PrintValueWideChars(log_file, str, length*sizeof(WCHAR), TRUE);	// print readable part
+		fprintf(log_file, "<invalid memory>");
+		return;
+	}
+
+	// print string
+	Dhp__PrintValueWideChars(log_file, str, length*sizeof(WCHAR), TRUE);
+}
+
+/// Prints a nul-terminated string value.
+/// Checks if the memory can be read from.
+///
+/// @param log_file Log file
+/// @param str Target string
+static VOID
+Dhp__PrintValueCString(
+	FILE*   log_file,
+	char*   str)
+{
+	ULONG64 length = 0;
+
+	assert( log_file != NULL );
+
+	// check if memory is readable
+	__try
+	{
+		while( str[length] != '\0' )
+			++length;
+	}
+	__except( EXCEPTION_EXECUTE_HANDLER )
+	{
+		if( length ) Dhp__PrintValueChars(log_file, str, length*sizeof(char), TRUE);	// print readable part
+		fprintf(log_file, "<invalid memory>");
+		return;
+	}
+
+	// print string
+	Dhp__PrintValueChars(log_file, str, length*sizeof(char), TRUE);
+}
+
+// forward declaration of Dhp__PrintDataContents
+static VOID Dhp__PrintDataContents(DWORD typeIndex, PVOID pVariable, InterData*  interData);
+
+/// Prints the value of the data symbol.
+/// Checks if the memory can be read from.
+///
+/// @param typeIndex Type index of the symbol
+/// @param symtag Symbol tag
+/// @param pVariable Address to the symbol contents
+/// @param pInterData Inter data
+static VOID
+Dhp__PrintDataValue(
+	DWORD       typeIndex,
+	DWORD       symtag,
+	PVOID       pVariable,
+	InterData*  pInterData)
+{
+	// inter data
+	FILE* log_file;
+	DWORD64 modBase;
+	HANDLE hProcess;
+	//
+	ULONG64 length = 0;
+	DWORD basetype;
+	BOOL isValid = TRUE;
+
+	assert( pInterData != NULL );
+	log_file = pInterData->log_file;
+	modBase  = pInterData->modBase;
+	hProcess = pInterData->hProcess;
+
+	if( !SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_GET_LENGTH, &length) )
+	{
+		fprintf(log_file, "<unknown data length>");
+		return;
+	}
+
+	// check if memory is readable
+	__try
+	{
+		BYTE* p = (BYTE*)pVariable;
+		ULONG i;
+		BYTE b = 0;
+		for( i = 0; i < length; ++i )
+			b += p[i];	// add to make sure it's not optimized out in release mode
+	}
+	__except( EXCEPTION_EXECUTE_HANDLER )
+	{
+		fprintf(log_file, "<invalid memory>");
+		return;
+	}
+
+	switch( symtag )
+	{
+	case SymTagBaseType:
+		{
+			if( !SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_GET_BASETYPE, &basetype) )
+			{
+				fprintf(log_file, "<basetype not found>");
+				Dhp__PrintValueBytes(log_file, (BYTE*)pVariable, length);
+				break;
+			}
+			switch( basetype )
+			{
+			case btInt:
+			case btLong:
+				Dhp__PrintValueSigned(log_file, pVariable, length);
+				break;
+			case btUInt:
+			case btULong:
+				Dhp__PrintValueUnsigned(log_file, pVariable, length);
+				break;
+			case btFloat:
+				Dhp__PrintValueFloat(log_file, pVariable, length);
+				break;
+			case btChar:
+				{
+					if( length == sizeof(char) ) fprintf(log_file, "%u ", *(unsigned char*)pVariable);
+					Dhp__PrintValueChars(log_file, (char*)pVariable, length, FALSE);
+				}
+				break;
+			case btWChar:
+				{
+					if( length == sizeof(WCHAR) ) fprintf(log_file, "%u ", *(WCHAR*)pVariable);
+					Dhp__PrintValueWideChars(log_file, (WCHAR*)pVariable, length, FALSE);
+				}
+				break;
+			case btVoid:
+				if( length > 0 ) Dhp__PrintValueBytes(log_file, (BYTE*)pVariable, length);
+				break;
+			default:
+				fprintf(log_file, "<TODO value of basetype %d>", basetype);
+				Dhp__PrintValueBytes(log_file, (BYTE*)pVariable, length);
+				break;
+			}
+		}
+		break;
+	case SymTagEnum:
+		Dhp__PrintValueHex(log_file, pVariable, length);
+		break;
+	case SymTagPointerType:
+		{
+			DWORD childTypeIndex;
+			DWORD childSymtag;
+
+			fprintf(log_file, "0x%p", *(void**)pVariable);
+			if( SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_GET_TYPE, &childTypeIndex) &&
+				SymGetTypeInfo_(hProcess, modBase, childTypeIndex, TI_GET_SYMTAG, &childSymtag) && 
+				childSymtag != SymTagPointerType )
+			{
+				DWORD childBasetype;
+
+				// child isn't a pointer, print the contents
+				fprintf(log_file, " ");
+				if( childSymtag == SymTagBaseType &&
+					SymGetTypeInfo_(hProcess, modBase, childTypeIndex, TI_GET_BASETYPE, &childBasetype) &&
+					(childBasetype == btChar || childBasetype == btWChar) )
+				{
+					// string or wide string
+					if( childBasetype == btChar ) Dhp__PrintValueCString(log_file, *(char**)pVariable);
+					else if( childBasetype == btWChar ) Dhp__PrintValueCWideString(log_file, *(WCHAR**)pVariable);
+					else fprintf(log_file, "<unexpected child basetype %d>", childBasetype);
+					break;
+				}
+				Dhp__PrintDataValue(childTypeIndex, childSymtag, *(PVOID*)pVariable, pInterData);
+			}
+		}
+		break;
+	case SymTagArrayType:
+		{
+			DWORD childTypeIndex;
+			DWORD childSymtag;
+			DWORD count;
+			DWORD i;
+
+			if( !SymGetTypeInfo_( hProcess, modBase, typeIndex, TI_GET_TYPE, &childTypeIndex) )
+			{
+				fprintf(log_file, "<child type not found>");
+				Dhp__PrintValueBytes(log_file, (BYTE*)pVariable, length);
+				break;
+			}
+			if( !SymGetTypeInfo_( hProcess, modBase, childTypeIndex, TI_GET_SYMTAG, &childSymtag) )
+			{
+				fprintf(log_file, "<child symtag not found>");
+				Dhp__PrintValueBytes(log_file, (BYTE*)pVariable, length);
+				break;
+			}
+			if( !SymGetTypeInfo_( hProcess, modBase, typeIndex, TI_GET_COUNT, &count) )
+			{
+				fprintf(log_file, "<count not found>");
+				Dhp__PrintValueBytes(log_file, (BYTE*)pVariable, length);
+				break;
+			}
+			// print values
+			fprintf(log_file, "{");
+			for( i = 0; i < count; ++i )
+			{
+				BYTE* pData = pVariable;
+				pData += i*(length/count);
+				if( i > 0 ) fprintf(log_file, ",");
+				Dhp__PrintDataValue(childTypeIndex, childSymtag, pData, pInterData);
+			}
+			fprintf(log_file, "}");
+		}
+		break;
+	default:
+#if 0
+		{//## TODO show children of structs/unions
+			TI_FINDCHILDREN_PARAMS* children;
+			DWORD childCount;
+			DWORD i;
+
+			// count children
+			if( !SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_GET_CHILDRENCOUNT, &childCount) )
+			{
+				fprintf(log_file, "<child count not found>");
+				Dhp__PrintValueBytes(log_file, (BYTE*)pVariable, length);
+				break;
+			}
+
+			// Prepare to get an array of "TypeIds", representing each of the children.
+			// SymGetTypeInfo(TI_FINDCHILDREN) expects more memory than just a
+			// TI_FINDCHILDREN_PARAMS struct has.  Use derivation to accomplish this.
+			children = (TI_FINDCHILDREN_PARAMS*)LocalAlloc(LMEM_FIXED, sizeof(TI_FINDCHILDREN_PARAMS)+childCount*sizeof(ULONG));
+			children->Count = childCount;
+			children->Start= 0;
+
+			// Get the array of TypeIds, one for each child type
+			if( !SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_FINDCHILDREN, &children) )
+			{
+				fprintf(log_file, "<children not found>");
+				Dhp__PrintValueBytes(log_file, (BYTE*)pVariable, length);
+				LocalFree(children);
+				return;
+			}
+
+			// Iterate through each of the children
+			fprintf(log_file, "{");
+			for( i = 0; i < childCount; ++i )
+			{
+				DWORD childOffset;
+				DWORD childTypeid;
+				WCHAR* childName;
+				DWORD_PTR pData;
+
+				if( i > 0 ) fprintf(log_file, ",");
+
+				// Get the offset of the child member, relative to its parent
+				if( !SymGetTypeInfo_(hProcess, modBase, children->ChildId[i], TI_GET_OFFSET, &childOffset) )
+				{
+					fprintf(log_file, "<child offset not found>");
+					continue;
+				}
+
+				// Get the real "TypeId" of the child.
+				if( !SymGetTypeInfo_(hProcess, modBase, children->ChildId[i], TI_GET_TYPEID, &childTypeid) )
+				{
+					fprintf(log_file, "<child typeid not found>");
+					continue;
+				}
+
+				// Calculate the address of the member
+				pData = (DWORD_PTR)pVariable;
+				pData += childOffset;
+
+				// print name of the child
+				if( !SymGetTypeInfo_(hProcess, modBase, childTypeid, TI_GET_SYMNAME, &childName) )
+				{
+					fprintf(log_file, "<child symname not found>");
+					continue;
+				}
+				fprintf(log_file, "%ws=", childName);
+				LocalFree(childName);
+
+				// print contents of the child
+				Dhp__PrintDataContents(childTypeid, (PVOID)pData, interData);
+			}
+			fprintf(log_file, "}");
+
+			LocalFree(children);
+		}
+#endif
+		Dhp__PrintValueBytes(log_file, (BYTE*)pVariable, length);
+		break;
+	}
+}
+
+/// Prints the contents of the data symbol. (type and value)
+///
+/// @param typeIndex Type index of the symbol
+/// @param pVariable Address of the symbol contents
+/// @param pInterData Inter data
+static VOID
+Dhp__PrintDataContents(
+	DWORD typeIndex,
+	PVOID pVariable,
+	InterData*  pInterData)
+{
+	// inter data
+	FILE* log_file;
+	HANDLE hProcess;
+	DWORD64 modBase;
+	//
+	DWORD symtag;
+
+	assert( pInterData != NULL );
+	log_file = pInterData->log_file;
+	hProcess = pInterData->hProcess;
+	modBase  = pInterData->modBase;
+
+	if( SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_GET_SYMTAG, &symtag) )
+	{
+		// print type
+		Dhp__PrintTypeName(typeIndex, symtag, TRUE, pInterData);
+		// print value
+		Dhp__PrintDataValue(typeIndex, symtag, pVariable, pInterData);
+	}
+	else
+		fprintf(log_file, "<symtag not found>");
+}
+
+/// Prints information about the data symbol.
+///
+/// @param pSymInfo Symbol info
+/// @param pInterData Inter data
+static VOID
+Dhp__PrintDataInfo(
+	PSYMBOL_INFO    pSymInfo,
+	InterData*      pInterData)
+{
+	// inter data
+	FILE* log_file;
+	STACKFRAME* pStackframe;
+	BOOL as_arg_list;
+	BOOL log_params;
+	BOOL log_locals;
+	BOOL log_globals;
+	int nr_of_var;
+	// my data
+	DWORD_PTR pVariable = 0;
+	enum{ UNKNOWN, PARAM, LOCAL, GLOBAL } scope = UNKNOWN;
+
+	assert( pSymInfo != NULL );
+	assert( pInterData != NULL );
+	assert( pSymInfo->Tag == SymTagData );
+	log_file    = pInterData->log_file;
+	pStackframe = pInterData->pStackframe;
+	as_arg_list = pInterData->as_arg_list;
+	log_params  = pInterData->log_params;
+	log_locals  = pInterData->log_locals;
+	log_globals = pInterData->log_globals;
+	nr_of_var   = pInterData->nr_of_var;
+
+	// Determine the scope and address of the variable
+    if( pSymInfo->Flags & SYMFLAG_REGREL )
+	{
+		pVariable = pStackframe->AddrFrame.Offset;
+		pVariable += (DWORD_PTR)pSymInfo->Address;
+		if( pSymInfo->Flags & SYMFLAG_PARAMETER )
+			scope = PARAM;	// parameter
+		else if( pSymInfo->Flags & SYMFLAG_LOCAL )
+		{
+			scope = LOCAL;	// local
+#if defined(_M_IX86)
+			if( (LONG64)pSymInfo->Address  > 0) scope = PARAM;	// parameter as local (bug in DBGHELP 5.1)
+#endif
+		}
+	}
+	else if( pSymInfo->Flags & SYMFLAG_REGISTER )
+	{
+		scope = ( pSymInfo->Flags & SYMFLAG_PARAMETER ? PARAM : LOCAL );	// register, optimized out(?)
+	}
+	else
+	{
+		pVariable = (DWORD_PTR)pSymInfo->Address;
+		scope = GLOBAL;	// It must be a global variable
+	}
+
+	// check if we should to log the variable
+	if( (scope == PARAM && log_params) ||
+		(scope == LOCAL && log_locals) ||
+		(scope == GLOBAL && log_globals) )
+	{
+		// print prefix and name
+		if( as_arg_list )
+			fprintf(log_file, "%s%s=", (nr_of_var ? ", " : ""), pSymInfo->Name);
+		else
+			fprintf(log_file, "\t%s = ", pSymInfo->Name);
+
+		// print value
+		if( !(pSymInfo->Flags & SYMFLAG_REGREL) && (pSymInfo->Flags & SYMF_REGISTER) )
+			fprintf(log_file, "<value optimized out>");
+		else
+		{
+			pInterData->modBase = pSymInfo->ModBase;
+			Dhp__PrintDataContents(pSymInfo->TypeIndex, (PVOID)pVariable, pInterData);
+		}
+
+		// print postfix
+		if( !as_arg_list )
+			fprintf(log_file, "\n");
+		pInterData->nr_of_var = ++nr_of_var;
+	}
+}
+
+/// Prints information about the symbol.
+///
+/// @param pSymInfo Symbol info
+/// @param pInterData Inter data
+static VOID
+Dhp__PrintSymbolInfo(
+	PSYMBOL_INFO    pSymInfo,
+	InterData*      pInterData)
+{
+	assert( pSymInfo != NULL );
+	assert( pInterData != NULL );
+
+	switch( pSymInfo->Tag ) 
+	{
+	case SymTagData: Dhp__PrintDataInfo( pSymInfo, pInterData ); break; 
+	default: /*fprintf(pInterData->log_file, "<unsupported symtag %d>", pSymInfo->Tag);*/ break;
+	}
+}
+
+/// Prints the details of one symbol to the log file.
+/// Used as a callback for SymEnumSymbols.
+///
+/// @param pSymInfo Symbol info
+/// @param symSize Size of the symbol info structure
+/// @param pData Inter data
+static BOOL WINAPI
+Dhp__EnumSymbolsCallback(
+	PSYMBOL_INFO    pSymInfo,
+	ULONG           symSize,
+	PVOID           pData)
+{
+	if( pSymInfo == NULL )
+		return TRUE;	// try other symbols
+
+	if( pData == NULL )
+	{
+		printf("Dhp__EnumSymbolsCallback: pData is NULL\n");
+		return FALSE;
+	}
+
+	Dhp__PrintSymbolInfo(pSymInfo, (InterData*)pData);
+	return TRUE;
+}
+
+/// Prints the source code of the target line.
+/// Searches for the target file in the original path,
+/// in the last src folder of the original path (relative)
+/// and in the current directory.
+///
+/// @param filename Original source file
+/// @param line Target line
+/// @param log_file Log file
+static VOID
+Dhp__PrintSourceLine(
+	FILE* log_file,
+	char* filename,
+	DWORD line)
+{
+	char path[MAX_PATH*3];
+	char pathBuffer[MAX_PATH+1];
+	char* p;
+
+	assert( filename != NULL );
+	assert( log_file != NULL );
+
+	// generate search paths
+	strcpy(path, filename);	// original path
+	p = strrchr(path, '\\');
+	if( p )
+	{
+		memcpy(p, ";\0", 2);
+		p = strstr(filename, "\\src\\");
+		if( p )
+		{
+			while( strstr(p+1, "\\src\\") )
+				p = strstr(p+1, "\\src\\");
+			strcat(path, p+1);	// last src folder path
+			p = strrchr(path, '\\');
+			memcpy(p, ";\0", 2);
+		}
+		filename = strrchr(filename, '\\')+1;
+	}
+	else
+		*path = '\0';	// no path
+	strcat(path, ".");	// current directoy
+
+	// search for file and line
+	if( SearchPathA(path, filename, NULL, MAX_PATH, pathBuffer, NULL) )
+	{
+		char code[1024+1];
+		DWORD i = 1;
+		FILE* fp;
+
+		fp = fopen(pathBuffer, "rt");
+		if( fp == NULL )
+			return;
+
+		code[1024] = '\0';
+		while( fgets(code, 1024, fp) )
+		{
+			if( i == line )
+			{// found line
+				char* term = strchr(code, '\n');
+				if( term && term != code && term[-1] == '\r' ) --term;
+				if( term ) *term = '\0';
+				fprintf(log_file, "%d\t%s\n", line, code);
+				break;
+			}
+			if( strchr(code, '\n') )
+				++i;
+		}
+		fclose(fp);
+	}
+}
+
+/// Prints details of one function to the log file.
+///
+/// @param interData Inter data
+static VOID
+Dhp__PrintFunctionDetails(
+	InterData*  pInterData)
+{
+	// inter data
+	HANDLE hProcess;
+	STACKFRAME* pStackframe;
+	FILE* log_file;
+	int nr_of_frame;
+	//
+	PSYMBOL_INFO pSymbolInfo;
+	DWORD64 funcDisplacement=0;
+	IMAGEHLP_STACK_FRAME imagehlpStackFrame;
+	IMAGEHLP_LINE imagehlpLine;
+	DWORD lineDisplacement=0;
+
+	assert( pInterData != NULL );
+	hProcess    = pInterData->hProcess;
+	pStackframe = pInterData->pStackframe;
+	log_file    = pInterData->log_file;
+	nr_of_frame = pInterData->nr_of_frame;
+
+	// frame info
+	fprintf(log_file,
+		"#%d  0x%p",
+		nr_of_frame, (void*)(DWORD_PTR)pStackframe->AddrPC.Offset);
+
+	// restrict symbol enumeration to this frame only
+	ZeroMemory(&imagehlpStackFrame, sizeof(IMAGEHLP_STACK_FRAME));
+	imagehlpStackFrame.InstructionOffset = pStackframe->AddrPC.Offset;
+	SymSetContext_(hProcess, &imagehlpStackFrame, 0);
+
+	// function name and displacement
+	pSymbolInfo = (PSYMBOL_INFO)LocalAlloc(LMEM_FIXED, sizeof(SYMBOL_INFO)+1024);
+	pSymbolInfo->SizeOfStruct = sizeof(SYMBOL_INFO);
+	pSymbolInfo->MaxNameLen = 1024;
+	if( SymFromAddr_(hProcess, pStackframe->AddrPC.Offset, &funcDisplacement, pSymbolInfo) == TRUE )
+	{
+		fprintf(log_file,
+			" in %.1024s+0x%I64X (",
+			pSymbolInfo->Name, funcDisplacement);
+
+		// log all function parameters
+		pInterData->as_arg_list = TRUE;
+		pInterData->log_params = TRUE;
+		pInterData->log_locals = FALSE;
+		pInterData->log_globals = FALSE;
+		pInterData->nr_of_var = 0;
+		SymEnumSymbols_(hProcess, 0, 0, Dhp__EnumSymbolsCallback, pInterData);
+
+		fprintf(log_file,
+			")");
+	}
+	else
+		fprintf(log_file,
+			"in <unknown function>");
+
+	// find the source line for this function.
+	imagehlpLine.SizeOfStruct = sizeof(IMAGEHLP_LINE);
+	if( SymGetLineFromAddr_(hProcess, pStackframe->AddrPC.Offset, &lineDisplacement, &imagehlpLine) != 0 )
+	{
+		char* filename = imagehlpLine.FileName;
+		DWORD line = imagehlpLine.LineNumber;
+
+		fprintf(log_file,
+			" at %s:%d\n",
+			filename, line);
+
+		Dhp__PrintSourceLine(log_file, filename, line);
+	}
+	else
+		fprintf(log_file,
+			"\n");
+
+	// log all function local variables
+	pInterData->as_arg_list = FALSE;
+	pInterData->log_params = FALSE;
+	pInterData->log_locals = TRUE;
+	pInterData->log_globals = FALSE;
+	pInterData->nr_of_var = 0;
+	SymEnumSymbols_(hProcess, 0, 0, Dhp__EnumSymbolsCallback, pInterData);
+
+	pInterData->nr_of_frame = ++nr_of_frame;
+	LocalFree(pSymbolInfo);
+}
+
+
+/// Walks over the stack and prints all relevant information to the log file.
+///
+/// @param context Exception context
+/// @param log_file Log file
+static VOID
+Dhp__PrintStacktrace(
+	CONTEXT *context,
+	FILE *log_file)
+{
+	HANDLE hProcess = GetCurrentProcess();
+	STACKFRAME stackframe;
+	DWORD machine;
+	CONTEXT ctx;
+	InterData interData;
+	int skip = 0;
+	int i;
+
+	assert( log_file != NULL );
+
+	fprintf(log_file,
+		"\nStacktrace:\n");
+
+	// Use thread information - if not supplied.
+	if( context == NULL )
+	{
+		// If no context is supplied, skip 1 frame
+		skip = 1;
+
+		ctx.ContextFlags = CONTEXT_FULL;
+		if( GetThreadContext(GetCurrentThread(), &ctx) )
+			context = &ctx;
+	}
+
+	if( context == NULL )
+		return;
+
+	// Write the stack trace
+	ZeroMemory(&stackframe, sizeof(STACKFRAME));
+	stackframe.AddrPC.Mode = AddrModeFlat;
+	stackframe.AddrStack.Mode = AddrModeFlat;
+	stackframe.AddrFrame.Mode = AddrModeFlat;
+#if defined(_M_IX86)
+	machine = IMAGE_FILE_MACHINE_I386;
+	stackframe.AddrPC.Offset = context->Eip;
+	stackframe.AddrStack.Offset = context->Esp;
+	stackframe.AddrFrame.Offset = context->Ebp;
+#else /* defined(_M_IX86) */
+#error FIXME add more processors
+some compilers don't stop on #error, this line makes sure it errors out
+#endif
+
+	interData.hProcess = hProcess;
+	interData.log_file = log_file;
+	interData.pStackframe = &stackframe;
+	interData.nr_of_frame = 0;
+	for( i = 0; ; ++i )
+	{
+		if( !StackWalk_(machine, hProcess, GetCurrentThread(),
+			&stackframe, context, NULL, SymFunctionTableAccess_,
+			SymGetModuleBase_, NULL))
+		{
+			break;
+		}
+
+		if( i >= skip )
+		{
+			// Check that the address is not zero.
+			// Sometimes StackWalk returns TRUE with a frame of zero.
+			if( stackframe.AddrPC.Offset != 0 )
+				Dhp__PrintFunctionDetails(&interData);
+		}
+	}
+}
+
+typedef BOOL (WINAPI *ISDEBUGGERPRESENT)(void);
+/// Checks if a debugger is attached to this process
+///
+/// @return TRUE is a debugger is present
+static BOOL
+Dhp__IsDebuggerPresent()
+{
+	HANDLE kernel32_dll;
+	ISDEBUGGERPRESENT IsDebuggerPresent_;
+	BOOL result;
+
+	kernel32_dll = LoadLibraryA("kernel32.dll");
+	if( kernel32_dll == NULL )
+		return FALSE;
+
+	IsDebuggerPresent_ = (ISDEBUGGERPRESENT)GetProcAddress(kernel32_dll, "IsDebuggerPresent");
+	if( IsDebuggerPresent_ )
+		result = IsDebuggerPresent_();
+	else
+		result = FALSE;
+
+	FreeLibrary(kernel32_dll);
+
+	return result;
+}
+
+/// Loads the dbghelp.dll library.
+///
+/// @return TRUE is sucessfull
+static BOOL
+Dhp__LoadDbghelpDll()
+{
+	dbghelp_dll = LoadLibraryA(DBGHELP_DLL);
+	if( dbghelp_dll != INVALID_HANDLE_VALUE )
+	{
+		DWORD opts;
+
+		// load the functions
+		MiniDumpWriteDump_      =      (MINIDUMPWRITEDUMP)GetProcAddress(dbghelp_dll, "MiniDumpWriteDump");
+		SymInitialize_          =          (SYMINITIALIZE)GetProcAddress(dbghelp_dll, "SymInitialize");
+		SymSetOptions_          =          (SYMSETOPTIONS)GetProcAddress(dbghelp_dll, "SymSetOptions");
+		SymGetOptions_          =          (SYMGETOPTIONS)GetProcAddress(dbghelp_dll, "SymGetOptions");
+		SymCleanup_             =             (SYMCLEANUP)GetProcAddress(dbghelp_dll, "SymCleanup");
+		SymGetTypeInfo_         =         (SYMGETTYPEINFO)GetProcAddress(dbghelp_dll, "SymGetTypeInfo");
+		SymGetLineFromAddr_     =     (SYMGETLINEFROMADDR)GetProcAddress(dbghelp_dll, "SymGetLineFromAddr");
+		SymEnumSymbols_         =         (SYMENUMSYMBOLS)GetProcAddress(dbghelp_dll, "SymEnumSymbols");
+		SymSetContext_          =          (SYMSETCONTEXT)GetProcAddress(dbghelp_dll, "SymSetContext");
+		SymFromAddr_            =            (SYMFROMADDR)GetProcAddress(dbghelp_dll, "SymFromAddr");
+		StackWalk_              =              (STACKWALK)GetProcAddress(dbghelp_dll, "StackWalk");
+		SymFunctionTableAccess_ = (SYMFUNCTIONTABLEACCESS)GetProcAddress(dbghelp_dll, "SymFunctionTableAccess");
+		SymGetModuleBase_       =       (SYMGETMODULEBASE)GetProcAddress(dbghelp_dll, "SymGetModuleBase");
+
+		if( MiniDumpWriteDump_ &&
+			SymInitialize_  && SymSetOptions_  && SymGetOptions_ &&
+			SymCleanup_     && SymGetTypeInfo_ && SymGetLineFromAddr_ &&
+			SymEnumSymbols_ && SymSetContext_  && SymFromAddr_ && StackWalk_ &&
+			SymFunctionTableAccess_ && SymGetModuleBase_ )
+		{
+			// initialize the symbol loading code
+			opts = SymGetOptions_();
+
+			// Set the 'load lines' option to retrieve line number information.
+			// Set the 'deferred loads' option to map the debug info in memory only when needed.
+			SymSetOptions_(opts | SYMOPT_LOAD_LINES | SYMOPT_DEFERRED_LOADS);
+
+			// Initialize the dbghelp DLL with the default path and automatic
+			// module enumeration (and loading of symbol tables) for this process.
+			SymInitialize_(GetCurrentProcess(), NULL, TRUE);
+
+			return TRUE;
+		}
+	}
+
+	if( dbghelp_dll )
+	{
+		FreeLibrary(dbghelp_dll);
+		dbghelp_dll = NULL;
+	}
+
+	return FALSE;
+}
+
+/// Unloads the dbghelp.dll library.
+static VOID
+Dhp__UnloadDbghlpDll()
+{
+	SymCleanup_(GetCurrentProcess());
+
+	FreeLibrary(dbghelp_dll);
+	dbghelp_dll = NULL;
+}
+
+/// Creates the report and minidump files.
+/// Puts the resulting pathnames in the arguments.
+/// The buffers must be at least MAX_PATH+1 in size.
+///
+/// @param out_lpszLogFileName Buffer for the report filename
+/// @param out_lpszDmpFileName Buffer for the minidump filename
+/// @return TRUE if the files were created
+static BOOL
+Dhp__CreateFiles(
+	char*   out_logFileName,
+	char*   out_dmpFileName)
+{
+#define LEN_TIMESTAMP 14	// "YYYYMMDDhhmmss"
+#define LEN_EXT 4	// ".rpt" or ".dmp"
+	char baseFileName[MAX_PATH+1];
+	char timestamp[LEN_TIMESTAMP+1];
+	FILE* fp;
+	time_t now;
+
+	// Generate base filename for the report/minidump
+	ZeroMemory(baseFileName, sizeof(baseFileName));
+	if( GetModuleFileName(NULL, baseFileName, MAX_PATH-LEN_TIMESTAMP-LEN_EXT) )
+	{
+		char* pTerm = strrchr(baseFileName, '\\');
+		if( pTerm == NULL ) pTerm = baseFileName;
+		pTerm = strrchr(pTerm, '.');
+		if( pTerm ) *pTerm = '\0';	// remove extension
+	}
+	else if( GetTempPathA(MAX_PATH-6-LEN_TIMESTAMP-LEN_EXT, baseFileName) )
+	{// in temp folder
+		strcat(baseFileName, DBG_DEFAULT_FILENAME);
+	}
+	else
+	{// in current folder
+		strcpy(baseFileName, DBG_DEFAULT_FILENAME);
+	}
+
+	time(&now);
+#if 0
+	szTimestamp[0] = '\0';
+#else
+	strftime(timestamp, sizeof(timestamp), "%Y%m%d%H%M%S", localtime(&now));
+#endif
+	timestamp[LEN_TIMESTAMP] = '\0';
+	
+	sprintf(out_logFileName, "%s%s.rpt", baseFileName, timestamp);
+	fp = fopen(out_logFileName, "w");
+	if( fp == NULL )
+		return FALSE;	// failed to create log file
+	fclose(fp);
+
+	sprintf(out_dmpFileName, "%s%s.dmp", baseFileName, timestamp);
+	fp = fopen(out_dmpFileName, "w");
+	if( fp == NULL)
+		return FALSE;	// failed to create dump file
+	fclose(fp);
+
+	return TRUE;	// success
+#undef LEN_EXT
+#undef LEN_TIMESTAMP
+}
+
+/// Unhandled exception handler. Where the magic starts... ;D
+///
+/// @param ptrs Exception information
+/// @return What to do with the exception
+LONG WINAPI
+Dhp__UnhandledExceptionFilter(PEXCEPTION_POINTERS ptrs)
+{
+	char szLogFileName[MAX_PATH+1];
+	char szDmpFileName[MAX_PATH+1];
+	FILE* log_file;
+
+	// check if the crash handler was already loaded (crash while handling the crash)
+	if( dbghelp_dll != INVALID_HANDLE_VALUE )
+		return EXCEPTION_CONTINUE_SEARCH;
+
+	// don't log anything if we're running inside a debugger ...
+	if( Dhp__IsDebuggerPresent() == TRUE )
+		return EXCEPTION_CONTINUE_SEARCH;
+
+	// ... or if we can't load dbghelp.dll ...
+	if( Dhp__LoadDbghelpDll() == FALSE )
+		return EXCEPTION_CONTINUE_SEARCH;
+
+	// ... or if we can't create the log files
+	if( Dhp__CreateFiles(szLogFileName, szDmpFileName) == FALSE )
+		return EXCEPTION_CONTINUE_SEARCH;
+
+	// open log file
+	log_file = fopen(szLogFileName, "wt");
+
+	// print information about the process
+	Dhp__PrintProcessInfo(
+		ptrs ? ptrs->ExceptionRecord : NULL,
+		ptrs ? ptrs->ContextRecord : NULL,
+		log_file);
+
+	// print the stacktrace
+	Dhp__PrintStacktrace(
+		ptrs ? ptrs->ContextRecord : NULL,
+		log_file);
+
+	// write the minidump file and use the callback to print the list of modules to the log file
+	Dhp__WriteMinidumpFile(
+		szDmpFileName,
+		ptrs,
+		Dhp__PrintModuleInfoCallback,
+		log_file);
+
+	fclose(log_file);
+
+	Dhp__UnloadDbghlpDll();
+
+	// inform the user
+	fprintf(stderr,
+		"\n"
+		"This application has halted due to an unexpected error.\n"
+		"A crash report and minidump file were saved to disk, you can find them here:\n"
+		"%s\n"
+		"%s\n"
+		DBG_EXTENDED_INFORMATION
+		"\n"
+		"NOTE: The crash report and minidump files can contain sensitive information\n"
+		"(filenames, partial file content, usernames and passwords etc.)\n",
+		szLogFileName,
+		szDmpFileName);
+
+	// terminate the application
+	return EXCEPTION_EXECUTE_HANDLER;
+}
+
+
+/////////////////////////////////////////////////////////////////////
+// DLL stuff
+#if !defined(DBG_EMBEDDED)
+
+/// Previous exception filter.
+static LPTOP_LEVEL_EXCEPTION_FILTER previousFilter;
+
+#if defined(__GNUC__)
+// GNU : define DLL load/unload functions
+static void Dhp__OnStartup(void) __attribute__((constructor));
+static void Dhp__OnExit(void) __attribute__((destructor));
+#endif /* defined(__GNUC__) */
+
+/// Installs as the unhandled exception handler.
+void Dhp__OnStartup(void)
+{
+	// Install the unhandled exception filter function
+	previousFilter = SetUnhandledExceptionFilter(Dhp__UnhandledExceptionFilter);
+}
+
+/// Uninstalls the handler.
+void Dhp__OnExit(void)
+{
+	SetUnhandledExceptionFilter(previousFilter);
+}
+
+#if !defined(__GNUC__)
+// Windows : invoke DLL load/unload functions
+BOOL APIENTRY DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
+{
+	switch( dwReason )
+	{
+		case DLL_PROCESS_ATTACH: Dhp__OnStartup(); break;
+		case DLL_PROCESS_DETACH: Dhp__OnExit(); break;
+	}
+	return TRUE;
+}
+#endif /* !defined(__GNUC__) */
+#endif /* !defined(DBG_EMBEDDED) */
+
+HPExport void plugin_init (void) {
+}
+
+#endif /* _WIN32 */
+