AuroraMiddleware/toml11
1
0
Fork 0
mirror of https://github.com/ToruNiina/toml11.git synced 2024-11-25 13:50:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: use source_location, not region_base*

Browse Source
This commit is contained in:
ToruNiina 2020-07-27 22:29:18 +09:00
parent ce68f6f4c2
commit 32a5341d09
5 changed files with 296 additions and 281 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
toml/get.hpp
View File

@ -189,7 +189,7 @@ get(const basic_value<C, M, V>& v)
{
throw type_error(detail::format_underline("toml::value: "
"bad_cast to std::chrono::system_clock::time_point", {
{detail::get_region(v),
{source_location(detail::get_region(v)),
concat_to_string("the actual type is ", v.type())}
}), v.location());
}
@ -336,7 +336,7 @@ get(const basic_value<C, M, V>& v)
throw std::out_of_range(detail::format_underline(concat_to_string(
"toml::get: specified container size is ", container.size(),
" but there are ", ar.size(), " elements in toml array."), {
{detail::get_region(v), "here"}
{source_location(detail::get_region(v)), "here"}
}));
}
std::transform(ar.cbegin(), ar.cend(), container.begin(),
@ -361,7 +361,7 @@ get(const basic_value<C, M, V>& v)
throw std::out_of_range(detail::format_underline(concat_to_string(
"toml::get: specified std::pair but there are ", ar.size(),
" elements in toml array."), {
{detail::get_region(v), "here"}
{source_location(detail::get_region(v)), "here"}
}));
}
return std::make_pair(::toml::get<first_type >(ar.at(0)),
@ -393,7 +393,7 @@ get(const basic_value<C, M, V>& v)
"toml::get: specified std::tuple with ",
std::tuple_size<T>::value, " elements, but there are ", ar.size(),
" elements in toml array."), {
{detail::get_region(v), "here"}
{source_location(detail::get_region(v)), "here"}
}));
}
return detail::get_tuple_impl<T>(ar,
@ -512,7 +512,7 @@ find(const basic_value<C, M, V>& v, const std::size_t idx)
{
throw std::out_of_range(detail::format_underline(concat_to_string(
"index ", idx, " is out of range"), {
{detail::get_region(v), "in this array"}
{source_location(detail::get_region(v)), "in this array"}
}));
}
return ary.at(idx);
@ -526,7 +526,7 @@ basic_value<C, M, V>& find(basic_value<C, M, V>& v, const std::size_t idx)
{
throw std::out_of_range(detail::format_underline(concat_to_string(
"index ", idx, " is out of range"), {
{detail::get_region(v), "in this array"}
{source_location(detail::get_region(v)), "in this array"}
}));
}
return ary.at(idx);
@ -540,7 +540,7 @@ basic_value<C, M, V> find(basic_value<C, M, V>&& v, const std::size_t idx)
{
throw std::out_of_range(detail::format_underline(concat_to_string(
"index ", idx, " is out of range"), {
{detail::get_region(v), "in this array"}
{source_location(detail::get_region(v)), "in this array"}
}));
}
return basic_value<C, M, V>(std::move(ary.at(idx)));
@ -600,7 +600,7 @@ find(const basic_value<C, M, V>& v, const std::size_t idx)
{
throw std::out_of_range(detail::format_underline(concat_to_string(
"index ", idx, " is out of range"), {
{detail::get_region(v), "in this array"}
{source_location(detail::get_region(v)), "in this array"}
}));
}
return ::toml::get<T>(ary.at(idx));
@ -615,7 +615,7 @@ find(basic_value<C, M, V>& v, const std::size_t idx)
{
throw std::out_of_range(detail::format_underline(concat_to_string(
"index ", idx, " is out of range"), {
{detail::get_region(v), "in this array"}
{source_location(detail::get_region(v)), "in this array"}
}));
}
return ::toml::get<T>(ary.at(idx));
@ -630,7 +630,7 @@ find(basic_value<C, M, V>&& v, const std::size_t idx)
{
throw std::out_of_range(detail::format_underline(concat_to_string(
"index ", idx, " is out of range"), {
{detail::get_region(v), "in this array"}
{source_location(detail::get_region(v)), "in this array"}
}));
}
return ::toml::get<T>(std::move(ary.at(idx)));

298
toml/parser.hpp
View File

@ -38,13 +38,13 @@ parse_boolean(location& loc)
{
throw internal_error(format_underline(
"toml::parse_boolean: internal error",
{{std::addressof(reg), "invalid token"}}),
{{source_location(reg), "invalid token"}}),
source_location(std::addressof(reg)));
}
}
loc.reset(first); //rollback
return err(format_underline("toml::parse_boolean: ",
{{std::addressof(loc), "the next token is not a boolean"}}));
{{source_location(loc), "the next token is not a boolean"}}));
}
inline result<std::pair<integer, region>, std::string>
@ -65,7 +65,7 @@ parse_binary_integer(location& loc)
{
throw internal_error(format_underline(
"toml::parse_integer: internal error",
{{std::addressof(token.unwrap()), "invalid token"}}),
{{source_location(token.unwrap()), "invalid token"}}),
source_location(std::addressof(loc)));
}
}
@ -73,7 +73,7 @@ parse_binary_integer(location& loc)
}
loc.reset(first);
return err(format_underline("toml::parse_binary_integer:",
{{std::addressof(loc), "the next token is not an integer"}}));
{{source_location(loc), "the next token is not an integer"}}));
}
inline result<std::pair<integer, region>, std::string>
@ -93,7 +93,7 @@ parse_octal_integer(location& loc)
}
loc.reset(first);
return err(format_underline("toml::parse_octal_integer:",
{{std::addressof(loc), "the next token is not an integer"}}));
{{source_location(loc), "the next token is not an integer"}}));
}
inline result<std::pair<integer, region>, std::string>
@ -113,7 +113,7 @@ parse_hexadecimal_integer(location& loc)
}
loc.reset(first);
return err(format_underline("toml::parse_hexadecimal_integer",
{{std::addressof(loc), "the next token is not an integer"}}));
{{source_location(loc), "the next token is not an integer"}}));
}
inline result<std::pair<integer, region>, std::string>
@ -136,13 +136,13 @@ parse_integer(location& loc)
{
return err(format_underline("toml::parse_integer: "
"leading zero in an Integer is not allowed.",
{{std::addressof(loc), "leading zero"}}));
{{source_location(loc), "leading zero"}}));
}
else if(std::isalpha(*second))
{
return err(format_underline("toml::parse_integer: "
"unknown integer prefix appeared.",
{{std::addressof(loc), "none of 0x, 0o, 0b"}}));
{{source_location(loc), "none of 0x, 0o, 0b"}}));
}
}
@ -158,7 +158,7 @@ parse_integer(location& loc)
}
loc.reset(first);
return err(format_underline("toml::parse_integer: ",
{{std::addressof(loc), "the next token is not an integer"}}));
{{source_location(loc), "the next token is not an integer"}}));
}
inline result<std::pair<floating, region>, std::string>
@ -246,7 +246,7 @@ parse_floating(location& loc)
}
loc.reset(first);
return err(format_underline("toml::parse_floating: ",
{{std::addressof(loc), "the next token is not a float"}}));
{{source_location(loc), "the next token is not a float"}}));
}
inline std::string read_utf8_codepoint(const region& reg, const location& loc)
@ -279,7 +279,7 @@ inline std::string read_utf8_codepoint(const region& reg, const location& loc)
throw syntax_error(format_underline(
"toml::read_utf8_codepoint: codepoints in the range "
"[0xD800, 0xDFFF] are not valid UTF-8.", {{
std::addressof(loc), "not a valid UTF-8 codepoint"
source_location(loc), "not a valid UTF-8 codepoint"
}}), source_location(std::addressof(loc)));
}
assert(codepoint < 0xD800 || 0xDFFF < codepoint);
@ -300,7 +300,7 @@ inline std::string read_utf8_codepoint(const region& reg, const location& loc)
{
throw syntax_error(format_underline("toml::read_utf8_codepoint:"
" input codepoint is too large.",
{{std::addressof(loc), "should be in [0x00..0x10FFFF]"}}),
{{source_location(loc), "should be in [0x00..0x10FFFF]"}}),
source_location(std::addressof(loc)));
}
return character;
@ -312,7 +312,7 @@ inline result<std::string, std::string> parse_escape_sequence(location& loc)
if(first == loc.end() || *first != '\\')
{
return err(format_underline("toml::parse_escape_sequence: ", {{
std::addressof(loc), "the next token is not a backslash \"\\\""}}));
source_location(loc), "the next token is not a backslash \"\\\""}}));
}
loc.advance();
switch(*loc.iter())
@ -334,7 +334,7 @@ inline result<std::string, std::string> parse_escape_sequence(location& loc)
{
return err(format_underline("parse_escape_sequence: "
"invalid token found in UTF-8 codepoint uXXXX.",
{{std::addressof(loc), "here"}}));
{{source_location(loc), "here"}}));
}
}
case 'U':
@ -347,13 +347,13 @@ inline result<std::string, std::string> parse_escape_sequence(location& loc)
{
return err(format_underline("parse_escape_sequence: "
"invalid token found in UTF-8 codepoint Uxxxxxxxx",
{{std::addressof(loc), "here"}}));
{{source_location(loc), "here"}}));
}
}
}
const auto msg = format_underline("parse_escape_sequence: "
"unknown escape sequence appeared.", {{std::addressof(loc),
"unknown escape sequence appeared.", {{source_location(loc),
"escape sequence is one of \\, \", b, t, n, f, r, uxxxx, Uxxxxxxxx"}},
/* Hints = */{"if you want to write backslash as just one backslash, "
"use literal string like: regex = '<\\i\\c*\\s*>'"});
@ -378,8 +378,8 @@ parse_ml_basic_string(location& loc)
{
throw internal_error(format_underline(
"parse_ml_basic_string: invalid token",
{{std::addressof(inner_loc), "should be \"\"\""}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "should be \"\"\""}}),
source_location(inner_loc));
}
// immediate newline is ignored (if exists)
/* discard return value */ lex_newline::invoke(inner_loc);
@ -405,8 +405,8 @@ parse_ml_basic_string(location& loc)
{
throw internal_error(format_underline(
"parse_ml_basic_string: unexpected end of region",
{{std::addressof(inner_loc), "not sufficient token"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "not sufficient token"}}),
source_location(inner_loc));
}
delim = lex_ml_basic_string_close::invoke(inner_loc);
}
@ -425,8 +425,8 @@ parse_ml_basic_string(location& loc)
{
throw internal_error(format_underline(
"parse_ml_basic_string: closing delimiter has invalid length",
{{std::addressof(inner_loc), "end of this"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "end of this"}}),
source_location(inner_loc));
}
}
return ok(std::make_pair(toml::string(retval), token.unwrap()));
@ -436,7 +436,7 @@ parse_ml_basic_string(location& loc)
loc.reset(first);
return err(format_underline("toml::parse_ml_basic_string: "
"the next token is not a valid multiline string",
{{std::addressof(loc), "here"}}));
{{source_location(loc), "here"}}));
}
}
@ -453,8 +453,8 @@ parse_basic_string(location& loc)
if(!quot)
{
throw internal_error(format_underline("parse_basic_string: "
"invalid token", {{std::addressof(inner_loc), "should be \""}}),
source_location(std::addressof(inner_loc)));
"invalid token", {{source_location(inner_loc), "should be \""}}),
source_location(inner_loc));
}
std::string retval;
@ -476,8 +476,8 @@ parse_basic_string(location& loc)
{
throw internal_error(format_underline(
"parse_basic_string: unexpected end of region",
{{std::addressof(inner_loc), "not sufficient token"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "not sufficient token"}}),
source_location(inner_loc));
}
quot = lex_quotation_mark::invoke(inner_loc);
}
@ -488,7 +488,7 @@ parse_basic_string(location& loc)
loc.reset(first); // rollback
return err(format_underline("toml::parse_basic_string: "
"the next token is not a valid string",
{{std::addressof(loc), "here"}}));
{{source_location(loc), "here"}}));
}
}
@ -505,8 +505,8 @@ parse_ml_literal_string(location& loc)
{
throw internal_error(format_underline(
"parse_ml_literal_string: invalid token",
{{std::addressof(inner_loc), "should be '''"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "should be '''"}}),
source_location(inner_loc));
}
// immediate newline is ignored (if exists)
/* discard return value */ lex_newline::invoke(inner_loc);
@ -518,8 +518,8 @@ parse_ml_literal_string(location& loc)
{
throw internal_error(format_underline(
"parse_ml_literal_string: invalid token",
{{std::addressof(inner_loc), "should be '''"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "should be '''"}}),
source_location(inner_loc));
}
// `lex_ml_literal_string_close` allows 3 to 5 `'`s to allow 1 or 2 `'`s
// at just before the delimiter. Here, we need to attach `'`s at the
@ -538,8 +538,8 @@ parse_ml_literal_string(location& loc)
{
throw internal_error(format_underline(
"parse_ml_literal_string: closing delimiter has invalid length",
{{std::addressof(inner_loc), "end of this"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "end of this"}}),
source_location(inner_loc));
}
}
return ok(std::make_pair(toml::string(retval, toml::string_t::literal),
@ -550,7 +550,7 @@ parse_ml_literal_string(location& loc)
loc.reset(first); // rollback
return err(format_underline("toml::parse_ml_literal_string: "
"the next token is not a valid multiline literal string",
{{std::addressof(loc), "here"}}));
{{source_location(loc), "here"}}));
}
}
@ -567,8 +567,8 @@ parse_literal_string(location& loc)
{
throw internal_error(format_underline(
"parse_literal_string: invalid token",
{{std::addressof(inner_loc), "should be '"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "should be '"}}),
source_location(inner_loc));
}
const auto body = repeat<lex_literal_char, unlimited>::invoke(inner_loc);
@ -578,8 +578,8 @@ parse_literal_string(location& loc)
{
throw internal_error(format_underline(
"parse_literal_string: invalid token",
{{std::addressof(inner_loc), "should be '"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "should be '"}}),
source_location(inner_loc));
}
return ok(std::make_pair(
toml::string(body.unwrap().str(), toml::string_t::literal),
@ -590,7 +590,7 @@ parse_literal_string(location& loc)
loc.reset(first); // rollback
return err(format_underline("toml::parse_literal_string: "
"the next token is not a valid literal string",
{{std::addressof(loc), "here"}}));
{{source_location(loc), "here"}}));
}
}
@ -622,7 +622,7 @@ parse_string(location& loc)
}
}
return err(format_underline("toml::parse_string: ",
{{std::addressof(loc), "the next token is not a string"}}));
{{source_location(loc), "the next token is not a string"}}));
}
inline result<std::pair<local_date, region>, std::string>
@ -638,8 +638,8 @@ parse_local_date(location& loc)
{
throw internal_error(format_underline(
"toml::parse_inner_local_date: invalid year format",
{{std::addressof(inner_loc), "should be `-`"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "should be `-`"}}),
source_location(inner_loc));
}
inner_loc.advance();
const auto m = lex_date_month::invoke(inner_loc);
@ -647,8 +647,8 @@ parse_local_date(location& loc)
{
throw internal_error(format_underline(
"toml::parse_local_date: invalid month format",
{{std::addressof(inner_loc), "should be `-`"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "should be `-`"}}),
source_location(inner_loc));
}
inner_loc.advance();
const auto d = lex_date_mday::invoke(inner_loc);
@ -656,8 +656,8 @@ parse_local_date(location& loc)
{
throw internal_error(format_underline(
"toml::parse_local_date: invalid day format",
{{std::addressof(inner_loc), "here"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "here"}}),
source_location(inner_loc));
}
return ok(std::make_pair(local_date(
static_cast<std::int16_t>(from_string<int>(y.unwrap().str(), 0)),
@ -670,7 +670,7 @@ parse_local_date(location& loc)
{
loc.reset(first);
return err(format_underline("toml::parse_local_date: ",
{{std::addressof(loc), "the next token is not a local_date"}}));
{{source_location(loc), "the next token is not a local_date"}}));
}
}
@ -687,8 +687,8 @@ parse_local_time(location& loc)
{
throw internal_error(format_underline(
"toml::parse_local_time: invalid year format",
{{std::addressof(inner_loc), "should be `:`"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "should be `:`"}}),
source_location(inner_loc));
}
inner_loc.advance();
const auto m = lex_time_minute::invoke(inner_loc);
@ -696,8 +696,8 @@ parse_local_time(location& loc)
{
throw internal_error(format_underline(
"toml::parse_local_time: invalid month format",
{{std::addressof(inner_loc), "should be `:`"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "should be `:`"}}),
source_location(inner_loc));
}
inner_loc.advance();
const auto s = lex_time_second::invoke(inner_loc);
@ -705,8 +705,8 @@ parse_local_time(location& loc)
{
throw internal_error(format_underline(
"toml::parse_local_time: invalid second format",
{{std::addressof(inner_loc), "here"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "here"}}),
source_location(inner_loc));
}
local_time time(
from_string<int>(h.unwrap().str(), 0),
@ -748,8 +748,8 @@ parse_local_time(location& loc)
{
throw internal_error(format_underline(
"toml::parse_local_time: invalid subsecond format",
{{std::addressof(inner_loc), "here"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "here"}}),
source_location(inner_loc));
}
}
return ok(std::make_pair(time, token.unwrap()));
@ -758,7 +758,7 @@ parse_local_time(location& loc)
{
loc.reset(first);
return err(format_underline("toml::parse_local_time: ",
{{std::addressof(loc), "the next token is not a local_time"}}));
{{source_location(loc), "the next token is not a local_time"}}));
}
}
@ -774,16 +774,16 @@ parse_local_datetime(location& loc)
{
throw internal_error(format_underline(
"toml::parse_local_datetime: invalid datetime format",
{{std::addressof(inner_loc), "date, not datetime"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "date, not datetime"}}),
source_location(inner_loc));
}
const char delim = *(inner_loc.iter());
if(delim != 'T' && delim != 't' && delim != ' ')
{
throw internal_error(format_underline(
"toml::parse_local_datetime: invalid datetime format",
{{std::addressof(inner_loc), "should be `T` or ` ` (space)"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "should be `T` or ` ` (space)"}}),
source_location(inner_loc));
}
inner_loc.advance();
const auto time = parse_local_time(inner_loc);
@ -791,8 +791,8 @@ parse_local_datetime(location& loc)
{
throw internal_error(format_underline(
"toml::parse_local_datetime: invalid datetime format",
{{std::addressof(inner_loc), "invalid time fomrat"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "invalid time fomrat"}}),
source_location(inner_loc));
}
return ok(std::make_pair(
local_datetime(date.unwrap().first, time.unwrap().first),
@ -802,7 +802,7 @@ parse_local_datetime(location& loc)
{
loc.reset(first);
return err(format_underline("toml::parse_local_datetime: ",
{{std::addressof(loc), "the next token is not a local_datetime"}}));
{{source_location(loc), "the next token is not a local_datetime"}}));
}
}
@ -818,8 +818,8 @@ parse_offset_datetime(location& loc)
{
throw internal_error(format_underline(
"toml::parse_offset_datetime: invalid datetime format",
{{std::addressof(inner_loc), "date, not datetime"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "date, not datetime"}}),
source_location(inner_loc));
}
time_offset offset(0, 0);
if(const auto ofs = lex_time_numoffset::invoke(inner_loc))
@ -840,8 +840,8 @@ parse_offset_datetime(location& loc)
{
throw internal_error(format_underline(
"toml::parse_offset_datetime: invalid datetime format",
{{std::addressof(inner_loc), "should be `Z` or `+HH:MM`"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "should be `Z` or `+HH:MM`"}}),
source_location(inner_loc));
}
return ok(std::make_pair(offset_datetime(datetime.unwrap().first, offset),
token.unwrap()));
@ -850,7 +850,7 @@ parse_offset_datetime(location& loc)
{
loc.reset(first);
return err(format_underline("toml::parse_offset_datetime: ",
{{std::addressof(loc), "the next token is not a offset_datetime"}}));
{{source_location(loc), "the next token is not a offset_datetime"}}));
}
}
@ -871,7 +871,7 @@ parse_simple_key(location& loc)
return ok(std::make_pair(reg.str(), reg));
}
return err(format_underline("toml::parse_simple_key: ",
{{std::addressof(loc), "the next token is not a simple key"}}));
{{source_location(loc), "the next token is not a simple key"}}));
}
// dotted key become vector of keys
@ -897,8 +897,8 @@ parse_key(location& loc)
{
throw internal_error(format_underline(
"toml::detail::parse_key: dotted key contains invalid key",
{{std::addressof(inner_loc), k.unwrap_err()}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), k.unwrap_err()}}),
source_location(inner_loc));
}
lex_ws::invoke(inner_loc);
@ -914,8 +914,8 @@ parse_key(location& loc)
{
throw internal_error(format_underline("toml::parse_key: "
"dotted key contains invalid key ",
{{std::addressof(inner_loc), "should be `.`"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "should be `.`"}}),
source_location(inner_loc));
}
}
return ok(std::make_pair(keys, reg));
@ -929,7 +929,7 @@ parse_key(location& loc)
smpl.unwrap().second));
}
return err(format_underline("toml::parse_key: ",
{{std::addressof(loc), "is not a valid key"}}));
{{source_location(loc), "is not a valid key"}}));
}
// forward-decl to implement parse_array and parse_table
@ -984,16 +984,16 @@ parse_array(location& loc)
throw syntax_error(format_underline("toml::parse_array: "
"type of elements should be the same each other.", {
{std::addressof(array_start_loc), "array starts here"},
{source_location(array_start_loc), "array starts here"},
{
get_region(retval.front()),
retval.front().location(),
"value has type " + stringize(retval.front().type())
},
{
get_region(val.unwrap()),
val.unwrap().location(),
"value has different type, " + stringize(val.unwrap().type())
}
}), source_location(std::addressof(loc)));
}), source_location(loc));
}
#endif
retval.push_back(std::move(val.unwrap()));
@ -1005,8 +1005,8 @@ parse_array(location& loc)
throw syntax_error(format_underline("toml::parse_array: "
"value having invalid format appeared in an array", {
{std::addressof(array_start_loc), "array starts here"},
{std::addressof(loc), "it is not a valid value."}
{source_location(array_start_loc), "array starts here"},
{source_location(loc), "it is not a valid value."}
}), source_location(std::addressof(loc)));
}
@ -1028,8 +1028,8 @@ parse_array(location& loc)
throw syntax_error(format_underline("toml::parse_array:"
" missing array separator `,` after a value", {
{std::addressof(array_start_loc), "array starts here"},
{std::addressof(loc), "should be `,`"}
{source_location(array_start_loc), "array starts here"},
{source_location(loc), "should be `,`"}
}), source_location(std::addressof(loc)));
}
}
@ -1037,7 +1037,7 @@ parse_array(location& loc)
loc.reset(first);
throw syntax_error(format_underline("toml::parse_array: "
"array did not closed by `]`",
{{std::addressof(loc), "should be closed"}}),
{{source_location(loc), "should be closed"}}),
source_location(std::addressof(loc)));
}
@ -1059,7 +1059,7 @@ parse_key_value_pair(location& loc)
loc.reset(first);
msg = format_underline("toml::parse_key_value_pair: "
"empty key is not allowed.",
{{std::addressof(loc), "key expected before '='"}});
{{source_location(loc), "key expected before '='"}});
}
return err(std::move(msg));
}
@ -1075,7 +1075,7 @@ parse_key_value_pair(location& loc)
{
msg = format_underline("toml::parse_key_value_pair: "
"invalid format for key",
{{std::addressof(loc), "invalid character in key"}},
{{source_location(loc), "invalid character in key"}},
{"Did you forget '.' to separate dotted-key?",
"Allowed characters for bare key are [0-9a-zA-Z_-]."});
}
@ -1083,7 +1083,7 @@ parse_key_value_pair(location& loc)
{
msg = format_underline("toml::parse_key_value_pair: "
"missing key-value separator `=`",
{{std::addressof(loc), "should be `=`"}});
{{source_location(loc), "should be `=`"}});
}
loc.reset(first);
return err(std::move(msg));
@ -1101,7 +1101,7 @@ parse_key_value_pair(location& loc)
loc.reset(after_kvsp);
msg = format_underline("toml::parse_key_value_pair: "
"missing value after key-value separator '='",
{{std::addressof(loc), "expected value, but got nothing"}});
{{source_location(loc), "expected value, but got nothing"}});
}
else // there is something not a comment/whitespace, so invalid format.
{
@ -1241,8 +1241,8 @@ insert_nested_key(typename Value::table_type& root, const Value& v,
"toml::insert_value: array of table (\"",
format_dotted_keys(first, last),
"\") cannot be defined"), {
{get_region(tab->at(k)), "table already defined"},
{get_region(v), "this conflicts with the previous table"}
{tab->at(k).location(), "table already defined"},
{v.location(), "this conflicts with the previous table"}
}), v.location());
}
else if(!(tab->at(k).is_array()))
@ -1251,10 +1251,10 @@ insert_nested_key(typename Value::table_type& root, const Value& v,
"toml::insert_value: array of table (\"",
format_dotted_keys(first, last), "\") collides with"
" existing value"), {
{get_region(tab->at(k)),
{tab->at(k).location(),
concat_to_string("this ", tab->at(k).type(),
" value already exists")},
{get_region(v),
{v.location(),
"while inserting this array-of-tables"}
}), v.location());
}
@ -1266,10 +1266,10 @@ insert_nested_key(typename Value::table_type& root, const Value& v,
"toml::insert_value: array of table (\"",
format_dotted_keys(first, last), "\") collides with"
" existing value"), {
{get_region(tab->at(k)),
{tab->at(k).location(),
concat_to_string("this ", tab->at(k).type(),
" value already exists")},
{get_region(v),
{v.location(),
"while inserting this array-of-tables"}
}), v.location());
}
@ -1296,10 +1296,10 @@ insert_nested_key(typename Value::table_type& root, const Value& v,
"toml::insert_value: array of table (\"",
format_dotted_keys(first, last), "\") collides "
"with existing array-of-tables"), {
{get_region(tab->at(k)),
{tab->at(k).location(),
concat_to_string("this ", tab->at(k).type(),
" value has static size")},
{get_region(v),
{v.location(),
"appending it to the statically sized array"}
}), v.location());
}
@ -1326,8 +1326,8 @@ insert_nested_key(typename Value::table_type& root, const Value& v,
"toml::insert_value: table (\"",
format_dotted_keys(first, last),
"\") already exists."), {
{get_region(tab->at(k)), "table already exists here"},
{get_region(v), "table defined twice"}
{tab->at(k).location(), "table already exists here"},
{v.location(), "table defined twice"}
}), v.location());
}
// to allow the following toml file.
@ -1351,8 +1351,8 @@ insert_nested_key(typename Value::table_type& root, const Value& v,
throw syntax_error(format_underline(concat_to_string(
"toml::insert_value: array of tables (\"",
format_dotted_keys(first, last), "\") already exists."), {
{get_region(tab->at(k)), "array of tables defined here"},
{get_region(v), "table conflicts with the previous array of table"}
{tab->at(k).location(), "array of tables defined here"},
{v.location(), "table conflicts with the previous array of table"}
}), v.location());
}
else
@ -1360,8 +1360,8 @@ insert_nested_key(typename Value::table_type& root, const Value& v,
throw syntax_error(format_underline(concat_to_string(
"toml::insert_value: value (\"",
format_dotted_keys(first, last), "\") already exists."), {
{get_region(tab->at(k)), "value already exists here"},
{get_region(v), "value defined twice"}
{tab->at(k).location(), "value already exists here"},
{v.location(), "value defined twice"}
}), v.location());
}
}
@ -1397,8 +1397,8 @@ insert_nested_key(typename Value::table_type& root, const Value& v,
"toml::insert_value: inserting to an inline table (",
format_dotted_keys(first, std::next(iter)),
") but inline tables are immutable"), {
{get_region(tab->at(k)), "inline tables are immutable"},
{get_region(v), "inserting this"}
{tab->at(k).location(), "inline tables are immutable"},
{v.location(), "inserting this"}
}), v.location());
}
}
@ -1413,9 +1413,9 @@ insert_nested_key(typename Value::table_type& root, const Value& v,
"toml::insert_value: target (",
format_dotted_keys(first, std::next(iter)),
") is neither table nor an array of tables"), {
{get_region(a.back()), concat_to_string(
{a.back().location(), concat_to_string(
"actual type is ", a.back().type())},
{get_region(v), "inserting this"}
{v.location(), "inserting this"}
}), v.location());
}
tab = std::addressof(a.back().as_table());
@ -1426,9 +1426,9 @@ insert_nested_key(typename Value::table_type& root, const Value& v,
"toml::insert_value: target (",
format_dotted_keys(first, std::next(iter)),
") is neither table nor an array of tables"), {
{get_region(tab->at(k)), concat_to_string(
{tab->at(k).location(), concat_to_string(
"actual type is ", tab->at(k).type())},
{get_region(v), "inserting this"}
{v.location(), "inserting this"}
}), v.location());
}
}
@ -1448,7 +1448,7 @@ parse_inline_table(location& loc)
if(!(loc.iter() != loc.end() && *loc.iter() == '{'))
{
return err(format_underline("toml::parse_inline_table: ",
{{std::addressof(loc), "the next token is not an inline table"}}));
{{source_location(loc), "the next token is not an inline table"}}));
}
loc.advance();
// it starts from "{". it should be formatted as inline-table
@ -1496,23 +1496,23 @@ parse_inline_table(location& loc)
{
throw syntax_error(format_underline(
"toml::parse_inline_table: missing curly brace `}`",
{{std::addressof(loc), "should be `}`"}}),
source_location(std::addressof(loc)));
{{source_location(loc), "should be `}`"}}),
source_location(loc));
}
else
{
throw syntax_error(format_underline(
"toml::parse_inline_table: missing table separator `,` ",
{{std::addressof(loc), "should be `,`"}}),
source_location(std::addressof(loc)));
{{source_location(loc), "should be `,`"}}),
source_location(loc));
}
}
}
loc.reset(first);
throw syntax_error(format_underline("toml::parse_inline_table: "
"inline table did not closed by `}`",
{{std::addressof(loc), "should be closed"}}),
source_location(std::addressof(loc)));
{{source_location(loc), "should be closed"}}),
source_location(loc));
}
inline result<value_t, std::string> guess_number_type(const location& l)
@ -1535,7 +1535,7 @@ inline result<value_t, std::string> guess_number_type(const location& l)
|| *loc.iter() == 'Z' || *loc.iter() == 'z'))
{
return err(format_underline("bad offset: should be [+-]HH:MM or Z",
{{std::addressof(loc), "[+-]HH:MM or Z"}},
{{source_location(loc), "[+-]HH:MM or Z"}},
{"pass: +09:00, -05:30", "fail: +9:00, -5:30"}));
}
return ok(value_t::local_datetime);
@ -1555,14 +1555,14 @@ inline result<value_t, std::string> guess_number_type(const location& l)
if(c == 'T' || c == 't')
{
return err(format_underline("bad time: should be HH:MM:SS.subsec",
{{std::addressof(loc), "HH:MM:SS.subsec"}},
{{source_location(loc), "HH:MM:SS.subsec"}},
{"pass: 1979-05-27T07:32:00, 1979-05-27 07:32:00.999999",
"fail: 1979-05-27T7:32:00, 1979-05-27 17:32"}));
}
if('0' <= c && c <= '9')
{
return err(format_underline("bad time: missing T",
{{std::addressof(loc), "T or space required here"}},
{{source_location(loc), "T or space required here"}},
{"pass: 1979-05-27T07:32:00, 1979-05-27 07:32:00.999999",
"fail: 1979-05-27T7:32:00, 1979-05-27 7:32"}));
}
@ -1571,7 +1571,7 @@ inline result<value_t, std::string> guess_number_type(const location& l)
{
loc.advance();
return err(format_underline("bad time: should be HH:MM:SS.subsec",
{{std::addressof(loc), "HH:MM:SS.subsec"}},
{{source_location(loc), "HH:MM:SS.subsec"}},
{"pass: 1979-05-27T07:32:00, 1979-05-27 07:32:00.999999",
"fail: 1979-05-27T7:32:00, 1979-05-27 7:32"}));
}
@ -1588,7 +1588,7 @@ inline result<value_t, std::string> guess_number_type(const location& l)
if(loc.iter() != loc.end() && *loc.iter() == '_')
{
return err(format_underline("bad float: `_` should be surrounded by digits",
{{std::addressof(loc), "here"}},
{{source_location(loc), "here"}},
{"pass: +1.0, -2e-2, 3.141_592_653_589, inf, nan",
"fail: .0, 1., _1.0, 1.0_, 1_.0, 1.0__0"}));
}
@ -1604,7 +1604,7 @@ inline result<value_t, std::string> guess_number_type(const location& l)
if(c == '_')
{
return err(format_underline("bad integer: `_` should be surrounded by digits",
{{std::addressof(loc), "here"}},
{{source_location(loc), "here"}},
{"pass: -42, 1_000, 1_2_3_4_5, 0xC0FFEE, 0b0010, 0o755",
"fail: 1__000, 0123"}));
}
@ -1613,21 +1613,21 @@ inline result<value_t, std::string> guess_number_type(const location& l)
// leading zero. point '0'
loc.retrace();
return err(format_underline("bad integer: leading zero",
{{std::addressof(loc), "here"}},
{{source_location(loc), "here"}},
{"pass: -42, 1_000, 1_2_3_4_5, 0xC0FFEE, 0b0010, 0o755",
"fail: 1__000, 0123"}));
}
if(c == ':' || c == '-')
{
return err(format_underline("bad datetime: invalid format",
{{std::addressof(loc), "here"}},
{{source_location(loc), "here"}},
{"pass: 1979-05-27T07:32:00-07:00, 1979-05-27 07:32:00.999999Z",
"fail: 1979-05-27T7:32:00-7:00, 1979-05-27 7:32-00:30"}));
}
if(c == '.' || c == 'e' || c == 'E')
{
return err(format_underline("bad float: invalid format",
{{std::addressof(loc), "here"}},
{{source_location(loc), "here"}},
{"pass: +1.0, -2e-2, 3.141_592_653_589, inf, nan",
"fail: .0, 1., _1.0, 1.0_, 1_.0, 1.0__0"}));
}
@ -1637,19 +1637,19 @@ inline result<value_t, std::string> guess_number_type(const location& l)
if(loc.iter() != loc.end() && *loc.iter() == '.')
{
return err(format_underline("bad float: invalid format",
{{std::addressof(loc), "integer part required before this"}},
{{source_location(loc), "integer part required before this"}},
{"pass: +1.0, -2e-2, 3.141_592_653_589, inf, nan",
"fail: .0, 1., _1.0, 1.0_, 1_.0, 1.0__0"}));
}
if(loc.iter() != loc.end() && *loc.iter() == '_')
{
return err(format_underline("bad number: `_` should be surrounded by digits",
{{std::addressof(loc), "`_` is not surrounded by digits"}},
{{source_location(loc), "`_` is not surrounded by digits"}},
{"pass: -42, 1_000, 1_2_3_4_5, 0xC0FFEE, 0b0010, 0o755",
"fail: 1__000, 0123"}));
}
return err(format_underline("bad format: unknown value appeared",
{{std::addressof(loc), "here"}}));
{{source_location(loc), "here"}}));
}
inline result<value_t, std::string> guess_value_type(const location& loc)
@ -1677,7 +1677,7 @@ result<Value, std::string> parse_value(location& loc)
if(first == loc.end())
{
return err(format_underline("toml::parse_value: input is empty",
{{std::addressof(loc), ""}}));
{{source_location(loc), ""}}));
}
const auto type = guess_value_type(loc);
@ -1700,7 +1700,7 @@ result<Value, std::string> parse_value(location& loc)
default:
{
const auto msg = format_underline("toml::parse_value: "
"unknown token appeared", {{std::addressof(loc), "unknown"}});
"unknown token appeared", {{source_location(loc), "unknown"}});
loc.reset(first);
return err(msg);
}
@ -1719,8 +1719,8 @@ parse_table_key(location& loc)
{
throw internal_error(format_underline(
"toml::parse_table_key: no `[`",
{{std::addressof(inner_loc), "should be `[`"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "should be `[`"}}),
source_location(inner_loc));
}
// to skip [ a . b . c ]
// ^----------- this whitespace
@ -1730,8 +1730,8 @@ parse_table_key(location& loc)
{
throw internal_error(format_underline(
"toml::parse_table_key: invalid key",
{{std::addressof(inner_loc), "not key"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "not key"}}),
source_location(inner_loc));
}
// to skip [ a . b . c ]
// ^-- this whitespace
@ -1741,8 +1741,8 @@ parse_table_key(location& loc)
{
throw internal_error(format_underline(
"toml::parse_table_key: no `]`",
{{std::addressof(inner_loc), "should be `]`"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "should be `]`"}}),
source_location(inner_loc));
}
// after [table.key], newline or EOF(empty table) requried.
@ -1755,8 +1755,8 @@ parse_table_key(location& loc)
{
throw syntax_error(format_underline(
"toml::parse_table_key: newline required after [table.key]",
{{std::addressof(loc), "expected newline"}}),
source_location(std::addressof(loc)));
{{source_location(loc), "expected newline"}}),
source_location(loc));
}
}
return ok(std::make_pair(keys.unwrap().first, token.unwrap()));
@ -1764,7 +1764,7 @@ parse_table_key(location& loc)
else
{
return err(format_underline("toml::parse_table_key: "
"not a valid table key", {{std::addressof(loc), "here"}}));
"not a valid table key", {{source_location(loc), "here"}}));
}
}
@ -1780,8 +1780,8 @@ parse_array_table_key(location& loc)
{
throw internal_error(format_underline(
"toml::parse_array_table_key: no `[[`",
{{std::addressof(inner_loc), "should be `[[`"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "should be `[[`"}}),
source_location(inner_loc));
}
lex_ws::invoke(inner_loc);
const auto keys = parse_key(inner_loc);
@ -1789,8 +1789,8 @@ parse_array_table_key(location& loc)
{
throw internal_error(format_underline(
"toml::parse_array_table_key: invalid key",
{{std::addressof(inner_loc), "not a key"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "not a key"}}),
source_location(inner_loc));
}
lex_ws::invoke(inner_loc);
const auto close = lex_array_table_close::invoke(inner_loc);
@ -1798,8 +1798,8 @@ parse_array_table_key(location& loc)
{
throw internal_error(format_underline(
"toml::parse_table_key: no `]]`",
{{std::addressof(inner_loc), "should be `]]`"}}),
source_location(std::addressof(inner_loc)));
{{source_location(inner_loc), "should be `]]`"}}),
source_location(inner_loc));
}
// after [[table.key]], newline or EOF(empty table) requried.
@ -1812,8 +1812,8 @@ parse_array_table_key(location& loc)
{
throw syntax_error(format_underline("toml::"
"parse_array_table_key: newline required after [[table.key]]",
{{std::addressof(loc), "expected newline"}}),
source_location(std::addressof(loc)));
{{source_location(loc), "expected newline"}}),
source_location(loc));
}
}
return ok(std::make_pair(keys.unwrap().first, token.unwrap()));
@ -1821,7 +1821,7 @@ parse_array_table_key(location& loc)
else
{
return err(format_underline("toml::parse_array_table_key: "
"not a valid table key", {{std::addressof(loc), "here"}}));
"not a valid table key", {{source_location(loc), "here"}}));
}
}
@ -1896,7 +1896,7 @@ parse_ml_table(location& loc)
const auto before2 = loc.iter();
lex_ws::invoke(loc); // skip whitespace
const auto msg = format_underline("toml::parse_table: "
"invalid line format", {{std::addressof(loc), concat_to_string(
"invalid line format", {{source_location(loc), concat_to_string(
"expected newline, but got '", show_char(*loc.iter()), "'.")}});
loc.reset(before2);
return err(msg);
@ -2010,7 +2010,7 @@ result<Value, std::string> parse_toml_file(location& loc)
continue;
}
return err(format_underline("toml::parse_toml_file: "
"unknown line appeared", {{std::addressof(loc), "unknown format"}}));
"unknown line appeared", {{source_location(loc), "unknown format"}}));
}
Value v(std::move(data), file);

