#include "cpsInternal.h"

#include "cpsUtils.h"

#include <vector>

#include <algorithm>

#if defined(_WIN32) && !defined(cpsWithoutDbgHelp)

std::string cpsExceptionToSymbolNames(EXCEPTION_POINTERS *ep)

{

EXCEPTION_RECORD &er = *ep->ExceptionRecord;

CONTEXT &context = *ep->ContextRecord;

HANDLE hProcess = GetCurrentProcess();

HANDLE hThread = GetCurrentThread();

STACKFRAME64 stackFrame;

memset(&stackFrame, 0, sizeof(stackFrame));

#if defined(_M_IX86)

DWORD machineType = IMAGE_FILE_MACHINE_I386;

stackFrame.AddrPC.Offset = context.Eip;

stackFrame.AddrPC.Mode = AddrModeFlat;

stackFrame.AddrFrame.Offset = context.Ebp;

stackFrame.AddrFrame.Mode = AddrModeFlat;

stackFrame.AddrStack.Offset = context.Esp;

stackFrame.AddrStack.Mode = AddrModeFlat;

#elif defined(_M_X64)

DWORD machineType = IMAGE_FILE_MACHINE_AMD64;

stackFrame.AddrPC.Offset = context.Rip;

stackFrame.AddrPC.Mode = AddrModeFlat;

stackFrame.AddrFrame.Offset = context.Rbp;

stackFrame.AddrFrame.Mode = AddrModeFlat;

stackFrame.AddrStack.Offset = context.Rsp;

stackFrame.AddrStack.Mode = AddrModeFlat;

#endif

std::string ret;

char buf[cpsMaxSymName];

{

cpsAddressToSymbolName(er.ExceptionAddress, buf, sizeof(buf));

ret += buf;

}

for (;;)

{

if (StackWalk64(machineType, hProcess, hThread, &stackFrame, &context, NULL, NULL, NULL, NULL) == FALSE ||

stackFrame.AddrPC.Offset == stackFrame.AddrReturn.Offset ||

stackFrame.AddrPC.Offset == 0 ||

stackFrame.AddrReturn.Offset == 0)

{

break;

}

cpsAddressToSymbolName((void*)stackFrame.AddrReturn.Offset, buf, sizeof(buf));

ret += buf;

}

return ret;

}

cpsAPI DWORD cpsSEHHandler(EXCEPTION_POINTERS *ep)

{

std::string message;

message += "CppScript: crash!!!\n";

message += cpsExceptionToSymbolNames(ep);

cpsDebugPrint(message.c_str());

return EXCEPTION_EXECUTE_HANDLER;

}

#endif

cpsAPI void cpsAddressToSymbolName(void *addr, char *out_name, size_t out_len)

{

// currently windows only

#ifdef _WIN32

#if defined(_M_IX86)

typedef DWORD DWORDX;

typedef PDWORD PDWORDX;

#elif defined(_M_X64)

typedef DWORD64 DWORDX;

typedef PDWORD64 PDWORDX;

#endif

HANDLE process = ::GetCurrentProcess();

IMAGEHLP_MODULE imageModule = { sizeof(IMAGEHLP_MODULE) };

IMAGEHLP_LINE line = { sizeof(IMAGEHLP_LINE) };

DWORDX dispSym = 0;

DWORD dispLine = 0;

char symbolBuffer[sizeof(IMAGEHLP_SYMBOL) + cpsMaxSymName] = { 0 };

IMAGEHLP_SYMBOL * imageSymbol = (IMAGEHLP_SYMBOL*)symbolBuffer;

imageSymbol->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL);

imageSymbol->MaxNameLength = MAX_PATH;

if (!::SymGetModuleInfo(process, (DWORDX)addr, &imageModule)) {

_snprintf(out_name, out_len, "[0x%p]\n", addr);

}

else if (!::SymGetSymFromAddr(process, (DWORDX)addr, &dispSym, imageSymbol)) {

_snprintf(out_name, out_len, "%s + 0x%x [0x%p]\n", imageModule.ModuleName, ((size_t)addr - (size_t)imageModule.BaseOfImage), addr);

}

else if (!::SymGetLineFromAddr(process, (DWORDX)addr, &dispLine, &line)) {

_snprintf(out_name, out_len, "%s!%s + 0x%x [0x%p]\n", imageModule.ModuleName, imageSymbol->Name, ((size_t)addr - (size_t)imageSymbol->Address), addr);

}

else {

_snprintf(out_name, out_len, "%s(%d): %s!%s + 0x%x [0x%p]\n", line.FileName, line.LineNumber,

imageModule.ModuleName, imageSymbol->Name, ((size_t)addr - (size_t)imageSymbol->Address), addr);

}

#else

