fix: improve err msg for multiline inline table

show "missing curly brace" instead of "missing table key-value separator"

README.md

@@ -19,6 +19,28 @@ Not only the test suite itself, a TOML reader/encoder also runs on [CircleCI](ht
 You can see the error messages about invalid files and serialization results of valid files at
 [CircleCI](https://circleci.com/gh/ToruNiina/toml11).
 
+## Example
+
+```cpp
+#include <toml11/toml.hpp>
+#include <iostream>
+
+int main()
+{
+    const auto data  = toml::parse("example.toml");
+
+    // title = "an example toml file"
+    std::string title = toml::get<std::string>(data.at("title"));
+    std::cout << "the title is " << title << std::endl;
+
+    // nums = [1, 2, 3, 4, 5]
+    std::vector<int> nums  = toml::get<std::vector<int>>(data.at("nums"));
+    std::cout << "the length of `nums` is" << nums.size() << std::endl;
+
+    return 0;
+}
+```
+
 ## Table of Contents
 
 - [Integration](#integration)
@@ -53,12 +75,14 @@ Just include the file after adding it to the include path.
 
 ```cpp
 #include <toml11/toml.hpp> // that's all! now you can use it.
+#include <iostream>
 
 int main()
 {
     const auto data  = toml::parse("example.toml");
     const auto title = toml::get<std::string>(data.at("title"));
     std::cout << "the title is " << title << std::endl;
+    return 0;
 }
 ```
 
@@ -579,6 +603,27 @@ toml::value operator""_toml(const char* str, std::size_t len);
 Access to the operator can be gained with `using namespace toml::literals;`,
 `using namespace toml::toml_literals`, and `using namespace toml::literals::toml_literals`.
 
+Note that a key that is composed only of digits is allowed in TOML.
+And, unlike the file parser, toml-literal allows a bare value without a key.
+Thus it is difficult to distinguish arrays having integers and definitions of
+tables that are named as digits.
+Currently, literal `[1]` becomes a table named "1".
+To ensure a literal to be considered as an array with one element, you need to
+add a comma after the first element (like `[1,]`).
+
+```cpp
+"[1,2,3]"_toml;   // This is an array
+"[table]"_toml;   // This is a table that has an empty table named "table" inside.
+"[[1,2,3]]"_toml; // This is an array of arrays
+"[[table]]"_toml; // This is a table that has an array of tables inside.
+
+"[[1]]"_toml;     // This literal is ambiguous.
+                  // Currently, it becomes a table taht has array of table "1".
+"1 = [{}]"_toml;  // This is a table that has an array of table named 1.
+"[[1,]]"_toml;    // This is an array of arrays.
+"[[1],]"_toml;    // ditto.
+```
+
 ## Conversion between toml value and arbitrary types
 
 You can also use `toml::get` and other related functions with the types you defined
@@ -937,11 +982,13 @@ I appreciate the help of the contributors who introduced the great feature to th
 - Quentin Khan (@xaxousis)
   - Found & Fixed a bug around ODR
   - Improved error messages for invaild keys to show the location where the parser fails
+- Petr Beneš (@wbenny)
+  - Fixed warnings on MSVC
 
 ## Licensing terms
 
 This product is licensed under the terms of the [MIT License](LICENSE).
 
-- Copyright (c) 2017 Toru Niina
+- Copyright (c) 2017-2019 Toru Niina
 
 All rights reserved.

tests/test_literals.cpp

@@ -33,6 +33,18 @@ BOOST_AUTO_TEST_CASE(test_file_as_literal)
             b = "baz"
         )"_toml;
 
+        BOOST_CHECK_EQUAL(r, v);
+    }
+    {
+        const toml::value r{
+            {"table", toml::table{{"a", 42}, {"b", "baz"}}}
+        };
+        const toml::value v = u8R"(
+            [table]
+            a = 42
+            b = "baz"
+        )"_toml;
+
         BOOST_CHECK_EQUAL(r, v);
     }
 }
@@ -91,6 +103,19 @@ BOOST_AUTO_TEST_CASE(test_value_as_literal)
 
         BOOST_CHECK(v1.is_array());
         BOOST_CHECK((toml::get<std::vector<int>>(v1) == std::vector<int>{1,2,3}));
+
+        const toml::value v2 = u8R"([1,])"_toml;
+
+        BOOST_CHECK(v2.is_array());
+        BOOST_CHECK((toml::get<std::vector<int>>(v2) == std::vector<int>{1}));
+
+        const toml::value v3 = u8R"([[1,]])"_toml;
+        BOOST_CHECK(v3.is_array());
+        BOOST_CHECK((toml::get<std::vector<int>>(toml::get<toml::array>(v3).front()) == std::vector<int>{1}));
+
+        const toml::value v4 = u8R"([[1],])"_toml;
+        BOOST_CHECK(v4.is_array());
+        BOOST_CHECK((toml::get<std::vector<int>>(toml::get<toml::array>(v4).front()) == std::vector<int>{1}));
     }
     {
         const toml::value v1 = u8R"({a = 42})"_toml;

toml/combinator.hpp

@@ -9,7 +9,10 @@
 #include <type_traits>
 #include <iterator>
 #include <limits>
+#include <array>
 #include <iomanip>
+#include <cstdio>
+#include <cassert>
 #include <cctype>
 
 // they scans characters and returns region if it matches to the condition.
@@ -38,10 +41,12 @@ inline std::string show_char(const char c)
     }
     else
     {
-        std::ostringstream oss;
-        oss << "0x" << std::hex << std::setfill('0') << std::setw(2)
-            << static_cast<int>(c);
-        return oss.str();
+        std::array<char, 5> buf;
+        buf.fill('\0');
+        const auto r = std::snprintf(
+                buf.data(), buf.size(), "0x%02x", static_cast<int>(c) & 0xFF);
+        assert(r == buf.size() - 1);
+        return std::string(buf.data());
     }
 }
 
@@ -51,7 +56,8 @@ struct character
     static constexpr char target = C;
 
     template<typename Cont>
