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

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

/ * 
 *  *   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( .. .)
   {
   }
}