ircproxy  The Ultimate Cyborg

---

exceptions.h

Go to the documentation of this file.

// ircproxy -- An IRC bouncer.
//
//! @file exceptions.h
//! @brief This file contains the declaration of exception related classes and (debug) macros.
//
// Copyright (C) 2006, 2007 by
//
// Carlo Wood, Run on IRC <carlo@alinoe.com>
// RSA-1024 0x624ACAD5 1997-01-26                    Sign & Encrypt
// Fingerprint16 = 32 EC A7 B6 AC DB 65 A6  F6 F6 55 DD 1C DC FF 61
//
// This file may be distributed under the terms of the Q Public License
// version 1.0 as appearing in the file LICENSE.QPL included in the
// packaging of this file.

#ifndef EXCEPTIONS_H
#define EXCEPTIONS_H

#ifndef USE_PCH
#include "debug.h"
#include <stdexcept>            // std::runtime_error
#include <sstream>              // std::ostringstream
#endif

/*! @brief An exception class
 *
 * An object of this class is thrown if the application tries
 * to resolve a target by name but no such target is known.
 *
 * \sa Target::get_joined_nick, Target::serverside_get_nick, Target::serverside_get_channel, Target::clientside_get_channel, Target::clientside_get_nick
 */
class unknown_target : public virtual std::exception {
public:
  //! Virtual destructor.
  virtual ~unknown_target() throw() { }
  //! Implementation of std::exception::what(). Returns the error message string.
  virtual char const* what(void) const throw() { return "unknown_target"; }
};

/*! @brief An exception class
 *
 * An object of this class is thrown in case a client message
 * causes an unrecoverable error. The result is that the client
 * is disconnected.
 */
class FatalError : public std::exception {
private:
  std::string M_message;        //!< The actual error message string.
public:
  //! Construct a FatalError instance with message string \a message.
  FatalError(std::string const& message) : M_message(message) { }
  //! Virtual destructor.
  virtual ~FatalError() throw() { }
  //! Assignment operator.
  FatalError& operator=(FatalError const& error) { M_message = error.M_message; return *this; }
  //! Implementation of std::exception::what(). Returns the error message string.
  virtual char const* what(void) const throw() { return M_message.c_str(); }
};

//! @brief Namespace with utilities copied from the edragon project.
namespace edragon {

// Declaration, specifying the noreturn attribute.
// "Indeed, 'throw' is a noreturn function" -- Richard Henderson, 2004/05/07.
// According to this, and other gcc developers, specifying that a function does NOT throw
// speeds up the code a little bit - however, there is no difference between specifying
// what a function throws and specifying nothing; except when then the function indeed
// throws at runtime, in which case it is slower because the code has to check if the
// thrown exception is one of the expected ones.
// Therefore it is best to not specify that this function throws `exception'.
template<class E>
  void throw_exception(E const& exception, std::string const& debug_msg) __attribute__ ((noreturn));

#if defined(CWDEBUG) || defined(DOXYGEN)
/*!
 * @internal
 * @brief Throw an exception.
 *
 * @param exception The exception to be thrown.
 * @param debug_msg A simple string for debugging purposes, to clarify the reason why the exception is thrown.
 *
 * Debug output has the form:
 *
 * EXCEPTIONS: &lt;debug_msg&gt;, throwing exception "<exception.what()>".
 *
 * Don't use this function directly, instead use the macro THROW_EXCEPTION.
 */
template<class E>
  void throw_exception(E const& exception, std::string const& debug_msg)
  {
#if CWDEBUG_LOCATION
    libcwd::location_ct loc((char*)__builtin_return_address(0) + libcwd::builtin_return_address_offset);
#else
    void* loc = (char*)__builtin_return_address(0) + libcwd::builtin_return_address_offset;
#endif
    Dout(dc::exceptions, loc << ": " << debug_msg << ", throwing exception \"" << exception.what() << "\".");
    throw exception; 
  }

/*! @brief Throw an exception.
 *
 * Always use this macro to throw an exception in eDragon.
 * @param exception The exception to be thrown.
 * @param debug_msg A simple string for debugging purposes, to clarify the reason why the exception is thrown.
 *
 * Debug output has the form:
 *
 * EXCEPTIONS: [&lt;addr location&gt;: ]&lt;debug_msg&gt;, throwing exception "<exception.what()>".
 */
#define THROW_EXCEPTION(exception, debug_msg...) \
    do { \
      std::ostringstream __ssbuf; \
      __ssbuf << debug_msg; \
      edragon::throw_exception(exception, __ssbuf.str()); \
    } while (0)
#else
#define THROW_EXCEPTION(exception, debug_msg...) \
    do { throw exception; } while (0)
#endif

#ifdef CWDEBUG
/*! @brief Debugging function.
 *
 * Print location that this function was called from and what \a exception was caught there.
 */
template<class E>
  void caught(E const& exception)
  {
#if CWDEBUG_LOCATION
    libcwd::location_ct loc((char*)__builtin_return_address(0) + libcwd::builtin_return_address_offset);
#else
    void* loc = (char*)__builtin_return_address(0) + libcwd::builtin_return_address_offset;
#endif
    Dout(dc::exceptions, loc << ": caught exception \"" << exception.what() << "\".");
  }
#endif

} // namespace edragon

#endif // EXCEPTIONS_H

---