error.h

Go to the documentation of this file.

/* 
 * Scythe Statistical Library Copyright (C) 2000-2002 Andrew D. Martin
 * and Kevin M. Quinn; 2002-present Andrew D. Martin, Kevin M. Quinn,
 * and Daniel Pemstein.  All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify under the terms of the GNU General Public License as
 * published by Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.  See the text files
 * COPYING and LICENSE, distributed with this source code, for further
 * information.
 * --------------------------------------------------------------------
 *  scythestat/error.h
 */
 
#ifndef SCYTHE_ERROR_H
#define SCYTHE_ERROR_H

#include <exception>
#include <string>
#include <sstream>
#include <iostream>
#include <vector>
#include <cstring>

#ifdef SCYTHE_RPACK
#include <R.h>           // needed to use Rprintf()
#include <R_ext/Utils.h> // needed to allow user interrupts
#endif

#ifdef SCYTHE_DEBUG_LIB
#define SCYTHE_DEBUG_MSG(MSG)                             \
{ std::cout << "SCYTHE_DEBUG_LIB: " << MSG << std::endl; }
#else
#define SCYTHE_DEBUG_MSG(MSG)
#endif

#define SCYTHE_THROW(EXCEP,MSG)                           \
  {                                                       \
    std::stringstream _SCYTHE_DEBUG_ss;                   \
    _SCYTHE_DEBUG_ss << MSG;                              \
    throw EXCEP(__FILE__, __func__, __LINE__,             \
        _SCYTHE_DEBUG_ss.str());                          \
  }

#define SCYTHE_CHECK(CHECK,EXCEP,MSG)                     \
{                                                         \
  if (CHECK)                                              \
    SCYTHE_THROW(EXCEP,MSG)                               \
}

#define SCYTHE_WARN_RPACK(MSG)                                        \
  {                                                                   \
    std::stringstream _SCYTHE_WARN_ss;                                \
    _SCYTHE_WARN_ss << "WARNING in " << __FILE__ << ", "              \
      << __func__ << ", " << __LINE__ << ": "                         \
      << MSG << "\n";                                                 \
    Rprintf(_SCYTHE_WARN_ss.str().c_str());                           \
  }

#define SCYTHE_WARN_STD(MSG)                                          \
  std::cerr << "WARNING in " << __FILE__ << ", "                      \
    << __func__ << ", " << __LINE__ << ": "                           \
    << MSG << "\n";

#ifdef SCYTHE_RPACK
#define SCYTHE_WARN SCYTHE_WARN_RPACK
#else
#define SCYTHE_WARN SCYTHE_WARN_STD
#endif

#define SCYTHE_CHECK_WARN(CHECK,MSG)                                  \
  {                                                                   \
  if (CHECK)                                                          \
    SCYTHE_WARN(MSG)                                                  \
  }

#ifndef SCYTHE_DEBUG
#define SCYTHE_DEBUG 3
#endif

#if SCYTHE_DEBUG > 0
#define SCYTHE_CHECK_10(CHECK,EXCEP,MSG) SCYTHE_CHECK(CHECK,EXCEP,MSG)
#else
#define SCYTHE_CHECK_10(CHECK, EXCEP, MSG)
#endif

#if SCYTHE_DEBUG > 1
#define SCYTHE_CHECK_20(CHECK,EXCEP,MSG) SCYTHE_CHECK(CHECK,EXCEP,MSG)
#else
#define SCYTHE_CHECK_20(CHECK, EXCEP, MSG)
#endif

#if SCYTHE_DEBUG > 2
#define SCYTHE_CHECK_30(CHECK,EXCEP,MSG) SCYTHE_CHECK(CHECK,EXCEP,MSG)
#else
#define SCYTHE_CHECK_30(CHECK, EXCEP, MSG)
#endif

#if SCYTHE_DEBUG > 0 
#define SCYTHE_THROW_10(EXCEP,MSG) SCYTHE_THROW(EXCEP,MSG)
#else
#define SCYTHE_THROW_10(EXCEP,MSG)
#endif

#if SCYTHE_DEBUG > 1 
#define SCYTHE_THROW_20(EXCEP,MSG) SCYTHE_THROW(EXCEP,MSG)
#else
#define SCYTHE_THROW_20(EXCEP,MSG)
#endif

#if SCYTHE_DEBUG > 2 
#define SCYTHE_THROW_30(EXCEP,MSG) SCYTHE_THROW(EXCEP,MSG)
#else
#define SCYTHE_THROW_30(EXCEP,MSG)
#endif

namespace scythe
{
  /* Forward declaration for serr */
  class scythe_exception;