-    static result<region<Cont>, std::string> invoke(location<Cont>& loc)
+    static result<region<Cont>, std::string>
+    invoke(location<Cont>& loc, const bool msg = false)
     {
         static_assert(std::is_same<char, typename Cont::value_type>::value,
                       "internal error: container::value_type should be `char`.");
@@ -62,10 +68,14 @@ struct character
         const char c = *(loc.iter());
         if(c != target)
         {
-            return err(concat_to_string("expected '", show_char(target),
-                                        "' but got '", show_char(c), "'."));
+            if(msg)
+            {
+                return err(concat_to_string("expected '", show_char(target),
+                                            "' but got '", show_char(c), "'."));
+            }
+            return err("");
         }
-        ++(loc.iter()); // update location
+        loc.advance(); // update location
 
         return ok(region<Cont>(loc, first, loc.iter()));
     }
@@ -86,7 +96,8 @@ struct in_range
     static constexpr char lower = Low;
 
     template<typename Cont>
-    static result<region<Cont>, std::string> invoke(location<Cont>& loc)
+    static result<region<Cont>, std::string>
+    invoke(location<Cont>& loc, const bool msg = false)
     {
         static_assert(std::is_same<char, typename Cont::value_type>::value,
                       "internal error: container::value_type should be `char`.");
@@ -97,12 +108,16 @@ struct in_range
         const char c = *(loc.iter());
         if(c < lower || upper < c)
         {
-            return err(concat_to_string("expected character in range "
-                "[", show_char(lower), ", ", show_char(upper), "] but got ",
-                "'", show_char(c), "'."));
+            if(msg)
+            {
+                return err(concat_to_string("expected character in range "
+                    "[", show_char(lower), ", ", show_char(upper), "] but got ",
+                    "'", show_char(c), "'."));
+            }
+            return err("");
         }
 
-        ++(loc.iter());
+        loc.advance();
         return ok(region<Cont>(loc, first, loc.iter()));
     }
 
