Error handling

Utilities to report handle errors, and to build and report error messages. More...

Classes
struct	c4::yml::Location
	holds a source or yaml file position, for example when an error is detected; See also location_format() and location_format_with_context(). More...
struct	c4::yml::ErrorDataBasic
	Data for a basic error. More...
struct	c4::yml::ErrorDataParse
	Data for a parse error. More...
struct	c4::yml::ErrorDataVisit
	Data for a visit error. More...
struct	c4::yml::ExceptionBasic
	Exception thrown by the default basic error implementation. More...
struct	c4::yml::ExceptionParse
	Exception thrown by the default parse error implementation. More...
struct	c4::yml::ExceptionVisit
	Exception thrown by the default visit error implementation. More...

Functions
template<class DumpFn>
size_t	c4::yml::location_format (DumpFn &&dumpfn, Location const &loc)
	generic formatting of a location
template<class DumpFn>
void	c4::yml::location_format_with_context (DumpFn &&dumpfn, Location const &location, csubstr source_buffer, csubstr call="", size_t num_lines_before=3, size_t num_lines_after=0, size_t first_col_highlight=0, size_t last_col_highlight=0, size_t maxlen=80u)
	Generic formatting of a location, printing the source code buffer region around the location.
template<class DumpFn>
void	c4::yml::err_basic_format (DumpFn &&dumpfn, csubstr msg, ErrorDataBasic const &errdata)
	Given an error message and associated basic error data, format it fully as a basic error message.
void	c4::yml::err_basic (Callbacks const &callbacks, ErrorDataBasic const &errdata, const char *msg_)
	trigger a basic error to its respective handler, with a non-formatted error message.
void	c4::yml::err_basic (ErrorDataBasic const &errdata, const char *msg)
	trigger a basic error to its respective handler, with a non-formatted error message.
template<class ... Args>
void	c4::yml::err_basic (Callbacks const &callbacks, ErrorDataBasic const &errdata, const char *fmt, Args const &...args)
	trigger a basic error to its respective handler, with a formatted error message.
template<class ... Args>
void	c4::yml::err_basic (ErrorDataBasic const &errdata, const char *fmt, Args const &...args)
	trigger a basic error to its respective handler, with a formatted error message.
template<class DumpFn>
void	c4::yml::err_parse_format (DumpFn &&dumpfn, csubstr msg, ErrorDataParse const &errdata)
	Given an error message and associated parse error data, format it fully as a parse error message.
void	c4::yml::err_parse (Callbacks const &callbacks, ErrorDataParse const &errdata, const char *msg)
	trigger a parse error to its respective handler, with a non-formatted error message
void	c4::yml::err_parse (ErrorDataParse const &errdata, const char *msg)
	trigger a parse error to its respective handler, with a non-formatted error message.
template<class ... Args>
void	c4::yml::err_parse (Callbacks const &callbacks, ErrorDataParse const &errdata, const char *fmt, Args const &...args)
	trigger a parse error to its respective handler, with a formatted error message
template<class ... Args>
void	c4::yml::err_parse (ErrorDataParse const &errdata, const char *fmt, Args const &...args)
	trigger a parse error to its respective handler, with a formatted error message.
template<class DumpFn>
void	c4::yml::err_visit_format (DumpFn &&dumpfn, csubstr msg, ErrorDataVisit const &errdata)
	Given an error message and associated visit error data, format it fully as a visit error message.
void	c4::yml::err_visit (Callbacks const &callbacks, ErrorDataVisit const &errdata, const char *msg)
	trigger a visit error to its respective handler, with a non-formatted error message
void	c4::yml::err_visit (ErrorDataVisit const &errdata, const char *msg)
	trigger a visit error to its respective handler, with a non-formatted error message.
template<class ... Args>
void	c4::yml::err_visit (Callbacks const &callbacks, ErrorDataVisit const &errdata, const char *fmt, Args const &...args)
	trigger a visit error to its respective handler, with a formatted error message
template<class ... Args>
void	c4::yml::err_visit (ErrorDataVisit const &errdata, const char *fmt, Args const &...args)
	trigger a visit error to its respective handler, with a formatted error message.
template<class CharContainer>
void	c4::yml::format_exc (CharContainer *out, ExceptionBasic const &exc)
	Format a basic exception to an existing char container.
template<class CharContainer>
void	c4::yml::format_exc (CharContainer *out, ExceptionParse const &exc)
	Format a parse exception to an existing char container.
