TracedException.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------------
//
// Pro-Vocation Light Engine (PVLE)
// Copyright (C) 2007-2009  Sukender, KinoX & Buzib
// For more information, contact us : sukender@free.fr
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// For any use that is not compatible with the terms of the GNU 
// General Public License, please contact the authors for alternative
// licensing options.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//-----------------------------------------------------------------------------------


#ifndef UTIL_PVEXCEPTION_H
#define UTIL_PVEXCEPTION_H

#include <PVLE/Export.h>
#include <PVLE/Config.h>


#include <exception>
#include <stdexcept>
#include <string>
#include <PVLE/Util/Log.h>  // for __PVLE_METHOD__



//msvc is a bit more strict on types cast than g++, so you may have to add explicit cast in the following file to avoid warnings:)
#include <boost/format.hpp>






// Supress the annoying "'class' : multiple default constructors specified" warning with msvc before 8.0
#if defined(_MSC_VER) && (_MSC_VER<1400)
    #pragma warning(push)
    #pragma warning(disable : 4520)
#endif





//choose asynchronous method to be used
#ifdef WIN32
#ifndef MINGW
    #define TRACED_EXCEPTION_USES_SEH
#endif  //MINGW
#endif  //WIN32



#ifdef TRACED_EXCEPTION_USES_SEH
    //Windows uses SEH, so if we wanna catch system raised exceptions, we have to install a translator

    #include <eh.h>

    //This is directly copied from <eh.h>
    //struct _EXCEPTION_POINTERS;
    //typedef void (__cdecl *_se_translator_function)(unsigned int, struct _EXCEPTION_POINTERS*);

    #define INIT_TRACED_EXCEPTIONS _set_se_translator(TracedException::SE_Translator)

#else
    //Linux uses kernel signals to report asynchronous exceptions
    #include <signal.h>

    // seg faults, illegal instructions, and floating point exceptions:
    #define INIT_TRACED_EXCEPTIONS  signal(SIGSEGV,TracedException::SignalHandler); \
                                    signal(SIGILL,TracedException::SignalHandler); \
                                    signal(SIGFPE,TracedException::SignalHandler);
#endif //TRACED_EXCEPTION_USES_SEH


#define THROW_TRACED_EXCEPTION(Reason)                          throw TracedException(Reason, __PVLE_METHOD__)

#define THROW_TRACED_FMT_EXCEPTION(Reason, Args)                throw TracedException( boost::format(Reason) % Args, __PVLE_METHOD__)

#define THROW_TRACED_EXCEPTION_FROM(Reason, FunctionName)       throw TracedException(Reason, FunctionName)

#define THROW_TRACED_FMT_EXCEPTION_FROM(Reason, FunctionName, Args)     throw TracedException( boost::format(Reason) % Args, FunctionName)


#define CATCH_TRACED_EXCEPTION_FROM(FunctionName)               catch( TracedException &e ) { e.UpdateFunctionStack(FunctionName); throw e; }   \
                                                                catch( std::exception &e )  { throw TracedException(e.what(), FunctionName); }  \
                                                                catch( std::string &e )     { throw TracedException(e       , FunctionName); }  \
                                                                catch( char * e )           { throw TracedException(e       , FunctionName); }  \
                                                                catch(...)                  { throw TracedException("Undefined Exception", FunctionName); }

#define CATCH_TRACED_EXCEPTION                                  CATCH_TRACED_EXCEPTION_FROM(__PVLE_METHOD__)


#define TRY_BLOCK_START                                     try {
#define CATCH_CUSTOM_EXCEPTION(FilterName)                  } catch(FilterName) {
#define TRY_BLOCK_END                                       } CATCH_TRACED_EXCEPTION
#define TRY_BLOCK_END_FROM(FunctionName)                    } CATCH_TRACED_EXCEPTION(FunctionName)


// Macro for debug or non time-critical guarded functions.
#if ENABLE_DEBUG_EXCEPTION_TRACE
    #define DBG_TRY_BLOCK_START                     TRY_BLOCK_START
    #define DBG_CATCH_CUSTOM_EXCEPTION(FilterName)  CATCH_CUSTOM_EXCEPTION(FilterName)
    #define DBG_TRY_BLOCK_END                       TRY_BLOCK_END
    #define DBG_TRY_BLOCK_END_FROM(FunctionName)    TRY_BLOCK_END_FROM(FunctionName)
#else
    #define DBG_TRY_BLOCK_START                     ((void)0);
    #define DBG_CATCH_CUSTOM_EXCEPTION(FilterName)  ((void)0);
    #define DBG_TRY_BLOCK_END                       ((void)0);
    #define DBG_TRY_BLOCK_END_FROM(FunctionName)    ((void)0);
#endif


class PVLE_EXPORT TracedException : public std::runtime_error
{

public:

    //Structors
    TracedException( const std::string& strReason = "Unknown Exception",
            const std::string& strFuncName = "");                           
    TracedException( const boost::format& fmtReason,
            const std::string& strFuncName = "");                           
    virtual ~TracedException() throw();                                     


    //Accessors
    const std::string& GetReason() const;                                   
    const std::string GetClassStack() const;                                


    //Actuators
    void UpdateFunctionStack( const std::string& strFuncName );             


#ifdef TRACED_EXCEPTION_USES_SEH
    // For asynchronous exception handling in windows
    static void SE_Translator(unsigned int SE_e, _EXCEPTION_POINTERS* pExp );       
#else
    //For asynchronous exception handling in linux
    static void SignalHandler(int sigint);                                          
#endif  //TRACED_EXCEPTION_USES_SEH

private:

    std::string m_Reason;                                                   
    std::vector<std::string> m_FuncStack;                                   

};


// Restore warnings
#if defined(_MSC_VER) && (_MSC_VER<1400)
    #pragma warning(pop)
#endif


#endif  // UTIL_PVEXCEPTION_H

---