101
toml/region.hpp
View File

@ -412,107 +412,6 @@ struct region final : public region_base
const_iterator first_, last_;
};
// to show a better error message.
inline std::string format_underline(const std::string& message,
const std::vector<std::pair<region_base const*, std::string>>& reg_com,
const std::vector<std::string>& helps = {},
const bool colorize = TOML11_ERROR_MESSAGE_COLORIZED)
{
assert(!reg_com.empty());
const auto line_num_width = static_cast<int>(std::max_element(
reg_com.begin(), reg_com.end(),
[](std::pair<region_base const*, std::string> const& lhs,
std::pair<region_base const*, std::string> const& rhs)
{
return lhs.first->line_num().size() < rhs.first->line_num().size();
}
)->first->line_num().size());
std::ostringstream retval;
if(colorize)
{
retval << color::colorize; // turn on ANSI color
}
// XXX
// Here, before `colorize` support, it does not output `[error]` prefix
// automatically. So some user may output it manually and this change may
// duplicate the prefix. To avoid it, check the first 7 characters and
// if it is "[error]", it removes that part from the message shown.
if(message.size() > 7 && message.substr(0, 7) == "[error]")
{
retval << color::bold << color::red << "[error]" << color::reset
<< color::bold << message.substr(7) << color::reset << '\n';
}
else
{
retval << color::bold << color::red << "[error] " << color::reset
<< color::bold << message << color::reset << '\n';
}
for(auto iter = reg_com.begin(); iter != reg_com.end(); ++iter)
{
// if the filenames are the same, print "..."
if(iter != reg_com.begin() &&
std::prev(iter)->first->name() == iter->first->name())
{
retval << color::bold << color::blue << "\n ...\n" << color::reset;
}
else // if filename differs, print " --> filename.toml"
{
if(iter != reg_com.begin()) {retval << '\n';}
retval << color::bold << color::blue << " --> " << color::reset
<< iter->first->name() << '\n';
// add one almost-empty line for readability
retval << make_string(static_cast<std::size_t>(line_num_width + 1), ' ')
<< color::bold << color::blue << " | " << color::reset << '\n';
}
const region_base* const reg = iter->first;
const std::string& comment = iter->second;
retval << ' ' << color::bold << color::blue << std::setw(line_num_width)
<< std::right << reg->line_num() << " | " << color::reset
<< reg->line() << '\n';
retval << make_string(static_cast<std::size_t>(line_num_width + 1), ' ')
<< color::bold << color::blue << " | " << color::reset
<< make_string(reg->before(), ' ');
if(reg->size() == 1)
{
// invalid
// ^------
retval << color::bold << color::red
<< '^' << make_string(reg->after(), '-') << color::reset;
}
else
{
// invalid
// ~~~~~~~
const auto underline_len = (std::min)(reg->size(), reg->line().size());
retval << color::bold << color::red
<< make_string(underline_len, '~') << color::reset;
}
retval << ' ';
retval << comment;
}
if(!helps.empty())
{
retval << '\n';
retval << make_string(static_cast<std::size_t>(line_num_width + 1), ' ');
retval << color::bold << color::blue << " | " << color::reset;
for(const auto& help : helps)
{
retval << color::bold << "\nHint: " << color::reset;
retval << help;
}
}
return retval.str();
}
} // detail
} // toml
#endif// TOML11_REGION_H