template<class CharContainer>
void	c4::yml::format_exc (CharContainer *out, ExceptionVisit const &exc)
	Format a visit exception to an existing char container.
template<class CharContainer, class ExceptionT>
CharContainer	c4::yml::format_exc (ExceptionT const &exc)
	Format a parse exception, and return a newly-created char container.

Detailed Description

Utilities to report handle errors, and to build and report error messages.

See also

sample::sample_error_handler

Function Documentation

location_format()

template<class DumpFn>

size_t c4::yml::location_format	(	DumpFn &&	dumpfn,
		Location const &	loc )

generic formatting of a location

Parameters

dumpfn	function taking a csubstr and abstracting a string concatenation operation, such as appending to a std::string or printing to terminal.
loc	the location to be formatted

For example:

/// to output to std::cerr:
location_format([&s](csubstr s){
    std::cerr.write(s.str, s.len);
}, loc);
 
/// to build a string:
std::string msg;
location_format([&s](csubstr s){
    msg.append(s.str, s.len);
}, loc);

Definition at line 18 of file error.def.hpp.

{
    if(!loc)
        return 0;
    char buf_[32];
    substr buf(buf_);
    size_t count = 0;
    if(!loc.name.empty())
    {
        std::forward<DumpFn>(dumpfn)(loc.name);
        std::forward<DumpFn>(dumpfn)(":");
        count += loc.name.len + 1;
    }
    if(loc.line != npos)
    {
        csubstr val = detail::_to_chars_limited(buf, loc.line);
        if(loc.name.empty())
        {
            std::forward<DumpFn>(dumpfn)("line=");
            std::forward<DumpFn>(dumpfn)(val);
            if(loc.col == npos)
            {
                std::forward<DumpFn>(dumpfn)(":");
                ++count;
            }
            count += val.len + 5;
        }
        else
        {
            std::forward<DumpFn>(dumpfn)(val);
            std::forward<DumpFn>(dumpfn)(":");
            count += val.len + 1;
        }
    }
    if(loc.col != npos)
    {
        csubstr val = detail::_to_chars_limited(buf, loc.col);
        if(loc.line != npos || !loc.name.empty())
        {
            std::forward<DumpFn>(dumpfn)(" ");
            ++count;
        }
        std::forward<DumpFn>(dumpfn)("col=");
        std::forward<DumpFn>(dumpfn)(val);
        count += val.len + 4;
        if(loc.offset == npos)
        {
            std::forward<DumpFn>(dumpfn)(":");
            ++count;
        }
    }
    if(loc.offset != npos)
    {
        csubstr val = detail::_to_chars_limited(buf, loc.offset);
        if(loc.line != npos || loc.col != npos || !loc.name.empty())
        {
            std::forward<DumpFn>(dumpfn)(" ");
            ++count;
        }
        std::forward<DumpFn>(dumpfn)("(");
        std::forward<DumpFn>(dumpfn)(val);
        std::forward<DumpFn>(dumpfn)("B):");
        count += val.len + 5;
    }
    return count;
}

location_format_with_context()

template<class DumpFn>

void c4::yml::location_format_with_context	(	DumpFn &&	dumpfn,
		Location const &	location,
		csubstr	source_buffer,
		csubstr	call = "",
		size_t	num_lines_before = 3,
		size_t	num_lines_after = 0,
		size_t	first_col_highlight = 0,
		size_t	last_col_highlight = 0,
		size_t	maxlen = 80u )

Generic formatting of a location, printing the source code buffer region around the location.

Parameters

dumpfn	function taking a csubstr and abstracting a string concatenation operation, such as appending to a std::string or printing to terminal.
location	the location
source_buffer	the source buffer
call	a string with a call of attention to print in the message (see examples below)
num_lines_before	how many source buffer lines to print before the location line
num_lines_after	how many source buffer lines to print after the location line
first_col_highlight	the first column to highlight around the location line
last_col_highlight	the last column to highlight around the location line
maxlen	the maximum number of columns to show in the error message; source buffer lines will have at most this number of columns shown; if the line is longer than this, the line will be trimmed as needed at the end and/or beginning, and only the relevant columns around the location are shown

For example:

std::string out;
auto dumpfn = [&out](csubstr s){ out.append(s.str, s.len); };
format_location_with_context(dumpfn, location, source, "error");

