tag: update patch version v3.3.1

doc: add contributor to README
Merge pull request #102 from jwillikers/cmake_cache_variables
2025-12-16 03:08:52 +08:00 · 2020-02-16 22:02:40 +09:00 · 2020-02-14 19:25:41 +09:00 · 2020-02-13 13:22:25 +09:00 · 2020-02-12 07:44:47 -06:00 · 2020-02-12 13:37:58 +09:00
33 changed files with 2162 additions and 512 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -12,7 +12,7 @@ jobs:
          command: |
              g++ --version
              cd tests/
-              g++ -std=c++11 -O2 -Wall -Wextra -Werror -I../ check_toml_test.cpp -o check_toml_test
+              g++ -std=c++11 -O2 -Wall -Wextra -Werror -DTOML11_COLORIZE_ERROR_MESSAGE -I../ check_toml_test.cpp -o check_toml_test
              go get github.com/BurntSushi/toml-test
              $GOPATH/bin/toml-test ./check_toml_test
  test_serialization:
@@ -24,7 +24,7 @@ jobs:
          command: |
              g++ --version
              cd tests/
-              g++ -std=c++11 -O2 -Wall -Wextra -Wpedantic -Werror -I../ check_serialization.cpp -o check_serialization
+              g++ -std=c++11 -O2 -Wall -Wextra -Wpedantic -Werror -DTOML11_COLORIZE_ERROR_MESSAGE -I../ check_serialization.cpp -o check_serialization
              git clone https://github.com/BurntSushi/toml-test.git
              cp check_serialization toml-test/tests/valid
              cd toml-test/tests/valid
@@ -47,7 +47,7 @@ jobs:
          command: |
              g++ --version
              cd tests/
-              g++ -std=c++11 -O2 -Wall -Wextra -Wpedantic -Werror -I../ check.cpp -o check
+              g++ -std=c++11 -O2 -Wall -Wextra -Wpedantic -Werror -DTOML11_COLORIZE_ERROR_MESSAGE -I../ check.cpp -o check
              git clone https://github.com/BurntSushi/toml-test.git
              cp check toml-test/tests/invalid
              cp check toml-test/tests/valid
--- a/.travis.yml
+++ b/.travis.yml
@@ -5,11 +5,11 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-5" CXX_STANDARD=11 TOML_HEAD=OFF
+    env: COMPILER="g++-5" CXX_STANDARD=11
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
        packages:
        - g++-5
@@ -17,11 +17,11 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-6" CXX_STANDARD=11 TOML_HEAD=OFF
+    env: COMPILER="g++-6" CXX_STANDARD=11
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
        packages:
        - g++-6
@@ -29,11 +29,11 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-7" CXX_STANDARD=11 TOML_HEAD=OFF
+    env: COMPILER="g++-7" CXX_STANDARD=11
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
        packages:
        - g++-7
@@ -41,11 +41,11 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-8" CXX_STANDARD=11 TOML_HEAD=OFF
+    env: COMPILER="g++-8" CXX_STANDARD=11
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
        packages:
        - g++-8
@@ -57,7 +57,7 @@ matrix:
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
        packages:
        - g++-8
@@ -65,11 +65,23 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-8" CXX_STANDARD=17 TOML_HEAD=OFF
+    env: COMPILER="g++-8" CXX_STANDARD=14
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
+        - sourceline: 'ppa:mhier/libboost-latest'
+        packages:
+        - g++-8
+        - boost1.70
+  - os: linux
+    language: cpp
+    compiler: gcc
+    env: COMPILER="g++-8" CXX_STANDARD=17
+    addons:
+      apt:
+        sources:
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
        packages:
        - g++-8
@@ -81,7 +93,7 @@ matrix:
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
        packages:
        - g++-8
@@ -89,27 +101,27 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-3.7" CXX_STANDARD=11 TOML_HEAD=OFF
+    env: COMPILER="clang++-3.9" CXX_STANDARD=11
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
-        - llvm-toolchain-precise-3.7
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
+        - llvm-toolchain-trusty-3.9
        packages:
        - g++-8
-        - clang-3.7
+        - clang-3.9
        - boost1.70
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-4.0" CXX_STANDARD=11 TOML_HEAD=OFF
+    env: COMPILER="clang++-4.0" CXX_STANDARD=11
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
+        - sourceline: 'ppa:mhier/libboost-latest'
        - llvm-toolchain-trusty-4.0
-        - sourceline: 'ppa:mhier/libboost-latest'
        packages:
        - g++-8
        - clang-4.0
@@ -117,13 +129,13 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-5.0" CXX_STANDARD=11 TOML_HEAD=OFF
+    env: COMPILER="clang++-5.0" CXX_STANDARD=11
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
-        - llvm-toolchain-trusty-5.0
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
+        - llvm-toolchain-trusty-5.0
        packages:
        - g++-8
        - clang-5.0
@@ -131,13 +143,13 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-6.0" CXX_STANDARD=11 TOML_HEAD=OFF
+    env: COMPILER="clang++-6.0" CXX_STANDARD=11
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
-        - llvm-toolchain-trusty-6.0
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
+        - llvm-toolchain-trusty-6.0
        packages:
        - g++-8
        - clang-6.0
@@ -145,13 +157,13 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-7" CXX_STANDARD=11 TOML_HEAD=OFF
+    env: COMPILER="clang++-7" CXX_STANDARD=11
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
-        - llvm-toolchain-trusty-7
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
+        - llvm-toolchain-trusty-7
        packages:
        - g++-8
        - clang-7
@@ -159,13 +171,13 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-8" CXX_STANDARD=11 TOML_HEAD=OFF
+    env: COMPILER="clang++-8" CXX_STANDARD=11
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
-        - llvm-toolchain-trusty-8
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
+        - llvm-toolchain-trusty-8
        packages:
        - g++-8
        - clang-8
@@ -177,9 +189,9 @@ matrix:
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
-        - llvm-toolchain-trusty-8
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
+        - llvm-toolchain-trusty-8
        packages:
        - g++-8
        - clang-8
@@ -187,13 +199,27 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-8" CXX_STANDARD=17 TOML_HEAD=OFF
+    env: COMPILER="clang++-8" CXX_STANDARD=14
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
-        - llvm-toolchain-trusty-8
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
+        - llvm-toolchain-trusty-8
+        packages:
+        - clang-8
+        - g++-8
+        - boost1.70
+  - os: linux
+    language: cpp
+    compiler: clang
+    env: COMPILER="clang++-8" CXX_STANDARD=17
+    addons:
+      apt:
+        sources:
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
+        - sourceline: 'ppa:mhier/libboost-latest'
+        - llvm-toolchain-trusty-8
        packages:
        - clang-8
        - g++-8
@@ -205,9 +231,37 @@ matrix:
    addons:
      apt:
        sources:
-        - ubuntu-toolchain-r-test
-        - llvm-toolchain-trusty-8
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
        - sourceline: 'ppa:mhier/libboost-latest'
+        - llvm-toolchain-trusty-8
+        packages:
+        - clang-8
+        - g++-8
+        - boost1.70
+  - os: linux
+    language: cpp
+    compiler: clang
+    env: COMPILER="clang++-8" CXX_STANDARD=11 WITH_ASAN=ON
+    addons:
+      apt:
+        sources:
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
+        - sourceline: 'ppa:mhier/libboost-latest'
+        - llvm-toolchain-trusty-8
+        packages:
+        - clang-8
+        - g++-8
+        - boost1.70
+  - os: linux
+    language: cpp
+    compiler: clang
+    env: COMPILER="clang++-8" CXX_STANDARD=11 WITH_UBSAN=ON
+    addons:
+      apt:
+        sources:
+        - sourceline: 'ppa:ubuntu-toolchain-r/test'
+        - sourceline: 'ppa:mhier/libboost-latest'
+        - llvm-toolchain-trusty-8
        packages:
        - clang-8
        - g++-8
@@ -216,6 +270,15 @@ matrix:
    language: cpp
    compiler: clang
    env: CXX_STANDARD=11
+    cache:
+      directories:
+        - $HOME/Library/Caches/Homebrew
+    addons:
+      homebrew:
+        update: true
+        packages:
+        - cmake
+        - boost

 script:
 - |
@@ -224,13 +287,33 @@ script:
    travis_retry wget "https://github.com/Kitware/CMake/releases/download/v3.14.5/cmake-3.14.5-Linux-x86_64.tar.gz"
    tar xf cmake-3.14.5-Linux-x86_64.tar.gz -C cmake --strip-components=1
    export PATH=${TRAVIS_BUILD_DIR}/cmake/bin:${PATH}
-  else
-    brew upgrade cmake boost
  fi
+- |
+  if [[ "${TOML_HEAD}" != "ON" ]]; then
+    export TOML_HEAD="OFF"
+  fi
+- echo "TOML_HEAD = ${TOML_HEAD}"
+- |
+  if [[ "${WITH_ASAN}" != "ON" ]]; then
+    export WITH_ASAN="OFF"
+  fi
+- echo "WITH_ASAN = ${WITH_ASAN}"
+- |
+  if [[ "${WITH_UBSAN}" != "ON" ]]; then
+    export WITH_UBSAN="OFF"
+  fi
+- echo "WITH_UBSAN = ${WITH_UBSAN}"
 - cmake --version
 - mkdir build
 - cd build
 - git clone https://github.com/toml-lang/toml.git
- cmake -DCMAKE_CXX_COMPILER=$COMPILER -DCMAKE_CXX_STANDARD=$CXX_STANDARD -DTOML11_USE_UNRELEASED_TOML_FEATURES=${TOML_HEAD} ..
+- cmake -DCMAKE_CXX_COMPILER=$COMPILER -DCMAKE_CXX_STANDARD=$CXX_STANDARD -DTOML11_USE_UNRELEASED_TOML_FEATURES=${TOML_HEAD} -Dtoml11_TEST_WITH_ASAN=${WITH_ASAN} -Dtoml11_TEST_WITH_UBSAN=${WITH_UBSAN} ..
 - make
 - ctest --output-on-failure