122
toml/source_location.hpp
View File

@ -61,6 +61,21 @@ struct source_location
}
}
explicit source_location(const detail::region& reg)
: line_num_(static_cast<std::uint_least32_t>(std::stoul(reg.line_num()))),
column_num_(static_cast<std::uint_least32_t>(reg.before() + 1)),
region_size_(static_cast<std::uint_least32_t>(reg.size())),
file_name_(reg.name()),
line_str_ (reg.line())
{}
explicit source_location(const detail::location& loc)
: line_num_(static_cast<std::uint_least32_t>(std::stoul(loc.line_num()))),
column_num_(static_cast<std::uint_least32_t>(loc.before() + 1)),
region_size_(static_cast<std::uint_least32_t>(loc.size())),
file_name_(loc.name()),
line_str_ (loc.line())
{}
~source_location() = default;
source_location(source_location const&) = default;
source_location(source_location &&) = default;
@ -83,5 +98,112 @@ struct source_location
std::string line_str_;
};
namespace detail
{
// internal error message generation.
inline std::string format_underline(const std::string& message,
const std::vector<std::pair<source_location, std::string>>& loc_com,
const std::vector<std::string>& helps = {},
const bool colorize = TOML11_ERROR_MESSAGE_COLORIZED)
{
assert(!loc_com.empty());
const auto line_num_width = static_cast<int>(std::to_string(std::max_element(
loc_com.begin(), loc_com.end(),
[](std::pair<source_location, std::string> const& lhs,
std::pair<source_location, std::string> const& rhs)
{
return std::to_string(lhs.first.line()).size() <
std::to_string(rhs.first.line()).size();
}
)->first.line()).size());
std::ostringstream retval;
if(colorize)
{
retval << color::colorize; // turn on ANSI color
}
// XXX
// Here, before `colorize` support, it does not output `[error]` prefix
// automatically. So some user may output it manually and this change may
// duplicate the prefix. To avoid it, check the first 7 characters and
// if it is "[error]", it removes that part from the message shown.
if(message.size() > 7 && message.substr(0, 7) == "[error]")
{
retval << color::bold << color::red << "[error]" << color::reset
<< color::bold << message.substr(7) << color::reset << '\n';
}
else
{
retval << color::bold << color::red << "[error] " << color::reset
<< color::bold << message << color::reset << '\n';
}
for(auto iter = loc_com.begin(); iter != loc_com.end(); ++iter)
{
// if the filenames are the same, print "..."
if(iter != loc_com.begin() &&
std::prev(iter)->first.file_name() == iter->first.file_name())
{
retval << color::bold << color::blue << "\n ...\n" << color::reset;
}
else // if filename differs, print " --> filename.toml"
{
if(iter != loc_com.begin()) {retval << '\n';}
retval << color::bold << color::blue << " --> " << color::reset
<< iter->first.file_name() << '\n';
// add one almost-empty line for readability
retval << make_string(static_cast<std::size_t>(line_num_width + 1), ' ')
<< color::bold << color::blue << " | " << color::reset << '\n';
}
const source_location& loc = iter->first;
const std::string& comment = iter->second;
retval << ' ' << color::bold << color::blue << std::setw(line_num_width)
<< std::right << loc.line() << " | " << color::reset
<< loc.line_str() << '\n';
retval << make_string(static_cast<std::size_t>(line_num_width + 1), ' ')
<< color::bold << color::blue << " | " << color::reset
<< make_string(loc.column()-1 /*1-origin*/, ' ');
if(loc.region() == 1)
{
// invalid
// ^------
retval << color::bold << color::red << "^---" << color::reset;
}
else
{
// invalid
// ~~~~~~~
const auto underline_len = (std::min)(
static_cast<std::size_t>(loc.region()), loc.line_str().size());
retval << color::bold << color::red
<< make_string(underline_len, '~') << color::reset;
}
retval << ' ';
retval << comment;
}
if(!helps.empty())
{
retval << '\n';
retval << make_string(static_cast<std::size_t>(line_num_width + 1), ' ');
retval << color::bold << color::blue << " | " << color::reset;
for(const auto& help : helps)
{
retval << color::bold << "\nHint: " << color::reset;
retval << help;
}
}
return retval.str();
}
} // detail
} // toml
#endif// TOML11_SOURCE_LOCATION_HPP