@@ -120,7 +135,8 @@ template<typename Combinator>
 struct exclude
 {
     template<typename Cont>
-    static result<region<Cont>, std::string> invoke(location<Cont>& loc)
+    static result<region<Cont>, std::string>
+    invoke(location<Cont>& loc, const bool msg = false)
     {
         static_assert(std::is_same<char, typename Cont::value_type>::value,
                       "internal error: container::value_type should be `char`.");
@@ -128,15 +144,18 @@ struct exclude
         if(loc.iter() == loc.end()) {return err("not sufficient characters");}
         auto first = loc.iter();
 
-        auto rslt = Combinator::invoke(loc);
+        auto rslt = Combinator::invoke(loc, msg);
         if(rslt.is_ok())
         {
-            loc.iter() = first; // rollback
-            return err(concat_to_string(
-                "invalid pattern (", Combinator::pattern(), ") appeared ",
-                rslt.unwrap().str()));
+            loc.reset(first);
+            if(msg)
+            {
+                return err(concat_to_string("invalid pattern (",
+                    Combinator::pattern(), ") appeared ", rslt.unwrap().str()));
+            }
+            return err("");
         }
-        loc.iter() = std::next(first);
+        loc.reset(std::next(first)); // XXX maybe loc.advance() is okay but...
         return ok(region<Cont>(loc, first, loc.iter()));
     }
 
@@ -151,12 +170,13 @@ template<typename Combinator>
 struct maybe
 {
     template<typename Cont>
-    static result<region<Cont>, std::string> invoke(location<Cont>& loc)
+    static result<region<Cont>, std::string>
+    invoke(location<Cont>& loc, const bool msg = false)
     {
         static_assert(std::is_same<char, typename Cont::value_type>::value,
                       "internal error: container::value_type should be `char`.");
 
-        const auto rslt = Combinator::invoke(loc);
+        const auto rslt = Combinator::invoke(loc, msg);
         if(rslt.is_ok())
         {
             return rslt;
@@ -177,34 +197,36 @@ template<typename Head, typename ... Tail>
 struct sequence<Head, Tail...>
 {
     template<typename Cont>
-    static result<region<Cont>, std::string> invoke(location<Cont>& loc)
+    static result<region<Cont>, std::string>
+    invoke(location<Cont>& loc, const bool msg = false)
     {
         static_assert(std::is_same<char, typename Cont::value_type>::value,
                       "internal error: container::value_type should be `char`.");
 
         const auto first = loc.iter();
-        const auto rslt = Head::invoke(loc);
+        const auto rslt = Head::invoke(loc, msg);
         if(rslt.is_err())
         {
-            loc.iter() = first;
+            loc.reset(first);
             return err(rslt.unwrap_err());
         }
-        return sequence<Tail...>::invoke(loc, std::move(rslt.unwrap()), first);
+        return sequence<Tail...>::invoke(loc, std::move(rslt.unwrap()), first, msg);
     }
 
     // called from the above function only, recursively.
     template<typename Cont, typename Iterator>
     static result<region<Cont>, std::string>
-    invoke(location<Cont>& loc, region<Cont> reg, Iterator first)
+    invoke(location<Cont>& loc, region<Cont> reg, Iterator first,
+           const bool msg = false)
     {
-        const auto rslt = Head::invoke(loc);
+        const auto rslt = Head::invoke(loc, msg);
         if(rslt.is_err())
         {
-            loc.iter() = first;
+            loc.reset(first);
             return err(rslt.unwrap_err());
         }
         reg += rslt.unwrap(); // concat regions
-        return sequence<Tail...>::invoke(loc, std::move(reg), first);
+        return sequence<Tail...>::invoke(loc, std::move(reg), first, msg);
     }
 
     static std::string pattern()
@@ -219,12 +241,13 @@ struct sequence<Head>
     // would be called from sequence<T ...>::invoke only.
     template<typename Cont, typename Iterator>
     static result<region<Cont>, std::string>
-    invoke(location<Cont>& loc, region<Cont> reg, Iterator first)
+    invoke(location<Cont>& loc, region<Cont> reg, Iterator first,
+           const bool msg = false)
     {
-        const auto rslt = Head::invoke(loc);
+        const auto rslt = Head::invoke(loc, msg);
         if(rslt.is_err())
         {
-            loc.iter() = first;
+            loc.reset(first);
             return err(rslt.unwrap_err());
         }
         reg += rslt.unwrap(); // concat regions
@@ -240,14 +263,15 @@ template<typename Head, typename ... Tail>
 struct either<Head, Tail...>
 {
     template<typename Cont>
-    static result<region<Cont>, std::string> invoke(location<Cont>& loc)
+    static result<region<Cont>, std::string>
+    invoke(location<Cont>& loc, const bool msg = false)
     {
         static_assert(std::is_same<char, typename Cont::value_type>::value,
                       "internal error: container::value_type should be `char`.");
 
-        const auto rslt = Head::invoke(loc);
+        const auto rslt = Head::invoke(loc, msg);
         if(rslt.is_ok()) {return rslt;}
-        return either<Tail...>::invoke(loc);
+        return either<Tail...>::invoke(loc, msg);
     }
 
     static std::string pattern()
@@ -259,11 +283,12 @@ template<typename Head>
 struct either<Head>
 {
     template<typename Cont>
-    static result<region<Cont>, std::string> invoke(location<Cont>& loc)
+    static result<region<Cont>, std::string>
+    invoke(location<Cont>& loc, const bool msg = false)
     {
         static_assert(std::is_same<char, typename Cont::value_type>::value,
                       "internal error: container::value_type should be `char`.");
-        return Head::invoke(loc);
+        return Head::invoke(loc, msg);
     }
     static std::string pattern()
     {
@@ -282,16 +307,17 @@ template<typename T, std::size_t N>
 struct repeat<T, exactly<N>>
 {
     template<typename Cont>
-    static result<region<Cont>, std::string> invoke(location<Cont>& loc)
+    static result<region<Cont>, std::string>
+    invoke(location<Cont>& loc, const bool msg = false)
     {
         region<Cont> retval(loc);
         const auto first = loc.iter();
         for(std::size_t i=0; i<N; ++i)
         {
-            auto rslt = T::invoke(loc);
+            auto rslt = T::invoke(loc, msg);
             if(rslt.is_err())
             {
-                loc.iter() = first;
+                loc.reset(first);
                 return err(rslt.unwrap_err());
             }
             retval += rslt.unwrap();
@@ -308,24 +334,25 @@ template<typename T, std::size_t N>
 struct repeat<T, at_least<N>>
 {
     template<typename Cont>
-    static result<region<Cont>, std::string> invoke(location<Cont>& loc)
+    static result<region<Cont>, std::string>
+    invoke(location<Cont>& loc, const bool msg = false)
     {
         region<Cont> retval(loc);
 
         const auto first = loc.iter();
         for(std::size_t i=0; i<N; ++i)
         {
-            auto rslt = T::invoke(loc);
+            auto rslt = T::invoke(loc, msg);
             if(rslt.is_err())
             {
-                loc.iter() = first;
+                loc.reset(first);
                 return err(rslt.unwrap_err());
             }
             retval += rslt.unwrap();
         }
         while(true)
         {
-            auto rslt = T::invoke(loc);
+            auto rslt = T::invoke(loc, msg);
             if(rslt.is_err())
             {
                 return ok(std::move(retval));
@@ -343,12 +370,13 @@ template<typename T>
 struct repeat<T, unlimited>
 {
     template<typename Cont>
-    static result<region<Cont>, std::string> invoke(location<Cont>& loc)
+    static result<region<Cont>, std::string>
+    invoke(location<Cont>& loc, const bool msg = false)
     {
         region<Cont> retval(loc);
         while(true)
         {
-            auto rslt = T::invoke(loc);
+            auto rslt = T::invoke(loc, msg);
             if(rslt.is_err())
             {
                 return ok(std::move(retval));

toml/datetime.hpp

@@ -25,20 +25,22 @@ inline std::tm localtime_s(const std::time_t* src)
 {
     std::tm dst;
     const auto result = ::localtime_r(src, &dst);
-    if(!result)
-    {
-        throw std::runtime_error("localtime_r failed.");
-    }
+    if (!result) { throw std::runtime_error("localtime_r failed."); }
+    return dst;
+}
+#elif _MSC_VER
+inline std::tm localtime_s(const std::time_t* src)
+{
+    std::tm dst;
+    const auto result = ::localtime_s(&dst, src);
+    if (result) { throw std::runtime_error("localtime_s failed."); }
     return dst;
 }
 #else
-// XXX: On Windows, std::localtime is thread-safe because they uses thread-local
-// storage to store the instance of std::tm. On the other platforms, it may not
-// be thread-safe.
 inline std::tm localtime_s(const std::time_t* src)
 {
     const auto result = std::localtime(src);
-    if(!result) {throw std::runtime_error("localtime failed.");}
+    if (!result) { throw std::runtime_error("localtime failed."); }
     return *result;
 }
 #endif
@@ -360,12 +362,12 @@ struct local_datetime
         // can be used to get millisecond & microsecond information.
         const auto t_diff = tp -
             std::chrono::system_clock::from_time_t(std::mktime(&time));
-        this->time.millisecond = std::chrono::duration_cast<
-            std::chrono::milliseconds>(t_diff).count();
-        this->time.microsecond = std::chrono::duration_cast<
-            std::chrono::microseconds>(t_diff).count();
-        this->time.nanosecond = std::chrono::duration_cast<
-            std::chrono::nanoseconds >(t_diff).count();
+        this->time.millisecond = static_cast<std::uint16_t>(
+          std::chrono::duration_cast<std::chrono::milliseconds>(t_diff).count());
+        this->time.microsecond = static_cast<std::uint16_t>(
+          std::chrono::duration_cast<std::chrono::microseconds>(t_diff).count());
+        this->time.nanosecond = static_cast<std::uint16_t>(
+          std::chrono::duration_cast<std::chrono::nanoseconds >(t_diff).count());
     }
 
     explicit local_datetime(const std::time_t t)

toml/from_toml.hpp

@@ -51,7 +51,7 @@ struct from_toml_tie_impl
 template<typename ... Ts>
 struct from_toml_tie_impl<0, Ts...>
 {
-    static void invoke(std::tuple<Ts& ...> tie, const toml::value& v)
+    static void invoke(std::tuple<Ts& ...>, const toml::value&)
     {
         return;
     }

toml/literal.hpp

@@ -30,16 +30,49 @@ inline ::toml::value operator""_toml(const char* str, std::size_t len)
         ::toml::detail::lex_ws, ::toml::detail::at_least<1>>;
     skip_ws::invoke(loc);
 
-    // literal may be a bare value. try them first.
-    if(auto data = ::toml::detail::parse_value(loc))
+    // to distinguish arrays and tables, first check it is a table or not.
+    //
+    // "[1,2,3]"_toml;   // this is an array
+    // "[table]"_toml;   // a table that has an empty table named "table" inside.
+    // "[[1,2,3]]"_toml; // this is an array of arrays
+    // "[[table]]"_toml; // this is a table that has an array of tables inside.
+    //
+    // "[[1]]"_toml;     // this can be both... (currently it becomes a table)
+    // "1 = [{}]"_toml;  // this is a table that has an array of table named 1.
+    // "[[1,]]"_toml;    // this is an array of arrays.
+    // "[[1],]"_toml;    // this also.
+
+    const auto the_front = loc.iter();
+
+    const bool is_table_key = ::toml::detail::lex_std_table::invoke(loc);
+    loc.reset(the_front);
+
+    const bool is_aots_key  = ::toml::detail::lex_array_table::invoke(loc);
+    loc.reset(the_front);
+
+    // If it is neither a table-key or a array-of-table-key, it may be a value.
+    if(!is_table_key && !is_aots_key)
     {
-        return data.unwrap();
+        if(auto data = ::toml::detail::parse_value(loc))
+        {
+            return data.unwrap();
+        }
     }
 
-    // literal is a TOML file (i.e. multiline table).
+    // Note that still it can be a table, because the literal might be something
+    // like the following.
+    // ```cpp
+    // R"( // c++11 raw string literals
+    //   key = "value"
+    //   int = 42
+    // )"_toml;
+    // ```
+    // It is a valid toml file.
+    // It should be parsed as if we parse a file with this content.
+
     if(auto data = ::toml::detail::parse_toml_file(loc))
     {
-        loc.iter() = loc.begin(); // rollback to the top of the literal
+        loc.reset(loc.begin()); // rollback to the top of the literal
         return ::toml::value(std::move(data.unwrap()),
                 ::toml::detail::region<std::vector<char>>(std::move(loc)));
     }

toml/parser.hpp

@@ -33,7 +33,7 @@ parse_boolean(location<Container>& loc)
                 {{std::addressof(reg), "invalid token"}}));
         }
     }
-    loc.iter() = first; //rollback
+    loc.reset(first); //rollback
     return err(format_underline("[error] toml::parse_boolean: ",
                {{std::addressof(loc), "the next token is not a boolean"}}));
 }
@@ -62,7 +62,7 @@ parse_binary_integer(location<Container>& loc)
         }
         return ok(std::make_pair(retval, token.unwrap()));
     }
-    loc.iter() = first;
+    loc.reset(first);
     return err(format_underline("[error] toml::parse_binary_integer:",
                {{std::addressof(loc), "the next token is not an integer"}}));
 }
@@ -83,7 +83,7 @@ parse_octal_integer(location<Container>& loc)
         iss >> std::oct >> retval;
         return ok(std::make_pair(retval, token.unwrap()));
     }
-    loc.iter() = first;
+    loc.reset(first);
     return err(format_underline("[error] toml::parse_octal_integer:",
                {{std::addressof(loc), "the next token is not an integer"}}));
 }
@@ -104,7 +104,7 @@ parse_hexadecimal_integer(location<Container>& loc)
         iss >> std::hex >> retval;
         return ok(std::make_pair(retval, token.unwrap()));
     }
-    loc.iter() = first;
+    loc.reset(first);
     return err(format_underline("[error] toml::parse_hexadecimal_integer",
                {{std::addressof(loc), "the next token is not an integer"}}));
 }
@@ -116,10 +116,28 @@ parse_integer(location<Container>& loc)
     const auto first = loc.iter();
     if(first != loc.end() && *first == '0')
     {
-        if(const auto bin = parse_binary_integer     (loc)) {return bin;}
-        if(const auto oct = parse_octal_integer      (loc)) {return oct;}
-        if(const auto hex = parse_hexadecimal_integer(loc)) {return hex;}
-        // else, maybe just zero.
+        const auto second = std::next(first);
+        if(second == loc.end()) // the token is just zero.
+        {
+            return ok(std::make_pair(0, region<Container>(loc, first, second)));
+        }
+
+        if(*second == 'b') {return parse_binary_integer     (loc);} // 0b1100
+        if(*second == 'o') {return parse_octal_integer      (loc);} // 0o775
+        if(*second == 'x') {return parse_hexadecimal_integer(loc);} // 0xC0FFEE
+
+        if(std::isdigit(*second))
+        {
+            return err(format_underline("[error] toml::parse_integer: "
+                "leading zero in an Integer is not allowed.",
+                {{std::addressof(loc), "leading zero"}}));
+        }
+        else if(std::isalpha(*second))
+        {
+             return err(format_underline("[error] toml::parse_integer: "
+                "unknown integer prefix appeared.",
+                {{std::addressof(loc), "none of 0x, 0o, 0b"}}));
+        }
     }
 
     if(const auto token = lex_dec_int::invoke(loc))
@@ -132,7 +150,7 @@ parse_integer(location<Container>& loc)
         iss >> retval;
         return ok(std::make_pair(retval, token.unwrap()));
     }
-    loc.iter() = first;
+    loc.reset(first);
     return err(format_underline("[error] toml::parse_integer: ",
                {{std::addressof(loc), "the next token is not an integer"}}));
 }
@@ -221,7 +239,7 @@ parse_floating(location<Container>& loc)
         iss >> v;
         return ok(std::make_pair(v, token.unwrap()));
     }
-    loc.iter() = first;
+    loc.reset(first);
     return err(format_underline("[error] toml::parse_floating: ",
                {{std::addressof(loc), "the next token is not a float"}}));
 }
@@ -288,16 +306,16 @@ result<std::string, std::string> parse_escape_sequence(location<Container>& loc)
         return err(format_underline("[error]: toml::parse_escape_sequence: ", {{
             std::addressof(loc), "the next token is not a backslash \"\\\""}}));
     }
-    ++loc.iter();
+    loc.advance();
     switch(*loc.iter())
     {
-        case '\\':{++loc.iter(); return ok(std::string("\\"));}
-        case '"' :{++loc.iter(); return ok(std::string("\""));}
-        case 'b' :{++loc.iter(); return ok(std::string("\b"));}
-        case 't' :{++loc.iter(); return ok(std::string("\t"));}
-        case 'n' :{++loc.iter(); return ok(std::string("\n"));}
-        case 'f' :{++loc.iter(); return ok(std::string("\f"));}
-        case 'r' :{++loc.iter(); return ok(std::string("\r"));}
+        case '\\':{loc.advance(); return ok(std::string("\\"));}
+        case '"' :{loc.advance(); return ok(std::string("\""));}
+        case 'b' :{loc.advance(); return ok(std::string("\b"));}
+        case 't' :{loc.advance(); return ok(std::string("\t"));}
+        case 'n' :{loc.advance(); return ok(std::string("\n"));}
+        case 'f' :{loc.advance(); return ok(std::string("\f"));}
+        case 'r' :{loc.advance(); return ok(std::string("\r"));}
         case 'u' :
         {
             if(const auto token = lex_escape_unicode_short::invoke(loc))
@@ -308,7 +326,7 @@ result<std::string, std::string> parse_escape_sequence(location<Container>& loc)
             {
                 return err(format_underline("[error] parse_escape_sequence: "
                            "invalid token found in UTF-8 codepoint uXXXX.",
-                           {{std::addressof(loc), token.unwrap_err()}}));
+                           {{std::addressof(loc), "here"}}));
             }
         }
         case 'U':
@@ -321,7 +339,7 @@ result<std::string, std::string> parse_escape_sequence(location<Container>& loc)
             {
                 return err(format_underline("[error] parse_escape_sequence: "
                            "invalid token found in UTF-8 codepoint Uxxxxxxxx",
-                           {{std::addressof(loc), token.unwrap_err()}}));
+                           {{std::addressof(loc), "here"}}));
             }
         }
     }