will result in this string:

file.yaml:3: col=3 (11B): error:
error:
error:     ccc
error:        |
error:        (here)
error:
error: see region:
error:
error:     aaa
error:     bbb
error:     ccc
error:        |
error:        (here)

If an empty string is passed for the call of attention,

format_location_with_context(dumpfn, location, source);

the returned string becomes:

file.yaml:3: col=3 (11B): ccc
                            |
                            (here)
file.yaml:3: col=3 (11B): see region:
aaa
bbb
ccc
   |
   (here)

Definition at line 86 of file error.def.hpp.

{
    if(!location)
        return;
    char buf_[32];
    substr buf(buf_);
    auto pr = [&](csubstr s){ std::forward<DumpFn>(dumpfn)(s); };
    auto prn = [&](csubstr s, size_t num_times){
        for(size_t i = 0; i < num_times; ++i)
            std::forward<DumpFn>(dumpfn)(s);
    };
    csubstr line = detail::_get_text_region(source_buffer, location.offset, 0, 0);
    size_t target_col = location.col != npos ? location.col : (last_col_highlight > first_col_highlight ? first_col_highlight : npos);
    size_t first_col_to_show = 0;
    if(target_col != npos && target_col > maxlen)
        first_col_to_show = target_col - maxlen + 1;
    auto print_line_maybe_truncated = [&](csubstr contents){
        if(contents.len <= maxlen)
        {
            if(first_col_to_show == 0)
            {
                pr(contents);
            }
            else if(first_col_to_show < contents.len)
            {
                csubstr show = contents.sub(first_col_to_show);
                pr("[...]");
                pr(show);
                if(maxlen > show.len)
                    prn(" ", maxlen - show.len + 5);
                pr(" (showing columns ");
                pr(detail::_to_chars_limited(buf, first_col_to_show));
                pr("-");
                pr(detail::_to_chars_limited(buf, contents.len));
                pr("/");
                pr(detail::_to_chars_limited(buf, contents.len));
                pr(")");
            }
            else
            {
                pr("[...]");
                prn(" ", maxlen + 5);
                pr(" (not showing, columns=");
                pr(detail::_to_chars_limited(buf, contents.len));
                pr(")");
            }
        }
        else
        {
            if(first_col_to_show == 0)
            {
                csubstr show = contents.first(maxlen);
                pr(show);
                pr("[...] (showing columns 0-");
                pr(detail::_to_chars_limited(buf, show.len));
                pr("/");
                pr(detail::_to_chars_limited(buf, contents.len));
                pr(")");
            }
            else if(first_col_to_show < contents.len && first_col_to_show + maxlen <= contents.len)
            {
                csubstr show = contents.sub(first_col_to_show, maxlen);
                pr("[...]");
                pr(show);
                pr("[...] (showing columns ");
                pr(detail::_to_chars_limited(buf, first_col_to_show));
                pr("-");
                pr(detail::_to_chars_limited(buf, first_col_to_show + maxlen));
                pr("/");
                pr(detail::_to_chars_limited(buf, contents.len));
                pr(")");
            }
            else if(first_col_to_show < contents.len)
            {
                csubstr show = contents.sub(first_col_to_show);
                pr("[...]");
                pr(show);
                if(maxlen > show.len)
                    prn(" ", maxlen - show.len + 5);
                pr(" (showing columns ");
                pr(detail::_to_chars_limited(buf, first_col_to_show));
                pr("-");
                pr(detail::_to_chars_limited(buf, contents.len));
                pr("/");
                pr(detail::_to_chars_limited(buf, contents.len));
                pr(")");
            }
            else
            {
                pr("[...]");
                prn(" ", maxlen + 5);
                pr(" (not showing, columns=");
                pr(detail::_to_chars_limited(buf, contents.len));
                pr(")");
            }
        }
    };
    // print the location, and compute how many cols it took
    size_t locsize = location_format(pr, location);
    // print line
    if(locsize)
    {
        pr(" ");
        //++locsize;
    }
    auto print_call = [&](csubstr after){
        pr(call);
        pr(":");
        if(after.len)
            pr(after);
    };
    size_t jump;
    if(call.empty())
    {
        print_line_maybe_truncated(line);
        pr("\n");
        jump = locsize + location.col - first_col_to_show;
    }
    else
    {
        print_call("\n");
        print_call("\n");
        print_call(" ");
        pr("    ");
        print_line_maybe_truncated(line);
        pr("\n");
        jump = call.len + 2;
    }
    // when skipping to the first col, add 5 to adjust for the [...]
    // leading the line as shown
    const size_t first_col_jump = first_col_to_show == 0 ? 0 : 5;
    // print a cursor pointing at the column on the previous printed line
    auto print_cursor = [&](size_t nocall_jump){
        if(location.offset == npos)
            return;
        if(call.empty())
        {
            if(nocall_jump != npos)
            {
                prn(" ", nocall_jump + first_col_jump);
                pr("|\n");
                prn(" ", nocall_jump + first_col_jump);
                pr("(here)\n");
            }
        }
        else if(location.col != npos)
        {
            print_call(" ");
            pr("    ");
            prn(" ", location.col - first_col_to_show + first_col_jump);
            pr("|\n");
            print_call(" ");
            pr("    ");
            prn(" ", location.col - first_col_to_show + first_col_jump);
            pr("(here)\n");
        }
    };
    // maybe highlighted zone
    size_t firstcol = first_col_highlight < line.len ? first_col_highlight : line.len;
    size_t lastcol = last_col_highlight < line.len ? last_col_highlight : line.len;
    firstcol = firstcol < maxlen ? firstcol : maxlen;
    lastcol = lastcol < maxlen ? lastcol : maxlen;
    if(firstcol < lastcol)
    {
        if(!call.empty())
        {
            print_call(" ");
            pr("    ");
        }
        else
        {
            for(size_t i = 0; i < locsize + firstcol; ++i)
                pr(" ");
        }
        for(size_t i = locsize + firstcol; i < locsize + lastcol; ++i)
            pr("~");
        pr("  (cols ");
        pr(detail::_to_chars_limited(buf, firstcol));
        pr("-");
        pr(detail::_to_chars_limited(buf, lastcol));
        pr("/");
        pr(detail::_to_chars_limited(buf, line.len));
        pr(")\n");
    }
    if(location.col != npos)
    {
        print_cursor(jump);
    }
    // maybe print the region
    if(num_lines_before || num_lines_after)
    {
        if(!call.empty())
        {
            print_call("\n");
            print_call(" ");
            pr("see region:\n");
            print_call("\n");
        }
        else
        {
            if(location)
            {
                location_format(pr, location);
                pr(" ");
            }
            pr("see region:\n");
        }
        csubstr region = detail::_get_text_region(source_buffer, location.offset, num_lines_before, num_lines_after);
        for(csubstr contents : region.split('\n'))
        {
            if(!call.empty())
            {
                print_call("     ");
            }
            print_line_maybe_truncated(contents);
            pr("\n");
        }
        assert(location.col == npos || location.col >= first_col_to_show);
        print_cursor(location.col - first_col_to_show);
    }
}