+
+# https://stackoverflow.com/a/53331571
+before_cache:
+- |
+  if [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
+    brew cleanup
+  fi
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,21 +4,21 @@ enable_testing()
 project(toml11)

 set(toml11_VERSION_MAYOR  3)
-set(toml11_VERSION_MINOR  0)
+set(toml11_VERSION_MINOR  3)
 set(toml11_VERSION_PATCH  1)
 set(toml11_VERSION
  "${toml11_VERSION_MAYOR}.${toml11_VERSION_MINOR}.${toml11_VERSION_PATCH}"
 )

 option(toml11_BUILD_TEST "Build toml tests" ON)
+option(toml11_TEST_WITH_ASAN  "use LLVM address sanitizer" OFF)
+option(toml11_TEST_WITH_UBSAN "use LLVM undefined behavior sanitizer" OFF)

 include(CheckCXXCompilerFlag)
 if("${CMAKE_VERSION}" VERSION_GREATER 3.1)
-    set(CMAKE_CXX_EXTENSIONS OFF)
-    if(NOT DEFINED CMAKE_CXX_STANDARD)
-        set(CMAKE_CXX_STANDARD 11)
-    endif()
-    set(CXX_STANDARD_REQUIRED ON)
+    set(CMAKE_CXX_STANDARD 11 CACHE STRING "The C++ standard whose features are requested to build all targets.")
+    set(CMAKE_CXX_STANDARD_REQUIRED ON CACHE BOOL "Boolean describing whether the value of CXX_STANDARD is a requirement.")
+    set(CMAKE_CXX_EXTENSIONS OFF CACHE BOOL "Boolean specifying whether compiler specific extensions are requested.")
 else()
    # Manually check for C++11 compiler flag.
    CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
--- a/README.md
+++ b/README.md
@@ -68,6 +68,9 @@ int main()
 - [TOML literal](#toml-literal)
 - [Conversion between toml value and arbitrary types](#conversion-between-toml-value-and-arbitrary-types)
 - [Formatting user-defined error messages](#formatting-user-defined-error-messages)
+- [Obtaining location information](#obtaining-location-information)
+- [Exceptions](#exceptions)
+- [Colorize Error Messages](#colorize-error-messages)
 - [Serializing TOML data](#serializing-toml-data)
 - [Underlying types](#underlying-types)
 - [Unreleased TOML features](#unreleased-toml-features)
@@ -271,10 +274,44 @@ const auto color = toml::find<std::string>(data, "fruit", "physical", "color");
 const auto shape = toml::find<std::string>(data, "fruit", "physical", "shape");
 ```

+### Finding a value in an array
+
+You can find n-th value in an array by `toml::find`.
+
+```toml
+values = ["foo", "bar", "baz"]
+```
+
+``` cpp
+const auto data   = toml::parse("sample.toml");
+const auto values = toml::find(data, "values");
+const auto bar    = toml::find<std::string>(values, 1);
+```
+
+`toml::find` can also search array recursively.
+
+```cpp
+const auto data = toml::parse("fruit.toml");
+const auto bar  = toml::find<std::string>(data, "values", 1);
+```
+
+Before calling `toml::find`, you can check if a value corresponding to a key
+exists. You can use both `bool toml::value::contains(const key&) const` and
+`std::size_t toml::value::count(const key&) const`. Those behaves like the
+`std::map::contains` and `std::map::count`.
+
+```cpp
+const auto data = toml::parse("fruit.toml");
+if(data.contains("fruit") && data.at("fruit").count("physical") != 0)
+{
+    // ...
+}
+```
+
 ### In case of error

-If the value does not exist, `toml::find` throws an error with the location of
-the table.
+If the value does not exist, `toml::find` throws `std::out_of_range` with the
+location of the table.

 ```console
 terminate called after throwing an instance of 'std::out_of_range'
@@ -284,11 +321,6 @@ terminate called after throwing an instance of 'std::out_of_range'
   | ~~~~~ in this table
 ```

-**Note**: It is recommended to find a table as `toml::value` because it has much information
-compared to `toml::table`, which is an alias of
-`std::unordered_map<std::string, toml::value>`. Since `toml::table` does not have
-any information about toml file, such as where the table was defined in the file.
-
 ----

 If the specified type differs from the actual value contained, it throws
@@ -351,6 +383,7 @@ The above code works with the following toml file.
 # NOT {"physical": {"color": "orange"}}.
 ```

+
 ## Casting a toml value

 ### `toml::get`
@@ -470,6 +503,44 @@ If an invalid key (integer for a table, string for an array), it throws
 `toml::type_error` for the conversion. If the provided key is out-of-range,
 it throws `std::out_of_range`.

+Note that, although `std::string` has `at()` member function, `toml::value::at`
+throws if the contained type is a string. Because `std::string` does not
+contain `toml::value`.
+
+### `operator[]`
+
+You can also access to the element of a table and an array by
+`toml::basic_value::operator[]`.
+
+```cpp
+const toml::value v{1,2,3,4,5};
+std::cout << v[2].as_integer() << std::endl; // 3
+
+const toml::value v{{"foo", 42}, {"bar", 3.14}};
+std::cout << v["foo"].as_integer() << std::endl; // 42
+```
+
+When you access to a `toml::value` that is not initialized yet via
+`operator[](const std::string&)`, the `toml::value` will be a table,
+just like the `std::map`.
+
+```cpp
+toml::value v; // not initialized as a table.
+v["foo"] = 42; // OK. `v` will be a table.
+```
+
+Contrary, if you access to a `toml::value` that contains an array via `operator[]`,
+it does not check anything. It converts `toml::value` without type check and then
+access to the n-th element without boundary check, just like the `std::vector::operator[]`.
+
+```cpp
+toml::value v; // not initialized as an array
+v[2] = 42;     // error! UB
+```
+
+Please make sure that the `toml::value` has an array inside when you access to
+its element via `operator[]`.
+
 ## Checking value type

 You can check the type of a value by `is_xxx` function.
@@ -692,6 +763,7 @@ date information, but it can be converted to `std::chrono::duration` that
 represents a duration from the beginning of the day, `00:00:00.000`.

 ```toml
+# sample.toml
 date = 2018-12-23
 time = 12:30:00
 l_dt = 2018-12-23T12:30:00
@@ -708,8 +780,12 @@ const auto o_dt = toml::get<std::chrono::system_clock::time_point>(data.at("o_dt
 const auto time = toml::get<std::chrono::minutes>(data.at("time")); // 12 * 60 + 30 min
 ```

-toml11 defines its own datetime classes.
-You can see the definitions in [toml/datetime.hpp](toml/datetime.hpp).
+`local_date` and `local_datetime` are assumed to be in the local timezone when
+they are converted into `time_point`. On the other hand, `offset_datetime` only
+uses the offset part of the data and it does not take local timezone into account.
+
+To contain datetime data, toml11 defines its own datetime types.
+For more detail, you can see the definitions in [toml/datetime.hpp](toml/datetime.hpp).

 ## Getting with a fallback

@@ -822,14 +898,25 @@ toml::value v(toml::local_time(std::chrono::hours(10)));
 ```

 You can construct an array object not only from `initializer_list`, but also
-from STL containers.
+from STL containers. In that case, the element type must be convertible to
+`toml::value`.

 ```cpp
 std::vector<int> vec{1,2,3,4,5};
-toml::value v = vec;
+toml::value v(vec);
 ```

-All the elements of `initializer_list` should be convertible into `toml::value`.
+When you construct an array value, all the elements of `initializer_list`
+must be convertible into `toml::value`.
+
+If a `toml::value` has an array, you can `push_back` an element in it.
+
+```cpp
+toml::value v{1,2,3,4,5};
+v.push_back(6);
+```
+
+`emplace_back` also works.

 ## Preserving comments

@@ -1046,7 +1133,7 @@ const auto data = toml::parse("example.toml");
 const foo f = toml::find<ext::foo>(data, "foo");
 ```

-There are 2 ways to use `toml::get` with the types that you defined.
+There are 3 ways to use `toml::get` with the types that you defined.

 The first one is to implement `from_toml(const toml::value&)` member function.

@@ -1073,7 +1160,31 @@ struct foo
 In this way, because `toml::get` first constructs `foo` without arguments,
 the type should be default-constructible.

-The second is to implement specialization of `toml::from` for your type.
+The second is to implement `constructor(const toml::value&)`.
+
+```cpp
+namespace ext
+{
+struct foo
+{
+    explicit foo(const toml::value& v)
+        : a(toml::find<int>(v, "a")), b(toml::find<double>(v, "b")),
+          c(toml::find<std::string>(v, "c"))
+    {}
+
+    int         a;
+    double      b;
+    std::string c;
+};
+} // ext
+```
+
+Note that implicit default constructor declaration will be suppressed
+when a constructor is defined. If you want to use the struct (here, `foo`)
+in a container (e.g. `std::vector<foo>`), you may need to define default
+constructor explicitly.
+
+The third is to implement specialization of `toml::from` for your type.

 ```cpp
 namespace ext
@@ -1254,7 +1365,28 @@ you will get an error message like this.
   |       ~~ maximum number here
 ```

-### Obtaining location information
+You can print hints at the end of the message.
+
+```cpp
+std::vector<std::string> hints;
+hints.push_back("positive number means n >= 0.");
+hints.push_back("negative number is not positive.");
+std::cerr << toml::format_error("[error] value should be positive",
+                                data.at("num"), "positive number required", hints)
+          << std::endl;
+```
+
+```console
+[error] value should be positive
+ --> example.toml
+ 2 | num = 42
+   |       ~~ positive number required
+   |
+Hint: positive number means n >= 0.
+Hint: negative number is not positive.
+```
+
+## Obtaining location information

 You can also format error messages in your own way by using `source_location`.

@@ -1279,6 +1411,92 @@ const toml::value           v   = /*...*/;
 const toml::source_location loc = v.location();
 ```

+## Exceptions
+
+All the exceptions thrown by toml11 inherits `toml::exception` that inherits
+`std::exception`.
+
+```cpp
+namespace toml {
+struct exception      : public std::exception  {/**/};
+struct syntax_error   : public toml::exception {/**/};
+struct type_error     : public toml::exception {/**/};
+struct internal_error : public toml::exception {/**/};
+} // toml
+```
+
+`toml::exception` has `toml::exception::location()` member function that returns
+`toml::source_location`, in addition to `what()`.
+
+```cpp
+namespace toml {
+struct exception : public std::exception
+{
+    // ...
+    source_location const& location() const noexcept;
+};
+} // toml
+```
+
+It represents where the error occurs.
+
+## Colorize Error Messages
+
+By defining `TOML11_COLORIZE_ERROR_MESSAGE`, the error messages from
+`toml::parse` and `toml::find|get` will be colorized. By default, this feature
+is turned off.
+
+With the following toml file taken from `toml-lang/toml/tests/hard_example.toml`,
+
+```toml
+[error]
+array = [
+         "This might most likely happen in multiline arrays",
+         Like here,
+         "or here,
+         and here"
+        ]     End of array comment, forgot the #
+```
+
+the error message would be like this.
+
+![error-message-1](https://github.com/ToruNiina/toml11/blob/misc/misc/toml11-err-msg-1.png)
+
+With the following,
+
+```toml
+[error]
+# array = [
+#          "This might most likely happen in multiline arrays",
+#          Like here,
+#          "or here,
+#          and here"
+#         ]     End of array comment, forgot the #
+number = 3.14  pi <--again forgot the #
+```
+
+the error message would be like this.
+
+![error-message-2](https://github.com/ToruNiina/toml11/blob/misc/misc/toml11-err-msg-2.png)
+
+The message would be messy when it is written to a file, not a terminal because
+it uses [ANSI escape code](https://en.wikipedia.org/wiki/ANSI_escape_code).
+
+Without `TOML11_COLORIZE_ERROR_MESSAGE`, you can still colorize user-defined
+error message by passing `true` to the `toml::format_error` function.
+If you define `TOML11_COLORIZE_ERROR_MESSAGE`, the value is `true` by default.
+If not, the defalut value would be `false`.
+
+```cpp
+std::cerr << toml::format_error("[error] value should be positive",
+                                data.at("num"), "positive number required",
+                                hints, /*colorize = */ true) << std::endl;
+```
+
+Note: It colorize `[error]` in red. That means that it detects `[error]` prefix
+at the front of the error message. If there is no `[error]` prefix,
+`format_error` adds it to the error message.
+
 ## Serializing TOML data

 toml11 enables you to serialize data into toml format.
@@ -1411,17 +1629,83 @@ This feature is introduced to make it easy to write a custom serializer.
 Because `std::chrono::system_clock::time_point` is a __time point__,
 not capable of representing a Local Time independent from a specific day.

-It is recommended to get `datetime`s as `std::chrono` classes through `toml::get`.
-
 ## Unreleased TOML features

 There are some unreleased features in toml-lang/toml:master.
 Currently, the following features are available after defining
 `TOML11_USE_UNRELEASED_TOML_FEATURES` macro flag.

+To use those features, `#define` `TOML11_USE_UNRELEASED_TOML_FEATURES` before
+including `toml.hpp` or pass `-DTOML11_USE_UNRELEASED_TOML_FEATURES` to your
+compiler.
+
 - Leading zeroes in exponent parts of floats are permitted.
  - e.g. `1.0e+01`, `5e+05`
+  - [toml-lang/toml/PR/656](https://github.com/toml-lang/toml/pull/656)
 - Allow raw tab characters in basic strings and multi-line basic strings.
+  - [toml-lang/toml/PR/627](https://github.com/toml-lang/toml/pull/627)
+- Allow heterogeneous arrays
+  - [toml-lang/toml/PR/676](https://github.com/toml-lang/toml/pull/676)
+
+### Note about heterogeneous arrays
+
+Although `toml::parse` allows heterogeneous arrays, constructor of `toml::value`
+does not.
+
+```cpp
+// this won't be compiled
+toml::value v{
+    "foo", 3.14, 42, {1,2,3,4,5}, {{"key", "value"}}
+}
+```
+
+There is a workaround for this issue. By explicitly converting values into
+`toml::value`, you can initialize `toml::value` with a heterogeneous array.
+
+```cpp
+// OK!
+toml::value v{
+    toml::value("foo"), toml::value(3.14), toml::value(42),
+    toml::value{1,2,3,4,5}, toml::value{{"key", "value"}}
+}
+```
+
+The reason why the first example is not allowed is the following.
+Let's assume that you are initializing a `toml::value` with a table.
+
+```cpp
+                    // # expecting TOML table.
+toml::value v{      // [v]
+    {"answer", 42}, // answer = 42
+    {"pi",   3.14}, // pi = 3.14
+    {"foo", "bar"}  // foo = "bar"
+};
+```
+
+This is indistinguishable from a (heterogeneous) TOML array definition.
+
+```toml
+v = [
+    ["answer", 42],
+    ["pi",   3.14],
+    ["foo", "bar"],
+]
+```
+
+This means that the above C++ code makes constructor's overload resolution
+ambiguous. So a constructor that allows both "table as an initializer-list" and
+"heterogeneous array as an initializer-list" cannot be implemented.
+
+Thus, although it is painful, you need to explicitly cast values into
+`toml::value` when you initialize heterogeneous array in C++ code.
+
+```cpp
+// You need to do this when you want to initialize hetero array.
+toml::value v{
+    toml::value("foo"), toml::value(3.14), toml::value(42),
+    toml::value{1,2,3,4,5}, toml::value{{"key", "value"}}
+}
+```

 ## Breaking Changes from v2

@@ -1494,11 +1778,20 @@ I appreciate the help of the contributors who introduced the great feature to th
  - Added installation script to CMake
 - J.C. Moyer (@jcmoyer)
  - Fixed an example code in the documentation
+- Jt Freeman (@blockparty-sh)
+  - Fixed feature test macro around `localtime_s`
+  - Suppress warnings in Debug mode
+- OGAWA Kenichi (@kenichiice)
+  - Suppress warnings on intel compiler
+- Jordan Williams (@jwillikers)
+  - Fixed clang range-loop-analysis warnings
+  - Fixed feature test macro to suppress -Wundef
+  - Use cache variables in CMakeLists.txt

 ## Licensing terms

 This product is licensed under the terms of the [MIT License](LICENSE).

- Copyright (c) 2017-2019 Toru Niina
+- Copyright (c) 2017-2020 Toru Niina

 All rights reserved.
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -39,6 +39,17 @@ set(TEST_NAMES
 CHECK_CXX_COMPILER_FLAG("-Wall"      COMPILER_SUPPORTS_WALL)
 CHECK_CXX_COMPILER_FLAG("-Wextra"    COMPILER_SUPPORTS_WEXTRA)
 CHECK_CXX_COMPILER_FLAG("-Wpedantic" COMPILER_SUPPORTS_WPEDANTIC)
+CHECK_CXX_COMPILER_FLAG("-Werror"    COMPILER_SUPPORTS_WERROR)
+
+CHECK_CXX_COMPILER_FLAG("-Wsign-conversion"     COMPILER_SUPPORTS_WSIGN_CONVERSION)
+CHECK_CXX_COMPILER_FLAG("-Wconversion"          COMPILER_SUPPORTS_WCONVERSION)
+CHECK_CXX_COMPILER_FLAG("-Wduplicated-cond"     COMPILER_SUPPORTS_WDUPLICATED_COND)
+CHECK_CXX_COMPILER_FLAG("-Wduplicated-branches" COMPILER_SUPPORTS_WDUPLICATED_BRANCHES)
+CHECK_CXX_COMPILER_FLAG("-Wlogical-op"          COMPILER_SUPPORTS_WLOGICAL_OP)
+CHECK_CXX_COMPILER_FLAG("-Wuseless-cast"        COMPILER_SUPPORTS_WUSELESS_CAST)
+CHECK_CXX_COMPILER_FLAG("-Wdouble-promotion"    COMPILER_SUPPORTS_WDOUBLE_PROMOTION)
+CHECK_CXX_COMPILER_FLAG("-Wrange-loop-analysis" COMPILER_SUPPORTS_WRANGE_LOOP_ANALYSIS)
+CHECK_CXX_COMPILER_FLAG("-Wundef"               COMPILER_SUPPORTS_WUNDEF)

 if(COMPILER_SUPPORTS_WALL)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
@@ -49,6 +60,36 @@ endif()
 if(COMPILER_SUPPORTS_WPEDANTIC)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wpedantic")
 endif()
+if(COMPILER_SUPPORTS_WERROR)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+endif()
+if(COMPILER_SUPPORTS_WSIGN_CONVERSION)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wsign-conversion")
+endif()
+if(COMPILER_SUPPORTS_WCONVERSION)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wconversion")
+endif()
+if(COMPILER_SUPPORTS_WDUPLICATED_COND)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wduplicated-cond")
+endif()
+if(COMPILER_SUPPORTS_WDUPLICATED_BRANCHES)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wduplicated-branches")
+endif()
+if(COMPILER_SUPPORTS_WLOGICAL_OP)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wlogical-op")
+endif()
+if(COMPILER_SUPPORTS_WUSELESS_CAST)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wuseless-cast")
+endif()
+if(COMPILER_SUPPORTS_WDOUBLE_PROMOTION)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wdouble-promotion")
+endif()
+if(COMPILER_SUPPORTS_WRANGE_LOOP_ANALYSIS)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wrange-loop-analysis")
+endif()
+if(COMPILER_SUPPORTS_WUNDEF)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wundef")
+endif()

 option(TOML11_USE_UNRELEASED_TOML_FEATURES
    "use features in toml-lang/toml master while testing" OFF)
@@ -104,6 +145,19 @@ foreach(TEST_NAME ${TEST_NAMES})
    add_executable(${TEST_NAME} ${TEST_NAME}.cpp)
    target_link_libraries(${TEST_NAME} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY} toml11::toml11)
    target_include_directories(${TEST_NAME} PRIVATE ${Boost_INCLUDE_DIRS})
+
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+        if(toml11_TEST_WITH_ASAN)
+            set_target_properties(${TEST_NAME} PROPERTIES
+                COMPILE_FLAGS "-fsanitize=address -fno-omit-frame-pointer"
+                LINK_FLAGS    "-fsanitize=address -fno-omit-frame-pointer")
+        elseif(toml11_TEST_WITH_UBSAN)
+            set_target_properties(${TEST_NAME} PROPERTIES
+                COMPILE_FLAGS "-fsanitize=undefined"
+                LINK_FLAGS    "-fsanitize=undefined")
+        endif()
+    endif()
+
    add_test(NAME ${TEST_NAME} COMMAND ${TEST_NAME} WORKING_DIRECTORY ${PROJECT_BINARY_DIR})

    # Set the PATH to be able to find Boost DLL
--- a/tests/check_toml_test.cpp
+++ b/tests/check_toml_test.cpp
@@ -84,9 +84,7 @@ struct json_serializer
        {
            if(!is_first) {std::cout << ", ";}
            is_first = false;
-            std::cout << toml::format(toml::value(elem.first),
-                    std::numeric_limits<std::size_t>::max());
-            std::cout << ':';
+            std::cout << this->format_key(elem.first) << ':';
            toml::visit(*this, elem.second);
        }
        std::cout << '}';
@@ -112,6 +110,12 @@ struct json_serializer
        }
        return retval;
    }
+
+    std::string format_key(const std::string& s) const
+    {
+        const auto quote("\"");
+        return quote + escape_string(s) + quote;
+    }
 };

 int main()
--- a/tests/test_error_detection.cpp
+++ b/tests/test_error_detection.cpp
@@ -80,10 +80,14 @@ BOOST_AUTO_TEST_CASE(test_detect_conflicting_value)

 BOOST_AUTO_TEST_CASE(test_detect_inhomogeneous_array)
 {
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+    BOOST_TEST_MESSAGE("heterogeneous array will be allowed in the next release");
+#else
    std::istringstream stream(std::string(
            "a = [1, 1.0]\n"
            ));
    BOOST_CHECK_THROW(toml::parse(stream), toml::syntax_error);
+#endif
 }

 BOOST_AUTO_TEST_CASE(test_detect_appending_array_of_table)
--- a/tests/test_extended_conversions.cpp
+++ b/tests/test_extended_conversions.cpp
@@ -44,6 +44,18 @@ struct qux
    int a;
    std::string b;
 };
+
+struct foobar
+{
+    foobar() = default; // later we use std::vector<foobar>, default ctor is required.
+
+    // via constructor
+    explicit foobar(const toml::value& v)
+        : a(toml::find<int>(v, "a")), b(toml::find<std::string>(v, "b"))
+    {}
+    int a;
+    std::string b;
+};
 } // extlib

 namespace toml
@@ -122,6 +134,19 @@ struct qux
    int a;
    std::string b;
 };
+
+struct foobar
+{
+    foobar() = default; // later we use std::vector<foobar>, default ctor is required.
+
+    template<typename C, template<typename ...> class M, template<typename ...> class A>
+    explicit foobar(const toml::basic_value<C, M, A>& v)
+        : a(toml::find<int>(v, "a")), b(toml::find<std::string>(v, "b"))
+    {}
+    int a;
+    std::string b;
+};
+
 } // extlib2

 namespace toml
@@ -284,6 +309,27 @@ BOOST_AUTO_TEST_CASE(test_conversion_one_way)
    }
 }

+BOOST_AUTO_TEST_CASE(test_conversion_via_constructor)
+{
+    {
+        const toml::value v{{"a", 42}, {"b", "foobar"}};
+
+        const auto foobar = toml::get<extlib::foobar>(v);
+        BOOST_TEST(foobar.a == 42);
+        BOOST_TEST(foobar.b == "foobar");
+    }
+
+    {
+        const toml::basic_value<toml::discard_comments, std::map> v{
+            {"a", 42}, {"b", "foobar"}
+        };
+
+        const auto foobar = toml::get<extlib2::foobar>(v);
+        BOOST_TEST(foobar.a == 42);
+        BOOST_TEST(foobar.b == "foobar");
+    }
+}
+
 BOOST_AUTO_TEST_CASE(test_recursive_conversion)
 {
    {
@@ -384,5 +430,63 @@ BOOST_AUTO_TEST_CASE(test_recursive_conversion)
        BOOST_TEST(bars.at(2).b == "quux");
        BOOST_TEST(bars.at(3).b == "foobar");
    }
+
+    // via constructor
+    {
+        const toml::value v{
+                toml::table{{"a", 42}, {"b", "baz"}},
+                toml::table{{"a", 43}, {"b", "qux"}},
+                toml::table{{"a", 44}, {"b", "quux"}},
+                toml::table{{"a", 45}, {"b", "foobar"}}
+            };
+
+        {
+            const auto foobars = toml::get<std::vector<extlib::foobar>>(v);
+            BOOST_TEST(foobars.size()  == 4ul);
+            BOOST_TEST(foobars.at(0).a == 42);
+            BOOST_TEST(foobars.at(1).a == 43);
+            BOOST_TEST(foobars.at(2).a == 44);
+            BOOST_TEST(foobars.at(3).a == 45);
+
+            BOOST_TEST(foobars.at(0).b == "baz");
+            BOOST_TEST(foobars.at(1).b == "qux");
+            BOOST_TEST(foobars.at(2).b == "quux");
+            BOOST_TEST(foobars.at(3).b == "foobar");
+        }
+        {
+            const auto foobars = toml::get<std::vector<extlib2::foobar>>(v);
+            BOOST_TEST(foobars.size()  == 4ul);
+            BOOST_TEST(foobars.at(0).a == 42);
+            BOOST_TEST(foobars.at(1).a == 43);
+            BOOST_TEST(foobars.at(2).a == 44);
+            BOOST_TEST(foobars.at(3).a == 45);
+
+            BOOST_TEST(foobars.at(0).b == "baz");
+            BOOST_TEST(foobars.at(1).b == "qux");
+            BOOST_TEST(foobars.at(2).b == "quux");
+            BOOST_TEST(foobars.at(3).b == "foobar");
+        }
+    }
+    {
+        const toml::basic_value<toml::discard_comments, std::map, std::deque>
+            v{
+                toml::table{{"a", 42}, {"b", "baz"}},
+                toml::table{{"a", 43}, {"b", "qux"}},
+                toml::table{{"a", 44}, {"b", "quux"}},
+                toml::table{{"a", 45}, {"b", "foobar"}}
+            };
+
+        const auto foobars = toml::get<std::vector<extlib2::foobar>>(v);
+        BOOST_TEST(foobars.size()  == 4ul);
+        BOOST_TEST(foobars.at(0).a == 42);
+        BOOST_TEST(foobars.at(1).a == 43);
+        BOOST_TEST(foobars.at(2).a == 44);
+        BOOST_TEST(foobars.at(3).a == 45);
+
+        BOOST_TEST(foobars.at(0).b == "baz");
+        BOOST_TEST(foobars.at(1).b == "qux");
+        BOOST_TEST(foobars.at(2).b == "quux");
+        BOOST_TEST(foobars.at(3).b == "foobar");
+    }
 }

--- a/tests/test_find.cpp
+++ b/tests/test_find.cpp
@@ -101,6 +101,78 @@ BOOST_AUTO_TEST_CASE(test_find_throws)
    }
 }

+BOOST_AUTO_TEST_CASE(test_find_array_throws)
+{
+    // -----------------------------------------------------------------------
+    // const-reference version
+    {
+        // value is not an array
+        const toml::value v(true);
+        BOOST_CHECK_THROW(toml::find<toml::boolean>(v, 0), toml::type_error);
+    }
+    {
+        // the value corresponding to the key is not the expected type
+        const toml::value v{1, 2, 3, 4, 5};
+        BOOST_CHECK_THROW(toml::find<toml::boolean>(v, 0), toml::type_error);
+    }
+    {
+        // the value corresponding to the key is not found
+        const toml::value v{1, 2, 3, 4, 5};
+        BOOST_CHECK_THROW(toml::find<toml::integer>(v, 6), std::out_of_range);
+    }
+    {
+        // the positive control.
+        const toml::value v{1, 2, 3, 4, 5};
+        BOOST_TEST(3 == toml::find<int>(v, 2));
+    }
+
+    // -----------------------------------------------------------------------
+    // non-const reference version
+    {
+        // value is not an array
+        toml::value v(true);
+        BOOST_CHECK_THROW(toml::find<toml::boolean>(v, 0), toml::type_error);
+    }
+    {
+        // the value corresponding to the key is not the expected type
+        toml::value v{1, 2, 3, 4, 5};
+        BOOST_CHECK_THROW(toml::find<toml::boolean>(v, 0), toml::type_error);
+    }
+    {
+        // the value corresponding to the key is not found
+        toml::value v{1, 2, 3, 4, 5};
+        BOOST_CHECK_THROW(toml::find<toml::integer>(v, 6), std::out_of_range);
+    }
+    {
+        // the positive control.
+        toml::value v{1, 2, 3, 4, 5};
+        BOOST_TEST(3 == toml::find<int>(v, 2));
+    }
+
+    // -----------------------------------------------------------------------
+    // move version
+    {
+        // value is not an array
+        toml::value v(true);
+        BOOST_CHECK_THROW(toml::find<toml::boolean>(std::move(v), 0), toml::type_error);
+    }
+    {
+        // the value corresponding to the key is not the expected type
+        toml::value v{1, 2, 3, 4, 5};
+        BOOST_CHECK_THROW(toml::find<toml::boolean>(std::move(v), 0), toml::type_error);
+    }
+    {
+        // the value corresponding to the key is not found
+        toml::value v{1, 2, 3, 4, 5};
+        BOOST_CHECK_THROW(toml::find<toml::integer>(std::move(v), 6), std::out_of_range);
+    }
+    {
+        // the positive control.
+        toml::value v{1, 2, 3, 4, 5};
+        BOOST_TEST(3 == toml::find<int>(std::move(v), 2));
+    }
+}
+
 BOOST_AUTO_TEST_CASE(test_find_recursive)
 {
    // recursively search tables
@@ -126,8 +198,76 @@ BOOST_AUTO_TEST_CASE(test_find_recursive)
        num2 = 42;
        BOOST_TEST(42 == toml::find<int>(v, a, b, c, d));

-        auto num3 = toml::find<toml::integer>(std::move(v), a, b, c, d);
+        auto num3 = toml::find<toml::integer>(v, a, "b", c, "d");
        BOOST_TEST(42 == num3);
+
+        auto num4 = toml::find<toml::integer>(std::move(v), a, b, c, d);
+        BOOST_TEST(42 == num4);
+    }
+    // recursively search arrays
+    {
+        toml::value v{
+            toml::array{"array", "of", "string"},
+            toml::array{toml::array{1, 2, 3}, toml::array{3.14, 2.71}}
+        };
+        BOOST_TEST("array"  == toml::find<std::string>(v, 0, 0));
+        BOOST_TEST("of"     == toml::find<std::string>(v, 0, 1));
+        BOOST_TEST("string" == toml::find<std::string>(v, 0, 2));
+
+        BOOST_TEST(1 == toml::find<int>(v, 1, 0, 0));
+        BOOST_TEST(2 == toml::find<int>(v, 1, 0, 1));
+        BOOST_TEST(3 == toml::find<int>(v, 1, 0, 2));
+
+        BOOST_TEST(3.14 == toml::find<double>(v, 1, 1, 0));
+        BOOST_TEST(2.71 == toml::find<double>(v, 1, 1, 1));
+
+        // reference that can be used to modify the content
+        auto& num = toml::find<toml::integer>(v, 1, 0, 2);
+        num = 42;
+        BOOST_TEST( 1 == toml::find<int>(v, 1, 0, 0));
+        BOOST_TEST( 2 == toml::find<int>(v, 1, 0, 1));
+        BOOST_TEST(42 == toml::find<int>(v, 1, 0, 2));
+
+        // move value
+        auto num2 = toml::find<toml::integer>(std::move(v), 1, 0, 2);
+        BOOST_TEST(42 == num2);
+    }
+    // recursively search mixtures
+    {
+        toml::value v = toml::table{{"array", toml::array{
+                toml::array{1,   2,   3},
+                toml::array{
+                    toml::table{{"foo", "bar"}, {"baz", "qux"}},
+                    toml::table{{"pi",   3.14}, {"e",    2.71}}
+                }}
+            }};
+
+        BOOST_TEST(1 == toml::find<int>(v, "array", 0, 0));
+        BOOST_TEST(2 == toml::find<int>(v, "array", 0, 1));
+        BOOST_TEST(3 == toml::find<int>(v, "array", 0, 2));
+
+        BOOST_TEST("bar" == toml::find<std::string>(v, "array", 1, 0, "foo"));
+        BOOST_TEST("qux" == toml::find<std::string>(v, "array", 1, 0, "baz"));
+
+        BOOST_TEST(3.14 == toml::find<double>(v, "array", 1, 1, "pi"));
+        BOOST_TEST(2.71 == toml::find<double>(v, "array", 1, 1, "e"));
+
+        const std::string ar("array");
+        const auto ar_c = "array";
+
+        const std::string pi("pi");
+        const auto pi_c = "pi";
+
+        BOOST_TEST(3.14 == toml::find<double>(v, ar, 1, 1, "pi"));
+        BOOST_TEST(3.14 == toml::find<double>(v, ar, 1, 1, pi));
+        BOOST_TEST(3.14 == toml::find<double>(v, ar, 1, 1, pi_c));
+
+        BOOST_TEST(3.14 == toml::find<double>(v, ar_c, 1, 1, "pi"));
+        BOOST_TEST(3.14 == toml::find<double>(v, ar_c, 1, 1, pi));
+        BOOST_TEST(3.14 == toml::find<double>(v, ar_c, 1, 1, pi_c));
+
+        BOOST_TEST(3.14 == toml::find<double>(v, "array", 1, 1, pi));
+        BOOST_TEST(3.14 == toml::find<double>(v, "array", 1, 1, pi_c));
    }
 }

@@ -309,10 +449,11 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_floating_type, value_type, test_value_ty
 {
    {
        value_type v{{"key", 3.14}};
-        BOOST_TEST(static_cast<float      >(3.14) == toml::find<float      >(v, "key"));
-        BOOST_TEST(static_cast<double     >(3.14) == toml::find<double     >(v, "key"));
-        BOOST_TEST(static_cast<long double>(3.14) == toml::find<long double>(v, "key"));
-        BOOST_TEST(static_cast<float      >(3.14) == toml::find<float      >(std::move(v), "key"));
+        const double ref(3.14);
+        BOOST_TEST(static_cast<float      >(ref) == toml::find<float      >(v, "key"));
+        BOOST_TEST(                         ref  == toml::find<double     >(v, "key"));
+        BOOST_TEST(static_cast<long double>(ref) == toml::find<long double>(v, "key"));
+        BOOST_TEST(static_cast<float      >(ref) == toml::find<float      >(std::move(v), "key"));
    }
 }

@@ -373,14 +514,14 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_toml_array, value_type, test_value_types
    BOOST_TEST(static_cast<std::int64_t>(72) == deq.at(3));

    std::array<int, 4> ary = toml::find<std::array<int, 4>>(v, "key");
-    BOOST_TEST(static_cast<int>(42) == ary.at(0));
-    BOOST_TEST(static_cast<int>(54) == ary.at(1));
-    BOOST_TEST(static_cast<int>(69) == ary.at(2));
-    BOOST_TEST(static_cast<int>(72) == ary.at(3));
+    BOOST_TEST(42 == ary.at(0));
+    BOOST_TEST(54 == ary.at(1));
+    BOOST_TEST(69 == ary.at(2));
+    BOOST_TEST(72 == ary.at(3));

    std::tuple<int, short, unsigned, long> tpl =
        toml::find<std::tuple<int, short, unsigned, long>>(v, "key");
-    BOOST_TEST(static_cast<int     >(42) == std::get<0>(tpl));
+    BOOST_TEST(                      42  == std::get<0>(tpl));
    BOOST_TEST(static_cast<short   >(54) == std::get<1>(tpl));
    BOOST_TEST(static_cast<unsigned>(69) == std::get<2>(tpl));
    BOOST_TEST(static_cast<long    >(72) == std::get<3>(tpl));
@@ -420,14 +561,14 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_move_toml_array, value_type, test_value_
    BOOST_TEST(static_cast<std::int64_t>(72) == deq.at(3));

    std::array<int, 4> ary = toml::find<std::array<int, 4>>(std::move(v4), "key");
-    BOOST_TEST(static_cast<int>(42) == ary.at(0));
-    BOOST_TEST(static_cast<int>(54) == ary.at(1));
-    BOOST_TEST(static_cast<int>(69) == ary.at(2));
-    BOOST_TEST(static_cast<int>(72) == ary.at(3));
+    BOOST_TEST(42 == ary.at(0));
+    BOOST_TEST(54 == ary.at(1));
+    BOOST_TEST(69 == ary.at(2));
+    BOOST_TEST(72 == ary.at(3));

    std::tuple<int, short, unsigned, long> tpl =
        toml::find<std::tuple<int, short, unsigned, long>>(std::move(v5), "key");
-    BOOST_TEST(static_cast<int     >(42) == std::get<0>(tpl));
+    BOOST_TEST(                      42  == std::get<0>(tpl));
    BOOST_TEST(static_cast<short   >(54) == std::get<1>(tpl));
    BOOST_TEST(static_cast<unsigned>(69) == std::get<2>(tpl));
    BOOST_TEST(static_cast<long    >(72) == std::get<3>(tpl));
--- a/tests/test_find_or.cpp
+++ b/tests/test_find_or.cpp
@@ -375,7 +375,8 @@ BOOST_AUTO_TEST_CASE(test_find_or_floating)
        toml::value v1{{"key", 42}};
        toml::value v2{{"key", 3.14}};
        BOOST_TEST(2.71f == toml::find_or(v1, "key", 2.71f));
-        BOOST_TEST(static_cast<float>(double(3.14)) == toml::find_or(v2, "key", 2.71f));
+        const double ref(3.14);
+        BOOST_TEST(static_cast<float>(ref) == toml::find_or(v2, "key", 2.71f));
    }
    {
        toml::value v1{{"key", 42}};
@@ -383,7 +384,8 @@ BOOST_AUTO_TEST_CASE(test_find_or_floating)
        const auto moved1 = toml::find_or(std::move(v1), "key", 2.71f);
        const auto moved2 = toml::find_or(std::move(v2), "key", 2.71f);
        BOOST_TEST(2.71f == moved1);
-        BOOST_TEST(static_cast<float>(double(3.14)) == moved2);
+        const double ref(3.14);
+        BOOST_TEST(static_cast<float>(ref) == moved2);
    }
 }

