Assert.hxx

Go to the documentation of this file.

/*
 * Copyright (c) 2001-2004 MUSIC TECHNOLOGY GROUP (MTG)
 *                         UNIVERSITAT POMPEU FABRA
 *
 *
 * 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 2 of the License, or
 * (at your option) any later version.
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#ifndef _ASSERT_
#define _ASSERT_

#include "Err.hxx"

namespace CLAM
{

// Microsoft VisualC++ and ancestror MSC
#ifdef _MSC_VER
#define CLAM_BREAKPOINT {__asm {int 3}}
        
// MetroWorks Code Warrior
#elif defined (__MWERKS__)
#define CLAM_BREAKPOINT {_asm {int 3}}

// GNU GCC
#elif defined (__GNUC__) && (defined  (__i386__) || defined(__x86_64__))
#define CLAM_BREAKPOINT {__asm__ (" int $3 "); }

/* g++ on powerpc linux */
#elif defined (__GNUC__) && defined  (__powerpc__)
#define CLAM_BREAKPOINT {__asm__ (" .long 0x7d821008 "); }

/* g++ on powerpc macosx */ 
#elif defined (__GNUC__) && defined  (__POWERPC__)
#define CLAM_BREAKPOINT {__asm__ (" .long 0x7d821008 "); }

// Insert your compiler here
#else
#warning Breakpoint code unknown for the platform. You can add it defining the CLAM_BREAKPOINT macro at file Assert.hxx.
#define CLAM_BREAKPOINT {}
#endif


#if ! defined(_DEBUG)
#define CLAM_USE_RELEASE_ASSERTS
#endif


#if defined(CLAM_USE_RELEASE_ASSERTS)
#define CLAM_ABORT(message) \
        do { \
                throw CLAM::ErrAssertionFailed( message, __FILE__, __LINE__); \
        } while(0)
#else
#define CLAM_ABORT(message) \
        do { \
                if ( !CLAM::ErrAssertionFailed::breakpointInCLAMAssertEnabled ) { \
                        throw CLAM::ErrAssertionFailed( message, __FILE__, __LINE__); \
                } else { \
                        CLAM::ExecuteAssertFailedHandler ( message, __FILE__, __LINE__); \
                        CLAM_BREAKPOINT; \
                } \
        } while(0)
#endif


#if defined(CLAM_DISABLE_CHECKS)
#define CLAM_BEGIN_CHECK if (0) {
#define CLAM_END_CHECK }
#define CLAM_ASSERT( expression, message )
#define CLAM_WARNING( expression, message )
#else
#define CLAM_BEGIN_CHECK {
#define CLAM_END_CHECK }
#define CLAM_ASSERT( expression, message ) \
        do { \
        if (!(expression)) { \
                CLAM_ABORT(message); \
        } } while (0)
#define CLAM_WARNING( expression, message ) \
        do { \
        if (!(expression)) { \
                CLAM::ExecuteWarningHandler ( message, __FILE__, __LINE__); \
        } } while (0)
#endif


#if defined(CLAM_DISABLE_CHECKS) || defined(CLAM_USE_RELEASE_ASSERTS)
#       define CLAM_BEGIN_DEBUG_CHECK if (0) {
#       define CLAM_END_DEBUG_CHECK }
#       define CLAM_DEBUG_ASSERT( expression, message )
#       define CLAM_DEBUG_WARNING( expression, message )
#else
#       define CLAM_BEGIN_DEBUG_CHECK {
#       define CLAM_END_DEBUG_CHECK }
#       define CLAM_DEBUG_ASSERT( expression, message ) \
                do { \
                if (!(expression)) { \
                        CLAM_ABORT(message); \
                } } while (0)
#       define CLAM_DEBUG_WARNING( expression, message ) \
                do { \
                if (!(expression)) { \
                        CLAM::ExecuteWarningHandler ( message, __FILE__, __LINE__); \
                } } while (0)
#endif


class ErrAssertionFailed : public Err {
public:
        static bool breakpointInCLAMAssertEnabled;

        ErrAssertionFailed(const char* message, const char* filename, int linenumber);
        virtual ~ErrAssertionFailed() throw () { }
};

typedef void (*AssertFailedHandlerType) (const char* message, const char* filename, int lineNumber);
AssertFailedHandlerType SetAssertFailedHandler(AssertFailedHandlerType handler);

void ExecuteAssertFailedHandler(const char* message, const char* filename, int linenumber);

typedef void (*WarningHandlerType) (const char* message, const char* filename, int lineNumber);
WarningHandlerType SetWarningHandler(WarningHandlerType handler);

void ExecuteWarningHandler(const char* message, const char* filename, int linenumber);


}

#endif //_ASSERT_