@@ -331,7 +349,7 @@ result<std::string, std::string> parse_escape_sequence(location<Container>& 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*>'"});
-    loc.iter() = first;
+    loc.reset(first);
     return err(msg);
 }
 
@@ -343,7 +361,7 @@ parse_ml_basic_string(location<Container>& loc)
     if(const auto token = lex_ml_basic_string::invoke(loc))
     {
         auto inner_loc = loc;
-        inner_loc.iter() = first;
+        inner_loc.reset(first);
 
         std::string retval;
         retval.reserve(token.unwrap().size());
@@ -387,8 +405,10 @@ parse_ml_basic_string(location<Container>& loc)
     }
     else
     {
-        loc.iter() = first;
-        return err(token.unwrap_err());
+        loc.reset(first);
+        return err(format_underline("[error] toml::parse_ml_basic_string: "
+                   "the next token is not a multiline string",
+                   {{std::addressof(loc), "here"}}));
     }
 }
 
@@ -400,7 +420,7 @@ parse_basic_string(location<Container>& loc)
     if(const auto token = lex_basic_string::invoke(loc))
     {
         auto inner_loc = loc;
-        inner_loc.iter() = first;
+        inner_loc.reset(first);
 
         auto quot = lex_quotation_mark::invoke(inner_loc);
         if(!quot)
@@ -436,8 +456,10 @@ parse_basic_string(location<Container>& loc)
     }
     else
     {
-        loc.iter() = first; // rollback
-        return err(token.unwrap_err());
+        loc.reset(first); // rollback
+        return err(format_underline("[error] toml::parse_basic_string: "
+                   "the next token is not a string",
+                   {{std::addressof(loc), "here"}}));
     }
 }
 