--- a/tests/test_get.cpp
+++ b/tests/test_get.cpp
@@ -195,11 +195,11 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_floating_type, value_type, test_value_typ
 {
    {
        value_type v(3.14);
-        BOOST_TEST(static_cast<float      >(3.14) == toml::get<float      >(v));
-        BOOST_TEST(static_cast<double     >(3.14) == toml::get<double     >(v));
-        BOOST_TEST(static_cast<long double>(3.14) == toml::get<long double>(v));
-
-        BOOST_TEST(3.14f == toml::get<float>(std::move(v)));
+        const double ref(3.14);
+        BOOST_TEST(static_cast<float      >(ref) == toml::get<float      >(v));
+        BOOST_TEST(                         ref  == toml::get<double     >(v));
+        BOOST_TEST(static_cast<long double>(ref) == toml::get<long double>(v));
+        BOOST_TEST(static_cast<float      >(ref) == toml::get<float>(std::move(v)));
    }
 }

@@ -262,14 +262,14 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_array, value_type, test_value_types)
        BOOST_TEST(static_cast<std::int64_t>(72) == deq.at(3));

        std::array<int, 4> ary = toml::get<std::array<int, 4>>(v);
-        BOOST_TEST(static_cast<int>(42) == ary.at(0));
-        BOOST_TEST(static_cast<int>(54) == ary.at(1));
-        BOOST_TEST(static_cast<int>(69) == ary.at(2));
-        BOOST_TEST(static_cast<int>(72) == ary.at(3));
+        BOOST_TEST(42 == ary.at(0));
+        BOOST_TEST(54 == ary.at(1));
+        BOOST_TEST(69 == ary.at(2));
+        BOOST_TEST(72 == ary.at(3));

        std::tuple<int, short, unsigned, long> tpl =
            toml::get<std::tuple<int, short, unsigned, long>>(v);
-        BOOST_TEST(static_cast<int     >(42) == std::get<0>(tpl));
+        BOOST_TEST(                      42  == std::get<0>(tpl));
        BOOST_TEST(static_cast<short   >(54) == std::get<1>(tpl));
        BOOST_TEST(static_cast<unsigned>(69) == std::get<2>(tpl));
        BOOST_TEST(static_cast<long    >(72) == std::get<3>(tpl));
@@ -308,16 +308,16 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_array, value_type, test_value_types)
    {
        value_type v{42, 54, 69, 72};
        std::array<int, 4> ary = toml::get<std::array<int, 4>>(std::move(v));
-        BOOST_TEST(static_cast<int>(42) == ary.at(0));
-        BOOST_TEST(static_cast<int>(54) == ary.at(1));
-        BOOST_TEST(static_cast<int>(69) == ary.at(2));
-        BOOST_TEST(static_cast<int>(72) == ary.at(3));
+        BOOST_TEST(42 == ary.at(0));
+        BOOST_TEST(54 == ary.at(1));
+        BOOST_TEST(69 == ary.at(2));
+        BOOST_TEST(72 == ary.at(3));
    }
    {
        value_type v{42, 54, 69, 72};
        std::tuple<int, short, unsigned, long> tpl =
            toml::get<std::tuple<int, short, unsigned, long>>(std::move(v));
-        BOOST_TEST(static_cast<int     >(42) == std::get<0>(tpl));
+        BOOST_TEST(                      42  == std::get<0>(tpl));
        BOOST_TEST(static_cast<short   >(54) == std::get<1>(tpl));
        BOOST_TEST(static_cast<unsigned>(69) == std::get<2>(tpl));
        BOOST_TEST(static_cast<long    >(72) == std::get<3>(tpl));
--- a/tests/test_lex_string.cpp
+++ b/tests/test_lex_string.cpp
@@ -57,6 +57,22 @@ BOOST_AUTO_TEST_CASE(test_ml_basic_string)
    TOML11_TEST_LEX_ACCEPT(lex_string,
        "\"\"\"\\\n  The quick brown \\\n\n  fox jumps over \\\n  the lazy dog.\\\n  \"\"\"",
        "\"\"\"\\\n  The quick brown \\\n\n  fox jumps over \\\n  the lazy dog.\\\n  \"\"\"");
+
+    TOML11_TEST_LEX_ACCEPT(lex_string,
+        "\"\"\"Here are two quotation marks: \"\". Simple enough.\"\"\"",
+        "\"\"\"Here are two quotation marks: \"\". Simple enough.\"\"\"");
+
+    TOML11_TEST_LEX_ACCEPT(lex_string,
+        "\"\"\"Here are three quotation marks: \"\"\\\".\"\"\"",
+        "\"\"\"Here are three quotation marks: \"\"\\\".\"\"\"");
+
+    TOML11_TEST_LEX_ACCEPT(lex_string,
+        "\"\"\"Here are fifteen quotation marks: \"\"\\\"\"\"\\\"\"\"\\\"\"\"\\\"\"\"\\\".\"\"\"",
+        "\"\"\"Here are fifteen quotation marks: \"\"\\\"\"\"\\\"\"\"\\\"\"\"\\\"\"\"\\\".\"\"\"");
+
+    TOML11_TEST_LEX_ACCEPT(lex_string,
+        "\"\"\"\"This,\" she said, \"is just a pointless statement.\"\"\"\"",
+        "\"\"\"\"This,\" she said, \"is just a pointless statement.\"\"\"\"");
 }

 BOOST_AUTO_TEST_CASE(test_literal_string)
@@ -83,4 +99,16 @@ BOOST_AUTO_TEST_CASE(test_ml_literal_string)
    TOML11_TEST_LEX_ACCEPT(lex_string,
        "'''\nThe first newline is\ntrimmed in raw strings.\n   All other whitespace\n   is preserved.\n'''",
        "'''\nThe first newline is\ntrimmed in raw strings.\n   All other whitespace\n   is preserved.\n'''");
+
+    TOML11_TEST_LEX_ACCEPT(lex_string,
+        "''''That's still pointless', she said.'''",
+        "''''That's still pointless', she said.'''");
+
+    TOML11_TEST_LEX_ACCEPT(lex_string,
+        "'''Here are fifteen quotation marks: \"\"\"\"\"\"\"\"\"\"\"\"\"\"\".'''",
+        "'''Here are fifteen quotation marks: \"\"\"\"\"\"\"\"\"\"\"\"\"\"\".'''");
+
+    TOML11_TEST_LEX_ACCEPT(lex_string,
+        "''''This,' she said, 'is just a pointless statement.''''",
+        "''''This,' she said, 'is just a pointless statement.''''");
 }
--- a/tests/test_parse_array.cpp
+++ b/tests/test_parse_array.cpp
@@ -128,3 +128,47 @@ BOOST_AUTO_TEST_CASE(test_multiline_array_value)
        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "[\"foo\",#comment\n\"b#r\",#comment\n\"b#z\"#comment\n]", toml::value(a));
    }
 }
