# Copyright Antony Polukhin 2016.

# Use, modification, and distribution are

# subject to the Boost Software License, Version 1.0. (See accompanying

# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

using quickbook ;

import boostbook : boostbook ;

import doxygen ;

doxygen autodoc

:

[ glob ../../../boost/stacktrace.hpp ]

:

<doxygen:param>EXTRACT_ALL=NO

<doxygen:param>HIDE_UNDOC_MEMBERS=YES

<doxygen:param>EXTRACT_PRIVATE=NO

<doxygen:param>ENABLE_PREPROCESSING=YES

<doxygen:param>EXPAND_ONLY_PREDEF=YES

<doxygen:param>MACRO_EXPANSION=YES

<doxygen:param>"PREDEFINED=\"stl_type_info=std::type_info\" \\

\"BOOST_STACKTRACE_FUNCTION\""

<xsl:param>"boost.doxygen.reftitle=Boost.Stacktrace Header Reference"

;

xml stacktrace : stacktrace.qbk : <dependency>autodoc ;

boostbook standalone

:

stacktrace

:

<xsl:param>boost.root=http://www.boost.org/doc/libs/1_61_0

# <xsl:param>boost.root=../../../..

<format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html

;

[library Boost.Stacktrace

[quickbook 1.6]

[version 1.0]

[copyright 2016 Antony Polukhin]

[category Language Features Emulation]

[license

Distributed under the Boost Software License, Version 1.0.

(See accompanying file LICENSE_1_0.txt or copy at

[@http://www.boost.org/LICENSE_1_0.txt])

]

]

[section Motivation]

How to display the call sequence in C++? From what function was called the current function? What call sequence lead to an exception?

Boost.Stacktrace library is a simple library that provides information about call sequence in human readable form.

[warning This is not an official Boost library! It wasn't reviewed and can't be downloaded from www.boost.org. This library is available to the community to know real interest and get comments for refinement. The intention is to submit library to formal review, if community think that it is interesting!]

[endsect]

[section Getting Started]

[endsect]

[xinclude autodoc.xml]

#include <boost/function.hpp>

struct events {

typedef boost::function<void (float)> callback_type;

static void from_keyboard(callback_type callback);

static void from_network(callback_type callback);

};

#include <boost/stacktrace.hpp>

#include <iostream>

BOOST_NOINLINE void validate_positive(float f) {

if (f < 0.f) {

std::cerr << "Negative number " << f << " detected. Call stack:\n"

<< boost::stacktrace::stacktrace() << '\n';

}

}

boost::function<void (float)> on_keyboard;

boost::function<void (float)> on_network;

BOOST_NOINLINE void keyboard_event() {

on_keyboard(-0.1f);

}

BOOST_NOINLINE void network_event() {

on_network(1.0f);

}

void events::from_keyboard(events::callback_type callback) {

on_keyboard = callback;

}

void events::from_network(events::callback_type callback) {

on_network = callback;

}

int main() {

events::from_keyboard(&validate_positive);

events::from_network(&validate_positive);

keyboard_event();

network_event();

}

#ifdef BOOST_HAS_PRAGMA_ONCE

# pragma once

#endif

#include <string>

#if defined(BOOST_STACKTRACE_HEADER_ONLY)

# define BOOST_STACKTRACE_FUNCTION inline

#else

# define BOOST_STACKTRACE_FUNCTION

#endif

BOOST_STATIC_CONSTEXPR std::size_t max_implementation_size = sizeof(void*) * 110u;

/// Stores the current function call sequence inside the class

BOOST_STACKTRACE_FUNCTION stacktrace() BOOST_NOEXCEPT;

BOOST_STACKTRACE_FUNCTION stacktrace(const stacktrace& bt) BOOST_NOEXCEPT;

BOOST_STACKTRACE_FUNCTION stacktrace& operator=(const stacktrace& bt) BOOST_NOEXCEPT;

BOOST_STACKTRACE_FUNCTION ~stacktrace() BOOST_NOEXCEPT;

/// @returns Number of function names stored inside the class.

BOOST_STACKTRACE_FUNCTION std::size_t size() const BOOST_NOEXCEPT;

/// @param frame Zero based index of function to return. 0

/// is the function index where stacktrace was constructed and

/// index close to this->size() contains function `main()`.

/// @returns Function name in a human readable form.

/// @throws std::bad_alloc if not enough memory.

BOOST_STACKTRACE_FUNCTION std::string operator[](std::size_t frame) const;

const std::string f = bt[i];

os << "# ";

if (f.empty()) {

os << "??";

} else {

os << f;

}

os << '\n';

#undef BOOST_STACKTRACE_FUNCTION

#if defined(BOOST_STACKTRACE_HEADER_ONLY)

# include <boost/stacktrace/detail/stacktrace.ipp>

#endif

#include <boost/config.hpp>

#ifdef BOOST_HAS_PRAGMA_ONCE

# pragma once

#endif

#include <boost/static_assert.hpp>

#elif defined(__has_include) && (!defined(__GNUC__) || __GNUC__ > 4)

# if __has_include(<libunwind.h>)

# include <boost/stacktrace/detail/stacktrace_libunwind.hpp>

# elif __has_include(<execinfo.h>)

# include <boost/stacktrace/detail/stacktrace_linux.hpp>

# endif

inline boost::stacktrace::detail::backtrace_holder& to_bt(T& data) BOOST_NOEXCEPT {

return *reinterpret_cast<boost::stacktrace::detail::backtrace_holder*>(&data);

inline const boost::stacktrace::detail::backtrace_holder& to_bt(const T& data) BOOST_NOEXCEPT {

return *reinterpret_cast<const boost::stacktrace::detail::backtrace_holder*>(&data);

new (&impl_) boost::stacktrace::detail::backtrace_holder();

new (&impl_) boost::stacktrace::detail::backtrace_holder(to_bt(bt.impl_));

to_bt(impl_) = to_bt(bt.impl_);

BOOST_STATIC_ASSERT_MSG(sizeof(impl_) >= sizeof(boost::stacktrace::detail::backtrace_holder), "Too small storage for holding backtrace");

to_bt(impl_).~backtrace_holder();

return to_bt(impl_).size();

std::string stacktrace::operator[](std::size_t frame) const BOOST_NOEXCEPT {

return to_bt(impl_).get_frame(frame);