err_basic_format()

template<class DumpFn>

void c4::yml::err_basic_format	(	DumpFn &&	dumpfn,
		csubstr	msg,
		ErrorDataBasic const &	errdata )

Given an error message and associated basic error data, format it fully as a basic error message.

Parameters

dumpfn	function taking a csubstr and abstracting a string concatenation operation, such as appending to a std::string or printing to terminal.
msg	the error message
errdata	the error data

For example:

/// to output to cerr:
err_basic_format([](csubstr s){
    std::cerr.write(s.str, s.len);
}, errmsg, errdata);
 
/// to build a string:
std::string msg;
error_basic_format([&msg](csubstr s){
    msg.append(s.str, s.len);
}, errmsg, errdata);

Definition at line 318 of file error.def.hpp.

{
    if(errdata.location)
    {
        location_format(dumpfn, errdata.location);
        std::forward<DumpFn>(dumpfn)(" ");
    }
    std::forward<DumpFn>(dumpfn)("ERROR: [basic] ");
    std::forward<DumpFn>(dumpfn)(msg);
}

err_basic() [1/4]

void c4::yml::err_basic	(	Callbacks const &	callbacks,
		ErrorDataBasic const &	errdata,
		const char *	msg_ )

trigger a basic error to its respective handler, with a non-formatted error message.

Definition at line 201 of file common.cpp.

{
    csubstr msg = to_csubstr(msg_);
    callbacks.m_error_basic(msg, errdata, callbacks.m_user_data);
    abort(); // the call above should not return, so force it here in case it does // LCOV_EXCL_LINE
    C4_UNREACHABLE_AFTER_ERR();
}

