StackWalker.h

#pragma once
#include <Windows.h>
#include <tchar.h>
#include <vector>

namespace textconv_helper
{
	// Forward declarations of our classes. They are defined later.
	class CA2A_;
	class CA2W_;
	class CW2A_;
	class CW2W_;
	class CA2BSTR_;
	class CW2BSTR_;

	// typedefs for the well known text conversions
	typedef CA2W_ A2W_;
	typedef CW2A_ W2A_;
	//typedef CW2BSTR_ W2BSTR_;
	//typedef CA2BSTR_ A2BSTR_;
	typedef CW2A_ BSTR2A_;
	typedef CW2W_ BSTR2W_;

#ifdef _UNICODE
	typedef CA2W_ A2T_;
	typedef CW2A_ T2A_;
	typedef CW2W_ T2W_;
	typedef CW2W_ W2T_;
	//typedef CW2BSTR_ T2BSTR_;
	//typedef BSTR2W_ BSTR2T_;
#else
	typedef CA2A_ A2T_;
	typedef CA2A_ T2A_;
	typedef CA2W_ T2W_;
	typedef CW2A_ W2T_;
	typedef CA2BSTR_ T2BSTR_;
	typedef BSTR2A_ BSTR2T_;
#endif

	typedef A2W_  A2OLE_;
	typedef T2W_  T2OLE_;
	typedef CW2W_ W2OLE_;
	typedef W2A_  OLE2A_;
	typedef W2T_  OLE2T_;
	typedef CW2W_ OLE2W_;

	class CA2W_
	{
	public:
		CA2W_(LPCSTR pStr, UINT codePage = CP_ACP) : m_pStr(pStr)
		{
			if (pStr)
			{
				// Resize the vector and assign null WCHAR to each element
				int length = MultiByteToWideChar(codePage, 0, pStr, -1, NULL, 0) + 1;
				m_vWideArray.assign(length, L'\0');

				// Fill our vector with the converted WCHAR array
				MultiByteToWideChar(codePage, 0, pStr, -1, &m_vWideArray[0], length);
			}
		}
		~CA2W_() {}
		operator LPCWSTR() { return m_pStr ? &m_vWideArray[0] : NULL; }
		//operator LPOLESTR() { return m_pStr ? (LPOLESTR)&m_vWideArray[0] : (LPOLESTR)NULL; }

	private:
		CA2W_(const CA2W_&);
		CA2W_& operator= (const CA2W_&);
		std::vector<wchar_t> m_vWideArray;
		LPCSTR m_pStr;
	};

	class CW2A_
	{
	public:
		CW2A_(LPCWSTR pWStr, UINT codePage = CP_ACP) : m_pWStr(pWStr)
			// Usage:
			//   CW2A_ ansiString(L"Some Text");
			//   CW2A_ utf8String(L"Some Text", CP_UTF8);
			//
			// or
			//   SetWindowTextA( W2A(L"Some Text") ); The ANSI version of SetWindowText
		{
			// Resize the vector and assign null char to each element
			int length = WideCharToMultiByte(codePage, 0, pWStr, -1, NULL, 0, NULL, NULL) + 1;
			m_vAnsiArray.assign(length, '\0');

			// Fill our vector with the converted char array
			WideCharToMultiByte(codePage, 0, pWStr, -1, &m_vAnsiArray[0], length, NULL, NULL);
		}

		~CW2A_()
		{
			m_pWStr = 0;
		}
		operator LPCSTR() { return m_pWStr ? &m_vAnsiArray[0] : NULL; }

	private:
		CW2A_(const CW2A_&);
		CW2A_& operator= (const CW2A_&);
		std::vector<char> m_vAnsiArray;
		LPCWSTR m_pWStr;
	};

	class CW2W_
	{
	public:
		CW2W_(LPCWSTR pWStr) : m_pWStr(pWStr) {}
		operator LPCWSTR() { return const_cast<LPWSTR>(m_pWStr); }
		//operator LPOLESTR() { return const_cast<LPOLESTR>(m_pWStr); }

	private:
		CW2W_(const CW2W_&);
		CW2W_& operator= (const CW2W_&);

		LPCWSTR m_pWStr;
	};

	class CA2A_
	{
	public:
		CA2A_(LPCSTR pStr) : m_pStr(pStr) {}
		operator LPCSTR() { return (LPSTR)m_pStr; }

	private:
		CA2A_(const CA2A_&);
		CA2A_& operator= (const CA2A_&);

		LPCSTR m_pStr;
	};

	/*class CW2BSTR_
	{
	public:
		CW2BSTR_(LPCWSTR pWStr) { m_bstrString = ::SysAllocString(pWStr); }
		~CW2BSTR_() { ::SysFreeString(m_bstrString); }
		operator BSTR() { return m_bstrString; }

	private:
		CW2BSTR_(const CW2BSTR_&);
		CW2BSTR_& operator= (const CW2BSTR_&);
		BSTR m_bstrString;
	};

	class CA2BSTR_
	{
	public:
		CA2BSTR_(LPCSTR pStr) { m_bstrString = ::SysAllocString(textconv_helper::CA2W_(pStr)); }
		~CA2BSTR_() { ::SysFreeString(m_bstrString); }
		operator BSTR() { return m_bstrString; }

	private:
		CA2BSTR_(const CA2BSTR_&);
		CA2BSTR_& operator= (const CA2BSTR_&);
		BSTR m_bstrString;
	};*/
}

