exception.cpp

Go to the documentation of this file.

// Copyright (c) 2011-2025  Made to Order Software Corp.  All Rights Reserved
//
// https://snapwebsites.org/
// contact@m2osw.com
//
// 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
// self
//
#include    "libexcept/exception.h"
 
#include    "libexcept/demangle.h"
 
 
// C++
//
#include    <iostream>
#include    <memory>
#include    <vector>
 
 
// C
//
#include    <execinfo.h>
#include    <link.h>
#include    <unistd.h>
 
 
 
namespace libexcept
{
 
 
 
 
namespace
{
 
 
collect_stack_t     g_collect_stack = collect_stack_t::COLLECT_STACK_YES;
 
 
 
 
} // no name namespace
 
 
 
 
 
 
 
 
 
 
 
 
 
collect_stack_t get_collect_stack()
{
    return g_collect_stack;
}
 
 
void set_collect_stack(collect_stack_t collect_stack)
{
    g_collect_stack = collect_stack;
}
 
 
 
 
 
exception_base_t::exception_base_t(int const stack_trace_depth)
{
    switch(get_collect_stack())
    {
    case collect_stack_t::COLLECT_STACK_NO:
        break;
 
    case collect_stack_t::COLLECT_STACK_YES:
        f_stack_trace = collect_stack_trace(stack_trace_depth);
        break;
 
    case collect_stack_t::COLLECT_STACK_COMPLETE:
        f_stack_trace = collect_stack_trace_with_line_numbers(stack_trace_depth);
        break;
 
    }
}
 
 
parameter_t const & exception_base_t::get_parameters() const
{
    return f_parameters;
}
 
 
std::string exception_base_t::get_parameter(std::string const & name) const
{
    auto const it(f_parameters.find(name));
    if(it == f_parameters.end())
    {
        return std::string();
    }
 
    return it->second;
}
 
 
exception_base_t & exception_base_t::set_parameter(std::string const & name, std::string const & value)
{
    if(!name.empty())
    {
        f_parameters[name] = value;
    }
 
    return *this;
}
 
 
logic_exception_t::logic_exception_t(
          std::string const & what
        , int const stack_trace_depth)
    : std::logic_error(what.c_str())
    , exception_base_t(stack_trace_depth)
{
}
 
 
logic_exception_t::logic_exception_t(
          char const * what
        , int const stack_trace_depth)
    : std::logic_error(what)
    , exception_base_t(stack_trace_depth)
{
}
 
 
char const * logic_exception_t::what() const throw()
{
    return std::logic_error::what();
}
 
 
 
 
 
 
 
 
 
 
 
out_of_range_t::out_of_range_t(
          std::string const & what
        , int const stack_trace_depth)
    : std::out_of_range(what.c_str())
    , exception_base_t(stack_trace_depth)
{
}
 
 
out_of_range_t::out_of_range_t(
          char const * what
        , int const stack_trace_depth)
    : std::out_of_range(what)
    , exception_base_t(stack_trace_depth)
{
}
 
 
char const * out_of_range_t::what() const throw()
{
    return std::out_of_range::what();
}
 
 
 
 
 
 
 
 
 
 
 
 
exception_t::exception_t(
          std::string const & what
        , int const stack_trace_depth)
    : std::runtime_error(what.c_str())
    , exception_base_t(stack_trace_depth)
{
}
 
 
exception_t::exception_t(
          char const * what
        , int const stack_trace_depth)
    : std::runtime_error(what)
    , exception_base_t(stack_trace_depth)
{
}
 
 
char const * exception_t::what() const throw()
{
    return std::runtime_error::what();
}
 
 
}
// namespace libexcept
// vim: ts=4 sw=4 et