using namespace backward;
Stacktrace st; st.load_here(32);
Printer p; p.print(st);

class StackTrace { public:
	// Take a snapshot of the current stack, with at most "trace_cnt_max"
	// traces in it. The first trace is the most recent (ie the current
	// frame). You can also provide a trace address to load_from() assuming
	// the address is a valid stack frame (useful for signal handling traces).
	// Both function return size().
	size_t load_here(size_t trace_cnt_max)
	size_t load_from(void* address, size_t trace_cnt_max)

	// The number of traces loaded. This can be less than "trace_cnt_max".
	size_t size() const

	// A unique id for the thread in which the trace was taken. The value
	// 0 means the stack trace comes from the main thread.
	size_t thread_id() const

	// Retrieve a trace by index. Index is the most recent trace, size()-1
	// is the older one.
	Trace operator[](size_t trace_idx)
};

using namespace backward;
Stacktrace st; st.load_here(32);

TraceResolver tr; tr.load_stacktrace(st);
for (size_t i = 0; i < st.size(); ++i) {
	ResolvedTrace trace = tr.resolve(st[i]);
	std::cout << "#" << i
		<< " " << trace.object_filename
		<< " " << trace.object_function
		<< " [" << trace.addr << "]"
	<< std::endl;
}

class TraceResolver { public:
	// Pre-load whatever is necessary from the stacktrace.
	template <class ST>
		void load_stacktrace(ST&)

	// Resolve a trace. It takes a ResolvedTrace, because a `Trace` or a
	// `TraceWithLocals` are implicitly convertible to a ResolvedTrace.
	ResolvedTrace resolve(ResolvedTrace t)
};

class SnippetFactory { public:
	// A snippet is a list of line number and content of the line.
	typedef std::vector<std::pair<size_t, std::string> > lines_t;

	// Return a snippet starting at line_start with as much as context_size
	// lines.
	lines_t get_snippet(const std::string& filename,
			size_t line_start, size_t context_size)

	// Return a combined snippet from two different location and combine them
	// together. context_size / 2 lines will be extracted from each location.
	lines_t get_combined_snippet(
			const std::string& filename_a, size_t line_a,
			const std::string& filename_b, size_t line_b,
			size_t context_size)

	// Tries to return an unified snippet if the two location from the same
	// file are close enough to fit inside one context_size, else returns
	// the equivalent of get_combined_snippet().
	lines_t get_coalesced_snippet(const std::string& filename,
			size_t line_a, size_t line_b, size_t context_size)

using namespace backward;
Stacktrace st; st.load_here(32);
Printer p;
p.object = true;
p.color = false;
p.address = true;
p.print(st, stderr);

class Printer { public:
	// Print a little snippet of code if possible.
	bool snippet = true;

	// Colorize the trace (only set a color when printing on a terminal)
	bool color = true;

	// Add the address on the trace to every source location.
	bool address = false;

	// Even if there is a source location, prints the object the trace comes
	// from as well.
	bool object = false;

	// Resolve and print a stacktrace. It takes a C FILE* object, for the only
	// reason that it is possible to access the underalying OS-level file
	// descriptor, which is then used to determine if the output is a terminal
	// to print in color.
	template <typename StackTrace>
		FILE* print(StackTrace& st, FILE* os = stderr)

backward::SignalHandling sh;

bool loaded() const // true if loaded with success

struct Trace {
	void*  addr; // address of the trace
	size_t idx;  // its index (0 == most recent)
};

struct TraceWithLocals: public Trace {
	std::vector<Variable> locals; // Locals variable and values.
};

struct ResolvedTrace: public TraceWithLocals {

	struct SourceLoc {
		std::string function;
		std::string filename;
		size_t      line;
		size_t      col;
	};

	// In which binary object this trace is located.
	std::string                    object_filename;

	// The function in the object that contain the trace. This is not the same
	// as source.function which can be an function inlined in object_function.
	std::string                    object_function;

	// The source location of this trace. It is possible for filename to be
	// empty and for line/col to be invalid (value 0) if this information
	// couldn't be deduced, for example if there is no debug information in the
	// binary object.
	SourceLoc                      source;

	// An optionals list of "inliners". All the successive sources location
	// from where the source location of the trace (the attribute right above)
	// is inlined. It is especially useful when you compile with optimization.
	typedef std::vector<SourceLoc> source_locs_t;
	source_locs_t                  inliners;
};