DebugFunctions.cpp

#include "DebugFunctions.h"
 
#include <sstream>
 
#include <ctime>
#include <iomanip>
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/Unicode.h"
 
#include "Context.h"
 
using namespace Cogs::Core;
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("DebugFunctions");
 
#ifdef _WIN32
  std::string getTimeStamp()
  {
    auto currentTime = std::time(nullptr);
 
#ifdef _WIN32
    tm gmTime_s;
    gmtime_s(&gmTime_s, &currentTime);
    auto gmTime = &gmTime_s;
#else
    auto gmTime = std::gmtime(&currentTime);
#endif
 
    std::stringstream ss;
 
    ss << std::setfill('0');
 
    ss << 1900 + gmTime->tm_year << "-";
    ss << std::setw(2) << gmTime->tm_mon + 1 << "-";
    ss << std::setw(2) << gmTime->tm_mday << " ";
 
    ss << std::setw(2) << gmTime->tm_hour << "-";
    ss << std::setw(2) << gmTime->tm_min << "-";
    ss << std::setw(2) << gmTime->tm_sec << " ";
 
    return ss.str();
  }
#endif
}
 
#ifdef _WIN32
 
void createMiniDump(BridgeContext* ctx, EXCEPTION_POINTERS * exceptionPointers)
{
  auto context = static_cast<Context*>(ctx);
  LOG_ERROR(logger, "Exception caught in native code. Creating mini dump file.");
 
  auto path = context->debug.miniDumpPath + std::string("/") + getTimeStamp() + context->debug.miniDumpName + std::string(".dmp");
 
  auto fileHandle = ::CreateFileW(Cogs::widen(path).c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 
  if ((fileHandle != NULL) && (fileHandle != INVALID_HANDLE_VALUE)) {
    MINIDUMP_EXCEPTION_INFORMATION exceptionInfo;
 
    exceptionInfo.ThreadId = ::GetCurrentThreadId();
    exceptionInfo.ExceptionPointers = exceptionPointers;
    exceptionInfo.ClientPointers = FALSE;
 
    MINIDUMP_TYPE miniDumpType = MiniDumpNormal;
 
    auto result = ::MiniDumpWriteDump(::GetCurrentProcess(), ::GetCurrentProcessId(), fileHandle, miniDumpType, &exceptionInfo, 0, 0);
 
    if (result) {
      LOG_INFO(logger, "Mini dump written successfully to %s.", path.c_str());
    }
    else {
      LOG_ERROR(logger, "Error writing mini dump to %s. Possible reasons are stack corruption, insufficient disk space.", path.c_str());
    }
 
    ::CloseHandle(fileHandle);
  }
  else {
    LOG_ERROR(logger, "Error accessing mini dump file path at %s. Check for sufficient disk permissions.", path.c_str());
  }
}
 
#else
 
void createMiniDump(BridgeContext* /*context*/)
{
  // Noop
}
 
#endif
 
void
enableExecutionChecks(BridgeContext* ctx, CogsBool enabled)
{
  auto context = static_cast<Context*>(ctx);
 
  context->debug.enableExecutionChecks = enabled;
}
 
void
setMiniDumpPath(BridgeContext* ctx, const char * path)
{
  auto context = static_cast<Context*>(ctx);
 
  context->debug.miniDumpPath = std::string(path);
}
 
void
setMiniDumpName(BridgeContext* ctx, const char * name)
{
  auto context = static_cast<Context*>(ctx);
 
  context->debug.miniDumpName = std::string(name);
}
 
namespace
{
  void accessViolationMethod()
  {
    LOG_DEBUG(logger, "Initiating access violation.");
 
    int * iPtr = (int *) 0;
    int i = *iPtr;
 
    // Make sure i is actually accessed.
    LOG_ERROR(logger, "Could not trigger access violation of variable %d.", i);
  }
}
 
void
triggerAccessViolation(BridgeContext* ctx)
{
  auto context = static_cast<Context*>(ctx);
 
  if (context->debug.enableExecutionChecks) {
    CHECKED(context, accessViolationMethod());
  } else {
    accessViolationMethod();
  }
}