exceptions

Go to the documentation of this file.

// vi:set ft=cpp: -*- Mode: C++ -*-
/*
 * (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() noexcept : _frame_cnt(0) {}
#else
    Exception_tracer() noexcept
    : _frame_cnt(l4util_backtrace(_pc_array, L4_CXX_EXCEPTION_BACKTRACE)) {}
#endif
 
  public:
    void const *const *pc_array() const noexcept { return _pc_array; }
    int frame_count() const noexcept { return _frame_cnt; }
#else
  protected:
    Exception_tracer() noexcept {}
 
  public:
    void const *const *pc_array() const noexcept { return 0; }
    int frame_count() const noexcept { return 0; }
#endif
  };
 
  class Base_exception : public Exception_tracer
  {
  protected:
    Base_exception() noexcept {}
 
  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
        {
          unsigned i = 0;
          for (; i < sizeof(_extra) && extra[i]; ++i)
            _extra[i] = extra[i];
          _extra[i < sizeof(_extra) ? i : sizeof(_extra) - 1] = 0;
        }
    }
    char const *str() const throw () override
    { return l4sys_errtostr(_errno); }
 
    char const *extra_str() const { return _extra; }
    ~Runtime_error() throw () {}
 
    long err_no() const noexcept { return _errno; }
  };
 
  class Out_of_memory : public Runtime_error
  {
  public:
    explicit Out_of_memory(char const *extra = "") noexcept
    : Runtime_error(-L4_ENOMEM, extra) {}
    ~Out_of_memory() noexcept {}
  };
 
 
  class Element_already_exists : public Runtime_error
  {
  public:
    explicit Element_already_exists(char const *e = "") noexcept
    : Runtime_error(-L4_EEXIST, e) {}
    ~Element_already_exists() noexcept {}
  };
 
  class Unknown_error : public Base_exception
  {
  public:
    Unknown_error() noexcept {}
    char const *str() const noexcept override { return "unknown error"; }
    ~Unknown_error() noexcept {}
  };
 
  class Element_not_found : public Runtime_error
  {
  public:
    explicit Element_not_found(char const *e = "") noexcept
    : Runtime_error(-L4_ENOENT, e) {}
  };
 
  class Invalid_capability : public Base_exception
  {
  private:
    Cap<void> const _o;
 
  public:
    explicit Invalid_capability(Cap<void> const &o) noexcept : _o(o) {}
    template< typename T>
    explicit Invalid_capability(Cap<T> const &o) noexcept : _o(o.cap()) {}
    char const *str() const noexcept override { return "invalid object"; }
 
    Cap<void> const &cap() const noexcept { return _o; }
    ~Invalid_capability() noexcept {}
  };
 
  class Com_error : public Runtime_error
  {
  public:
    explicit Com_error(long err) noexcept : Runtime_error(err) {}
 
    ~Com_error() noexcept {}
  };
 
  class Bounds_error : public Runtime_error
  {
  public:
    explicit Bounds_error(char const *e = "") noexcept
    : Runtime_error(-L4_ERANGE, e) {}
    ~Bounds_error() noexcept {}
  };
};
 
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;
}