+
+BOOST_AUTO_TEST_CASE(test_heterogeneous_array)
+{
+#ifndef TOML11_USE_UNRELEASED_TOML_FEATURES
+    BOOST_TEST_MESSAGE("In strict TOML v0.5.0, heterogeneous arrays are not allowed.");
+#else
+    {
+        array a(5);
+        a[0] = toml::value("foo");
+        a[1] = toml::value(3.14);
+        a[2] = toml::value(42);
+        a[3] = toml::value{toml::value("array"), toml::value("of"), toml::value("hetero-array"), toml::value(1)};
+        a[4] = toml::value{{"key", "value"}};
+        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "[\"foo\", 3.14, 42, [\"array\", \"of\", \"hetero-array\", 1], {key = \"value\"}]", toml::value(a));
+    }
+    {
+        array a(5);
+        a[0] = toml::value("foo");
+        a[1] = toml::value(3.14);
+        a[2] = toml::value(42);
+        a[3] = toml::value{toml::value("array"), toml::value("of"), toml::value("hetero-array"), toml::value(1)};
+        a[4] = toml::value{{"key", "value"}};
+        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "[\"foo\",\n 3.14,\n 42,\n [\"array\", \"of\", \"hetero-array\", 1],\n {key = \"value\"},\n]", toml::value(a));
+    }
+    {
+        array a(5);
+        a[0] = toml::value("foo");
+        a[1] = toml::value(3.14);
+        a[2] = toml::value(42);
+        a[3] = toml::value{toml::value("array"), toml::value("of"), toml::value("hetero-array"), toml::value(1)};
+        a[4] = toml::value{{"key", "value"}};
+        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "[\"foo\",#comment\n 3.14,#comment\n 42,#comment\n [\"array\", \"of\", \"hetero-array\", 1],#comment\n {key = \"value\"},#comment\n]#comment", toml::value(a));
+    }
+    {
+        array a(5);
+        a[0] = toml::value("foo");
+        a[1] = toml::value(3.14);
+        a[2] = toml::value(42);
+        a[3] = toml::value{toml::value("array"), toml::value("of"), toml::value("hetero-array"), toml::value(1)};
+        a[4] = toml::value{{"key", "value"}};
+        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "[\"foo\",\n 3.14,\n 42,\n [\"array\",\n \"of\",\n \"hetero-array\",\n 1],\n {key = \"value\"},\n]", toml::value(a));
+    }
+#endif
+}
--- a/tests/test_parse_inline_table.cpp
+++ b/tests/test_parse_inline_table.cpp
@@ -46,3 +46,19 @@ BOOST_AUTO_TEST_CASE(test_inline_table_value)
        TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "{type.name = \"pug\"}", value(t));
    }
 }
+
+BOOST_AUTO_TEST_CASE(test_inline_table_immutability)
+{
+    {
+        std::istringstream stream(std::string(
+                "a = {b = 1}\n"
+                "a.c = 2\n"));
+        BOOST_CHECK_THROW(toml::parse(stream), toml::syntax_error);
+    }
+    {
+        std::istringstream stream(std::string(
+                "a = {b = {c = 1}}\n"
+                "a.b.d = 2\n"));
+        BOOST_CHECK_THROW(toml::parse(stream), toml::syntax_error);
+    }
+}
--- a/tests/test_parse_string.cpp
+++ b/tests/test_parse_string.cpp
@@ -29,16 +29,16 @@ BOOST_AUTO_TEST_CASE(test_string)

 BOOST_AUTO_TEST_CASE(test_string_value)
 {
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
        "\"The quick brown fox jumps over the lazy dog\"",
        toml::value("The quick brown fox jumps over the lazy dog", string_t::basic));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
        "\'The quick brown fox jumps over the lazy dog\'",
        toml::value("The quick brown fox jumps over the lazy dog", string_t::literal));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
        "\"\"\"The quick brown fox \\\njumps over the lazy dog\"\"\"",
        toml::value("The quick brown fox jumps over the lazy dog", string_t::basic));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
        "'''The quick brown fox \njumps over the lazy dog'''",
        toml::value("The quick brown fox \njumps over the lazy dog", string_t::literal));
 }
@@ -69,14 +69,17 @@ BOOST_AUTO_TEST_CASE(test_basic_string)
    TOML11_TEST_PARSE_EQUAL(parse_string,
        "\" And when \\\"'s are in the along with # \\\"\"",
        string(" And when \"'s are in the along with # \"", string_t::basic));
+    TOML11_TEST_PARSE_EQUAL(parse_string,
+        "\"Here are fifteen apostrophes: '''''''''''''''\"",
+        string("Here are fifteen apostrophes: '''''''''''''''", string_t::basic));
 }

 BOOST_AUTO_TEST_CASE(test_basic_string_value)
 {
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
        "\"GitHub Cofounder & CEO\\nLikes tater tots and beer.\"",
        value("GitHub Cofounder & CEO\nLikes tater tots and beer.", string_t::basic));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
        "\"192.168.1.1\"",
        value("192.168.1.1", string_t::basic));
 #if defined(_MSC_VER) || defined(__INTEL_COMPILER)
@@ -84,16 +87,19 @@ BOOST_AUTO_TEST_CASE(test_basic_string_value)
        "\"\xE4\xB8\xAD\xE5\x9B\xBD\"",
        value("\xE4\xB8\xAD\xE5\x9B\xBD", string_t::basic));
 #else
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
        "\"中国\"",
        value("中国", string_t::basic));
 #endif
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
        "\"You'll hate me after this - #\"",
        value("You'll hate me after this - #", string_t::basic));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
        "\" And when \\\"'s are in the along with # \\\"\"",
        value(" And when \"'s are in the along with # \"", string_t::basic));
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+        "\"Here are fifteen apostrophes: '''''''''''''''\"",
+        value("Here are fifteen apostrophes: '''''''''''''''", string_t::basic));
 }

 BOOST_AUTO_TEST_CASE(test_ml_basic_string)
@@ -104,16 +110,41 @@ BOOST_AUTO_TEST_CASE(test_ml_basic_string)
    TOML11_TEST_PARSE_EQUAL(parse_string,
        "\"\"\"\\\n  The quick brown \\\n\n  fox jumps over \\\n  the lazy dog.\\\n  \"\"\"",
        string("The quick brown fox jumps over the lazy dog.", string_t::basic));
+    TOML11_TEST_PARSE_EQUAL(parse_string,
+        "\"\"\"Here are two quotation marks: \"\". Simple enough.\"\"\"",
+        string("Here are two quotation marks: \"\". Simple enough.", string_t::basic));
+    TOML11_TEST_PARSE_EQUAL(parse_string,
+        "\"\"\"Here are three quotation marks: \"\"\\\".\"\"\"",
+        string("Here are three quotation marks: \"\"\".", string_t::basic));
+    TOML11_TEST_PARSE_EQUAL(parse_string,
+        "\"\"\"Here are fifteen quotation marks: \"\"\\\"\"\"\\\"\"\"\\\"\"\"\\\"\"\"\\\".\"\"\"",
+        string("Here are fifteen quotation marks: \"\"\"\"\"\"\"\"\"\"\"\"\"\"\".", string_t::basic));
+    TOML11_TEST_PARSE_EQUAL(parse_string,
+        "\"\"\"\"This,\" she said, \"is just a pointless statement.\"\"\"\"",
+        string("\"This,\" she said, \"is just a pointless statement.\"", string_t::basic));
 }

 BOOST_AUTO_TEST_CASE(test_ml_basic_string_value)
 {
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
        "\"\"\"\nThe quick brown \\\n\n  fox jumps over \\\n  the lazy dog.\"\"\"",
        value("The quick brown fox jumps over the lazy dog.", string_t::basic));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
        "\"\"\"\\\n  The quick brown \\\n\n  fox jumps over \\\n  the lazy dog.\\\n  \"\"\"",
        value("The quick brown fox jumps over the lazy dog.", string_t::basic));
+
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+        "\"\"\"Here are two quotation marks: \"\". Simple enough.\"\"\"",
+        value("Here are two quotation marks: \"\". Simple enough.", string_t::basic));
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+        "\"\"\"Here are three quotation marks: \"\"\\\".\"\"\"",
+        value("Here are three quotation marks: \"\"\".", string_t::basic));
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+        "\"\"\"Here are fifteen quotation marks: \"\"\\\"\"\"\\\"\"\"\\\"\"\"\\\"\"\"\\\".\"\"\"",
+        value("Here are fifteen quotation marks: \"\"\"\"\"\"\"\"\"\"\"\"\"\"\".", string_t::basic));
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+        "\"\"\"\"This,\" she said, \"is just a pointless statement.\"\"\"\"",
+        value("\"This,\" she said, \"is just a pointless statement.\"", string_t::basic));
 }

 BOOST_AUTO_TEST_CASE(test_literal_string)
@@ -134,16 +165,16 @@ BOOST_AUTO_TEST_CASE(test_literal_string)

 BOOST_AUTO_TEST_CASE(test_literal_string_value)
 {
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
        "'C:\\Users\\nodejs\\templates'",
        value("C:\\Users\\nodejs\\templates", string_t::literal));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
        "'\\\\ServerX\\admin$\\system32\\'",
        value("\\\\ServerX\\admin$\\system32\\", string_t::literal));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
        "'Tom \"Dubs\" Preston-Werner'",
        value("Tom \"Dubs\" Preston-Werner", string_t::literal));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
        "'<\\i\\c*\\s*>'",
        value("<\\i\\c*\\s*>", string_t::literal));
 }
@@ -156,16 +187,34 @@ BOOST_AUTO_TEST_CASE(test_ml_literal_string)
    TOML11_TEST_PARSE_EQUAL(parse_string,
        "'''\nThe first newline is\ntrimmed in raw strings.\n   All other whitespace\n   is preserved.\n'''",
        string("The first newline is\ntrimmed in raw strings.\n   All other whitespace\n   is preserved.\n", string_t::literal));
+    TOML11_TEST_PARSE_EQUAL(parse_string,
+        "''''That's still pointless', she said.'''",
+        string("'That's still pointless', she said.", string_t::literal));
+    TOML11_TEST_PARSE_EQUAL(parse_string,
+        "'''Here are fifteen quotation marks: \"\"\"\"\"\"\"\"\"\"\"\"\"\"\".'''",
+        string("Here are fifteen quotation marks: \"\"\"\"\"\"\"\"\"\"\"\"\"\"\".", string_t::literal));
+    TOML11_TEST_PARSE_EQUAL(parse_string,
+        "''''This,' she said, 'is just a pointless statement.''''",
+        string("'This,' she said, 'is just a pointless statement.'", string_t::literal));
 }

 BOOST_AUTO_TEST_CASE(test_ml_literal_string_value)
 {
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
        "'''I [dw]on't need \\d{2} apples'''",
        value("I [dw]on't need \\d{2} apples", string_t::literal));
-    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, 
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
        "'''\nThe first newline is\ntrimmed in raw strings.\n   All other whitespace\n   is preserved.\n'''",
        value("The first newline is\ntrimmed in raw strings.\n   All other whitespace\n   is preserved.\n", string_t::literal));
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+        "''''That's still pointless', she said.'''",
+        value("'That's still pointless', she said.", string_t::literal));
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+        "'''Here are fifteen quotation marks: \"\"\"\"\"\"\"\"\"\"\"\"\"\"\".'''",
+        value("Here are fifteen quotation marks: \"\"\"\"\"\"\"\"\"\"\"\"\"\"\".", string_t::literal));
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>,
+        "''''This,' she said, 'is just a pointless statement.''''",
+        value("'This,' she said, 'is just a pointless statement.'", string_t::literal));
 }

 BOOST_AUTO_TEST_CASE(test_unicode_escape_sequence)
--- a/tests/test_string.cpp
+++ b/tests/test_string.cpp
@@ -111,3 +111,44 @@ BOOST_AUTO_TEST_CASE(test_literal_ml_string)
    }
 }

+BOOST_AUTO_TEST_CASE(test_string_add_assign)
+{
+    // string literal
+    {
+        toml::string str("foo");
+        str += "bar";
+        BOOST_TEST(str.str == "foobar");
+    }
+    // std::string
+    {
+        toml::string str("foo");
+        std::string str2("bar");
+        str += str2;
+        BOOST_TEST(str.str == "foobar");
+    }
+    // toml::string
+    {
+        toml::string str("foo");
+        toml::string str2("bar");
+        str += str2;
+        BOOST_TEST(str.str == "foobar");
+    }
+#if __cplusplus >= 201703L
+    // std::string_view
+    {
+        toml::string str("foo");
+        str += std::string_view("bar");
+        BOOST_TEST(str == "foobar");
+    }
+#endif
+    // std::string += toml::string
+    {
+        std::string  str("foo");
+        toml::string str2("bar");
+        str += str2;
+        BOOST_TEST(str == "foobar");
+    }
+
+
+}
+
--- a/tests/test_value.cpp
+++ b/tests/test_value.cpp
@@ -934,3 +934,86 @@ BOOST_AUTO_TEST_CASE(test_value_at)
        BOOST_CHECK_THROW(v1.at(5),     std::out_of_range);
    }
 }