snprintf(out_name, out_len, "[0x%p]\n", addr);

#endif

}

static inline std::string cpsStringizeArgTypes(cpsMethod mt)

{

std::string ret;

bool first = true;

mt.eachArgTypes([&](cpsType &t){

if (!first) { ret += ", "; }

first = false;

ret += t.getName();

});

return ret;

}

static inline std::string cpsStringizeMethodAttributes(cpsMethod mt)

{

std::string ret;

if (mt.isVirtual()) { ret += "virtual "; }

if (mt.isStatic()) { ret += "static "; }

return ret;

}

cpsAPI void cpsDumpClassStructure(cpsClass cpsc)

{

cpsDebugPrint("class %s\n", cpsc.getName());

cpsDebugPrint("methods:\n");

cpsc.eachMethodsUpwards([&](cpsMethod &m, cpsClass &c){

cpsDebugPrint(" %s%s::%s(%s) : %s\n", cpsStringizeMethodAttributes(m).c_str(), c.getName(), m.getName(), cpsStringizeArgTypes(m).c_str(), m.getReturnType().getName());

});

cpsDebugPrint("properties:\n");

cpsc.eachPropertiesUpwards([&](cpsProperty &m, cpsClass &c){

cpsDebugPrint(" %s::%s\n", c.getName(), m.getName());

if (cpsMethod getter = m.getGetter()) {

cpsDebugPrint(" getter(%s) : %s\n", cpsStringizeArgTypes(getter).c_str(), getter.getReturnType().getName());

}

if (cpsMethod setter = m.getSetter()) {

cpsDebugPrint(" setter(%s) : %s\n", cpsStringizeArgTypes(setter).c_str(), setter.getReturnType().getName());

}

});

cpsDebugPrint("fields:\n");

cpsc.eachFieldsUpwards([&](cpsField &m, cpsClass &c){

cpsDebugPrint(" %s::%s : %s\n", c.getName(), m.getName(), m.getType().getName());

});

}

cpsAPI void cpsDebugPrint(const char *format, ...)

{

va_list args;

va_start(args, format);

char buf[1024 * 8];

vsprintf(buf, format, args);

//UnityEngine::Debug::Log(cpsString::create(buf));

#ifdef WIN32

::OutputDebugStringA(buf);

#else // WIN32

puts(buf);

#endif // WIN32

va_end(args);

}

struct cpsCaches

{

std::vector<cpsCachedImage*> images;

std::vector<cpsCachedClass*> classes;

std::vector<cpsCachedField*> fields;

std::vector<cpsCachedMethod*> methods;

std::vector<cpsCachedProperty*> properties;

} g_cpsCaches;

cpsAPI void cpsClearCache()

{

for (auto o : g_cpsCaches.images) { o->mimage = nullptr; }

for (auto o : g_cpsCaches.classes) { o->mclass = nullptr; }

for (auto o : g_cpsCaches.fields) { o->mfield = nullptr; }

for (auto o : g_cpsCaches.methods) { o->mmethod = nullptr; }

for (auto o : g_cpsCaches.properties) { o->mproperty = nullptr; }

}

cpsCachedImage::cpsCachedImage() : cpsImage(nullptr)

{

g_cpsCaches.images.push_back(this);

}

cpsCachedImage::~cpsCachedImage()

{

g_cpsCaches.images.erase(std::find(g_cpsCaches.images.begin(), g_cpsCaches.images.end(), this));

}

cpsCachedClass::cpsCachedClass() : cpsClass(nullptr)

{

g_cpsCaches.classes.push_back(this);

}

cpsCachedClass::~cpsCachedClass()

{

g_cpsCaches.classes.erase(std::find(g_cpsCaches.classes.begin(), g_cpsCaches.classes.end(), this));

}

cpsCachedField::cpsCachedField() : cpsField(nullptr)

{

g_cpsCaches.fields.push_back(this);

}

cpsCachedField::~cpsCachedField()

{

g_cpsCaches.fields.erase(std::find(g_cpsCaches.fields.begin(), g_cpsCaches.fields.end(), this));

}

cpsCachedMethod::cpsCachedMethod() : cpsMethod(nullptr)

{

g_cpsCaches.methods.push_back(this);

}

cpsCachedMethod::~cpsCachedMethod()

{

g_cpsCaches.methods.erase(std::find(g_cpsCaches.methods.begin(), g_cpsCaches.methods.end(), this));

}

cpsCachedProperty::cpsCachedProperty() : cpsProperty(nullptr)

{

g_cpsCaches.properties.push_back(this);

}

cpsCachedProperty::~cpsCachedProperty()

{

g_cpsCaches.properties.erase(std::find(g_cpsCaches.properties.begin(), g_cpsCaches.properties.end(), this));

}