PVLE (Pro-Vocation Light Engine): TracedException.cpp Source File

00001 //-----------------------------------------------------------------------------------
00002 //
00003 // Pro-Vocation Light Engine (PVLE)
00004 // Copyright (C) 2007-2009  Sukender, KinoX & Buzib
00005 // For more information, contact us : sukender@free.fr
00006 //
00007 // This program is free software; you can redistribute it and/or modify
00008 // it under the terms of the GNU General Public License as published by
00009 // the Free Software Foundation; either version 3 of the License, or
00010 // (at your option) any later version.
00011 //
00012 // For any use that is not compatible with the terms of the GNU 
00013 // General Public License, please contact the authors for alternative
00014 // licensing options.
00015 //
00016 // This program is distributed in the hope that it will be useful,
00017 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00018 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00019 // GNU General Public License for more details.
00020 //
00021 // You should have received a copy of the GNU General Public License along
00022 // with this program; if not, write to the Free Software Foundation, Inc.,
00023 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
00024 //
00025 //-----------------------------------------------------------------------------------
00026 
00029 
00030 #include <PVLE/Util/TracedException.h>
00031 #include <PVLE/Util/Util.h>
00032 
00033 //Commented because unecessary... 
00034 //#ifdef TRACED_EXCEPTION_USES_SEH
00036 //#ifndef EXCEPTION_DATATYPE_MISALIGNMENT           // To avoid warning if they are already defined
00037 //
00038 //#define EXCEPTION_DATATYPE_MISALIGNMENT     ((int   )0x80000002L)
00039 //#define EXCEPTION_ACCESS_VIOLATION          ((int   )0xC0000005L)
00040 //#define EXCEPTION_IN_PAGE_ERROR             ((int   )0xC0000006L)
00041 //#define EXCEPTION_INVALID_HANDLE            ((int   )0xC0000008L)
00042 //#define EXCEPTION_ILLEGAL_INSTRUCTION       ((int   )0xC000001DL)
00043 //#define EXCEPTION_NONCONTINUABLE_EXCEPTION  ((int   )0xC0000025L)
00044 //#define EXCEPTION_INVALID_DISPOSITION       ((int   )0xC0000026L)
00045 //#define EXCEPTION_ARRAY_BOUNDS_EXCEEDED     ((int   )0xC000008CL)
00046 //#define EXCEPTION_FLT_DENORMAL_OPERAND        ((int   )0xC000008DL)
00047 //#define EXCEPTION_FLT_DIVIDE_BY_ZERO      ((int   )0xC000008EL)
00048 //#define EXCEPTION_FLT_INEXACT_RESULT      ((int   )0xC000008FL)
00049 //#define EXCEPTION_FLT_INVALID_OPERATION       ((int   )0xC0000090L)
00050 //#define EXCEPTION_FLT_OVERFLOW                ((int   )0xC0000091L)
00051 //#define EXCEPTION_FLT_STACK_CHECK         ((int   )0xC0000092L)
00052 //#define EXCEPTION_FLT_UNDERFLOW               ((int   )0xC0000093L)
00053 //#define EXCEPTION_INT_DIVIDE_BY_ZERO      ((int   )0xC0000094L)
00054 //#define EXCEPTION_INT_OVERFLOW                ((int   )0xC0000095L)
00055 //#define EXCEPTION_PRIV_INSTRUCTION            ((int   )0xC0000096L)
00056 //#define EXCEPTION_STACK_OVERFLOW            ((int   )0xC00000FDL)
00057 //
00058 //#endif    // EXCEPTION_DATATYPE_MISALIGNMENT
00059 //#endif    // TRACED_EXCEPTION_USES_SEH
00060 
00061 /*-------------------- Structors --------------------*/
00062 
00063 
00064 TracedException::TracedException( const std::string& strReason, const std::string& strFuncName ) :
00065 m_Reason(strReason), runtime_error(strReason)
00066 {
00067     UpdateFunctionStack(strFuncName);
00068 }
00069 
00070 
00071 TracedException::TracedException( const boost::format& fmtReason, const std::string& strFuncName) :
00072     m_Reason(fmtReason.str()), runtime_error(fmtReason.str())
00073 {
00074     UpdateFunctionStack(strFuncName);
00075 }
00076 
00077 
00078 
00079 TracedException::~TracedException() throw()
00080 {
00081 }
00082 
00083 
00084 
00085 
00086 /*-------------------- Accessors --------------------*/
00087 
00088 
00089 const std::string& TracedException::GetReason() const
00090 {
00091     return m_Reason;
00092 }
00093 
00094 const std::string TracedException::GetClassStack() const
00095 {
00096     std::string strStack;
00097     std::vector<std::string>::const_reverse_iterator cit;
00098 
00099     //to speed up string aggregation
00100     strStack.reserve(4000);
00101     
00102     //build a string from the function stack (frome vector end to vector start)
00103     for( cit = m_FuncStack.rbegin(); cit != m_FuncStack.rend(); ++cit)
00104     {
00105         strStack += *(cit);                         //aggregate function name
00106         if ( *(cit) != m_FuncStack.front() ) strStack += "->";
00107     }
00108 
00109     
00110 
00111     return strStack;
00112 }
00113 
00114 
00115 
00116 #ifdef TRACED_EXCEPTION_USES_SEH
00117 
00118 #ifdef WIN32
00119     #ifndef WIN32_LEAN_AND_MEAN
00120         #define WIN32_LEAN_AND_MEAN     // Exclude rarely-used stuff from Windows headers
00121     #endif
00122     #include <windows.h>
00123 #endif
00124 
00125 //Windows SEH Asynchronous exception handler
00126 void TracedException::SE_Translator(unsigned int SE_e, _EXCEPTION_POINTERS* pExp )
00127 {
00128     //Build reason string
00129     std::string strExcept("Asynchroneous exception ");
00130     std::string strAddress("(0x????????)");
00131 
00133     switch(SE_e)
00134     {
00135     case EXCEPTION_DATATYPE_MISALIGNMENT:
00136         strExcept += "EXCEPTION_DATATYPE_MISALIGNMENT";
00137         break;
00138     case EXCEPTION_ACCESS_VIOLATION:
00139         strExcept += "EXCEPTION_ACCESS_VIOLATION";
00140         break;
00141     case EXCEPTION_IN_PAGE_ERROR:
00142         strExcept += "EXCEPTION_IN_PAGE_ERROR";
00143         break;
00144     case EXCEPTION_INVALID_HANDLE:
00145         strExcept += "EXCEPTION_INVALID_HANDLE";
00146         break;
00147     case EXCEPTION_ILLEGAL_INSTRUCTION:
00148         strExcept += "EXCEPTION_ILLEGAL_INSTRUCTION";
00149         break;
00150     case EXCEPTION_NONCONTINUABLE_EXCEPTION:
00151         strExcept += "EXCEPTION_NONCONTINUABLE_EXCEPTION";
00152         break;
00153     case EXCEPTION_INVALID_DISPOSITION:
00154         strExcept += "EXCEPTION_INVALID_DISPOSITION";
00155         break;
00156     case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
00157         strExcept += "EXCEPTION_ARRAY_BOUNDS_EXCEEDED";
00158         break;
00159     case EXCEPTION_FLT_DENORMAL_OPERAND:
00160         strExcept += "EXCEPTION_FLT_DENORMAL_OPERAND";
00161         break;
00162     case EXCEPTION_FLT_DIVIDE_BY_ZERO:
00163         strExcept += "EXCEPTION_FLT_DIVIDE_BY_ZERO";
00164         break;
00165     case EXCEPTION_FLT_INEXACT_RESULT:
00166         strExcept += "EXCEPTION_FLT_INEXACT_RESULT";
00167         break;
00168     case EXCEPTION_FLT_INVALID_OPERATION:
00169         strExcept += "EXCEPTION_FLT_INVALID_OPERATION";
00170         break;
00171     case EXCEPTION_FLT_OVERFLOW:
00172         strExcept += "EXCEPTION_FLT_OVERFLOW";
00173         break;
00174     case EXCEPTION_FLT_STACK_CHECK:
00175         strExcept += "EXCEPTION_FLT_STACK_CHECK";
00176         break;
00177     case EXCEPTION_FLT_UNDERFLOW:
00178         strExcept += "EXCEPTION_FLT_UNDERFLOW";
00179         break;
00180     case EXCEPTION_INT_DIVIDE_BY_ZERO:
00181         strExcept += "EXCEPTION_INT_DIVIDE_BY_ZERO";
00182         break;
00183     case EXCEPTION_INT_OVERFLOW:
00184         strExcept += "EXCEPTION_INT_OVERFLOW";
00185         break;
00186     case EXCEPTION_PRIV_INSTRUCTION:
00187         strExcept += "EXCEPTION_PRIV_INSTRUCTION";
00188         break;
00189     case EXCEPTION_STACK_OVERFLOW:
00190         strExcept += "EXCEPTION_STACK_OVERFLOW";
00191         break;
00192     default:
00193         //Other exceptions ar marked as unknown
00195         strExcept += "EXCEPTION_UNKNOWN";
00196         return;
00197     }
00198 
00199     //build function stream using current excecution address
00200     if (pExp)
00201     {
00202         strAddress = str(boost::format("(0x%08X)") % pExp->ContextRecord->Eip);
00203     }
00204 
00205 
00206     //Rethrow our exception in a C++ fashion
00207     throw TracedException( strExcept, strAddress);
00208 }
00209 
00210 
00211 #else 
00212 
00213 void TracedException::SignalHandler(int sigint)
00214 {
00215     //Build reason string
00216     std::string strExcept("Asynchroneous exception ");
00217     std::string strAddress("(0x????????)");
00218 
00219     switch(sigint)
00220     {
00221     case SIGSEGV:
00222         strExcept += "SIGSEGV";
00223         break;
00224     case SIGILL:
00225         strExcept += "SIGILL";
00226         break;
00227     case SIGFPE:
00228         strExcept += "SIGFPE";
00229         break;
00230     default:
00231         strExcept += "EXCEPTION_UNKNOWN";
00232         return;
00233     }
00234 
00236 
00237     //Rethrow our exception in a C++ fashion
00238     throw TracedException( strExcept, strAddress);
00239 }
00240 
00241 #endif //TRACED_EXCEPTION_USES_SEH
00242 
00243 /*-------------------- Actuators --------------------*/
00244 void TracedException::UpdateFunctionStack( const std::string& strFuncName )
00245 {
00246     m_FuncStack.push_back(strFuncName);
00247 }