@@ -475,8 +497,10 @@ parse_ml_literal_string(location<Container>& loc)
     }
     else
     {
-        loc.iter() = first; // rollback
-        return err(token.unwrap_err());
+        loc.reset(first); // rollback
+        return err(format_underline("[error] toml::parse_ml_literal_string: "
+                   "the next token is not a multiline literal string",
+                   {{std::addressof(loc), "here"}}));
     }
 }
 
@@ -512,8 +536,10 @@ parse_literal_string(location<Container>& loc)
     }
     else
     {
-        loc.iter() = first; // rollback
-        return err(token.unwrap_err());
+        loc.reset(first); // rollback
+        return err(format_underline("[error] toml::parse_literal_string: "
+                   "the next token is not a literal string",
+                   {{std::addressof(loc), "here"}}));
     }
 }
 
@@ -521,10 +547,30 @@ template<typename Container>
 result<std::pair<toml::string, region<Container>>, std::string>
 parse_string(location<Container>& loc)
 {
-    if(const auto rslt = parse_ml_basic_string(loc))   {return rslt;}
-    if(const auto rslt = parse_ml_literal_string(loc)) {return rslt;}
-    if(const auto rslt = parse_basic_string(loc))      {return rslt;}
-    if(const auto rslt = parse_literal_string(loc))    {return rslt;}
+    if(loc.iter() != loc.end() && *(loc.iter()) == '"')
+    {
+        if(loc.iter() + 1 != loc.end() && *(loc.iter() + 1) == '"' &&
+           loc.iter() + 2 != loc.end() && *(loc.iter() + 2) == '"')
+        {
+            return parse_ml_basic_string(loc);
+        }
+        else
+        {
+            return parse_basic_string(loc);
+        }
+    }
+    else if(loc.iter() != loc.end() && *(loc.iter()) == '\'')
+    {
+        if(loc.iter() + 1 != loc.end() && *(loc.iter() + 1) == '\'' &&
+           loc.iter() + 2 != loc.end() && *(loc.iter() + 2) == '\'')
+        {
+            return parse_ml_literal_string(loc);
+        }
+        else
+        {
+            return parse_literal_string(loc);
+        }
+    }
     return err(format_underline("[error] toml::parse_string: ",
                 {{std::addressof(loc), "the next token is not a string"}}));
 }
@@ -548,7 +594,7 @@ parse_local_date(location<Container>& loc)
                 "toml::parse_inner_local_date: invalid year format",
                 {{std::addressof(inner_loc), msg}}));
         }
-        ++inner_loc.iter();
+        inner_loc.advance();
         const auto m = lex_date_month::invoke(inner_loc);
         if(!m || inner_loc.iter() == inner_loc.end() || *inner_loc.iter() != '-')
         {
@@ -559,7 +605,7 @@ parse_local_date(location<Container>& loc)
                 "toml::parse_local_date: invalid month format",
                 {{std::addressof(inner_loc), msg}}));
         }
-        ++inner_loc.iter();
+        inner_loc.advance();
         const auto d = lex_date_mday::invoke(inner_loc);
         if(!d)
         {
@@ -576,7 +622,7 @@ parse_local_date(location<Container>& loc)
     }
     else
     {
-        loc.iter() = first;
+        loc.reset(first);
         return err(format_underline("[error]: toml::parse_local_date: ",
             {{std::addressof(loc), "the next token is not a local_date"}}));
     }
@@ -601,7 +647,7 @@ parse_local_time(location<Container>& loc)
                 "toml::parse_local_time: invalid year format",
                 {{std::addressof(inner_loc), msg}}));
         }