  /**** This file-local variable holds the output of the last
   * scythe_exception constructed.
   ****/
#ifdef __MINGW32__
  static scythe_exception *serr;
#else
  namespace
  {
    scythe_exception *serr;
  }
#endif

  /**** A replacement for the default terminate handler.  This outputs
   * the string held in serr before calling abort, thereby notifying
   * the user of why the program crashed.
   ****/
  inline void scythe_terminate ();

  /**** The scythe exception abstract base class ****/
  class scythe_exception:public std::exception
  {
  public:
    scythe_exception (const std::string & head,
                      const std::string & file,
                      const std::string & function,
                      const unsigned int &line,
                      const std::string & message = "",
                      const bool & halt = false) throw ()
      : exception (),
        head_ (head),
        file_ (file),
        function_ (function),
        line_ (line),
        message_ (message),
        call_files_ (),
        call_funcs_ (),
        call_lines_ ()
    {
      std::ostringstream os;
      os << head_ << " in " << file_ << ", " << function_ << ", "
        << line_ << ": " << message_ << "!\n\n";

      serr = this;
      std::set_terminate (scythe_terminate);
      if (halt) {
#ifdef SCYTHE_RPACK
        error("Aborting Scythe C++ execution");
#else
        std::terminate ();
#endif
      }
    }

    scythe_exception (const scythe_exception & e) throw ()
      : exception (),
        head_ (e.head_),
        file_ (e.file_),
        function_ (e.function_),
        line_ (e.line_),
        message_ (e.message_),
        call_files_ (e.call_files_),
        call_funcs_ (e.call_funcs_),
        call_lines_ (e.call_lines_)
    {
    }

    scythe_exception & operator= (const scythe_exception & e) throw ()
    {
      head_ = e.head_;
      file_ = e.file_;
      function_ = e.function_;
      line_ = e.line_;
      message_ = e.message_;

      return *this;
    }

    virtual ~ scythe_exception () throw ()
    {
    }

    /* This function is only called from scythe_terminate, and only
     * once, so this memory leak is not an issue.  We can't just return
     * os.str().c_str() because that is a dangling pointer after the
     * function returns...
     * TODO: Deal with memory leak issue that might affect R packages
     */
    virtual const char *what () const throw ()
    {
      std::ostringstream os;
      for (int i = call_files_.size() - 1; i > -1; ++i) {
        os << "Called from " << call_files_[i] << ", "
          << call_funcs_[i] << ", " << call_lines_[i] << std::endl;
      }
      os << head_ << " in " << file_ << ", " << function_ << ", "
        << line_ << ": " << message_ << "!";
      char *retval = new char[os.str().length()];
      std::strcpy(retval, os.str().c_str());
      return retval;
    }

    virtual std::string message () const throw ()
    {
      return message_;
    }

    virtual void add_caller (const std::string &file,
      const std::string &function, const unsigned int &line) throw ()
    {

      /* This if allows one to catch and rethrow an error in the same
       * function w/out messing things up.  Nice to keep try-catch
       * blocks to a minimum
       */

      if (file != file_ && function != function_) {
        call_files_.push_back(file);
        call_funcs_.push_back(function);
        call_lines_.push_back(line);
      }
    }

  private:
    std::string head_;
    std::string file_;
    std::string function_;
    unsigned int line_;
    std::string message_;
    std::vector<std::string> call_files_;
    std::vector<std::string> call_funcs_;
    std::vector<unsigned int> call_lines_;
  };


  /**** Exception class types, added as needed ****/

  class scythe_alloc_error:public scythe_exception
  {
  public:
    scythe_alloc_error (const std::string & file,
                        const std::string & function,
                        const unsigned int &line,
                        const std::string & message = "",
                        const bool & halt = false) throw ()
      : scythe_exception ("SCYTHE_ALLOCATION_ERROR", file, function,
          line, message, halt)
    {
    }
  };

  class scythe_invalid_arg:public scythe_exception
  {
  public:
    scythe_invalid_arg (const std::string & file,
                        const std::string & function,
                        const unsigned int &line,
                        const std::string & message = "",
                        const bool & halt = false) throw ()
      : scythe_exception ("SCYTHE_INVALID ARGUMENT", file, function,
          line, message, halt)
    {
    }
  };

  class scythe_file_error:public scythe_exception
  {
  public:
    scythe_file_error(const std::string & file,
                       const std::string & function,
                       const unsigned int &line,
                       const std::string & message = "",
                       const bool & halt = false) throw ()
      : scythe_exception ("SCYTHE FILE ERROR", file, function, line, 
          message, halt)
    {
    }
  };