36
toml/value.hpp
View File

@ -46,7 +46,8 @@ throw_bad_cast(const std::string& funcname, value_t actual, const Value& v)
{
throw type_error(detail::format_underline(
concat_to_string(funcname, "bad_cast to ", Expected), {
{get_region(v), concat_to_string("the actual type is ", actual)}
{source_location(get_region(v)),
concat_to_string("the actual type is ", actual)}
}), v.location());
}
@ -73,8 +74,8 @@ throw_key_not_found_error(const Value& v, const key& ky)
// It actually points to the top-level table at the first character,
// not `[table]`. But it is too confusing. To avoid the confusion, the error
// message should explicitly say "key not found in the top-level table".
const auto* reg = get_region(v);
if(reg->line_num() == "1" && reg->size() == 1)
const auto loc = source_location(get_region(v));
if(loc.line() == 1 && loc.region() == 1)
{
// Here it assumes that top-level table starts at the first character.
// The region corresponds to the top-level table will be generated at
@ -110,14 +111,14 @@ throw_key_not_found_error(const Value& v, const key& ky)
//
throw std::out_of_range(format_underline(concat_to_string(
"key \"", ky, "\" not found in the top-level table"), {
{reg, "the top-level table starts here"}
{loc, "the top-level table starts here"}
}));
}
else
{
// normal table.
throw std::out_of_range(format_underline(concat_to_string(
"key \"", ky, "\" not found"), { {reg, "in this table"} }));
"key \"", ky, "\" not found"), { {loc, "in this table"} }));
}
}
@ -1567,7 +1568,7 @@ class basic_value
{
throw std::out_of_range(detail::format_underline(
"toml::value::at(idx): no element corresponding to the index", {
{this->region_info_.get(),
{source_location(this->region_info_.get()),
concat_to_string("the length is ", this->as_array(std::nothrow).size(),
", and the specified index is ", idx)}
}));
@ -1585,7 +1586,7 @@ class basic_value
{
throw std::out_of_range(detail::format_underline(
"toml::value::at(idx): no element corresponding to the index", {
{this->region_info_.get(),
{source_location(this->region_info_.get()),
concat_to_string("the length is ", this->as_array(std::nothrow).size(),
", and the specified index is ", idx)}
}));
@ -1657,7 +1658,7 @@ class basic_value
{
throw type_error(detail::format_underline(
"toml::value::size(): bad_cast to container types", {
{this->region_info_.get(),
{source_location(this->region_info_.get()),
concat_to_string("the actual type is ", this->type_)}
}), this->location());
}
@ -1915,10 +1916,8 @@ inline std::string format_error(const std::string& err_msg,
std::vector<std::string> hints = {},
const bool colorize = TOML11_ERROR_MESSAGE_COLORIZED)
{
return detail::format_underline(err_msg,
std::vector<std::pair<detail::region_base const*, std::string>>{
{detail::get_region(v), comment}
}, std::move(hints), colorize);
return detail::format_underline(err_msg, {{v.location(), comment}},
std::move(hints), colorize);
}
template<typename C, template<typename ...> class T, template<typename ...> class A>
@ -1928,10 +1927,8 @@ inline std::string format_error(const std::string& err_msg,
std::vector<std::string> hints = {},
const bool colorize = TOML11_ERROR_MESSAGE_COLORIZED)
{
return detail::format_underline(err_msg,
std::vector<std::pair<detail::region_base const*, std::string>>{
{detail::get_region(v1), comment1},
{detail::get_region(v2), comment2}
return detail::format_underline(err_msg, {
{v1.location(), comment1}, {v2.location(), comment2}
}, std::move(hints), colorize);
}
@ -1943,11 +1940,8 @@ inline std::string format_error(const std::string& err_msg,
std::vector<std::string> hints = {},
const bool colorize = TOML11_ERROR_MESSAGE_COLORIZED)
{
return detail::format_underline(err_msg,
std::vector<std::pair<detail::region_base const*, std::string>>{
{detail::get_region(v1), comment1},
{detail::get_region(v2), comment2},
{detail::get_region(v3), comment3}
return detail::format_underline(err_msg, {{v1.location(), comment1},
{v2.location(), comment2}, {v3.location(), comment3}
}, std::move(hints), colorize);
}