-        ++inner_loc.iter();
+        inner_loc.advance();
         const auto m = lex_time_minute::invoke(inner_loc);
         if(!m || inner_loc.iter() == inner_loc.end() || *inner_loc.iter() != ':')
         {
@@ -612,7 +658,7 @@ parse_local_time(location<Container>& loc)
                 "toml::parse_local_time: invalid month format",
                 {{std::addressof(inner_loc), msg}}));
         }
-        ++inner_loc.iter();
+        inner_loc.advance();
         const auto s = lex_time_second::invoke(inner_loc);
         if(!s)
         {
@@ -661,7 +707,7 @@ parse_local_time(location<Container>& loc)
     }
     else
     {
-        loc.iter() = first;
+        loc.reset(first);
         return err(format_underline("[error]: toml::parse_local_time: ",
             {{std::addressof(loc), "the next token is not a local_time"}}));
     }
@@ -685,13 +731,14 @@ parse_local_datetime(location<Container>& loc)
                 "toml::parse_local_datetime: invalid datetime format",
                 {{std::addressof(inner_loc), msg}}));
         }
-        const char delim = *(inner_loc.iter()++);
+        const char delim = *(inner_loc.iter());
         if(delim != 'T' && delim != 't' && delim != ' ')
         {
             throw internal_error(format_underline("[error]: "
                 "toml::parse_local_datetime: invalid datetime format",
                 {{std::addressof(inner_loc), "should be `T` or ` ` (space)"}}));
         }
+        inner_loc.advance();
         const auto time = parse_local_time(inner_loc);
         if(!time)
         {
@@ -705,7 +752,7 @@ parse_local_datetime(location<Container>& loc)
     }
     else
     {
-        loc.iter() = first;
+        loc.reset(first);
         return err(format_underline("[error]: toml::parse_local_datetime: ",
             {{std::addressof(loc), "the next token is not a local_datetime"}}));
     }
@@ -755,9 +802,9 @@ parse_offset_datetime(location<Container>& loc)
     }
     else
     {
-        loc.iter() = first;
+        loc.reset(first);
         return err(format_underline("[error]: toml::parse_offset_datetime: ",
-            {{std::addressof(loc), "the next token is not a local_datetime"}}));
+            {{std::addressof(loc), "the next token is not a offset_datetime"}}));
     }
 }
 
@@ -816,7 +863,7 @@ parse_key(location<Container>& loc)
             }
             else if(*inner_loc.iter() == '.')
             {
-                ++inner_loc.iter(); // to skip `.`
+                inner_loc.advance(); // to skip `.`
             }
             else
             {
@@ -827,7 +874,7 @@ parse_key(location<Container>& loc)
         }
         return ok(std::make_pair(keys, reg));
     }
-    loc.iter() = first;
+    loc.reset(first);
 
     // simple key -> foo
     if(const auto smpl = parse_simple_key(loc))
@@ -856,7 +903,7 @@ parse_array(location<Container>& loc)
     {
         return err("[error] toml::parse_array: token is not an array");
     }
-    ++loc.iter();
+    loc.advance();
 
     using lex_ws_comment_newline = repeat<
         either<lex_wschar, lex_newline, lex_comment>, unlimited>;
@@ -868,7 +915,7 @@ parse_array(location<Container>& loc)
 
         if(loc.iter() != loc.end() && *loc.iter() == ']')
         {
-            ++loc.iter(); // skip ']'
+            loc.advance(); // skip ']'
             return ok(std::make_pair(retval,
                       region<Container>(loc, first, loc.iter())));
         }