  class scythe_conformation_error:public scythe_exception
  {
  public:
    scythe_conformation_error(const std::string & file,
                               const std::string & function,
                               const unsigned int &line,
                               const std::string & message = "",
                               const bool & halt = false) throw ()
      : scythe_exception ("SCYTHE CONFORMATION ERROR", file, function, 
          line, message, halt)
    {
    }
  };

  class scythe_dimension_error:public scythe_exception
  {
  public:
    scythe_dimension_error (const std::string & file,
                            const std::string & function,
                            const unsigned int &line,
                            const std::string & message = "",
                            const bool & halt = false) throw ()
      : scythe_exception ("SCYTHE DIMENSION ERROR", file, function,
          line, message, halt)
    {
    }
  };

  class scythe_null_error:public scythe_exception
  {
  public:
    scythe_null_error(const std::string & file,
                       const std::string & function,
                       const unsigned int &line,
                       const std::string & message = "",
                       const bool & halt = false) throw ()
      : scythe_exception ("SCYTHE NULL ERROR", file, function, line,
          message, halt)
    {
    }
  };

  class scythe_type_error:public scythe_exception
  {
  public:
    scythe_type_error(const std::string & file,
                       const std::string & function,
                       const unsigned int &line,
                       const std::string & message = "",
                       const bool & halt = false) throw ()
      : scythe_exception ("SCYTHE TYPE ERROR", file, function, line,
          message, halt)
    {
    }
  };

  class scythe_bounds_error:public scythe_exception
  {
  public:
    scythe_bounds_error(const std::string & file,
                               const std::string & function,
                               const unsigned int &line,
                               const std::string & message = "",
                               const bool & halt = false) throw ()
      : scythe_exception ("SCYTHE BOUNDS ERROR", file, function,
          line, message, halt)
    {
    }
  };

  class scythe_convergence_error:public scythe_exception
  {
  public:
    scythe_convergence_error (const std::string & file,
                              const std::string & function,
                              const unsigned int &line,
                              const std::string & message = "",
                              const bool & halt = false) throw ()
      : scythe_exception ("SCYTHE CONVERGENCE ERROR", file, function,
          line, message, halt)
    {
    }
  };

  class scythe_range_error:public scythe_exception
  {
  public:
    scythe_range_error (const std::string & file,
                        const std::string & function,
                        const unsigned int &line,
                        const std::string & message = "",
                        const bool & halt = false) throw ()
      : scythe_exception ("SCYTHE RANGE ERROR", file, function, line,
          message, halt)
    {
    }
  };

  class scythe_precision_error:public scythe_exception
  {
  public:
    scythe_precision_error (const std::string & file,
                            const std::string & function,
                            const unsigned int &line,
                            const std::string & message = "",
                            const bool & halt = false) throw ()
      : scythe_exception ("SCYTHE PRECISION ERROR", file, function,
          line, message, halt)
    {
    }
  };
  
  class scythe_randseed_error:public scythe_exception
  {
  public:
    scythe_randseed_error(const std::string & file,
                          const std::string & function,
                          const unsigned int &line,
                          const std::string & message = "",
                          const bool & halt = false) throw ()
      : scythe_exception ("SCYTHE RANDOM SEED ERROR", file, function,
          line, message, halt)
    {
    }
  };

  class scythe_style_error:public scythe_exception
  {
    public:
      scythe_style_error(const std::string& file,
          const std::string& function,
          const unsigned int& line,
          const std::string& message = "",
          const bool& halt = false) throw ()
        : scythe_exception("SCYTHE STYLE ERROR", file, function,
            line, message, halt)
      {}
  };

  class scythe_lapack_internal_error:public scythe_exception
  {
    public:
      scythe_lapack_internal_error(const std::string& file,
          const std::string& function,
          const unsigned int& line,
          const std::string& message = "",
          const bool& halt = false) throw ()
        : scythe_exception("SCYTHE LAPACK/BLAS INTERNAL  ERROR", file, 
            function, line, message, halt)
      {}
  };

  class scythe_unexpected_default_error:public scythe_exception
  {
    public:
      scythe_unexpected_default_error(const std::string& file,
          const std::string& function,
          const unsigned int& line,
          const std::string& message = "",
          const bool& halt = false) throw ()
        : scythe_exception("SCYTHE UNEXPECTED DEFAULT ERROR", file, 
            function, line, message, halt)
      {}
  };

  // The definition of our terminate handler described above
  inline void scythe_terminate ()
  {
#ifdef SCYTHE_RPACK
    Rprintf(serr->what());
    error("Aborting Scythe C++ execution");
#else
    std::cerr << serr->what() << std::endl;
    std::cerr << std::endl;
    abort ();
#endif
  }

}        // end namspace SCYTHE

#endif /* SCYTHE_ERROR_H */