err_basic() [2/4]

void c4::yml::err_basic	(	ErrorDataBasic const &	errdata,
		const char *	msg )

trigger a basic error to its respective handler, with a non-formatted error message.

Like (1), but use the current global callbacks.

Definition at line 196 of file common.cpp.

{
    err_basic(get_callbacks(), errdata, msg);
    C4_UNREACHABLE_AFTER_ERR();
}

err_basic() [3/4]

template<class ... Args>

void c4::yml::err_basic	(	Callbacks const &	callbacks,
		ErrorDataBasic const &	errdata,
		const char *	fmt,
		Args const &...	args )

trigger a basic error to its respective handler, with a formatted error message.

Definition at line 328 of file error.hpp.

{
    char errbuf[RYML_ERRMSG_SIZE];
    csubstr msg = detail::_mk_err_msg(errbuf, to_csubstr(fmt), args...);
    callbacks.m_error_basic(msg, errdata, callbacks.m_user_data);
    std::abort(); // the call above should not return, but force it here in case it does // LCOV_EXCL_LINE
    C4_UNREACHABLE_AFTER_ERR();
}

err_basic() [4/4]

template<class ... Args>

void c4::yml::err_basic	(	ErrorDataBasic const &	errdata,
		const char *	fmt,
		Args const &...	args )

trigger a basic error to its respective handler, with a formatted error message.

Like (1), but use the current global callbacks.

Definition at line 338 of file error.hpp.

{
    err_basic(get_callbacks(), errdata, fmt, args...);
    C4_UNREACHABLE_AFTER_ERR();
}

err_parse_format()

template<class DumpFn>

void c4::yml::err_parse_format	(	DumpFn &&	dumpfn,
		csubstr	msg,
		ErrorDataParse const &	errdata )

Given an error message and associated parse error data, format it fully as a parse error message.

Parameters

dumpfn	function taking a csubstr and abstracting a string concatenation operation, such as appending to a std::string or printing to terminal.
msg	the error message
errdata	the error data

For example:

/// to output to cerr:
/// this is what err_parse_print() does
err_parse_format([](csubstr s){
    std::cerr.write(s.str, s.len);
}, errmsg, errdata);
 
/// to build a string:
std::string msg;
err_parse_format([](csubstr s){
    s.append(s.str, s.len);
}, errmsg, errdata);

Note

if the (preferably original) source buffer is kept, location_format_with_context() can be used to also an additional rich error message showing the YAML source buffer region around that location.

Definition at line 331 of file error.def.hpp.

{
    if(errdata.ymlloc)
    {
        location_format(std::forward<DumpFn>(dumpfn), errdata.ymlloc);
        std::forward<DumpFn>(dumpfn)(" ");
    }
    std::forward<DumpFn>(dumpfn)("ERROR: [parse] ");
    std::forward<DumpFn>(dumpfn)(msg);
    if(errdata.cpploc)
    {
        std::forward<DumpFn>(dumpfn)("\n");
        location_format(std::forward<DumpFn>(dumpfn), errdata.cpploc);
        std::forward<DumpFn>(dumpfn)(" (detected here)");
    }
}

err_parse() [1/4]

void c4::yml::err_parse	(	Callbacks const &	callbacks,
		ErrorDataParse const &	errdata,
		const char *	msg_ )

trigger a parse error to its respective handler, with a non-formatted error message

Definition at line 215 of file common.cpp.

{
    csubstr msg = to_csubstr(msg_);
    if(callbacks.m_error_parse)
        callbacks.m_error_parse(msg, errdata, callbacks.m_user_data);
    // fall to basic error if there is no parse handler set
    else if(callbacks.m_error_basic)
        callbacks.m_error_basic(msg, errdata.ymlloc, callbacks.m_user_data);
    abort(); // the call above should not return, so force it here in case it does // LCOV_EXCL_LINE
    C4_UNREACHABLE_AFTER_ERR();
}

err_parse() [2/4]

void c4::yml::err_parse	(	ErrorDataParse const &	errdata,
		const char *	msg )

trigger a parse error to its respective handler, with a non-formatted error message.

Like (1), but use the current global callbacks.

Definition at line 210 of file common.cpp.

{
    err_parse(get_callbacks(), errdata, msg);
    C4_UNREACHABLE_AFTER_ERR();
}

err_parse() [3/4]