+
+BOOST_AUTO_TEST_CASE(test_value_bracket)
+{
+    {
+        toml::value v1{{"foo", 42}, {"bar", 3.14}, {"baz", "qux"}};
+
+        BOOST_TEST(v1["foo"].as_integer()  == 42);
+        BOOST_TEST(v1["bar"].as_floating() == 3.14);
+        BOOST_TEST(v1["baz"].as_string()   == "qux");
+
+        v1["qux"] = 54;
+        BOOST_TEST(v1["qux"].as_integer()  == 54);
+    }
+    {
+        toml::value v1;
+        v1["foo"] = 42;
+
+        BOOST_TEST(v1.is_table());
+        BOOST_TEST(v1["foo"].as_integer()  == 42);
+    }
+    {
+        toml::value v1{1,2,3,4,5};
+
+        BOOST_TEST(v1[0].as_integer() == 1);
+        BOOST_TEST(v1[1].as_integer() == 2);
+        BOOST_TEST(v1[2].as_integer() == 3);
+        BOOST_TEST(v1[3].as_integer() == 4);
+        BOOST_TEST(v1[4].as_integer() == 5);
+
+        BOOST_CHECK_THROW(v1["foo"], toml::type_error);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_value_map_methods)
+{
+    {
+        toml::value v1{{"foo", 42}, {"bar", 3.14}, {"baz", "qux"}};
+
+        BOOST_TEST(v1.count("foo") == 1u);
+        BOOST_TEST(v1.count("bar") == 1u);
+        BOOST_TEST(v1.count("baz") == 1u);
+        BOOST_TEST(v1.count("qux") == 0u);
+
+        BOOST_TEST( v1.contains("foo"));
+        BOOST_TEST( v1.contains("bar"));
+        BOOST_TEST( v1.contains("baz"));
+        BOOST_TEST(!v1.contains("qux"));
+
+        BOOST_TEST(v1.size() == 3);
+
+        v1["qux"] = 54;
+        BOOST_TEST(v1.count("qux") == 1u);
+        BOOST_TEST(v1.contains("qux"));
+        BOOST_TEST(v1.size() == 4);
+    }
+    {
+        toml::value v1(42);
+        BOOST_CHECK_THROW(v1.size()       , toml::type_error);
+        BOOST_CHECK_THROW(v1.count("k")   , toml::type_error);
+        BOOST_CHECK_THROW(v1.contains("k"), toml::type_error);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_value_vector_methods)
+{
+    {
+        toml::value v1{1, 2, 3, 4, 5};
+
+        BOOST_TEST(v1.size() == 5);
+
+        v1.push_back(6);
+        BOOST_TEST(v1.size() == 6);
+
+        v1.emplace_back(6);
+        BOOST_TEST(v1.size() == 7);
+    }
+    {
+        toml::value v1(42);
+        BOOST_CHECK_THROW(v1.size(),          toml::type_error);
+        BOOST_CHECK_THROW(v1.push_back(1),    toml::type_error);
+        BOOST_CHECK_THROW(v1.emplace_back(1), toml::type_error);
+    }
+}
--- a/toml/color.hpp
+++ b/toml/color.hpp
@@ -0,0 +1,64 @@
+#ifndef TOML11_COLOR_HPP
+#define TOML11_COLOR_HPP
+#include <ostream>
+#include <cstdint>
+
+#ifdef TOML11_COLORIZE_ERROR_MESSAGE
+#define TOML11_ERROR_MESSAGE_COLORIZED true
+#else
+#define TOML11_ERROR_MESSAGE_COLORIZED false
+#endif
+
+namespace toml
+{
+
+// put ANSI escape sequence to ostream
+namespace color_ansi
+{
+namespace detail
+{
+inline int colorize_index()
+{
+    static const int index = std::ios_base::xalloc();
+    return index;
+}
+} // detail
+
+inline std::ostream& colorize(std::ostream& os)
+{
+    // by default, it is zero.
+    os.iword(detail::colorize_index()) = 1;
+    return os;
+}
+inline std::ostream& nocolorize(std::ostream& os)
+{
+    os.iword(detail::colorize_index()) = 0;
+    return os;
+}
+inline std::ostream& reset  (std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[00m";} return os;}
+inline std::ostream& bold   (std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[01m";} return os;}
+inline std::ostream& grey   (std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[30m";} return os;}
+inline std::ostream& red    (std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[31m";} return os;}
+inline std::ostream& green  (std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[32m";} return os;}
+inline std::ostream& yellow (std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[33m";} return os;}
+inline std::ostream& blue   (std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[34m";} return os;}
+inline std::ostream& magenta(std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[35m";} return os;}
+inline std::ostream& cyan   (std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[36m";} return os;}
+inline std::ostream& white  (std::ostream& os)
+{if(os.iword(detail::colorize_index()) == 1) {os << "\033[37m";} return os;}
+} // color_ansi
+
+// ANSI escape sequence is the only and default colorization method currently
+namespace color = color_ansi;
+
+} // toml
+#endif// TOML11_COLOR_HPP
--- a/toml/combinator.hpp
+++ b/toml/combinator.hpp
@@ -45,6 +45,7 @@ inline std::string show_char(const char c)
        buf.fill('\0');
        const auto r = std::snprintf(
                buf.data(), buf.size(), "0x%02x", static_cast<int>(c) & 0xFF);
+        (void) r; // Unused variable warning
        assert(r == static_cast<int>(buf.size()) - 1);
        return std::string(buf.data());
    }
--- a/toml/datetime.hpp
+++ b/toml/datetime.hpp
@@ -20,7 +20,7 @@ namespace toml
 namespace detail
 {
 // TODO: find more sophisticated way to handle this
-#if _POSIX_C_SOURCE >= 1 || _XOPEN_SOURCE || _BSD_SOURCE || _SVID_SOURCE || _POSIX_SOURCE
+#if (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 1) || defined(_XOPEN_SOURCE) || defined(_BSD_SOURCE) || defined(_SVID_SOURCE) || defined(_POSIX_SOURCE)
 inline std::tm localtime_s(const std::time_t* src)
 {
    std::tm dst;
@@ -28,7 +28,14 @@ inline std::tm localtime_s(const std::time_t* src)
    if (!result) { throw std::runtime_error("localtime_r failed."); }
    return dst;
 }
-#elif _MSC_VER
+inline std::tm gmtime_s(const std::time_t* src)
+{
+    std::tm dst;
+    const auto result = ::gmtime_r(src, &dst);
+    if (!result) { throw std::runtime_error("gmtime_r failed."); }
+    return dst;
+}
+#elif defined(_MSC_VER)
 inline std::tm localtime_s(const std::time_t* src)
 {
    std::tm dst;
@@ -36,13 +43,26 @@ inline std::tm localtime_s(const std::time_t* src)
    if (result) { throw std::runtime_error("localtime_s failed."); }
    return dst;
 }
-#else
+inline std::tm gmtime_s(const std::time_t* src)
+{
+    std::tm dst;
+    const auto result = ::gmtime_s(&dst, src);
+    if (result) { throw std::runtime_error("gmtime_s failed."); }
+    return dst;
+}
+#else // fallback. not threadsafe
 inline std::tm localtime_s(const std::time_t* src)
 {
    const auto result = std::localtime(src);
    if (!result) { throw std::runtime_error("localtime failed."); }
    return *result;
 }
+inline std::tm gmtime_s(const std::time_t* src)
+{
+    const auto result = std::gmtime(src);
+    if (!result) { throw std::runtime_error("gmtime failed."); }
+    return *result;
+}
 #endif
 } // detail

@@ -152,9 +172,9 @@ template<typename charT, typename traits>
 std::basic_ostream<charT, traits>&
 operator<<(std::basic_ostream<charT, traits>& os, const local_date& date)
 {
-    os << std::setfill('0') << std::setw(4) << static_cast<int>(date.year     ) << '-';
-    os << std::setfill('0') << std::setw(2) << static_cast<int>(date.month + 1) << '-';
-    os << std::setfill('0') << std::setw(2) << static_cast<int>(date.day      );
+    os << std::setfill('0') << std::setw(4) << static_cast<int>(date.year )     << '-';
+    os << std::setfill('0') << std::setw(2) << static_cast<int>(date.month) + 1 << '-';
+    os << std::setfill('0') << std::setw(2) << static_cast<int>(date.day  )    ;
    return os;
 }

@@ -378,10 +398,31 @@ struct local_datetime
    {
        using internal_duration =
            typename std::chrono::system_clock::time_point::duration;
+
+        // Normally DST begins at A.M. 3 or 4. If we re-use conversion operator
+        // of local_date and local_time independently, the conversion fails if
+        // it is the day when DST begins or ends. Since local_date considers the
+        // time is 00:00 A.M. and local_time does not consider DST because it
+        // does not have any date information. We need to consider both date and
+        // time information at the same time to convert it correctly.
+
+        std::tm t;
+        t.tm_sec   = static_cast<int>(this->time.second);
+        t.tm_min   = static_cast<int>(this->time.minute);
+        t.tm_hour  = static_cast<int>(this->time.hour);
+        t.tm_mday  = static_cast<int>(this->date.day);
+        t.tm_mon   = static_cast<int>(this->date.month);
+        t.tm_year  = static_cast<int>(this->date.year) - 1900;
+        t.tm_wday  = 0; // the value will be ignored
+        t.tm_yday  = 0; // the value will be ignored
+        t.tm_isdst = -1;
+
        // std::mktime returns date as local time zone. no conversion needed
-        auto dt = std::chrono::system_clock::time_point(this->date);
+        auto dt = std::chrono::system_clock::from_time_t(std::mktime(&t));
        dt += std::chrono::duration_cast<internal_duration>(
-                   std::chrono::nanoseconds(this->time));
+                std::chrono::milliseconds(this->time.millisecond) +
+                std::chrono::microseconds(this->time.microsecond) +
+                std::chrono::nanoseconds (this->time.nanosecond));
        return dt;
    }

@@ -447,40 +488,71 @@ struct offset_datetime
        : date(dt.date), time(dt.time), offset(o)
    {}
    explicit offset_datetime(const local_datetime& ld)
-        : date(ld.date), time(ld.time), offset(get_local_offset())
+        : date(ld.date), time(ld.time), offset(get_local_offset(nullptr))
+          // use the current local timezone offset
    {}
    explicit offset_datetime(const std::chrono::system_clock::time_point& tp)
-        : offset_datetime(local_datetime(tp))
-    {}
+        : offset(0, 0) // use gmtime
+    {
+        const auto timet = std::chrono::system_clock::to_time_t(tp);
+        const auto tm    = detail::gmtime_s(&timet);
+        this->date = local_date(tm);
+        this->time = local_time(tm);
+    }
    explicit offset_datetime(const std::time_t& t)
-        : offset_datetime(local_datetime(t))
-    {}
+        : offset(0, 0) // use gmtime
+    {
+        const auto tm    = detail::gmtime_s(&t);
+        this->date = local_date(tm);
+        this->time = local_time(tm);
+    }
    explicit offset_datetime(const std::tm& t)
-        : offset_datetime(local_datetime(t))
-    {}
+        : offset(0, 0) // assume gmtime
+    {
+        this->date = local_date(t);
+        this->time = local_time(t);
+    }

    operator std::chrono::system_clock::time_point() const
    {
        // get date-time
        using internal_duration =
            typename std::chrono::system_clock::time_point::duration;
-        std::chrono::system_clock::time_point tp =
-            std::chrono::system_clock::time_point(this->date) +
-            std::chrono::duration_cast<internal_duration>(
-                   std::chrono::nanoseconds(this->time));

-        // get date-time in UTC. let's say we are in +09:00 (JPN).
-        // writing 12:00:00 in +09:00 means 03:00:00Z. to represent
-        // 12:00:00Z, first we need to add +09:00.
-        const auto ofs = get_local_offset();
+        // first, convert it to local date-time information in the same way as
+        // local_datetime does. later we will use time_t to adjust time offset.
+        std::tm t;
+        t.tm_sec   = static_cast<int>(this->time.second);
+        t.tm_min   = static_cast<int>(this->time.minute);
+        t.tm_hour  = static_cast<int>(this->time.hour);
+        t.tm_mday  = static_cast<int>(this->date.day);
+        t.tm_mon   = static_cast<int>(this->date.month);
+        t.tm_year  = static_cast<int>(this->date.year) - 1900;
+        t.tm_wday  = 0; // the value will be ignored
+        t.tm_yday  = 0; // the value will be ignored
+        t.tm_isdst = -1;
+        const std::time_t tp_loc = std::mktime(std::addressof(t));
+
+        auto tp = std::chrono::system_clock::from_time_t(tp_loc);
+        tp += std::chrono::duration_cast<internal_duration>(
+                std::chrono::milliseconds(this->time.millisecond) +
+                std::chrono::microseconds(this->time.microsecond) +
+                std::chrono::nanoseconds (this->time.nanosecond));
+
+        // Since mktime uses local time zone, it should be corrected.
+        // `12:00:00+09:00` means `03:00:00Z`. So mktime returns `03:00:00Z` if
+        // we are in `+09:00` timezone. To represent `12:00:00Z` there, we need
+        // to add `+09:00` to `03:00:00Z`.
+        //    Here, it uses the time_t converted from date-time info to handle
+        // daylight saving time.
+        const auto ofs = get_local_offset(std::addressof(tp_loc));
        tp += std::chrono::hours  (ofs.hour);
        tp += std::chrono::minutes(ofs.minute);

-        // here, tp represents 12:00:00 in UTC but we have offset information.
-        // we need to subtract it. For example, let's say the input is
-        // 12:00:00-08:00. now we have tp = 12:00:00Z as a result of the above
-        // conversion. But the actual time we need to return is 20:00:00Z
-        // because of -08:00.
+        // We got `12:00:00Z` by correcting local timezone applied by mktime.
+        // Then we will apply the offset. Let's say `12:00:00-08:00` is given.
+        // And now, we have `12:00:00Z`. `12:00:00-08:00` means `20:00:00Z`.
+        // So we need to subtract the offset.
        tp -= std::chrono::minutes(this->offset);
        return tp;
    }
@@ -500,11 +572,10 @@ struct offset_datetime

  private:

-    static time_offset get_local_offset()
+    static time_offset get_local_offset(const std::time_t* tp)
    {
-         // get current timezone
-        const auto tmp1 = std::time(nullptr);
-        const auto t    = detail::localtime_s(&tmp1);
+        // get local timezone with the same date-time information as mktime
+        const auto t = detail::localtime_s(tp);

        std::array<char, 6> buf;
        const auto result = std::strftime(buf.data(), 6, "%z", &t); // +hhmm\0
--- a/toml/exception.hpp
+++ b/toml/exception.hpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT License.
 #ifndef TOML11_EXCEPTION_HPP
 #define TOML11_EXCEPTION_HPP
+#include "source_location.hpp"
 #include <stdexcept>
 #include <string>

@@ -11,15 +12,21 @@ namespace toml
 struct exception : public std::exception
 {
  public:
+    explicit exception(const source_location& loc): loc_(loc) {}
    virtual ~exception() noexcept override = default;
    virtual const char* what() const noexcept override {return "";}
+    virtual source_location const& location() const noexcept {return loc_;}
+
+  protected:
+    source_location loc_;
 };

 struct syntax_error : public toml::exception
 {
  public:
-    explicit syntax_error(const std::string& what_arg) : what_(what_arg){}
-    explicit syntax_error(const char* what_arg)        : what_(what_arg){}
+    explicit syntax_error(const std::string& what_arg, const source_location& loc)
+        : exception(loc), what_(what_arg)
+    {}
    virtual ~syntax_error() noexcept override = default;
    virtual const char* what() const noexcept override {return what_.c_str();}

@@ -30,8 +37,9 @@ struct syntax_error : public toml::exception
 struct type_error : public toml::exception
 {
  public:
-    explicit type_error(const std::string& what_arg) : what_(what_arg){}
-    explicit type_error(const char* what_arg)        : what_(what_arg){}
+    explicit type_error(const std::string& what_arg, const source_location& loc)
+        : exception(loc), what_(what_arg)
+    {}
    virtual ~type_error() noexcept override = default;
    virtual const char* what() const noexcept override {return what_.c_str();}

@@ -42,10 +50,12 @@ struct type_error : public toml::exception
 struct internal_error : public toml::exception
 {
  public:
-    explicit internal_error(const std::string& what_arg) : what_(what_arg){}
-    explicit internal_error(const char* what_arg)        : what_(what_arg){}
+    explicit internal_error(const std::string& what_arg, const source_location& loc)
+        : exception(loc), what_(what_arg)
+    {}
    virtual ~internal_error() noexcept override = default;
    virtual const char* what() const noexcept override {return what_.c_str();}
+
  protected:
    std::string what_;
 };
--- a/toml/get.hpp
+++ b/toml/get.hpp
@@ -186,11 +186,11 @@ get(const basic_value<C, M, V>& v)
        }
        default:
        {
-            throw type_error(detail::format_underline("[error] toml::value "
+            throw type_error(detail::format_underline("toml::value: "
                "bad_cast to std::chrono::system_clock::time_point", {
                    {std::addressof(detail::get_region(v)),
                     concat_to_string("the actual type is ", v.type())}
-                }));
+                }), v.location());
        }
    }
 }
@@ -259,6 +259,15 @@ template<typename T, typename C,
         std::size_t S = sizeof(::toml::from<T>)>
 T get(const basic_value<C, M, V>&);

+// T(const toml::value&) and T is not toml::basic_value
+template<typename T, typename C,
+         template<typename ...> class M, template<typename ...> class V>
+detail::enable_if_t<detail::conjunction<
+    detail::negation<detail::is_basic_value<T>>,
+    std::is_constructible<T, const basic_value<C, M, V>&>
+    >::value, T>
+get(const basic_value<C, M, V>&);
+
 // ============================================================================
 // array-like types; most likely STL container, like std::vector, etc.

@@ -301,7 +310,7 @@ get(const basic_value<C, M, V>& v)
    if(ar.size() != container.size())
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[erorr] toml::get specified container size is ", container.size(),
+            "toml::get: specified container size is ", container.size(),
            " but there are ", ar.size(), " elements in toml array."), {
                {std::addressof(detail::get_region(v)), "here"}
            }));
@@ -326,7 +335,7 @@ get(const basic_value<C, M, V>& v)
    if(ar.size() != 2)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[erorr] toml::get specified std::pair but there are ", ar.size(),
+            "toml::get: specified std::pair but there are ", ar.size(),
            " elements in toml array."), {
                {std::addressof(detail::get_region(v)), "here"}
            }));
@@ -357,8 +366,8 @@ get(const basic_value<C, M, V>& v)
    if(ar.size() != std::tuple_size<T>::value)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[erorr] toml::get specified std::tuple with ",
-            std::tuple_size<T>::value, "elements, but there are ", ar.size(),
+            "toml::get: specified std::tuple with ",
+            std::tuple_size<T>::value, " elements, but there are ", ar.size(),
            " elements in toml array."), {
                {std::addressof(detail::get_region(v)), "here"}
            }));
@@ -417,6 +426,17 @@ T get(const basic_value<C, M, V>& v)
    return ::toml::from<T>::from_toml(v);
 }

+template<typename T, typename C,
+         template<typename ...> class M, template<typename ...> class V>
+detail::enable_if_t<detail::conjunction<
+    detail::negation<detail::is_basic_value<T>>,
+    std::is_constructible<T, const basic_value<C, M, V>&>
+    >::value, T>
+get(const basic_value<C, M, V>& v)
+{
+    return T(v);
+}
+
 // ============================================================================
 // find

@@ -430,7 +450,7 @@ basic_value<C, M, V> const& find(const basic_value<C, M, V>& v, const key& ky)
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[error] key \"", ky, "\" not found"), {
+            "key \"", ky, "\" not found"), {
                {std::addressof(detail::get_region(v)), "in this table"}
            }));
    }
@@ -444,7 +464,7 @@ basic_value<C, M, V>& find(basic_value<C, M, V>& v, const key& ky)
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[error] key \"", ky, "\" not found"), {
+            "key \"", ky, "\" not found"), {
                {std::addressof(detail::get_region(v)), "in this table"}
            }));
    }
@@ -458,13 +478,59 @@ basic_value<C, M, V> find(basic_value<C, M, V>&& v, const key& ky)
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[error] key \"", ky, "\" not found"), {
+            "key \"", ky, "\" not found"), {
                {std::addressof(detail::get_region(v)), "in this table"}
            }));
    }
    return basic_value<C, M, V>(std::move(tab.at(ky)));
 }

+// ----------------------------------------------------------------------------
+// find(value, idx)
+template<typename C,
+         template<typename ...> class M, template<typename ...> class V>
+basic_value<C, M, V> const&
+find(const basic_value<C, M, V>& v, const std::size_t idx)
+{
+    const auto& ary = v.as_array();
+    if(ary.size() <= idx)
+    {
+        throw std::out_of_range(detail::format_underline(concat_to_string(
+            "index ", idx, " is out of range"), {
+                {std::addressof(detail::get_region(v)), "in this array"}
+            }));
+    }
+    return ary.at(idx);
+}
+template<typename C,
+         template<typename ...> class M, template<typename ...> class V>
+basic_value<C, M, V>& find(basic_value<C, M, V>& v, const std::size_t idx)
+{
+    auto& ary = v.as_array();
+    if(ary.size() <= idx)
+    {
+        throw std::out_of_range(detail::format_underline(concat_to_string(
+            "index ", idx, " is out of range"), {
+                {std::addressof(detail::get_region(v)), "in this array"}
+            }));
+    }
+    return ary.at(idx);
+}
+template<typename C,
+         template<typename ...> class M, template<typename ...> class V>
+basic_value<C, M, V> find(basic_value<C, M, V>&& v, const std::size_t idx)
+{
+    auto& ary = v.as_array();
+    if(ary.size() <= idx)
+    {
+        throw std::out_of_range(detail::format_underline(concat_to_string(
+            "index ", idx, " is out of range"), {
+                {std::addressof(detail::get_region(v)), "in this array"}
+            }));
+    }
+    return basic_value<C, M, V>(std::move(ary.at(idx)));
+}
+
 // ----------------------------------------------------------------------------
 // find<T>(value, key);

@@ -477,7 +543,7 @@ find(const basic_value<C, M, V>& v, const key& ky)
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[error] key \"", ky, "\" not found"), {
+            "key \"", ky, "\" not found"), {
                {std::addressof(detail::get_region(v)), "in this table"}
            }));
    }
@@ -493,7 +559,7 @@ find(basic_value<C, M, V>& v, const key& ky)
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[error] key \"", ky, "\" not found"), {
+            "key \"", ky, "\" not found"), {
                {std::addressof(detail::get_region(v)), "in this table"}
            }));
    }
@@ -509,64 +575,159 @@ find(basic_value<C, M, V>&& v, const key& ky)
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[error] key \"", ky, "\" not found"), {
+            "key \"", ky, "\" not found"), {
                {std::addressof(detail::get_region(v)), "in this table"}
            }));
    }
    return ::toml::get<T>(std::move(tab.at(ky)));
 }

+// ----------------------------------------------------------------------------
+// find<T>(value, idx)
+template<typename T, typename C,
+         template<typename ...> class M, template<typename ...> class V>
+decltype(::toml::get<T>(std::declval<basic_value<C, M, V> const&>()))
+find(const basic_value<C, M, V>& v, const std::size_t idx)
+{
+    const auto& ary = v.as_array();
+    if(ary.size() <= idx)
+    {
+        throw std::out_of_range(detail::format_underline(concat_to_string(
+            "index ", idx, " is out of range"), {
+                {std::addressof(detail::get_region(v)), "in this array"}
+            }));
+    }
+    return ::toml::get<T>(ary.at(idx));
+}
+template<typename T, typename C,
+         template<typename ...> class M, template<typename ...> class V>
+decltype(::toml::get<T>(std::declval<basic_value<C, M, V>&>()))
+find(basic_value<C, M, V>& v, const std::size_t idx)
+{
+    auto& ary = v.as_array();
+    if(ary.size() <= idx)
+    {
+        throw std::out_of_range(detail::format_underline(concat_to_string(
+            "index ", idx, " is out of range"), {
+                {std::addressof(detail::get_region(v)), "in this array"}
+            }));
+    }
+    return ::toml::get<T>(ary.at(idx));
+}
+template<typename T, typename C,
+         template<typename ...> class M, template<typename ...> class V>
+decltype(::toml::get<T>(std::declval<basic_value<C, M, V>&&>()))
+find(basic_value<C, M, V>&& v, const std::size_t idx)
+{
+    typename basic_value<C, M, V>::array_type ary = std::move(v).as_array();
+    if(ary.size() <= idx)
+    {
+        throw std::out_of_range(detail::format_underline(concat_to_string(
+            "index ", idx, " is out of range"), {
+                {std::addressof(detail::get_region(v)), "in this array"}
+            }));
+    }
+    return ::toml::get<T>(std::move(ary.at(idx)));
+}
+
 // --------------------------------------------------------------------------
 // toml::find(toml::value, toml::key, Ts&& ... keys)

