Stacktrace.cpp

Go to the documentation of this file.

/*
    Copyright (C) 2014-2016 Leosac
 
    This file is part of Leosac.
 
    Leosac is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    Leosac 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 Affero General Public License for more details.
 
    You should have received a copy of the GNU Affero General Public License
    along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
 
#include "Stacktrace.hpp"
#include "Colorize.hpp"
#include "log.hpp"
 
#if (!defined(__GNUG__) && defined(__clang__)) || defined(LEOSAC_STACKTRACE_DISABLED)
#define LEOSAC_STACKTRACE_DISABLED
#else
#include <backtrace.h>
#endif
 
#include <boost/core/demangle.hpp>
#include <boost/range/adaptor/reversed.hpp>
 
using namespace Leosac;
using namespace Leosac::Tools;
 
Stacktrace::Stacktrace(uint skip /* = 0 */)
{
#ifndef LEOSAC_STACKTRACE_DISABLED
    auto cb_error = [](void * /*data*/, const char *msg, int errnum) {
        ERROR("Problem when generating stacktrace: " << msg
                                                     << ". Error code: " << errnum);
    };
 
    auto cb_full = [](void *data, uintptr_t /*pc*/, const char *filename, int line,
                      const char *function) -> int {
        std::vector<Frame> *stack = static_cast<std::vector<Frame> *>(data);
        Frame frame;
        if (!function)
        {
            frame.suppressed_ = true;
        }
        else
        {
            frame.function_ = boost::core::demangle(function);
            frame.line_     = line;
            frame.file_     = filename;
        }
        stack->push_back(frame);
        return 0;
    };
 
    struct backtrace_state *bt =
        backtrace_create_state(nullptr, 0, nullptr, nullptr);
    backtrace_full(bt, skip, cb_full, cb_error, &stack_);
#endif
}
 
std::string Stacktrace::str(int max_frames /* = 10 */) const
{
    int frame_count      = 0;
    int suppressed_count = 0; // count suppressed frame that follows each other.
    std::stringstream ss;
 
    for (const auto &frame : stack_)
    {
        if (frame_count == max_frames)
            break;
        if (frame.suppressed_)
        {
            suppressed_count++;
            continue;
        }
        if (suppressed_count)
            ss << Colorize::red("Frames suppressed: ") << suppressed_count
               << std::endl;
        suppressed_count = 0;
 
        ss << "#" << frame_count << " in " << Colorize::cyan(frame.function_)
           << " at " << Colorize::bright_green(frame.file_) << ":" << frame.line_
           << std::endl;
        frame_count++;
    }
    return ss.str();
}