zhangyiss/toml11
1
0
Fork 0
mirror of https://github.com/ToruNiina/toml11.git synced 2025-09-17 17:58:09 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

add corresponding region to each value

Browse Source
This commit is contained in:
ToruNiina
2018-12-10 15:57:17 +09:00
parent 28ba2713ee
commit ff19c9f492
1 changed files with 122 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

202
toml/parser.hpp
View File

@@ -13,14 +13,15 @@ namespace detail
{ {
template<typename Container> template<typename Container>
result<boolean, std::string> parse_boolean(location<Container>& loc) result<std::pair<boolean, region<Container>>, std::string>
parse_boolean(location<Container>& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
if(const auto token = lex_boolean::invoke(loc)) if(const auto token = lex_boolean::invoke(loc))
{ {
const auto reg = token.unwrap(); const auto reg = token.unwrap();
if (reg.str() == "true") {return ok(true);} if (reg.str() == "true") {return ok(std::make_pair(true, reg));}
else if(reg.str() == "false") {return ok(false);} else if(reg.str() == "false") {return ok(std::make_pair(false, reg));}
else // internal error. else // internal error.
{ {
throw toml::internal_error(format_underline( throw toml::internal_error(format_underline(
@@ -34,7 +35,8 @@ result<boolean, std::string> parse_boolean(location<Container>& loc)
} }
template<typename Container> template<typename Container>
result<integer, std::string> parse_binary_integer(location<Container>& loc) result<std::pair<integer, region<Container>>, std::string>
parse_binary_integer(location<Container>& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
if(const auto token = lex_bin_int::invoke(loc)) if(const auto token = lex_bin_int::invoke(loc))
@@ -54,7 +56,7 @@ result<integer, std::string> parse_binary_integer(location<Container>& loc)
token.unwrap(), "invalid token")); token.unwrap(), "invalid token"));
} }
} }
return ok(retval); return ok(std::make_pair(retval, token.unwrap()));
} }
loc.iter() = first; loc.iter() = first;
return err(format_underline("[error] toml::parse_binary_integer", loc, return err(format_underline("[error] toml::parse_binary_integer", loc,
@@ -62,7 +64,8 @@ result<integer, std::string> parse_binary_integer(location<Container>& loc)
} }
template<typename Container> template<typename Container>
result<integer, std::string> parse_octal_integer(location<Container>& loc) result<std::pair<integer, region<Container>>, std::string>
parse_octal_integer(location<Container>& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
if(const auto token = lex_oct_int::invoke(loc)) if(const auto token = lex_oct_int::invoke(loc))
@@ -74,7 +77,7 @@ result<integer, std::string> parse_octal_integer(location<Container>& loc)
std::istringstream iss(str); std::istringstream iss(str);
integer retval(0); integer retval(0);
iss >> std::oct >> retval; iss >> std::oct >> retval;
return ok(retval); return ok(std::make_pair(retval, token.unwrap()));
} }
loc.iter() = first; loc.iter() = first;
@@ -83,7 +86,8 @@ result<integer, std::string> parse_octal_integer(location<Container>& loc)
} }
template<typename Container> template<typename Container>
result<integer, std::string> parse_hexadecimal_integer(location<Container>& loc) result<std::pair<integer, region<Container>>, std::string>
parse_hexadecimal_integer(location<Container>& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
if(const auto token = lex_hex_int::invoke(loc)) if(const auto token = lex_hex_int::invoke(loc))
@@ -95,7 +99,7 @@ result<integer, std::string> parse_hexadecimal_integer(location<Container>& loc)
std::istringstream iss(str); std::istringstream iss(str);
integer retval(0); integer retval(0);
iss >> std::hex >> retval; iss >> std::hex >> retval;
return ok(retval); return ok(std::make_pair(retval, token.unwrap()));
} }
loc.iter() = first; loc.iter() = first;
return err(format_underline("[error] toml::parse_hexadecimal_integer", loc, return err(format_underline("[error] toml::parse_hexadecimal_integer", loc,
@@ -103,7 +107,8 @@ result<integer, std::string> parse_hexadecimal_integer(location<Container>& loc)
} }
template<typename Container> template<typename Container>
result<integer, std::string> parse_integer(location<Container>& loc) result<std::pair<integer, region<Container>>, std::string>
parse_integer(location<Container>& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
if(first != loc.end() && *first == '0') if(first != loc.end() && *first == '0')
@@ -111,6 +116,7 @@ result<integer, std::string> parse_integer(location<Container>& loc)
if(const auto bin = parse_binary_integer (loc)) {return bin;} if(const auto bin = parse_binary_integer (loc)) {return bin;}
if(const auto oct = parse_octal_integer (loc)) {return oct;} if(const auto oct = parse_octal_integer (loc)) {return oct;}
if(const auto hex = parse_hexadecimal_integer(loc)) {return hex;} if(const auto hex = parse_hexadecimal_integer(loc)) {return hex;}
// else, maybe just zero.
} }
if(const auto token = lex_dec_int::invoke(loc)) if(const auto token = lex_dec_int::invoke(loc))
@@ -121,7 +127,7 @@ result<integer, std::string> parse_integer(location<Container>& loc)
std::istringstream iss(str); std::istringstream iss(str);
integer retval(0); integer retval(0);
iss >> retval; iss >> retval;
return ok(retval); return ok(std::make_pair(retval, token.unwrap()));
} }
loc.iter() = first; loc.iter() = first;
return err(format_underline("[error] toml::parse_integer", loc, return err(format_underline("[error] toml::parse_integer", loc,
@@ -131,7 +137,8 @@ result<integer, std::string> parse_integer(location<Container>& loc)
} }
template<typename Container> template<typename Container>
result<floating, std::string> parse_floating(location<Container>& loc) result<std::pair<floating, region<Container>>, std::string>
parse_floating(location<Container>& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
if(const auto token = lex_float::invoke(loc)) if(const auto token = lex_float::invoke(loc))
@@ -141,7 +148,8 @@ result<floating, std::string> parse_floating(location<Container>& loc)
{ {
if(std::numeric_limits<floating>::has_infinity) if(std::numeric_limits<floating>::has_infinity)
{ {
return ok(std::numeric_limits<floating>::infinity()); return ok(std::make_pair(
std::numeric_limits<floating>::infinity(), token.unwrap()));
} }
else else
{ {
@@ -155,7 +163,8 @@ result<floating, std::string> parse_floating(location<Container>& loc)
{ {
if(std::numeric_limits<floating>::has_infinity) if(std::numeric_limits<floating>::has_infinity)
{ {
return ok(-std::numeric_limits<floating>::infinity()); return ok(std::make_pair(
-std::numeric_limits<floating>::infinity(), token.unwrap()));
} }
else else
{ {
@@ -169,11 +178,13 @@ result<floating, std::string> parse_floating(location<Container>& loc)
{ {
if(std::numeric_limits<floating>::has_quiet_NaN) if(std::numeric_limits<floating>::has_quiet_NaN)
{ {
return ok(std::numeric_limits<floating>::quiet_NaN()); return ok(std::make_pair(
std::numeric_limits<floating>::quiet_NaN(), token.unwrap()));
} }
else if(std::numeric_limits<floating>::has_signaling_NaN) else if(std::numeric_limits<floating>::has_signaling_NaN)
{ {
return ok(std::numeric_limits<floating>::signaling_NaN()); return ok(std::make_pair(
std::numeric_limits<floating>::signaling_NaN(), token.unwrap()));
} }
else else
{ {
@@ -187,11 +198,13 @@ result<floating, std::string> parse_floating(location<Container>& loc)
{ {
if(std::numeric_limits<floating>::has_quiet_NaN) if(std::numeric_limits<floating>::has_quiet_NaN)
{ {
return ok(-std::numeric_limits<floating>::quiet_NaN()); return ok(std::make_pair(
-std::numeric_limits<floating>::quiet_NaN(), token.unwrap()));
} }
else if(std::numeric_limits<floating>::has_signaling_NaN) else if(std::numeric_limits<floating>::has_signaling_NaN)
{ {
return ok(-std::numeric_limits<floating>::signaling_NaN()); return ok(std::make_pair(
-std::numeric_limits<floating>::signaling_NaN(), token.unwrap()));
} }
else else
{ {
@@ -205,7 +218,7 @@ result<floating, std::string> parse_floating(location<Container>& loc)
std::istringstream iss(str); std::istringstream iss(str);
floating v(0.0); floating v(0.0);
iss >> v; iss >> v;
return ok(v); return ok(std::make_pair(v, token.unwrap()));
} }
loc.iter() = first; loc.iter() = first;
return err(format_underline("[error] toml::parse_floating: ", loc, return err(format_underline("[error] toml::parse_floating: ", loc,
@@ -320,7 +333,7 @@ result<std::string, std::string> parse_escape_sequence(location<Container>& loc)
} }
template<typename Container> template<typename Container>
result<toml::string, std::string> result<std::pair<toml::string, region<Container>>, std::string>
parse_ml_basic_string(location<Container>& loc) parse_ml_basic_string(location<Container>& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -366,7 +379,7 @@ parse_ml_basic_string(location<Container>& loc)
} }
delim = lex_ml_basic_string_delim::invoke(inner_loc); delim = lex_ml_basic_string_delim::invoke(inner_loc);
} }
return ok(toml::string(retval)); return ok(std::make_pair(toml::string(retval), token.unwrap()));
} }
else else
{ {
@@ -376,7 +389,8 @@ parse_ml_basic_string(location<Container>& loc)
} }
template<typename Container> template<typename Container>
result<toml::string, std::string> parse_basic_string(location<Container>& loc) result<std::pair<toml::string, region<Container>>, std::string>
parse_basic_string(location<Container>& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
if(const auto token = lex_basic_string::invoke(loc)) if(const auto token = lex_basic_string::invoke(loc))
@@ -413,7 +427,7 @@ result<toml::string, std::string> parse_basic_string(location<Container>& loc)
} }
quot = lex_quotation_mark::invoke(inner_loc); quot = lex_quotation_mark::invoke(inner_loc);
} }
return ok(toml::string(retval)); return ok(std::make_pair(toml::string(retval), token.unwrap()));
} }
else else
{ {
@@ -423,7 +437,7 @@ result<toml::string, std::string> parse_basic_string(location<Container>& loc)
} }
template<typename Container> template<typename Container>
result<toml::string, std::string> result<std::pair<toml::string, region<Container>>, std::string>
parse_ml_literal_string(location<Container>& loc) parse_ml_literal_string(location<Container>& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -450,7 +464,9 @@ parse_ml_literal_string(location<Container>& loc)
"parse_ml_literal_string: invalid token", "parse_ml_literal_string: invalid token",
inner_loc, "should be '''")); inner_loc, "should be '''"));
} }
return ok(toml::string(body.unwrap().str())); return ok(std::make_pair(
toml::string(body.unwrap().str(), toml::string_t::literal),
token.unwrap()));
} }
else else
{ {
@@ -460,7 +476,8 @@ parse_ml_literal_string(location<Container>& loc)
} }
template<typename Container> template<typename Container>
result<toml::string, std::string> parse_literal_string(location<Container>& loc) result<std::pair<toml::string, region<Container>>, std::string>
parse_literal_string(location<Container>& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
if(const auto token = lex_literal_string::invoke(loc)) if(const auto token = lex_literal_string::invoke(loc))
@@ -484,7 +501,9 @@ result<toml::string, std::string> parse_literal_string(location<Container>& loc)
"parse_literal_string: invalid token", "parse_literal_string: invalid token",
inner_loc, "should be '")); inner_loc, "should be '"));
} }
return ok(toml::string(body.unwrap().str())); return ok(std::make_pair(
toml::string(body.unwrap().str(), toml::string_t::literal),
token.unwrap()));
} }
else else
{ {
@@ -494,30 +513,20 @@ result<toml::string, std::string> parse_literal_string(location<Container>& loc)
} }
template<typename Container> template<typename Container>
result<toml::string, std::string> parse_string(location<Container>& loc) result<std::pair<toml::string, region<Container>>, std::string>
parse_string(location<Container>& loc)
{ {
if(const auto rslt = parse_ml_basic_string(loc)) if(const auto rslt = parse_ml_basic_string(loc)) {return rslt;}
{ if(const auto rslt = parse_ml_literal_string(loc)) {return rslt;}
return ok(rslt.unwrap()); if(const auto rslt = parse_basic_string(loc)) {return rslt;}
} if(const auto rslt = parse_literal_string(loc)) {return rslt;}
if(const auto rslt = parse_ml_literal_string(loc))
{
return ok(rslt.unwrap());
}
if(const auto rslt = parse_basic_string(loc))
{
return ok(rslt.unwrap());
}
if(const auto rslt = parse_literal_string(loc))
{
return ok(rslt.unwrap());
}
return err(format_underline("[error] toml::parse_string: not a string", return err(format_underline("[error] toml::parse_string: not a string",
loc, "not a string")); loc, "not a string"));
} }
template<typename Container> template<typename Container>
result<local_date, std::string> parse_local_date(location<Container>& loc) result<std::pair<local_date, region<Container>>, std::string>
parse_local_date(location<Container>& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
if(const auto token = lex_local_date::invoke(loc)) if(const auto token = lex_local_date::invoke(loc))
@@ -551,11 +560,12 @@ result<local_date, std::string> parse_local_date(location<Container>& loc)
"toml::parse_local_date: invalid day format", "toml::parse_local_date: invalid day format",
inner_loc, d.unwrap_err())); inner_loc, d.unwrap_err()));
} }
return ok(local_date( return ok(std::make_pair(local_date(
static_cast<std::int16_t>(from_string<int>(y.unwrap().str(), 0)), static_cast<std::int16_t>(from_string<int>(y.unwrap().str(), 0)),
static_cast<month_t>( static_cast<month_t>(
static_cast<std::int8_t>(from_string<int>(m.unwrap().str(), 0)-1)), static_cast<std::int8_t>(from_string<int>(m.unwrap().str(), 0)-1)),
static_cast<std::int8_t>(from_string<int>(d.unwrap().str(), 0)))); static_cast<std::int8_t>(from_string<int>(d.unwrap().str(), 0))),
token.unwrap()));
} }
else else
{ {
@@ -568,7 +578,8 @@ result<local_date, std::string> parse_local_date(location<Container>& loc)
} }
template<typename Container> template<typename Container>
result<local_time, std::string> parse_local_time(location<Container>& loc) result<std::pair<local_time, region<Container>>, std::string>
parse_local_time(location<Container>& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
if(const auto token = lex_local_time::invoke(loc)) if(const auto token = lex_local_time::invoke(loc))
@@ -639,7 +650,7 @@ result<local_time, std::string> parse_local_time(location<Container>& loc)
inner_loc, secfrac.unwrap_err())); inner_loc, secfrac.unwrap_err()));
} }
} }
return ok(time); return ok(std::make_pair(time, token.unwrap()));
} }
else else
{ {
@@ -652,7 +663,7 @@ result<local_time, std::string> parse_local_time(location<Container>& loc)
} }
template<typename Container> template<typename Container>
result<local_datetime, std::string> result<std::pair<local_datetime, region<Container>>, std::string>
parse_local_datetime(location<Container>& loc) parse_local_datetime(location<Container>& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -682,7 +693,9 @@ parse_local_datetime(location<Container>& loc)
"toml::parse_local_datetime: invalid datetime format", "toml::parse_local_datetime: invalid datetime format",
inner_loc, "invalid time fomrat")); inner_loc, "invalid time fomrat"));
} }
return ok(local_datetime(date.unwrap(), time.unwrap())); return ok(std::make_pair(
local_datetime(date.unwrap().first, time.unwrap().first),
token.unwrap()));
} }
else else
{ {
@@ -695,7 +708,7 @@ parse_local_datetime(location<Container>& loc)
} }
template<typename Container> template<typename Container>
result<offset_datetime, std::string> result<std::pair<offset_datetime, region<Container>>, std::string>
parse_offset_datetime(location<Container>& loc) parse_offset_datetime(location<Container>& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
@@ -732,7 +745,8 @@ parse_offset_datetime(location<Container>& loc)
"toml::parse_offset_datetime: invalid datetime format", "toml::parse_offset_datetime: invalid datetime format",
inner_loc, "should be `Z` or `+HH:MM`")); inner_loc, "should be `Z` or `+HH:MM`"));
} }
return ok(offset_datetime(datetime.unwrap(), offset)); return ok(std::make_pair(offset_datetime(datetime.unwrap().first, offset),
token.unwrap()));
} }
else else
{ {
@@ -750,11 +764,11 @@ result<key, std::string> parse_simple_key(location<Container>& loc)
{ {
if(const auto bstr = parse_basic_string(loc)) if(const auto bstr = parse_basic_string(loc))
{ {
return ok(bstr.unwrap().str); return ok(bstr.unwrap().first.str);
} }
if(const auto lstr = parse_literal_string(loc)) if(const auto lstr = parse_literal_string(loc))
{ {
return ok(lstr.unwrap().str); return ok(lstr.unwrap().first.str);
} }
if(const auto bare = lex_unquoted_key::invoke(loc)) if(const auto bare = lex_unquoted_key::invoke(loc))
{ {
@@ -821,7 +835,8 @@ template<typename Container>
result<value, std::string> parse_value(location<Container>&); result<value, std::string> parse_value(location<Container>&);
template<typename Container> template<typename Container>
result<array, std::string> parse_array(location<Container>& loc) result<std::pair<array, region<Container>>, std::string>
parse_array(location<Container>& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
if(loc.iter() == loc.end()) if(loc.iter() == loc.end())
@@ -846,7 +861,8 @@ result<array, std::string> parse_array(location<Container>& loc)
if(loc.iter() != loc.end() && *loc.iter() == ']') if(loc.iter() != loc.end() && *loc.iter() == ']')
{ {
++loc.iter(); // skip ']' ++loc.iter(); // skip ']'
return ok(retval); return ok(std::make_pair(retval,
region<Container>(loc, first, loc.iter())));
} }
if(auto val = parse_value(loc)) if(auto val = parse_value(loc))
@@ -867,7 +883,8 @@ result<array, std::string> parse_array(location<Container>& loc)
if(loc.iter() != loc.end() && *loc.iter() == ']') if(loc.iter() != loc.end() && *loc.iter() == ']')
{ {
++loc.iter(); // skip ']' ++loc.iter(); // skip ']'
return ok(retval); return ok(std::make_pair(retval,
region<Container>(loc, first, loc.iter())));
} }
else else
{ {
@@ -1019,7 +1036,8 @@ insert_nested_key(table& root, const toml::value& v,
} }
template<typename Container> template<typename Container>
result<table, std::string> parse_inline_table(location<Container>& loc) result<std::pair<table, region<Container>>, std::string>
parse_inline_table(location<Container>& loc)
{ {
const auto first = loc.iter(); const auto first = loc.iter();
table retval; table retval;
@@ -1035,7 +1053,8 @@ result<table, std::string> parse_inline_table(location<Container>& loc)
if(loc.iter() != loc.end() && *loc.iter() == '}') if(loc.iter() != loc.end() && *loc.iter() == '}')
{ {
++loc.iter(); // skip `}` ++loc.iter(); // skip `}`
return ok(retval); return ok(std::make_pair(
retval, region<Container>(loc, first, loc.iter())));
} }
const auto kv_r = parse_key_value_pair(loc); const auto kv_r = parse_key_value_pair(loc);
@@ -1062,7 +1081,8 @@ result<table, std::string> parse_inline_table(location<Container>& loc)
if(loc.iter() != loc.end() && *loc.iter() == '}') if(loc.iter() != loc.end() && *loc.iter() == '}')
{ {
++loc.iter(); // skip `}` ++loc.iter(); // skip `}`
return ok(retval); return ok(std::make_pair(
retval, region<Container>(loc, first, loc.iter())));
} }
else else
{ {
@@ -1084,16 +1104,26 @@ result<value, std::string> parse_value(location<Container>& loc)
{ {
return err(std::string("[error] toml::parse_value: input is empty")); return err(std::string("[error] toml::parse_value: input is empty"));
} }
if(auto r = parse_string (loc)) {return ok(value(std::move(r.unwrap())));} if(auto r = parse_string (loc))
if(auto r = parse_array (loc)) {return ok(value(std::move(r.unwrap())));} {return ok(value(std::move(r.unwrap().first), std::move(r.unwrap().second)));}
if(auto r = parse_inline_table (loc)) {return ok(value(std::move(r.unwrap())));} if(auto r = parse_array (loc))
if(auto r = parse_boolean (loc)) {return ok(value(std::move(r.unwrap())));} {return ok(value(std::move(r.unwrap().first), std::move(r.unwrap().second)));}
if(auto r = parse_offset_datetime(loc)) {return ok(value(std::move(r.unwrap())));} if(auto r = parse_inline_table (loc))
if(auto r = parse_local_datetime (loc)) {return ok(value(std::move(r.unwrap())));} {return ok(value(std::move(r.unwrap().first), std::move(r.unwrap().second)));}
if(auto r = parse_local_date (loc)) {return ok(value(std::move(r.unwrap())));} if(auto r = parse_boolean (loc))
if(auto r = parse_local_time (loc)) {return ok(value(std::move(r.unwrap())));} {return ok(value(std::move(r.unwrap().first), std::move(r.unwrap().second)));}
if(auto r = parse_floating (loc)) {return ok(value(std::move(r.unwrap())));} if(auto r = parse_offset_datetime(loc))
if(auto r = parse_integer (loc)) {return ok(value(std::move(r.unwrap())));} {return ok(value(std::move(r.unwrap().first), std::move(r.unwrap().second)));}
if(auto r = parse_local_datetime (loc))
{return ok(value(std::move(r.unwrap().first), std::move(r.unwrap().second)));}
if(auto r = parse_local_date (loc))
{return ok(value(std::move(r.unwrap().first), std::move(r.unwrap().second)));}
if(auto r = parse_local_time (loc))
{return ok(value(std::move(r.unwrap().first), std::move(r.unwrap().second)));}
if(auto r = parse_floating (loc))
{return ok(value(std::move(r.unwrap().first), std::move(r.unwrap().second)));}
if(auto r = parse_integer (loc))
{return ok(value(std::move(r.unwrap().first), std::move(r.unwrap().second)));}
const auto msg = format_underline("[error] toml::parse_value: " const auto msg = format_underline("[error] toml::parse_value: "
"unknown token appeared", loc, "unknown"); "unknown token appeared", loc, "unknown");
@@ -1102,7 +1132,8 @@ result<value, std::string> parse_value(location<Container>& loc)
} }
template<typename Container> template<typename Container>
result<std::vector<key>, std::string> parse_table_key(location<Container>& loc) result<std::pair<std::vector<key>, region<Container>>, std::string>
parse_table_key(location<Container>& loc)
{ {
if(auto token = lex_std_table::invoke(loc)) if(auto token = lex_std_table::invoke(loc))
{ {
@@ -1126,7 +1157,7 @@ result<std::vector<key>, std::string> parse_table_key(location<Container>& loc)
throw internal_error(format_underline("[error] " throw internal_error(format_underline("[error] "
"toml::parse_table_key: no `]`", inner_loc, "should be `]`")); "toml::parse_table_key: no `]`", inner_loc, "should be `]`"));
} }
return keys; return ok(std::make_pair(keys.unwrap(), token.unwrap()));
} }
else else
{ {
@@ -1135,7 +1166,7 @@ result<std::vector<key>, std::string> parse_table_key(location<Container>& loc)
} }
template<typename Container> template<typename Container>
result<std::vector<key>, std::string> result<std::pair<std::vector<key>, region<Container>>, std::string>
parse_array_table_key(location<Container>& loc) parse_array_table_key(location<Container>& loc)
{ {
if(auto token = lex_array_table::invoke(loc)) if(auto token = lex_array_table::invoke(loc))
@@ -1162,7 +1193,7 @@ parse_array_table_key(location<Container>& loc)
throw internal_error(format_underline("[error] " throw internal_error(format_underline("[error] "
"toml::parse_table_key: no `]]`", inner_loc, "should be `]]`")); "toml::parse_table_key: no `]]`", inner_loc, "should be `]]`"));
} }
return keys; return ok(std::make_pair(keys.unwrap(), token.unwrap()));
} }
else else
{ {
@@ -1241,19 +1272,27 @@ result<table, std::string> parse_toml_file(location<Container>& loc)
{ {
data = std::move(tab.unwrap()); data = std::move(tab.unwrap());
} }
else // failed (empty table is also success) else // failed (empty table is regarded as success in parse_ml_table)
{ {
return err(tab.unwrap_err()); return err(tab.unwrap_err());
} }
while(loc.iter() != loc.end()) while(loc.iter() != loc.end())
{ {
// here, the region of [table] is regarded as the table-key because
// the table body is normally too big and it is not so informative
// if the first key-value pair of the table is shown in the error
// message.
if(const auto tabkey = parse_array_table_key(loc)) if(const auto tabkey = parse_array_table_key(loc))
{ {
const auto tab = parse_ml_table(loc); const auto tab = parse_ml_table(loc);
if(!tab){return err(tab.unwrap_err());} if(!tab){return err(tab.unwrap_err());}
const auto inserted = insert_nested_key(data, tab.unwrap(), const auto& keys = tabkey.unwrap().first;
tabkey.unwrap().begin(), tabkey.unwrap().end(), true); const auto& reg = tabkey.unwrap().second;
const auto inserted = insert_nested_key(data,
toml::value(tab.unwrap(), reg),
keys.begin(), keys.end(), /*is_array_of_table=*/ true);
if(!inserted) {return err(inserted.unwrap_err());} if(!inserted) {return err(inserted.unwrap_err());}
continue; continue;
@@ -1263,8 +1302,11 @@ result<table, std::string> parse_toml_file(location<Container>& loc)
const auto tab = parse_ml_table(loc); const auto tab = parse_ml_table(loc);
if(!tab){return err(tab.unwrap_err());} if(!tab){return err(tab.unwrap_err());}
const auto inserted = insert_nested_key(data, tab.unwrap(), const auto& keys = tabkey.unwrap().first;
tabkey.unwrap().begin(), tabkey.unwrap().end()); const auto& reg = tabkey.unwrap().second;
const auto inserted = insert_nested_key(data,
toml::value(tab.unwrap(), reg), keys.begin(), keys.end());
if(!inserted) {return err(inserted.unwrap_err());} if(!inserted) {return err(inserted.unwrap_err());}
continue; continue;