+namespace detail
+{
+// It suppresses warnings by -Wsign-conversion. Let's say we have the following
+// code.
+// ```cpp
+// const auto x = toml::find<std::string>(data, "array", 0);
+// ```
+// Here, the type of literal number `0` is `int`. `int` is a signed integer.
+// `toml::find` takes `std::size_t` as an index. So it causes implicit sign
+// conversion and `-Wsign-conversion` warns about it. Using `0u` instead of `0`
+// suppresses the warning, but it makes user code messy.
+//     To suppress this warning, we need to be aware of type conversion caused
+// by `toml::find(v, key1, key2, ... keys)`. But the thing is that the types of
+// keys can be any combination of {string-like, size_t-like}. Of course we can't
+// write down all the combinations. Thus we need to use some function that
+// recognize the type of argument and cast it into `std::string` or
+// `std::size_t` depending on the context.
+//     `key_cast` does the job. It has 2 overloads. One is invoked when the
+// argument type is an integer and cast the argument into `std::size_t`. The
+// other is invoked when the argument type is not an integer, possibly one of
+// std::string, const char[N] or const char*, and construct std::string from
+// the argument.
+//     `toml::find(v, k1, k2, ... ks)` uses `key_cast` before passing `ks` to
+// `toml::find(v, k)` to suppress -Wsign-conversion.
+
+template<typename T>
+enable_if_t<conjunction<std::is_integral<remove_cvref_t<T>>,
+            negation<std::is_same<remove_cvref_t<T>, bool>>>::value, std::size_t>
+key_cast(T&& v) noexcept
+{
+    return std::size_t(v);
+}
+template<typename T>
+enable_if_t<negation<conjunction<std::is_integral<remove_cvref_t<T>>,
+            negation<std::is_same<remove_cvref_t<T>, bool>>>>::value, std::string>
+key_cast(T&& v) noexcept
+{
+    return std::string(std::forward<T>(v));
+}
+} // detail
+
 template<typename C,
         template<typename ...> class M, template<typename ...> class V,
-         typename ... Ts>
+         typename Key1, typename Key2, typename ... Keys>
 const basic_value<C, M, V>&
-find(const basic_value<C, M, V>& v, const ::toml::key& ky, Ts&& ... keys)
+find(const basic_value<C, M, V>& v, Key1&& k1, Key2&& k2, Keys&& ... keys)
 {
-    return ::toml::find(::toml::find(v, ky), std::forward<Ts>(keys)...);
+    return ::toml::find(::toml::find(v, detail::key_cast(k1)),
+            detail::key_cast(k2), std::forward<Keys>(keys)...);
 }
 template<typename C,
         template<typename ...> class M, template<typename ...> class V,
-         typename ... Ts>
+         typename Key1, typename Key2, typename ... Keys>
 basic_value<C, M, V>&
-find(basic_value<C, M, V>& v, const ::toml::key& ky, Ts&& ... keys)
+find(basic_value<C, M, V>& v, Key1&& k1, Key2&& k2, Keys&& ... keys)
 {
-    return ::toml::find(::toml::find(v, ky), std::forward<Ts>(keys)...);
+    return ::toml::find(::toml::find(v, detail::key_cast(k1)),
+            detail::key_cast(k2), std::forward<Keys>(keys)...);
 }
 template<typename C,
         template<typename ...> class M, template<typename ...> class V,
-         typename ... Ts>
+         typename Key1, typename Key2, typename ... Keys>
 basic_value<C, M, V>
-find(basic_value<C, M, V>&& v, const ::toml::key& ky, Ts&& ... keys)
+find(basic_value<C, M, V>&& v, Key1&& k1, Key2&& k2, Keys&& ... keys)
 {
-    return ::toml::find(::toml::find(std::move(v), ky), std::forward<Ts>(keys)...);
+    return ::toml::find(::toml::find(std::move(v), std::forward<Key1>(k1)),
+            detail::key_cast(k2), std::forward<Keys>(keys)...);
 }

 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V,
-         typename ... Ts>
+         typename Key1, typename Key2, typename ... Keys>
 decltype(::toml::get<T>(std::declval<const basic_value<C, M, V>&>()))
-find(const basic_value<C, M, V>& v, const ::toml::key& ky, Ts&& ... keys)
+find(const basic_value<C, M, V>& v, Key1&& k1, Key2&& k2, Keys&& ... keys)
 {
-    return ::toml::find<T>(::toml::find(v, ky), std::forward<Ts>(keys)...);
+    return ::toml::find<T>(::toml::find(v, detail::key_cast(k1)),
+            detail::key_cast(k2), std::forward<Keys>(keys)...);
 }
 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V,
-         typename ... Ts>
+         typename Key1, typename Key2, typename ... Keys>
 decltype(::toml::get<T>(std::declval<basic_value<C, M, V>&>()))
-find(basic_value<C, M, V>& v, const ::toml::key& ky, Ts&& ... keys)
+find(basic_value<C, M, V>& v, Key1&& k1, Key2&& k2, Keys&& ... keys)
 {
-    return ::toml::find<T>(::toml::find(v, ky), std::forward<Ts>(keys)...);
+    return ::toml::find<T>(::toml::find(v, detail::key_cast(k1)),
+            detail::key_cast(k2), std::forward<Keys>(keys)...);
 }
 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V,
-         typename ... Ts>
+         typename Key1, typename Key2, typename ... Keys>
 decltype(::toml::get<T>(std::declval<basic_value<C, M, V>&&>()))
-find(basic_value<C, M, V>&& v, const ::toml::key& ky, Ts&& ... keys)
+find(basic_value<C, M, V>&& v, Key1&& k1, Key2&& k2, Keys&& ... keys)
 {
-    return ::toml::find<T>(::toml::find(std::move(v), ky), std::forward<Ts>(keys)...);
+    return ::toml::find<T>(::toml::find(std::move(v), detail::key_cast(k1)),
+            detail::key_cast(k2), std::forward<Keys>(keys)...);
 }

 // ============================================================================
--- a/toml/lexer.hpp
+++ b/toml/lexer.hpp
@@ -154,12 +154,53 @@ using lex_basic_string = sequence<lex_quotation_mark,
                                  repeat<lex_basic_char, unlimited>,
                                  lex_quotation_mark>;

+// After toml post-v0.5.0, it is explicitly clarified how quotes in ml-strings
+// are allowed to be used.
+// After this, the following strings are *explicitly* allowed.
+// - One or two `"`s in a multi-line basic string is allowed wherever it is.
+// - Three consecutive `"`s in a multi-line basic string is considered as a delimiter.
+// - One or two `"`s can appear just before or after the delimiter.
+// ```toml
+// str4 = """Here are two quotation marks: "". Simple enough."""
+// str5 = """Here are three quotation marks: ""\"."""
+// str6 = """Here are fifteen quotation marks: ""\"""\"""\"""\"""\"."""
+// str7 = """"This," she said, "is just a pointless statement.""""
+// ```
+// In the current implementation (v3.3.0), it is difficult to parse `str7` in
+// the above example. It is difficult to recognize `"` at the end of string body
+// collectly. It will be misunderstood as a `"""` delimiter and an additional,
+// invalid `"`. Like this:
+// ```console
+//   what():  [error] toml::parse_table: invalid line format
+//  --> hoge.toml
+//     |
+//  13 | str7 = """"This," she said, "is just a pointless statement.""""
+//     |                                                               ^- expected newline, but got '"'.
+// ```
+// As a quick workaround for this problem, `lex_ml_basic_string_delim` was
+// splitted into two, `lex_ml_basic_string_open` and `lex_ml_basic_string_close`.
+// `lex_ml_basic_string_open` allows only `"""`. `_close` allows 3-5 `"`s.
+// In parse_ml_basic_string() function, the trailing `"`s will be attached to
+// the string body.
+//
+// Note: This feature is a "clarification". Therefore this change is considered
+//       as a spec that has been defined since the time when the multi-line
+//       basic string was introduced. Although it is a post-v0.5.0 changes,
+//       this change will be activated regardless of the flag,
+//       `TOML11_USE_UNRELEASED_TOML_FEATURES`.
+//
 using lex_ml_basic_string_delim = repeat<lex_quotation_mark, exactly<3>>;
+using lex_ml_basic_string_open  = lex_ml_basic_string_delim;
+using lex_ml_basic_string_close = sequence<
+        repeat<lex_quotation_mark, exactly<3>>,
+        maybe<lex_quotation_mark>, maybe<lex_quotation_mark>
+    >;
+
 #ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
 using lex_ml_basic_unescaped    = exclude<either<in_range<0x00, 0x08>, // 0x09
                                                 in_range<0x0a, 0x1F>, // is tab
-                                                 character<0x5C>,
-                                                 character<0x7F>,
+                                                 character<0x5C>, // backslash
+                                                 character<0x7F>, // DEL
                                                 lex_ml_basic_string_delim>>;
 #else // TOML v0.5.0
 using lex_ml_basic_unescaped    = exclude<either<in_range<0x00,0x1F>,
@@ -176,9 +217,9 @@ using lex_ml_basic_char = either<lex_ml_basic_unescaped, lex_escaped>;
 using lex_ml_basic_body = repeat<either<lex_ml_basic_char, lex_newline,
                                        lex_ml_basic_escaped_newline>,
                                 unlimited>;
-using lex_ml_basic_string = sequence<lex_ml_basic_string_delim,
+using lex_ml_basic_string = sequence<lex_ml_basic_string_open,
                                     lex_ml_basic_body,
-                                     lex_ml_basic_string_delim>;
+                                     lex_ml_basic_string_close>;

 using lex_literal_char = exclude<either<in_range<0x00, 0x08>,
                                        in_range<0x10, 0x19>, character<0x27>>>;
@@ -187,7 +228,13 @@ using lex_literal_string = sequence<lex_apostrophe,
                                    repeat<lex_literal_char, unlimited>,
                                    lex_apostrophe>;

+// the same reason as above.
 using lex_ml_literal_string_delim = repeat<lex_apostrophe, exactly<3>>;
+using lex_ml_literal_string_open  = lex_ml_literal_string_delim;
+using lex_ml_literal_string_close = sequence<
+        repeat<lex_apostrophe, exactly<3>>,
+        maybe<lex_apostrophe>, maybe<lex_apostrophe>
+    >;

 using lex_ml_literal_char = exclude<either<in_range<0x00, 0x08>,
                                           in_range<0x10, 0x1F>,
@@ -195,9 +242,9 @@ using lex_ml_literal_char = exclude<either<in_range<0x00, 0x08>,
                                           lex_ml_literal_string_delim>>;
 using lex_ml_literal_body = repeat<either<lex_ml_literal_char, lex_newline>,
                                   unlimited>;
-using lex_ml_literal_string = sequence<lex_ml_literal_string_delim,
+using lex_ml_literal_string = sequence<lex_ml_literal_string_open,
                                       lex_ml_literal_body,
-                                       lex_ml_literal_string_delim>;
+                                       lex_ml_literal_string_close>;

 using lex_string = either<lex_ml_basic_string,   lex_basic_string,
                          lex_ml_literal_string, lex_literal_string>;
--- a/toml/literal.hpp
+++ b/toml/literal.hpp
@@ -76,7 +76,8 @@ inline ::toml::value operator"" _toml(const char* str, std::size_t len)
    }
    else // none of them.
    {
-        throw ::toml::syntax_error(data.unwrap_err());
+        throw ::toml::syntax_error(data.unwrap_err(),
+                                   source_location(std::addressof(loc)));
    }
 }

--- a/toml/parser.hpp
+++ b/toml/parser.hpp
--- a/toml/region.hpp
+++ b/toml/region.hpp
@@ -2,7 +2,6 @@
 // Distributed under the MIT License.
 #ifndef TOML11_REGION_HPP
 #define TOML11_REGION_HPP
-#include "exception.hpp"
 #include <memory>
 #include <vector>
 #include <algorithm>
@@ -10,6 +9,7 @@
 #include <iterator>
 #include <iomanip>
 #include <cassert>
+#include "color.hpp"

 namespace toml
 {
@@ -41,6 +41,7 @@ struct region_base
    region_base& operator=(region_base&&     ) = default;

    virtual bool is_ok()           const noexcept {return false;}
+    virtual char front()           const noexcept {return '\0';}

    virtual std::string str()      const {return std::string("unknown region");}
    virtual std::string name()     const {return std::string("unknown file");}
@@ -89,6 +90,7 @@ struct location final : public region_base
    ~location() = default;

    bool is_ok() const noexcept override {return static_cast<bool>(source_);}
+    char front() const noexcept override {return *iter_;}

    // this const prohibits codes like `++(loc.iter())`.
    const const_iterator iter()  const noexcept {return iter_;}
@@ -231,16 +233,16 @@ struct region final : public region_base

    region& operator+=(const region& other)
    {
-        if(this->begin() != other.begin() || this->end() != other.end() ||
-           this->last_  != other.first_)
-        {
-            throw internal_error("invalid region concatenation");
-        }
+        // different regions cannot be concatenated
+        assert(this->begin() == other.begin() && this->end() == other.end() &&
+               this->last_   == other.first_);
+
        this->last_ = other.last_;
        return *this;
    }

    bool is_ok() const noexcept override {return static_cast<bool>(source_);}
+    char front() const noexcept override {return *first_;}

    std::string str()  const override {return make_string(first_, last_);}
    std::string line() const override
@@ -420,7 +422,8 @@ struct region final : public region_base
 // 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 std::vector<std::string>& helps = {},
+        const bool colorize = TOML11_ERROR_MESSAGE_COLORIZED)
 {
    assert(!reg_com.empty());

@@ -434,7 +437,27 @@ inline std::string format_underline(const std::string& message,
    )->first->line_num().size());

    std::ostringstream retval;
-    retval << message << '\n';
+
+    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)
    {
@@ -442,34 +465,42 @@ inline std::string format_underline(const std::string& message,
        if(iter != reg_com.begin() &&
           std::prev(iter)->first->name() == iter->first->name())
        {
-            retval << "\n ...\n";
+            retval << color::bold << color::blue << "\n ...\n" << color::reset;
        }
        else // if filename differs, print " --> filename.toml"
        {
            if(iter != reg_com.begin()) {retval << '\n';}
-            retval << " --> " << iter->first->name() << '\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 << ' ' << std::setw(line_num_width) << reg->line_num();
-        retval << " | " << reg->line() << '\n';
-        retval << make_string(static_cast<std::size_t>(line_num_width + 1), ' ');
-        retval << " | " << make_string(reg->before(), ' ');
+        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 << '^';
-            retval << make_string(reg->after(), '-');
+            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 << make_string(underline_len, '~');
+            retval << color::bold << color::red
+                   << make_string(underline_len, '~') << color::reset;
        }
        retval << ' ';
        retval << comment;
@@ -479,10 +510,10 @@ inline std::string format_underline(const std::string& message,
    {
        retval << '\n';
        retval << make_string(static_cast<std::size_t>(line_num_width + 1), ' ');
-        retval << " | ";
-        for(const auto help : helps)
+        retval << color::bold << color::blue << " | " << color::reset;
+        for(const auto& help : helps)
        {
-            retval << "\nHint: ";
+            retval << color::bold << "\nHint: " << color::reset;
            retval << help;
        }
    }
--- a/toml/serializer.hpp
+++ b/toml/serializer.hpp
@@ -118,8 +118,19 @@ struct serializer
        {
            return token; // there is no exponent part. just return it.
        }
-
-        // zero-prefix in an exponent is NOT allowed in TOML.
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+        // Although currently it is not released yet as a tagged version,
+        // TOML will allow zero-prefix in an exponent part, such as `1.234e+01`.
+        // ```toml
+        // num1 = 1.234e+1  # OK in TOML v0.5.0
+        // num2 = 1.234e+01 # error in TOML v0.5.0 but will be allowed soon
+        // ```
+        // To avoid `e+01`, the following `else` section removes the zero
+        // prefixes in the exponent part.
+        // If the feature is activated, it can be skipped.
+        return token;
+#else
+        // zero-prefix in an exponent is NOT allowed in TOML v0.5.0.
        // remove it if it exists.
        bool        sign_exists = false;
        std::size_t zero_prefix = 0;
@@ -137,17 +148,29 @@ struct serializer
                        zero_prefix);
        }
        return token;
+#endif
    }
    std::string operator()(const string_type& s) const
    {
        if(s.kind == string_t::basic)
        {
-            if(std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend())
+            if(std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend() ||
+               std::find(s.str.cbegin(), s.str.cend(), '\"') != s.str.cend())
            {
-                // if linefeed is contained, make it multiline-string.
-                const std::string open("\"\"\"\n");
-                const std::string close("\\\n\"\"\"");
-                return open + this->escape_ml_basic_string(s.str) + close;
+                // if linefeed or double-quote is contained,
+                // make it multiline basic string.
+                const auto escaped = this->escape_ml_basic_string(s.str);
+                std::string open("\"\"\"");
+                std::string close("\"\"\"");
+                if(escaped.find('\n') != std::string::npos ||
+                   this->width_ < escaped.size() + 6)
+                {
+                    // if the string body contains newline or is enough long,
+                    // add newlines after and before delimiters.
+                    open += "\n";
+                    close = std::string("\\\n") + close;
+                }
+                return open + escaped + close;
            }

            // no linefeed. try to make it oneline-string.
@@ -188,7 +211,11 @@ struct serializer
            if(std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend() ||
               std::find(s.str.cbegin(), s.str.cend(), '\'') != s.str.cend() )
            {
-                const std::string open("'''\n");
+                std::string open("'''");
+                if(this->width_ + 6 < s.str.size())
+                {
+                    open += '\n'; // the first newline is ignored by TOML spec
+                }
                const std::string close("'''");
                return open + s.str + close;
            }
@@ -483,7 +510,9 @@ struct serializer
            switch(*i)
            {
                case '\\': {retval += "\\\\"; break;}
-                case '\"': {retval += "\\\""; break;}
+                // One or two consecutive "s are allowed.
+                // Later we will check there are no three consecutive "s.
+                //   case '\"': {retval += "\\\""; break;}
                case '\b': {retval += "\\b";  break;}
                case '\t': {retval += "\\t";  break;}
                case '\f': {retval += "\\f";  break;}
@@ -504,6 +533,23 @@ struct serializer
                default: {retval += *i; break;}
            }
        }
+        // Only 1 or 2 consecutive `"`s are allowed in multiline basic string.
+        // 3 consecutive `"`s are considered as a closing delimiter.
+        // We need to check if there are 3 or more consecutive `"`s and insert
+        // backslash to break them down into several short `"`s like the `str6`
+        // in the following example.
+        // ```toml
+        // str4 = """Here are two quotation marks: "". Simple enough."""
+        // # str5 = """Here are three quotation marks: """."""  # INVALID
+        // str5 = """Here are three quotation marks: ""\"."""
+        // str6 = """Here are fifteen quotation marks: ""\"""\"""\"""\"""\"."""
+        // ```
+        auto found_3_quotes = retval.find("\"\"\"");
+        while(found_3_quotes != std::string::npos)
+        {
+            retval.replace(found_3_quotes, 3, "\"\"\\\"");
+            found_3_quotes = retval.find("\"\"\"");
+        }
        return retval;
    }

