exceptions

// vi:ft=cpp
/*
 * (c) 2008-2009 Adam Lackorzynski <adam@os.inf.tu-dresden.de>,
 *               Alexander Warg <warg@os.inf.tu-dresden.de>
 *     economic rights: Technische Universität Dresden (Germany)
 *
 * This file is part of TUD:OS and distributed under the terms of the
 * GNU General Public License 2.
 * Please see the COPYING-GPL-2 file for details.
 *
 * As a special exception, you may use this file as part of a free software
 * library without restriction.  Specifically, if other files instantiate
 * templates or use macros or inline functions from this file, or you compile
 * this file and link it with other files to produce an executable, this
 * file does not by itself cause the resulting executable to be covered by
 * the GNU General Public License.  This exception does not however
 * invalidate any other reasons why the executable file might be covered by
 * the GNU General Public License.
 */

#pragma once

#include <l4/cxx/l4types.h>
#include <l4/cxx/basic_ostream>
#include <l4/sys/err.h>
#include <l4/sys/capability>



#ifndef L4_CXX_NO_EXCEPTION_BACKTRACE
# define L4_CXX_EXCEPTION_BACKTRACE 20
#endif

#if defined(L4_CXX_EXCEPTION_BACKTRACE)
#include <l4/util/backtrace.h>
#endif

namespace L4
{

  class Exception_tracer
  {
#if defined(L4_CXX_EXCEPTION_BACKTRACE)
  private:
    void *_pc_array[L4_CXX_EXCEPTION_BACKTRACE];
    int   _frame_cnt;

  protected:
#if defined(__PIC__)
    Exception_tracer() throw() : _frame_cnt(0) {}
#else
    Exception_tracer() throw() : _frame_cnt(l4util_backtrace(_pc_array, L4_CXX_EXCEPTION_BACKTRACE)) {}
#endif

  public:
    void const *const *pc_array() const throw() { return _pc_array; }
    int frame_count() const throw() { return _frame_cnt; }
#else
  protected:
    Exception_tracer() throw() {}

  public:
    void const *const *pc_array() const throw() { return 0; }
    int frame_count() const throw() { return 0; }
#endif
  };

  class Base_exception : public Exception_tracer
  {
  protected:
    Base_exception() throw() {}

  public:
    virtual char const *str() const throw () = 0;

    virtual ~Base_exception() throw () {}
  };

  class Runtime_error : public Base_exception
  {
  private:
    long _errno;
    char _extra[80];

  public:
    explicit Runtime_error(long err_no, char const *extra = 0) throw ()
      : _errno(err_no)
    {
      if (!extra)
        _extra[0] = 0;
      else
        {
          for (unsigned i = 0; i < sizeof(_extra) && extra[i]; ++i)
            _extra[i] = extra[i];
          _extra[sizeof(_extra) - 1] = 0;
        }
    }
    char const *str() const throw ()
    { return l4sys_errtostr(_errno); }
    char const *extra_str() const { return _extra; }
    ~Runtime_error() throw () {}

    long err_no() const throw() { return _errno; }
  };

  class Out_of_memory : public Runtime_error
  {
  public:
    explicit Out_of_memory(char const *extra = "") throw()
    : Runtime_error(-L4_ENOMEM, extra) {}
    ~Out_of_memory() throw() {}
  };


  class Element_already_exists : public Runtime_error
  {
  public:
    explicit Element_already_exists(char const *e = "") throw()
    : Runtime_error(-L4_EEXIST, e) {}
    ~Element_already_exists() throw() {}
  };

  class Unknown_error : public Base_exception
  {
  public:
    Unknown_error() throw() {}
    char const *str() const throw() { return "unknown error"; }
    ~Unknown_error() throw() {}
  };

  
  class Element_not_found : public Runtime_error
  {
  public:
    explicit Element_not_found(char const *e = "") throw()
    : Runtime_error(-L4_ENOENT, e) {}
  };

  class Invalid_capability : public Base_exception
  {
  private:
    Cap<void> const _o;

  public:
    explicit Invalid_capability(Cap<void> const &o) throw() : _o(o) {}
    template< typename T>
    explicit Invalid_capability(Cap<T> const &o) throw() : _o(o.cap()) {}
    char const *str() const throw() { return "invalid object"; }

    Cap<void> const &cap() const throw() { return _o; }
    ~Invalid_capability() throw() {}
  };

  class Com_error : public Runtime_error
  {
  public:
    explicit Com_error(long err) throw() : Runtime_error(err) {}

    ~Com_error() throw() {}
  };

  class Bounds_error : public Runtime_error
  {
  public:
    explicit Bounds_error(char const *e = "") throw()
    : Runtime_error(-L4_ERANGE, e) {}
    ~Bounds_error() throw() {}
  };
};

inline
L4::BasicOStream &
operator << (L4::BasicOStream &o, L4::Base_exception const &e)
{
  o << "Exception: " << e.str() << ", backtrace ...\n";
  for (int i = 0; i < e.frame_count(); ++i)
    o << L4::n_hex(l4_addr_t(e.pc_array()[i])) << '\n';

  return o;
}

inline
L4::BasicOStream &
operator << (L4::BasicOStream &o, L4::Runtime_error const &e)
{
  o << "Exception: " << e.str() << ": ";
  if (e.extra_str())
    o << e.extra_str() << ": ";
  o << "backtrace ...\n";
  for (int i = 0; i < e.frame_count(); ++i)
    o << L4::n_hex(l4_addr_t(e.pc_array()[i])) << '\n';

  return o;
}