template<class ... Args>

void c4::yml::err_parse	(	Callbacks const &	callbacks,
		ErrorDataParse const &	errdata,
		const char *	fmt,
		Args const &...	args )

trigger a parse error to its respective handler, with a formatted error message

Definition at line 383 of file error.hpp.

{
    char errbuf[RYML_ERRMSG_SIZE];
    csubstr msg = detail::_mk_err_msg(errbuf, to_csubstr(fmt), args...);
    if(callbacks.m_error_parse)
        callbacks.m_error_parse(msg, errdata, callbacks.m_user_data);
    // fall to basic error if there is no parse handler set, but use errdata.ymlloc instead of errdata.cpploc
    else if(callbacks.m_error_basic)
        callbacks.m_error_basic(msg, errdata.ymlloc, callbacks.m_user_data);
    std::abort(); // the call above should not return, so force it here in case it does // LCOV_EXCL_LINE
    C4_UNREACHABLE_AFTER_ERR();
}

err_parse() [4/4]

template<class ... Args>

void c4::yml::err_parse	(	ErrorDataParse const &	errdata,
		const char *	fmt,
		Args const &...	args )

trigger a parse error to its respective handler, with a formatted error message.

Like (1), but use the current global callbacks.

Definition at line 397 of file error.hpp.

{
    err_parse(get_callbacks(), errdata, fmt, args...);
    C4_UNREACHABLE_AFTER_ERR();
}

err_visit_format()

template<class DumpFn>

void c4::yml::err_visit_format	(	DumpFn &&	dumpfn,
		csubstr	msg,
		ErrorDataVisit const &	errdata )

Given an error message and associated visit error data, format it fully as a visit error message.

Parameters

dumpfn	function taking a csubstr and abstracting a string concatenation operation, such as appending to a std::string or printing to terminal.
msg	the error message
errdata	the error data

For example:

/// to output to cerr:
err_visit_format([](csubstr s){
    std::cerr.write(s.str, s.len);
}, errmsg, errdata);
 
/// to build a string:
std::string msg;
err_visit_format([&msg](csubstr s){
    msg.append(s.str, s.len);
}, errmsg, errdata);
 
@note under certain conditions, it is possible to obtain an
associated location, and subsequently use @ref
location_format_with_context() to also create a rich error message
showing the YAML source buffer region around that location. This is
possible if the (preferably original) source buffer is kept, and
the node location can be retrieved from the parser.

Definition at line 350 of file error.def.hpp.

{
    char buf_[32];
    substr buf(buf_);
    if(errdata.cpploc)
    {
        location_format(dumpfn, errdata.cpploc);
        std::forward<DumpFn>(dumpfn)(" ");
    }
    std::forward<DumpFn>(dumpfn)("ERROR: [visit] ");
    std::forward<DumpFn>(dumpfn)(msg);
    if(errdata.node != NONE && errdata.tree != nullptr)
    {
        if(errdata.cpploc)
        {
            std::forward<DumpFn>(dumpfn)("\n");
            location_format(dumpfn, errdata.cpploc);
            std::forward<DumpFn>(dumpfn)(" ");
        }
        std::forward<DumpFn>(dumpfn)("ERROR: (");
        if(errdata.node != NONE)
        {
            std::forward<DumpFn>(dumpfn)("node=");
            std::forward<DumpFn>(dumpfn)(detail::_to_chars_limited(buf, errdata.node));
            if(errdata.tree != nullptr)
                std::forward<DumpFn>(dumpfn)(" ");
        }
        if(errdata.tree != nullptr)
        {
            std::forward<DumpFn>(dumpfn)("tree=");
            std::forward<DumpFn>(dumpfn)(detail::_to_chars_limited(buf, static_cast<void const*>(errdata.tree)));
        }
        std::forward<DumpFn>(dumpfn)(")");
    }
}

err_visit() [1/4]

void c4::yml::err_visit	(	Callbacks const &	callbacks,
		ErrorDataVisit const &	errdata,
		const char *	msg_ )

trigger a visit error to its respective handler, with a non-formatted error message

Definition at line 233 of file common.cpp.

{
    csubstr msg = to_csubstr(msg_);
    if(callbacks.m_error_visit)
        callbacks.m_error_visit(msg, errdata, callbacks.m_user_data);
    // fall to basic error if there is no visit handler set
    else if(callbacks.m_error_basic)
        callbacks.m_error_basic(msg, errdata.cpploc, callbacks.m_user_data);
    abort(); // the call above should not return, so force it here in case it does // LCOV_EXCL_LINE
    C4_UNREACHABLE_AFTER_ERR();
}