@@ -573,7 +619,7 @@ struct serializer

        // print non-table stuff first. because after printing [foo.bar], the
        // remaining non-table values will be assigned into [foo.bar], not [foo]
-        for(const auto kv : v)
+        for(const auto& kv : v)
        {
            if(kv.second.is_table() || is_array_of_tables(kv.second))
            {
--- a/toml/source_location.hpp
+++ b/toml/source_location.hpp
@@ -48,7 +48,11 @@ struct source_location
    {
        if(reg)
        {
-            line_num_    = static_cast<std::uint_least32_t>(std::stoul(reg->line_num()));
+            if(reg->line_num() != detail::region_base().line_num())
+            {
+                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();
--- a/toml/storage.hpp
+++ b/toml/storage.hpp
@@ -16,10 +16,9 @@ struct storage
 {
    using value_type = T;

-    storage(value_type const& v): ptr(toml::make_unique<T>(v)) {}
-    storage(value_type&&      v): ptr(toml::make_unique<T>(std::move(v))) {}
+    explicit storage(value_type const& v): ptr(toml::make_unique<T>(v)) {}
+    explicit storage(value_type&&      v): ptr(toml::make_unique<T>(std::move(v))) {}
    ~storage() = default;
-
    storage(const storage& rhs): ptr(toml::make_unique<T>(*rhs.ptr)) {}
    storage& operator=(const storage& rhs)
    {
--- a/toml/string.hpp
+++ b/toml/string.hpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT License.
 #ifndef TOML11_STRING_HPP
 #define TOML11_STRING_HPP
+#include <algorithm>
 #include <string>
 #include <cstdint>
 #if __cplusplus >= 201703L
@@ -45,6 +46,11 @@ struct string
    operator std::string const& () const& noexcept {return str;}
    operator std::string&&      () &&     noexcept {return std::move(str);}

+    string& operator+=(const char*        rhs) {str += rhs; return *this;}
+    string& operator+=(const char         rhs) {str += rhs; return *this;}
+    string& operator+=(const std::string& rhs) {str += rhs; return *this;}
+    string& operator+=(const string&      rhs) {str += rhs.str; return *this;}
+
 #if __cplusplus >= 201703L
    explicit string(std::string_view s): kind(string_t::basic), str(s){}
    string(std::string_view s, string_t k): kind(k), str(s){}
@@ -54,6 +60,8 @@ struct string

    explicit operator std::string_view() const noexcept
    {return std::string_view(str);}
+
+    string& operator+=(const std::string_view& rhs) {str += rhs; return *this;}
 #endif

    string_t    kind;
--- a/toml/traits.hpp
+++ b/toml/traits.hpp
@@ -105,12 +105,20 @@ struct has_into_toml_method
 : decltype(has_into_toml_method_impl::check<T>(nullptr)){};

 #ifdef __INTEL_COMPILER
-#undef decltype(...)
+#undef decltype
 #endif

 // ---------------------------------------------------------------------------
 // C++17 and/or/not

+#if __cplusplus >= 201703L
+
+using std::conjunction;
+using std::disjunction;
+using std::negation;
+
+#else
+
 template<typename ...> struct conjunction : std::true_type{};
 template<typename T>   struct conjunction<T> : T{};
 template<typename T, typename ... Ts>
@@ -128,6 +136,8 @@ struct disjunction<T, Ts...> :
 template<typename T>
 struct negation : std::integral_constant<bool, !static_cast<bool>(T::value)>{};

+#endif
+
 // ---------------------------------------------------------------------------
 // type checkers

@@ -182,6 +192,13 @@ struct is_basic_value<::toml::basic_value<C, M, V>>: std::true_type{};
 // ---------------------------------------------------------------------------
 // C++14 index_sequence

+#if __cplusplus >= 201402L
+
+using std::index_sequence;
+using std::make_index_sequence;
+
+#else
+
 template<std::size_t ... Ns> struct index_sequence{};

 template<typename IS, std::size_t N> struct push_back_index_sequence{};
@@ -205,11 +222,22 @@ struct index_sequence_maker<0>
 template<std::size_t N>
 using make_index_sequence = typename index_sequence_maker<N-1>::type;

+#endif // __cplusplus >= 2014
+
 // ---------------------------------------------------------------------------
 // C++14 enable_if_t
+
+#if __cplusplus >= 201402L
+
+using std::enable_if_t;
+
+#else
+
 template<bool B, typename T>
 using enable_if_t = typename std::enable_if<B, T>::type;

+#endif // __cplusplus >= 2014
+
 // ---------------------------------------------------------------------------
 // return_type_of_t

--- a/toml/utility.hpp
+++ b/toml/utility.hpp
@@ -20,12 +20,20 @@
 namespace toml
 {

+#if __cplusplus >= 201402L
+
+using std::make_unique;
+
+#else
+
 template<typename T, typename ... Ts>
 inline std::unique_ptr<T> make_unique(Ts&& ... args)
 {
    return std::unique_ptr<T>(new T(std::forward<Ts>(args)...));
 }

+#endif // __cplusplus >= 2014
+
 namespace detail
 {

@@ -76,10 +84,10 @@ std::string concat_to_string(Ts&& ... args)
    return detail::concat_to_string_impl(oss, std::forward<Ts>(args) ...);
 }

-template<typename T, typename U>
-T from_string(const std::string& str, U&& opt)
+template<typename T>
+T from_string(const std::string& str, T opt)
 {
-    T v(static_cast<T>(std::forward<U>(opt)));
+    T v(opt);
    std::istringstream iss(str);
    iss >> v;
    return v;
--- a/toml/value.hpp
+++ b/toml/value.hpp
@@ -32,10 +32,10 @@ template<value_t Expected,
 throw_bad_cast(value_t actual, const ::toml::basic_value<C, T, A>& v)
 {
    throw type_error(detail::format_underline(concat_to_string(
-        "[error] toml::value bad_cast to ", Expected), {
+        "toml::value: bad_cast to ", Expected), {
            {std::addressof(get_region(v)),
             concat_to_string("the actual type is ", actual)}
-        }));
+        }), v.location());
 }

 // switch by `value_t` and call the corresponding `value::as_xxx()`. {{{
@@ -529,14 +529,6 @@ class basic_value
        assigner(this->boolean_, b);
        return *this;
    }
-    template<typename Container>
-    basic_value(boolean b, detail::region<Container> reg)
-        : type_(value_t::boolean),
-          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
-          comments_(region_info_->comments())
-    {
-        assigner(this->boolean_, b);
-    }
    basic_value(boolean b, std::vector<std::string> comments)
        : type_(value_t::boolean),
          region_info_(std::make_shared<region_base>(region_base{})),
@@ -557,19 +549,6 @@ class basic_value
        assigner(this->integer_, static_cast<integer>(i));
    }

-    template<typename T, typename Container, typename std::enable_if<
-        detail::conjunction<
-            std::is_integral<T>,
-            detail::negation<std::is_same<T, boolean>>
-        >::value, std::nullptr_t>::type = nullptr>
-    basic_value(T i, detail::region<Container> reg)
-        : type_(value_t::integer),
-          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
-          comments_(region_info_->comments())
-    {
-        assigner(this->integer_, static_cast<integer>(i));
-    }
-
    template<typename T, typename std::enable_if<detail::conjunction<
        std::is_integral<T>, detail::negation<std::is_same<T, boolean>>>::value,
        std::nullptr_t>::type = nullptr>
@@ -604,15 +583,6 @@ class basic_value
        assigner(this->floating_, static_cast<floating>(f));
    }

-    template<typename T, typename Container, typename std::enable_if<
-        std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr>
-    basic_value(T f, detail::region<Container> reg)
-        : type_(value_t::floating),
-          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
-          comments_(region_info_->comments())
-    {
-        assigner(this->floating_, static_cast<floating>(f));
-    }

    template<typename T, typename std::enable_if<
        std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr>
@@ -643,14 +613,6 @@ class basic_value
    {
        assigner(this->string_, std::move(s));
    }
-    template<typename Container>
-    basic_value(toml::string s, detail::region<Container> reg)
-        : type_(value_t::string),
-          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
-          comments_(region_info_->comments())
-    {
-        assigner(this->string_, std::move(s));
-    }
    basic_value& operator=(toml::string s)
    {
        this->cleanup();
@@ -782,14 +744,6 @@ class basic_value
    {
        assigner(this->local_date_, ld);
    }
-    template<typename Container>
-    basic_value(const local_date& ld, detail::region<Container> reg)
-        : type_(value_t::local_date),
-          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
-          comments_(region_info_->comments())
-    {
-        assigner(this->local_date_, ld);
-    }
    basic_value& operator=(const local_date& ld)
    {
        this->cleanup();
@@ -814,14 +768,6 @@ class basic_value
    {
        assigner(this->local_time_, lt);
    }
-    template<typename Container>
-    basic_value(const local_time& lt, detail::region<Container> reg)
-        : type_(value_t::local_time),
-          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
-          comments_(region_info_->comments())
-    {
-        assigner(this->local_time_, lt);
-    }
    basic_value(const local_time& lt, std::vector<std::string> comments)
        : type_(value_t::local_time),
          region_info_(std::make_shared<region_base>(region_base{})),
@@ -872,14 +818,6 @@ class basic_value
    {
        assigner(this->local_datetime_, ldt);
    }
-    template<typename Container>
-    basic_value(const local_datetime& ldt, detail::region<Container> reg)
-        : type_(value_t::local_datetime),
-          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
-          comments_(region_info_->comments())
-    {
-        assigner(this->local_datetime_, ldt);
-    }
    basic_value(const local_datetime& ldt, std::vector<std::string> comments)
        : type_(value_t::local_datetime),
          region_info_(std::make_shared<region_base>(region_base{})),
@@ -904,14 +842,6 @@ class basic_value
    {
        assigner(this->offset_datetime_, odt);
    }
-    template<typename Container>
-    basic_value(const offset_datetime& odt, detail::region<Container> reg)
-        : type_(value_t::offset_datetime),
-          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
-          comments_(region_info_->comments())
-    {
-        assigner(this->offset_datetime_, odt);
-    }
    basic_value(const offset_datetime& odt, std::vector<std::string> comments)
        : type_(value_t::offset_datetime),
          region_info_(std::make_shared<region_base>(region_base{})),
@@ -958,14 +888,6 @@ class basic_value
    {
        assigner(this->array_, ary);
    }
-    template<typename Container>
-    basic_value(const array_type& ary, detail::region<Container> reg)
-        : type_(value_t::array),
-          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
-          comments_(region_info_->comments())
-    {
-        assigner(this->array_, ary);
-    }
    basic_value(const array_type& ary, std::vector<std::string> comments)
        : type_(value_t::array),
          region_info_(std::make_shared<region_base>(region_base{})),
@@ -1079,14 +1001,6 @@ class basic_value
    {
        assigner(this->table_, tab);
    }
-    template<typename Container>
-    basic_value(const table_type& tab, detail::region<Container> reg)
-        : type_(value_t::table),
-          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
-          comments_(region_info_->comments())
-    {
-        assigner(this->table_, tab);
-    }
    basic_value(const table_type& tab, std::vector<std::string> comments)
        : type_(value_t::table),
          region_info_(std::make_shared<region_base>(region_base{})),
@@ -1216,6 +1130,93 @@ class basic_value
    }

    // for internal use ------------------------------------------------------
+    //
+    // Those constructors take detail::region that contains parse result.
+
+    template<typename Container>
+    basic_value(boolean b, detail::region<Container> reg)
+        : type_(value_t::boolean),
+          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
+          comments_(region_info_->comments())
+    {
+        assigner(this->boolean_, b);
+    }
+    template<typename T, typename Container, typename std::enable_if<
+        detail::conjunction<
+            std::is_integral<T>, detail::negation<std::is_same<T, boolean>>
+        >::value, std::nullptr_t>::type = nullptr>
+    basic_value(T i, detail::region<Container> reg)
+        : type_(value_t::integer),
+          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
+          comments_(region_info_->comments())
+    {
+        assigner(this->integer_, static_cast<integer>(i));
+    }
+    template<typename T, typename Container, typename std::enable_if<
+        std::is_floating_point<T>::value, std::nullptr_t>::type = nullptr>
+    basic_value(T f, detail::region<Container> reg)
+        : type_(value_t::floating),
+          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
+          comments_(region_info_->comments())
+    {
+        assigner(this->floating_, static_cast<floating>(f));
+    }
+    template<typename Container>
+    basic_value(toml::string s, detail::region<Container> reg)
+        : type_(value_t::string),
+          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
+          comments_(region_info_->comments())
+    {
+        assigner(this->string_, std::move(s));
+    }
+    template<typename Container>
+    basic_value(const local_date& ld, detail::region<Container> reg)
+        : type_(value_t::local_date),
+          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
+          comments_(region_info_->comments())
+    {
+        assigner(this->local_date_, ld);
+    }
+    template<typename Container>
+    basic_value(const local_time& lt, detail::region<Container> reg)
+        : type_(value_t::local_time),
+          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
+          comments_(region_info_->comments())
+    {
+        assigner(this->local_time_, lt);
+    }
+    template<typename Container>
+    basic_value(const local_datetime& ldt, detail::region<Container> reg)
+        : type_(value_t::local_datetime),
+          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
+          comments_(region_info_->comments())
+    {
+        assigner(this->local_datetime_, ldt);
+    }
+    template<typename Container>
+    basic_value(const offset_datetime& odt, detail::region<Container> reg)
+        : type_(value_t::offset_datetime),
+          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
+          comments_(region_info_->comments())
+    {
+        assigner(this->offset_datetime_, odt);
+    }
+    template<typename Container>
+    basic_value(const array_type& ary, detail::region<Container> reg)
+        : type_(value_t::array),
+          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
+          comments_(region_info_->comments())
+    {
+        assigner(this->array_, ary);
+    }
+    template<typename Container>
+    basic_value(const table_type& tab, detail::region<Container> reg)
+        : type_(value_t::table),
+          region_info_(std::make_shared<detail::region<Container>>(std::move(reg))),
+          comments_(region_info_->comments())
+    {
+        assigner(this->table_, tab);
+    }

    template<typename T, typename Container, typename std::enable_if<
        detail::is_exact_toml_type<T, value_type>::value,
@@ -1247,7 +1248,7 @@ class basic_value
    bool is_array()           const noexcept {return this->is(value_t::array          );}
    bool is_table()           const noexcept {return this->is(value_t::table          );}

-    value_t type() const {return type_;}
+    value_t type() const noexcept {return type_;}

    template<value_t T>
    typename detail::enum_to_type<T, value_type>::type&       cast() &
@@ -1579,6 +1580,14 @@ class basic_value
    {
        return this->as_table().at(k);
    }
+    value_type&       operator[](const key& k)
+    {
+        if(this->is_uninitialized())
+        {
+            *this = table_type{};
+        }
+        return this->as_table()[k];
+    }

    value_type&       at(const std::size_t idx)
    {
@@ -1589,6 +1598,110 @@ class basic_value
        return this->as_array().at(idx);
    }

+    value_type&       operator[](const std::size_t idx) noexcept
+    {
+        return this->as_array(std::nothrow)[idx];
+    }
+    value_type const& operator[](const std::size_t idx) const noexcept
+    {
+        return this->as_array(std::nothrow)[idx];
+    }
+
+    void push_back(const value_type& x)
+    {
+        if(this->type_ != value_t::array)
+        {
+            throw type_error(detail::format_underline(
+                "toml::value::push_back(value): bad_cast to array type", {
+                    {this->region_info_.get(),
+                     concat_to_string("the actual type is ", this->type_)}
+                }), this->location());
+        }
+        this->as_array(std::nothrow).push_back(x);
+        return;
+    }
+    void push_back(value_type&& x)
+    {
+        if(this->type_ != value_t::array)
+        {
+            throw type_error(detail::format_underline(
+                "toml::value::push_back(value): bad_cast to array type", {
+                    {this->region_info_.get(),
+                     concat_to_string("the actual type is ", this->type_)}
+                }), this->location());
+        }
+        this->as_array(std::nothrow).push_back(std::move(x));
+        return;
+    }
+
+    template<typename ... Ts>
+    value_type& emplace_back(Ts&& ... args)
+    {
+        if(this->type_ != value_t::array)
+        {
+            throw type_error(detail::format_underline(
+                "toml::value::emplace_back(value): bad_cast to array type", {
+                    {this->region_info_.get(),
+                     concat_to_string("the actual type is ", this->type_)}
+                }), this->location());
+        }
+        this->as_array(std::nothrow).emplace_back(std::forward<Ts>(args) ...);
+        return this->as_array(std::nothrow).back();
+    }
+
+    std::size_t size() const
+    {
+        switch(this->type_)
+        {
+            case value_t::array:
+            {
+                return this->as_array().size();
+            }
+            case value_t::table:
+            {
+                return this->as_table().size();
+            }
+            case value_t::string:
+            {
+                return this->as_string().str.size();
+            }
+            default:
+            {
+                throw type_error(detail::format_underline(
+                    "toml::value::size(): bad_cast to container types", {
+                        {this->region_info_.get(),
+                         concat_to_string("the actual type is ", this->type_)}
+                    }), this->location());
+            }
+        }
+    }
+
+    std::size_t count(const key_type& k) const
+    {
+        if(this->type_ != value_t::table)
+        {
+            throw type_error(detail::format_underline(
+                "toml::value::count(key): bad_cast to table type", {
+                    {this->region_info_.get(),
+                     concat_to_string("the actual type is ", this->type_)}
+                }), this->location());
+        }
+        return this->as_table().count(k);
+    }
+
+    bool contains(const key_type& k) const
+    {
+        if(this->type_ != value_t::table)
+        {
+            throw type_error(detail::format_underline(
+                "toml::value::contains(key): bad_cast to table type", {
+                    {this->region_info_.get(),
+                     concat_to_string("the actual type is ", this->type_)}
+                }), this->location());
+        }
+        return (this->as_table().count(k) != 0);
+    }
+
    source_location location() const
    {
        return source_location(this->region_info_.get());
@@ -1843,25 +1956,27 @@ operator>=(const basic_value<C, T, A>& lhs, const basic_value<C, T, A>& rhs)
 template<typename C, template<typename ...> class T, template<typename ...> class A>
 inline std::string format_error(const std::string& err_msg,
        const basic_value<C, T, A>& v, const std::string& comment,
-        std::vector<std::string> hints = {})
+        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>>{
            {std::addressof(detail::get_region(v)), comment}
-        }, std::move(hints));
+        }, std::move(hints), colorize);
 }

 template<typename C, template<typename ...> class T, template<typename ...> class A>
 inline std::string format_error(const std::string& err_msg,
        const toml::basic_value<C, T, A>& v1, const std::string& comment1,
        const toml::basic_value<C, T, A>& v2, const std::string& comment2,
-        std::vector<std::string> hints = {})
+        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>>{
            {std::addressof(detail::get_region(v1)), comment1},
            {std::addressof(detail::get_region(v2)), comment2}
-        }, std::move(hints));
+        }, std::move(hints), colorize);
 }

 template<typename C, template<typename ...> class T, template<typename ...> class A>