#define MAX_SYMBOL_PATH 1024
#define MAX_MODULE_NAME32 255
#define TH32CS_SNAPMODULE 0x00000008
#define MAX_VERSION_LENGTH 512
#define STACKWALK_MAX_NAMELEN 1024

#define ASSERT(judge)\
	{\
		if(!(judge))\
		{\
			DebugBreak();\
		}\
	}

typedef struct tagMODULEENTRY32
{
	DWORD   dwSize;
	DWORD   th32ModuleID;  // This module
	DWORD   th32ProcessID; // owning process
	DWORD   GlblcntUsage;  // Global usage count on the module
	DWORD   ProccntUsage;  // Module usage count in th32ProcessID's context
	BYTE*   modBaseAddr;   // Base address of module in th32ProcessID's context
	DWORD   modBaseSize;   // Size in bytes of module starting at modBaseAddr
	HMODULE hModule;       // The hModule of this module in th32ProcessID's context
	TCHAR   szModule[MAX_MODULE_NAME32 + 1];
	TCHAR   szExePath[MAX_PATH];
} MODULEENTRY32;

typedef struct _MODULEINFO
{
	LPVOID lpBaseOfDll;
	DWORD  SizeOfImage;
	LPVOID EntryPoint;
} MODULEINFO, *LPMODULEINFO;

typedef MODULEENTRY32* PMODULEENTRY32;
typedef MODULEENTRY32* LPMODULEENTRY32;

typedef struct _tag_MODULE_INFO 
{
	DWORD64 ModuleAddress;
	DWORD dwModSize;
	TCHAR szModuleName[MAX_MODULE_NAME32 + 1];
	TCHAR szModulePath[MAX_PATH];
	TCHAR szSymbolPath[MAX_PATH];
	TCHAR szVersion[MAX_VERSION_LENGTH];
	struct _tag_MODULE_INFO* pNext;
}MODULE_INFO, *LPMODULE_INFO;

typedef struct tagSTACKINFO
{
	DWORD64 szFncAddr;
	TCHAR szFileName[MAX_PATH];
	TCHAR szFncName[MAX_PATH];
	unsigned long uFileNum;
	TCHAR    undName[STACKWALK_MAX_NAMELEN];
	TCHAR    undFullName[STACKWALK_MAX_NAMELEN];
	tagSTACKINFO *pNext;
}STACKINFO, *LPSTACKINFO;

class CStackWalker
{
public:
	CStackWalker(HANDLE hProcess = GetCurrentProcess(), WORD wPID = GetCurrentProcessId(), LPCTSTR lpSymbolPath = NULL);
	~CStackWalker(void);
	BOOL LoadSymbol();
	LPMODULE_INFO GetLoadModules();
	void GetModuleInformation(LPMODULE_INFO pmi);

	void FreeModuleInformations(LPMODULE_INFO pmi);
	virtual void OutputString(LPCTSTR lpszFormat, ...);

	LPSTACKINFO StackWalker(HANDLE hThread = GetCurrentThread(), const CONTEXT* context = NULL);
	void FreeStackInformations(LPSTACKINFO psi);

protected:
	LPMODULE_INFO GetModulesTH32();
	LPMODULE_INFO GetModulesPSAPI();
protected:
	HANDLE m_hProcess;
	WORD m_wPID;
	LPTSTR m_lpszSymbolPath;
	BOOL m_bSymbolLoaded;
};

#if defined(_M_IX86)
#ifdef CURRENT_THREAD_VIA_EXCEPTION
#define GET_CURRENT_THREAD_CONTEXT(c, contextFlags)\
do\
{\
	memset(&c, 0, sizeof(CONTEXT));\
	EXCEPTION_POINTERS* pExp = NULL;\
	__try\
	{\
		throw 0;\
	}\
	__except (((pExp = GetExceptionInformation()) ? EXCEPTION_EXECUTE_HANDLER:EXCEPTION_EXECUTE_HANDLER))\
	{\
	}\
	if (pExp != NULL)\
		memcpy(&c, pExp->ContextRecord, sizeof(CONTEXT));\
	c.ContextFlags = contextFlags;\
} while (0);
#else
#define GET_CURRENT_THREAD_CONTEXT(c, contextFlags) \
	do\
	{\
		memset(&c, 0, sizeof(CONTEXT));\
		c.ContextFlags = contextFlags;\
		__asm    call $+5\
		__asm    pop eax\
		__asm    mov c.Eip, eax\
		__asm    mov c.Ebp, ebp\
		__asm    mov c.Esp, esp\
} while (0)
#endif

#else
#define GET_CURRENT_THREAD_CONTEXT(c, contextFlags) \
	do\
	{ \
		memset(&c, 0, sizeof(CONTEXT));\
		c.ContextFlags = contextFlags;\
		RtlCaptureContext(&c);\
} while (0);
#endif