@@ -878,7 +925,7 @@ parse_array(location<Container>& loc)
             if(!retval.empty() && retval.front().type() != val.as_ok().type())
             {
                 auto array_start_loc = loc;
-                array_start_loc.iter() = first;
+                array_start_loc.reset(first);
 
                 throw syntax_error(format_underline("[error] toml::parse_array: "
                     "type of elements should be the same each other.", {
@@ -898,7 +945,7 @@ parse_array(location<Container>& loc)
         else
         {
             auto array_start_loc = loc;
-            array_start_loc.iter() = first;
+            array_start_loc.reset(first);
 
             throw syntax_error(format_underline("[error] toml::parse_array: "
                 "value having invalid format appeared in an array", {
@@ -914,14 +961,14 @@ parse_array(location<Container>& loc)
             lex_ws_comment_newline::invoke(loc);
             if(loc.iter() != loc.end() && *loc.iter() == ']')
             {
-                ++loc.iter(); // skip ']'
+                loc.advance(); // skip ']'
                 return ok(std::make_pair(retval,
                           region<Container>(loc, first, loc.iter())));
             }
             else
             {
                 auto array_start_loc = loc;
-                array_start_loc.iter() = first;
+                array_start_loc.reset(first);
 
                 throw syntax_error(format_underline("[error] toml::parse_array:"
                     " missing array separator `,` after a value", {
@@ -931,7 +978,7 @@ parse_array(location<Container>& loc)
             }
         }
     }
-    loc.iter() = first;
+    loc.reset(first);
     throw syntax_error(format_underline("[error] toml::parse_array: "
             "array did not closed by `]`",
             {{std::addressof(loc), "should be closed"}}));
@@ -950,7 +997,7 @@ parse_key_value_pair(location<Container>& loc)
         // key. then we need to show error as "empty key is not allowed".
         if(const auto keyval_sep = lex_keyval_sep::invoke(loc))
         {
-            loc.iter() = first;
+            loc.reset(first);
             msg = format_underline("[error] toml::parse_key_value_pair: "
                 "empty key is not allowed.",
                 {{std::addressof(loc), "key expected before '='"}});
@@ -979,7 +1026,7 @@ parse_key_value_pair(location<Container>& loc)
                 "missing key-value separator `=`",
                 {{std::addressof(loc), "should be `=`"}});
         }
-        loc.iter() = first;
+        loc.reset(first);
         return err(std::move(msg));
     }
 
@@ -988,11 +1035,11 @@ parse_key_value_pair(location<Container>& loc)
     if(!val)
     {
         std::string msg;
-        loc.iter() = after_kvsp;
+        loc.reset(after_kvsp);
         // check there is something not a comment/whitespace after `=`
         if(sequence<maybe<lex_ws>, maybe<lex_comment>, lex_newline>::invoke(loc))
         {
-            loc.iter() = after_kvsp;
+            loc.reset(after_kvsp);
             msg = format_underline("[error] toml::parse_key_value_pair: "
                     "missing value after key-value separator '='",
                     {{std::addressof(loc), "expected value, but got nothing"}});
@@ -1001,7 +1048,7 @@ parse_key_value_pair(location<Container>& loc)
         {
             msg = std::move(val.unwrap_err());
         }
-        loc.iter() = first;
+        loc.reset(first);
         return err(msg);
     }
     return ok(std::make_pair(std::move(key_reg.unwrap()),
@@ -1028,6 +1075,7 @@ std::string format_dotted_keys(InputIterator first, const InputIterator last)
 template<typename Container>
 result<std::pair<std::vector<key>, region<Container>>, std::string>
 parse_table_key(location<Container>& loc);
+
 // The following toml file is allowed.
 // ```toml
 // [a.b.c]     # here, table `a` has element `b`.
@@ -1318,14 +1366,14 @@ parse_inline_table(location<Container>& loc)
         return err(format_underline("[error] toml::parse_inline_table: ", 
             {{std::addressof(loc), "the next token is not an inline table"}}));
     }
-    ++loc.iter();
+    loc.advance();
     // it starts from "{". it should be formatted as inline-table
     while(loc.iter() != loc.end())
     {
         maybe<lex_ws>::invoke(loc);
         if(loc.iter() != loc.end() && *loc.iter() == '}')
         {
-            ++loc.iter(); // skip `}`
+            loc.advance(); // skip `}`
             return ok(std::make_pair(
                         retval, region<Container>(loc, first, loc.iter())));
         }
@@ -1354,24 +1402,70 @@ parse_inline_table(location<Container>& loc)
             maybe<lex_ws>::invoke(loc);
             if(loc.iter() != loc.end() && *loc.iter() == '}')
             {
-                ++loc.iter(); // skip `}`
+                loc.advance(); // skip `}`
                 return ok(std::make_pair(
                             retval, region<Container>(loc, first, loc.iter())));
             }
+            else if(*loc.iter() == '#' || *loc.iter() == '\r' || *loc.iter() == '\n')
+            {
+                throw syntax_error(format_underline("[error] "
+                    "toml::parse_inline_table: missing curly brace `}`",
+                    {{std::addressof(loc), "should be `}`"}}));
+            }
             else
             {
                 throw syntax_error(format_underline("[error] "
-                    "toml:::parse_inline_table: missing table separator `,` ",
+                    "toml::parse_inline_table: missing table separator `,` ",
                     {{std::addressof(loc), "should be `,`"}}));
             }
         }
     }
-    loc.iter() = first;
+    loc.reset(first);
     throw syntax_error(format_underline("[error] toml::parse_inline_table: "
             "inline table did not closed by `}`",
             {{std::addressof(loc), "should be closed"}}));
 }
 
+template<typename Container>
+value_t guess_number_type(const location<Container>& l)
+{
+    location<Container> loc = l;
+
+    if(lex_offset_date_time::invoke(loc)) {return value_t::OffsetDatetime;}
+    loc.reset(l.iter());
+
+    if(lex_local_date_time::invoke(loc)) {return value_t::LocalDatetime;}
+    loc.reset(l.iter());
+
+    if(lex_local_date::invoke(loc)) {return value_t::LocalDate;}
+    loc.reset(l.iter());
+
+    if(lex_local_time::invoke(loc)) {return value_t::LocalTime;}
+    loc.reset(l.iter());
+
+    if(lex_float::invoke(loc)) {return value_t::Float;}
+    loc.reset(l.iter());
+
+    return value_t::Integer;
+}
+
+template<typename Container>
+value_t guess_value_type(const location<Container>& loc)
+{
+    switch(*loc.iter())
+    {
+        case '"' : {return value_t::String; }
+        case '\'': {return value_t::String; }
+        case 't' : {return value_t::Boolean;}
+        case 'f' : {return value_t::Boolean;}
+        case '[' : {return value_t::Array;  }
+        case '{' : {return value_t::Table;  }
+        case 'i' : {return value_t::Float;  } // inf.
+        case 'n' : {return value_t::Float;  } // nan.
+        default  : {return guess_number_type(loc);}
+    }
+}
+
 template<typename Container>
 result<value, std::string> parse_value(location<Container>& loc)
 {
@@ -1381,31 +1475,27 @@ result<value, std::string> parse_value(location<Container>& loc)
         return err(format_underline("[error] toml::parse_value: input is empty",
                    {{std::addressof(loc), ""}}));
     }
-    if(auto r = parse_string         (loc))
-    {return ok(value(std::move(r.unwrap().first), std::move(r.unwrap().second)));}
-    if(auto r = parse_array          (loc))
-    {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().first), std::move(r.unwrap().second)));}
-    if(auto r = parse_boolean        (loc))
-    {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().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: "
-            "unknown token appeared", {{std::addressof(loc), "unknown"}});
-    loc.iter() = first;
-    return err(msg);
+    switch(guess_value_type(loc))
+    {
+        case value_t::Boolean        : {return parse_boolean(loc);        }
+        case value_t::Integer        : {return parse_integer(loc);        }
+        case value_t::Float          : {return parse_floating(loc);       }
+        case value_t::String         : {return parse_string(loc);         }
+        case value_t::OffsetDatetime : {return parse_offset_datetime(loc);}
+        case value_t::LocalDatetime  : {return parse_local_datetime(loc); }
+        case value_t::LocalDate      : {return parse_local_date(loc);     }
+        case value_t::LocalTime      : {return parse_local_time(loc);     }
+        case value_t::Array          : {return parse_array(loc);          }
+        case value_t::Table          : {return parse_inline_table(loc);   }
+        default:
+        {
+            const auto msg = format_underline("[error] toml::parse_value: "
+                    "unknown token appeared", {{std::addressof(loc), "unknown"}});
+            loc.reset(first);
+            return err(msg);
+        }
+    }
 }
 
 template<typename Container>
@@ -1461,7 +1551,8 @@ parse_table_key(location<Container>& loc)
     }
     else
     {
-        return err(token.unwrap_err());
+        return err(format_underline("[error] toml::parse_table_key: "
+            "not a valid table key", {{std::addressof(loc), "here"}}));
     }
 }
 
@@ -1469,7 +1560,7 @@ template<typename Container>
 result<std::pair<std::vector<key>, region<Container>>, std::string>
 parse_array_table_key(location<Container>& loc)
 {
-    if(auto token = lex_array_table::invoke(loc))
+    if(auto token = lex_array_table::invoke(loc, true))
     {
         location<std::string> inner_loc(loc.name(), token.unwrap().str());
 
@@ -1514,7 +1605,8 @@ parse_array_table_key(location<Container>& loc)
     }
     else
     {
-        return err(token.unwrap_err());
+        return err(format_underline("[error] toml::parse_array_table_key: "
+            "not a valid table key", {{std::addressof(loc), "here"}}));
     }
 }
 
@@ -1540,12 +1632,12 @@ result<table, std::string> parse_ml_table(location<Container>& loc)
         const auto before = loc.iter();
         if(const auto tmp = parse_array_table_key(loc)) // next table found
         {
-            loc.iter() = before;
+            loc.reset(before);
             return ok(tab);
         }
         if(const auto tmp = parse_table_key(loc)) // next table found
         {
-            loc.iter() = before;
+            loc.reset(before);
             return ok(tab);
         }
 
@@ -1585,7 +1677,7 @@ result<table, std::string> parse_ml_table(location<Container>& loc)
             const auto msg = format_underline("[error] toml::parse_table: "
                 "invalid line format", {{std::addressof(loc), concat_to_string(
                 "expected newline, but got '", show_char(*loc.iter()), "'.")}});
-            loc.iter() = before;
+            loc.reset(before);
             return err(msg);
         }
 