@@ -1869,14 +1984,15 @@ inline std::string format_error(const std::string& err_msg,
        const toml::basic_value<C, T, A>& v1, const std::string& comment1,
        const toml::basic_value<C, T, A>& v2, const std::string& comment2,
        const toml::basic_value<C, T, A>& v3, const std::string& comment3,
-        std::vector<std::string> hints = {})
+        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>>{
            {std::addressof(detail::get_region(v1)), comment1},
            {std::addressof(detail::get_region(v2)), comment2},
            {std::addressof(detail::get_region(v3)), comment3}
-        }, std::move(hints));
+        }, std::move(hints), colorize);
 }

 template<typename Visitor, typename C,
Author	SHA1	Message	Date
ToruNiina	ac1130f9f4	tag: update patch version v3.3.1	2020-02-16 22:02:40 +09:00
ToruNiina	d290c3b7e5	doc: add contributor to README	2020-02-14 19:25:41 +09:00
Toru Niina	e4140ac1fd	Merge pull request #102 from jwillikers/cmake_cache_variables Set CMake Standard Cache Variables. Fixes #101	2020-02-13 13:22:25 +09:00
Jordan Williams	ef33c10ba8	use cache variables for the CMake standard and extensions settings	2020-02-12 07:44:47 -06:00
Toru Niina	ced710bb4c	Merge pull request #100 from jwillikers/clang_warnings Silence Clang Warnings. Fixes #98 & #99	2020-02-12 13:37:58 +09:00
Jordan Williams	6b5944e839	fix -Wundef warnings	2020-02-11 06:30:18 -06:00
Jordan Williams	76cae8c057	enable -Wundef flag for tests	2020-02-11 06:25:10 -06:00
Jordan Williams	3930a44ccd	enable range-loop-analysis flag for tests	2020-02-11 06:17:54 -06:00
Jordan Williams	3b6417de00	fix clang range-loop-analysis warnings	2020-02-11 06:13:55 -06:00
ToruNiina	573a6f1d81	test: use JSON format_key to format a key in JSON The rule to format a basic string and a key is different. `"""` cannot be used with JSON keys. Also, toml key is basically not wrapped by `"`. So we need a function to format a key in JSON.	2020-02-06 01:28:37 +09:00
ToruNiina	f6a41d986c	feat: handle quotes in strings in the better way - if a basic string contains any double quote, make it multiline. - because 1 or 2 consecutive "s do not require escape sequence in it. - if a basic string will be sufficiently long, make it multiline. - if 3 consecutive "s appeared, insert backslash to break it down.	2020-02-05 22:42:10 +09:00
ToruNiina	16fc172b21	feat: check string length before adding newline In literal strings, only the first newline will be trimmed. ```toml str = ''' The first newline will be trimmed.''' ``` The previous code always adds this first-newline, but after this commit it checks the length of the string and adds newline if the string is sufficiently long.	2020-02-05 22:39:08 +09:00
ToruNiina	7d03eb489a	test: add test cases with quotes in ml-string some of these example strings are copied from toml-lang/toml:README.md and some are modified.	2020-02-04 22:37:11 +09:00
ToruNiina	0582e1535b	fix: handle edge-cases with quotes in ml-string See comments in the code for detail.	2020-02-04 22:36:39 +09:00
ToruNiina	d495df93a6	refactor: remove trailing whitespaces	2020-02-04 22:21:37 +09:00
ToruNiina	5ca3a3c262	refactor: change ifdef UNRELEASED_FEATURE region to eliminate dead code after returning from a function	2020-02-04 21:05:03 +09:00
ToruNiina	aa8d574dfe	chore: update minor version	2020-01-24 22:08:12 +09:00
ToruNiina	49fdb61731	refactor: add explicit to ctors of internal types	2020-01-24 15:58:24 +09:00
ToruNiina	b2bb21a473	doc: update year of copyright notice	2020-01-23 22:18:04 +09:00
ToruNiina	0c58549fc6	Merge branch 'master' of github.com:ToruNiina/toml11	2020-01-22 12:20:34 +09:00
ToruNiina	b7b5e847d3	ci: test with C++14, not only 11/17	2020-01-22 12:19:53 +09:00
ToruNiina	22d630fec1	feat: replace detail::stuff by std if possible	2020-01-20 12:18:05 +09:00
ToruNiina	f7bf341452	fix: add missing noexcept specifier	2020-01-19 21:06:10 +09:00
ToruNiina	0934d90f90	refactor: move ctors that are only used internally	2020-01-19 18:30:27 +09:00
ToruNiina	f2c8d0e279	refactor: add missing explicit to toml::exception	2020-01-19 17:51:24 +09:00
ToruNiina	8c7d83d985	Merge branch 'add-value-member-methods'	2020-01-17 20:30:26 +09:00
ToruNiina	5ce44adbdc	doc: add description about toml::value memfuns	2020-01-17 20:26:36 +09:00
ToruNiina	5c5b1320d0	test: add test for map/vector methods	2020-01-16 20:58:36 +09:00
ToruNiina	8b737dc21f	feat: add member methods to toml::value	2020-01-16 20:58:10 +09:00
ToruNiina	ee654b6c3f	chore: add -Werror when building test codes	2020-01-13 11:31:03 +09:00
ToruNiina	c59782d180	fix: remove useless conversions in the test codes	2020-01-13 11:29:17 +09:00
ToruNiina	9bef715ccd	fix: use u32 as a result of binary operation	2020-01-13 11:26:53 +09:00
ToruNiina	d2b1cf5123	refactor: just use a constructor to remove conversions	2020-01-13 11:26:29 +09:00
ToruNiina	9f92916d1d	fix: suppress -Wuseless-conversion `{integer} + 1` will automatically be an int, so static_cast<int>(a+1) will be useless conversion.	2020-01-13 11:24:48 +09:00
ToruNiina	666e4cf9dc	fix: suppress sign-conversion warnings	2020-01-13 00:46:21 +09:00
ToruNiina	cafee29c64	test: add some combinations of types in toml::find	2020-01-13 00:27:39 +09:00
ToruNiina	a7a2272b29	chore: turn more diagnostic flags on	2020-01-13 00:16:33 +09:00
ToruNiina	dc0bca2bb6	fix: update patch version ...	2020-01-12 23:18:03 +09:00
ToruNiina	490abe04fd	refactor: remove redundant template argument	2020-01-12 23:07:17 +09:00
ToruNiina	81ed4c0e9d	Merge branch 'master' of github.com:ToruNiina/toml11	2020-01-10 21:17:17 +09:00
ToruNiina	1b07baf184	doc: add toml::get specialization using ctor	2020-01-10 20:46:54 +09:00
ToruNiina	9073d52159	test: check get<foo> works with constructor	2020-01-10 20:39:56 +09:00
ToruNiina	55260654bf	feat: get user-defined value by constructor If a user-defined constructor has constructor(const toml::value&), then it should be convertible in `toml::get` and `toml::find`.	2020-01-10 20:38:52 +09:00
ToruNiina	aa6271af75	doc: update README	2020-01-09 01:40:05 +09:00
ToruNiina	c54a03f189	Merge branch 'master' into find-idx	2020-01-09 00:27:51 +09:00
ToruNiina	c153c0e8c3	ci: test with sanitizers	2020-01-08 23:28:17 +09:00
ToruNiina	1f90af8e67	ci: refactor list of env vars	2020-01-08 23:17:38 +09:00
ToruNiina	a0c5192b74	chore: add option to use sanitizers	2020-01-08 23:07:05 +09:00
ToruNiina	7f020f3f44	refactor: remove error prefix that will automatically be added in format_underline	2020-01-07 22:27:13 +09:00
ToruNiina	827b433389	Merge branch 'master' into find-idx	2020-01-07 22:13:15 +09:00
ToruNiina	b1827e6fca	test: check immutability of inline tables	2019-12-20 19:46:54 +09:00
ToruNiina	18f84088b4	perf: avoid tmp str construction while checking	2019-12-19 22:13:47 +09:00
ToruNiina	c199bd8b49	feat: enable to access the 1st char of region	2019-12-19 22:13:33 +09:00
ToruNiina	5b35c1a74e	fix: prohibit modification on inline table According to toml-lang/toml:36d3091b3 "Clarify that inline tables are immutable", check if it adds key-value pair to an inline table. This is one of the unreleased (after-0.5.0) toml feature. But this is marked as "Clarify", so TOML-lang intended that inline tables are immutable in all version.	2019-12-19 22:02:17 +09:00
ToruNiina	d3513c0f84	fix: fmt line num in err msg correctly	2019-12-17 19:35:26 +09:00
ToruNiina	8567f09cbf	chore: update version info in CMake	2019-12-13 20:25:52 +09:00
ToruNiina	a6d24b02d5	Merge branch 'colorize-err-msg'	2019-12-13 20:23:27 +09:00
ToruNiina	08bf5ffbdf	doc: put screenshot to colorize-error-message	2019-12-13 17:28:43 +09:00
ToruNiina	a945bd6eac	ci: pass TOML11_COLORIZE_ERROR_MESSAGE on CircleCI	2019-12-13 16:47:33 +09:00
ToruNiina	f4ac286b0f	doc: add description about format_error	2019-12-12 21:31:21 +09:00
ToruNiina	f31dc6ba37	doc: add example of hints in an error message	2019-12-12 18:09:13 +09:00
ToruNiina	fecd50dfeb	doc: add contributors	2019-12-12 18:02:16 +09:00
ToruNiina	d48d454a61	doc: modify README a bit	2019-12-12 17:55:20 +09:00
ToruNiina	4688c235f5	refactor: rename internal macro value	2019-12-12 17:38:29 +09:00
ToruNiina	5c146857a3	Merge branch 'master' into colorize-err-msg	2019-12-11 22:49:38 +09:00
ToruNiina	bc51699415	Merge branch 'bracket-operator'	2019-12-11 19:36:21 +09:00
Toru Niina	8b923d56e9	Merge pull request #96 from kenichiice/icpc_warning2 Suppress warning on Intel C++ Compiler	2019-12-11 18:30:44 +09:00
OGAWA KenIchi	3190c1da9f	fix: suppress warning on Intel C++ Compiler	2019-12-11 17:47:16 +09:00
ToruNiina	a41dc08025	doc: add document of operator[]	2019-12-10 20:06:01 +09:00
ToruNiina	0c084b3a5c	test: add test: accessing via bracket operator	2019-12-10 00:08:40 +09:00
ToruNiina	8fbeaabfd9	feat: add operator[] to access table/array	2019-12-10 00:00:05 +09:00
ToruNiina	331de4ea5d	fix: use datetime info while getting time offset to convert offset_datetime to system_clock::time_point.	2019-12-08 22:44:12 +11:00
ToruNiina	b246f5ac5c	fix: combine date and time to convert loc datetime Normally DST begins at A.M. 3 or 4. If we re-use conversion operator of local_date and local_time independently, the conversion fails if it is the day when DST begins or ends. Since local_date considers the time is 00:00 A.M. and local_time does not consider DST because it does not have any date information. We need to consider both date and time information at the same time to convert it correctly.	2019-12-08 22:38:49 +11:00
ToruNiina	89714fb24b	doc: note about local timezone and datetime	2019-12-06 21:15:31 +09:00
ToruNiina	62c01f9826	fix: consider timezone correctly explicitly set tm.tm_isdst = 0 and use UTC offset	2019-12-06 20:57:51 +09:00
ToruNiina	5a8d368927	feat: add thread-safe detail::gmtime_s	2019-12-06 20:33:15 +09:00
ToruNiina	28519f5712	doc: add colorize section to README	2019-12-02 17:08:00 +09:00
Toru Niina	63fdbd25cf	Merge pull request #95 from blockparty-sh/unused-variable-warning Suppress unused variable warning	2019-11-23 12:59:21 +09:00
blockparty	6d41a1adb9	Suppress unused variable warning	2019-11-22 05:59:55 -06:00
Toru Niina	26a09b2f65	Merge pull request #93 from blockparty-sh/fix_compile_error Check if features are defined	2019-11-21 21:57:26 +09:00
blockparty	7e62dad6dc	Check if features are defined	2019-11-21 05:51:31 -06:00
ToruNiina	2fd466a3c3	fix: skip only the prefix, keep spaces	2019-11-14 15:32:17 +09:00
ToruNiina	6f7539dc6a	fix: deduplicate [error] prefix in the messages	2019-11-14 15:31:27 +09:00
ToruNiina	f290390c63	fix: consider the no-space cases like [error]:	2019-11-13 18:14:42 +09:00
ToruNiina	571baa2c26	refactor: remove nocolor:: operations since color can be on-off at runtime	2019-11-13 18:08:31 +09:00
ToruNiina	bbe33e87d9	feat: detect [error] prefix duplication	2019-11-13 18:05:37 +09:00
ToruNiina	4c5076f263	feat: add runtime colorize flag	2019-11-13 18:01:47 +09:00
ToruNiina	d47174954f	feat: colorize user-defined msg by format_error	2019-11-13 18:00:55 +09:00
ToruNiina	821eb9632b	feat: add a macro-dependent constant	2019-11-13 17:59:47 +09:00
ToruNiina	af116991b6	fix: remove overlapping [error] sign	2019-11-13 17:35:23 +09:00
ToruNiina	87bebbc37d	feat: put color to the internal error messages	2019-11-13 17:35:05 +09:00
ToruNiina	c2d0351e69	feat: add (ANSI) terminal colorize operators	2019-11-13 17:24:51 +09:00
ToruNiina	1526b9feee	Merge branch 'heterogeneous-array'	2019-11-09 11:03:18 +09:00
ToruNiina	281206dcc6	doc: add heterogeneous array to README	2019-11-08 19:03:16 +09:00
ToruNiina	adf8fa9234	fix: fix typos in an error message in toml::get when converting toml::value to std::tuple	2019-11-08 16:12:18 +09:00
ToruNiina	0a66be3257	test: add test for parsing heterogeneous array this test case is activated only if TOML11_USE_UNRELEASED_TOML_FEATURES is defined.	2019-11-08 15:52:31 +09:00
ToruNiina	160537360c	test: deactivate error check for hetero array if TOML11_USE_UNRELEASED_TOML_FEATURES is activated.	2019-11-08 15:39:14 +09:00
ToruNiina	9af2d65417	feat: allow heterogenous array if TOML11_USE_UNRELEASED_TOML_FEATURES is activated. In TOML v0.5.0, heterogenous arrays are not allowed. But after some discussions in toml-lang/toml, it is decided to allow it in the next release (toml-lang/toml/pull/676). To support it, disable type check in parse_array function.	2019-11-08 15:36:58 +09:00
ToruNiina	429763377f	Merge branch 'add-src-loc-to-exception' #87	2019-11-02 13:42:14 +09:00
ToruNiina	c774beb79a	doc: write about source_location in exceptions	2019-11-02 13:03:50 +09:00
ToruNiina	8240fffeca	Merge branch 'master' into add-src-loc-to-exception	2019-11-02 12:53:16 +09:00
ToruNiina	047611764c	fix: silly typo	2019-11-01 21:15:20 +09:00
ToruNiina	bc3eb9d967	feat: add src_loc to all the exceptions including internal_error.	2019-11-01 21:14:33 +09:00
ToruNiina	6862264bde	feat: use the first char as the top-level region A bit related to #89	2019-11-01 20:47:25 +09:00
ToruNiina	2ee69fc420	fix: improve error messages about strings a bit	2019-11-01 13:34:15 +09:00
ToruNiina	6a15e8360f	refactor: remove redundant namespace specifier	2019-10-31 23:13:49 +09:00
ToruNiina	b4c6d26842	Merge origin/add-src-loc-to-exception #87	2019-10-31 23:11:53 +09:00
ToruNiina	41eb1d6887	feat: pass source_location to exception	2019-10-31 22:23:31 +09:00
ToruNiina	3ca712a8da	feat: check line_num before converting it to int	2019-10-31 22:21:24 +09:00
ToruNiina	8e589ff4d7	feat: add source_location to (syntax_\|type_)error	2019-10-31 22:04:16 +09:00
ToruNiina	56812114c3	refactor: simplify inclusion dependencies	2019-10-31 21:58:28 +09:00
ToruNiina	f98615d0df	fix: check file content is empty or not	2019-10-30 16:49:49 +09:00
ToruNiina	37769e28f0	fix #88 : check if input is null-terminated or not	2019-10-30 16:33:22 +09:00
ToruNiina	2acdec00aa	Merge branch 'refactor-ci'	2019-10-15 23:13:44 +09:00
ToruNiina	354cfc979a	ci: cache brew directory	2019-10-15 23:13:11 +09:00
ToruNiina	3dc3b001ff	ci: update clang 3.x from 3.7 to 3.9	2019-10-15 23:13:06 +09:00
ToruNiina	ea24a91f4c	ci: use `sourceline`	2019-10-15 20:32:09 +09:00
ToruNiina	5bba73a8ca	ci: use addons in OS X on Travis.CI	2019-10-15 20:27:27 +09:00
ToruNiina	54eced6c82	test: add test for toml::string::operator+=	2019-10-09 21:51:33 +09:00
ToruNiina	258e62f8f3	feat: add operator+= to toml::string	2019-10-09 21:51:14 +09:00
ToruNiina	06086a9ff7	doc: add note about value::at	2019-10-09 21:09:38 +09:00
ToruNiina	b4b35ea33e	feat: allow 0-prefix exponent if the flag is on If unreleased feature is activated, zero-prefixes in an exponent part of a floating point is allowed. If the flag TOML11_UNRELEASED_TOML_FEATURES is turned on, we don't need to check whether there is a zero prefix in the exponent part that is formatted by a standard library.	2019-10-08 23:23:53 +09:00
ToruNiina	d7b4d104d3	refactor: reduce checking; just check once	2019-10-08 23:15:03 +09:00
ToruNiina	1148d01c70	Merge branch 'master' into find-idx	2019-10-07 11:11:08 +09:00
ToruNiina	17d78553ff	test: add test cases for find(v, idx) - check whether find(v, idx) throws - check find(v, ks...) works with both indices and strings	2019-10-03 15:48:04 +09:00
ToruNiina	4c12dad51f	feat: add find<T>(value, idx) for arrays (#79 )	2019-10-03 15:27:25 +09:00