err_visit() [2/4]

void c4::yml::err_visit	(	ErrorDataVisit const &	errdata,
		const char *	msg )

trigger a visit error to its respective handler, with a non-formatted error message.

Like (1), but uses the current global callbacks.

Definition at line 228 of file common.cpp.

{
    err_visit(get_callbacks(), errdata, msg);
    C4_UNREACHABLE_AFTER_ERR();
}

err_visit() [3/4]

template<class ... Args>

void c4::yml::err_visit	(	Callbacks const &	callbacks,
		ErrorDataVisit const &	errdata,
		const char *	fmt,
		Args const &...	args )

trigger a visit error to its respective handler, with a formatted error message

Definition at line 445 of file error.hpp.

{
    char errbuf[RYML_ERRMSG_SIZE];
    csubstr msg = detail::_mk_err_msg(errbuf, to_csubstr(fmt), args...);
    if(callbacks.m_error_visit)
        callbacks.m_error_visit(msg, errdata, callbacks.m_user_data);
    // fall to basic error if there is no visit handler set
    else if(callbacks.m_error_basic)
        callbacks.m_error_basic(msg, errdata.cpploc, callbacks.m_user_data);
    std::abort(); // the call above should not return, so force it here in case it does // LCOV_EXCL_LINE
    C4_UNREACHABLE_AFTER_ERR();
}

err_visit() [4/4]

template<class ... Args>

void c4::yml::err_visit	(	ErrorDataVisit const &	errdata,
		const char *	fmt,
		Args const &...	args )

trigger a visit error to its respective handler, with a formatted error message.

Like (1), but use the current global callbacks.

Definition at line 459 of file error.hpp.

{
    err_visit(get_callbacks(), errdata, fmt, args...);
    C4_UNREACHABLE_AFTER_ERR();
}

format_exc() [1/4]

template<class CharContainer>

void c4::yml::format_exc	(	CharContainer *	out,
		ExceptionBasic const &	exc )

Format a basic exception to an existing char container.

Note

Available only if RYML_DEFAULT_CALLBACK_USES_EXCEPTIONS is defined, and RYML_NO_DEFAULT_CALLBACKS is NOT defined.

Definition at line 526 of file error.hpp.

{
    out->clear();
    err_basic_format([out](csubstr s){
        out->append(s.str, s.len);
    }, csubstr{exc.msg, strlen(exc.msg)}, exc.errdata_basic);
}

format_exc() [2/4]

template<class CharContainer>

void c4::yml::format_exc	(	CharContainer *	out,
		ExceptionParse const &	exc )

Format a parse exception to an existing char container.

Note

Available only if RYML_DEFAULT_CALLBACK_USES_EXCEPTIONS is defined, and RYML_NO_DEFAULT_CALLBACKS is NOT defined.

Definition at line 539 of file error.hpp.

{
    out->clear();
    err_parse_format([out](csubstr s){
        out->append(s.str, s.len);
    }, csubstr{exc.msg, strlen(exc.msg)}, exc.errdata_parse);
}

format_exc() [3/4]

template<class CharContainer>

void c4::yml::format_exc	(	CharContainer *	out,
		ExceptionVisit const &	exc )

Format a visit exception to an existing char container.

Note

Available only if RYML_DEFAULT_CALLBACK_USES_EXCEPTIONS is defined, and RYML_NO_DEFAULT_CALLBACKS is NOT defined.

Definition at line 552 of file error.hpp.

{
    out->clear();
    err_visit_format([out](csubstr s){
        out->append(s.str, s.len);
    }, csubstr{exc.msg, strlen(exc.msg)}, exc.errdata_visit);
}

format_exc() [4/4]

template<class CharContainer, class ExceptionT>

CharContainer c4::yml::format_exc

(

ExceptionT const &

exc

)

Format a parse exception, and return a newly-created char container.

Note

Available only if RYML_DEFAULT_CALLBACK_USES_EXCEPTIONS is defined, and RYML_NO_DEFAULT_CALLBACKS is NOT defined.

Definition at line 566 of file error.hpp.

{
    CharContainer str;
    format_exc(&str, exc);
    return str;
}