@@ -1688,7 +1780,7 @@ inline table parse(std::istream& is, std::string fname = "unknown file")
         std::memcpy(BOM.data(), loc.source()->data(), 3);
         if(BOM[0] == 0xEF && BOM[1] == 0xBB && BOM[2] == 0xBF)
         {
-            loc.iter() += 3; // BOM found. skip.
+            loc.advance(3); // BOM found. skip.
         }
     }
 

toml/region.hpp

@@ -62,12 +62,16 @@ struct region_base
 template<typename Container>
 struct location final : public region_base
 {
-    static_assert(std::is_same<char, typename Container::value_type>::value,"");
     using const_iterator = typename Container::const_iterator;
     using source_ptr     = std::shared_ptr<const Container>;
 
+    static_assert(std::is_same<char, typename Container::value_type>::value,"");
+    static_assert(std::is_same<std::random_access_iterator_tag,
+        typename std::iterator_traits<const_iterator>::iterator_category>::value,
+        "container should be randomly accessible");
+
     location(std::string name, Container cont)
-      : source_(std::make_shared<Container>(std::move(cont))),
+      : source_(std::make_shared<Container>(std::move(cont))), line_number_(1),
         source_name_(std::move(name)), iter_(source_->cbegin())
     {}
     location(const location&) = default;
@@ -78,18 +82,54 @@ struct location final : public region_base
 
     bool is_ok() const noexcept override {return static_cast<bool>(source_);}
 
-    const_iterator& iter()       noexcept {return iter_;}
-    const_iterator  iter() const noexcept {return iter_;}
+    // this const prohibits codes like `++(loc.iter())`.
+    const const_iterator iter()  const noexcept {return iter_;}
 
-    const_iterator  begin() const noexcept {return source_->cbegin();}
-    const_iterator  end()   const noexcept {return source_->cend();}
+    const_iterator begin() const noexcept {return source_->cbegin();}
+    const_iterator end()   const noexcept {return source_->cend();}
+
+    // XXX `location::line_num()` used to be implemented using `std::count` to
+    // count a number of '\n'. But with a long toml file (typically, 10k lines),
+    // it becomes intolerably slow because each time it generates error messages,
+    // it counts '\n' from thousands of characters. To workaround it, I decided
+    // to introduce `location::line_number_` member variable and synchronize it
+    // to the location changes the point to look. So an overload of `iter()`
+    // which returns mutable reference is removed and `advance()`, `retrace()`
+    // and `reset()` is added.
+    void advance(std::size_t n = 1) noexcept
+    {
+        this->line_number_ += std::count(this->iter_, this->iter_ + n, '\n');
+        this->iter_ += n;
+        return;
+    }
+    void retrace(std::size_t n = 1) noexcept
+    {
+        this->line_number_ -= std::count(this->iter_ - n, this->iter_, '\n');
+        this->iter_ -= n;
+        return;
+    }
+    void reset(const_iterator rollback) noexcept
+    {
+        // since c++11, std::distance works in both ways for random-access
+        // iterators and returns a negative value if `first > last`.
+        if(0 <= std::distance(rollback, this->iter_)) // rollback < iter
+        {
+            this->line_number_ -= std::count(rollback, this->iter_, '\n');
+        }
+        else // iter < rollback [[unlikely]]
+        {
+            this->line_number_ += std::count(this->iter_, rollback, '\n');
+        }
+        this->iter_ = rollback;
+        return;
+    }
 
     std::string str()  const override {return make_string(1, *this->iter());}
     std::string name() const override {return source_name_;}
 
     std::string line_num() const override
     {
-        return std::to_string(1+std::count(this->begin(), this->iter(), '\n'));
+        return std::to_string(this->line_number_);
     }
 
     std::string line() const override
@@ -128,6 +168,7 @@ struct location final : public region_base
   private:
 
     source_ptr     source_;
+    std::size_t    line_number_;
     std::string    source_name_;
     const_iterator iter_;
 };
@@ -139,10 +180,14 @@ struct location final : public region_base
 template<typename Container>
 struct region final : public region_base
 {
-    static_assert(std::is_same<char, typename Container::value_type>::value,"");
     using const_iterator = typename Container::const_iterator;
     using source_ptr     = std::shared_ptr<const Container>;
 
+    static_assert(std::is_same<char, typename Container::value_type>::value,"");
+    static_assert(std::is_same<std::random_access_iterator_tag,
+        typename std::iterator_traits<const_iterator>::iterator_category>::value,
+        "container should be randomly accessible");
+
     // delete default constructor. source_ never be null.
     region() = delete;
 

toml/value.hpp

@@ -572,6 +572,14 @@ class value
         return *this;
     }
 
+    // for internal use ------------------------------------------------------
+
+    template<typename T, typename Container, typename std::enable_if<
+        detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+    value(std::pair<T, detail::region<Container>> parse_result)
+        : value(std::move(parse_result.first), std::move(parse_result.second))
+    {}
+
     // type checking and casting ============================================
 
     template<typename T>