Anton (Все сообщения пользователя)

/* =================================================================== */

/*
** Local configuration. You can use this space to add your redefinitions
** without modifying the main part of the file.
*/


/* =================================================================== */
/* SEH and C++ exceptions should be converted to lua errors
/* =================================================================== */

struct luasehtrans
{

   luasehtrans() throw();
   ~luasehtrans();
   static void onex(void * s) throw();

private:

   // disallow copy/move
   luasehtrans(const luasehtrans &);
   luasehtrans(luasehtrans &&);
   luasehtrans & operator=(const luasehtrans &);
   luasehtrans & operator=(luasehtrans &&);

   void * _bkp;

};

#define LUAI_THROW(L,c) throw (c)

#define LUAI_TRY(L,c,a) \
   try { ::luasehtrans st; a } \
   catch(...) { if ((c)->status == 0) { ::luasehtrans::onex(L); (c)->status = -1; } }

#define luai_jmpbuf int

#include "luaconf.h"
#include "lua.h"
#include "lobject.h"
#include <string>
#include <stdexcept>
#include <eh.h>
#include <windows.h>

struct sehex
{

   sehex(struct _EXCEPTION_POINTERS * pep) throw();
   const std::string & str(void) const throw();

private:

   std::string _str;

};

static const char * ecstr(DWORD ec) throw()
{
   switch(ec)
   {
   case EXCEPTION_ACCESS_VIOLATION: return "ACCESS VIOLATION";
   case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: return "ARRAY BOUNDS EXCEEDED";
   case EXCEPTION_BREAKPOINT: return "DEBUG BREAKPOINT";
   case EXCEPTION_DATATYPE_MISALIGNMENT: return "MISALIGNMENT";
   case EXCEPTION_FLT_DENORMAL_OPERAND: return "FPU DENORMAL OPERAND";
   case EXCEPTION_FLT_DIVIDE_BY_ZERO: return "FPU DIVISION BY ZERO";
   case EXCEPTION_FLT_INEXACT_RESULT: return "FPU INEXACT RESULT";
   case EXCEPTION_FLT_INVALID_OPERATION: return "FPU GENERIC EXCEPTION";
   case EXCEPTION_FLT_OVERFLOW: return "FPU OVERFLOW";
   case EXCEPTION_FLT_STACK_CHECK: return "FPU STACK OVERFLOW";
   case EXCEPTION_FLT_UNDERFLOW: return "FPU UNDERFLOW";
   case EXCEPTION_ILLEGAL_INSTRUCTION: return "ILLEGAL INSTRUCTION";
   case EXCEPTION_IN_PAGE_ERROR: return "PAGE ERROR";
   case EXCEPTION_INT_DIVIDE_BY_ZERO: return "DIVISION BY ZERO";
   case EXCEPTION_INT_OVERFLOW: return "INTEGRAL OVERFLOW";
   case EXCEPTION_INVALID_DISPOSITION: return "INVALID DISPOSITION";
   case EXCEPTION_NONCONTINUABLE_EXCEPTION: return "NONCONTINUABLE EXCEPTION";
   case EXCEPTION_PRIV_INSTRUCTION: return "PRIVILEGED INSTRUCTION";
   case EXCEPTION_SINGLE_STEP: return "DEBUG STEP";
   case EXCEPTION_STACK_OVERFLOW: return "STACK OVERFLOW";
   default: return "UNKNOWN EXCEPTION";
   }
}

sehex::sehex(struct _EXCEPTION_POINTERS * pep) throw()
{
   static const char fmt[] = "%s at address %p";
   try
   {
      ::PEXCEPTION_RECORD per = pep->ExceptionRecord;
      if(per)
      {
         const char * pen = ecstr(per->ExceptionCode);
         int len = _scprintf(fmt, pen, per->ExceptionAddress);
         if(len++ > 0)
         {
            char * pbuf = static_cast<char *>(_alloca(len));
            if(pbuf)
            {
               sprintf_s(pbuf, len, fmt, pen, per->ExceptionAddress);
               _str.assign(pbuf, len - 1);
            }
         }
      }
   }
   catch(...)
   {
      // we shouldn't show to the user a garbage string
      _str.clear();
   }
}

const std::string & sehex::str(void) const throw()
{
   return _str;
}

static void translator(unsigned int, struct _EXCEPTION_POINTERS * pep)
{
   throw sehex(pep);
}

luasehtrans::luasehtrans() throw()
   : _bkp(_set_se_translator(::translator))
{
}

luasehtrans::~luasehtrans()
{
   _set_se_translator(static_cast<_se_translator_function>(_bkp));
}

void luasehtrans::onex(void * vs) throw()
{
   try
   {
      lua_State * s = static_cast<lua_State *>(vs);
      std::exception_ptr pe(std::current_exception());
      if(!(nullptr == pe))
      {
         try
         {
            std::rethrow_exception(pe);
         }
         catch(const sehex & e)
         {
            luaO_pushfstring(s, "%s", e.str().c_str());
         }
         catch(const std::exception & e)
         {
            luaO_pushfstring(s, "%s", e.what());
         }
         catch(...)
         {
            luaO_pushfstring(s, "unrecognized exception");
         }
      }
   }
   catch(...)
   {
   }
}