Update build to 0.7.0.

Update travis config to use updated versions of OS and compilers.
This fixes the linux/gcc error building Google Test with gcc 4.7: https://travis-ci.org/github/jbeder/yaml-cpp/jobs/668233706
2021-07-10 10:49:09 -05:00 · 2020-04-07 22:27:32 -05:00
393 changed files with 24452 additions and 22981 deletions
--- a/.bazelignore
+++ b/.bazelignore
@ -1 +0,0 @@
-test/gtest-1.11.0
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@ -1,11 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "monthly"
-    groups:
-      github-actions:
-        patterns:
-          - "*"
-
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@ -1,138 +0,0 @@
-name: Github PR
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-  workflow_dispatch:
-permissions: read-all
-defaults:
-  run:
-    shell: bash
-jobs:
-  cmake-build:
-      strategy:
-        fail-fast: false
-        matrix:
-          os: [ubuntu-latest, windows-latest, macos-latest]
-          cxx_standard: [11, 17, 20]
-          build: [static, shared]
-          googletest: [build, system]
-          generator: ["Default Generator", "MinGW Makefiles"]
-          exclude:
-          - os: macos-latest
-            build: shared
-          - os: macos-latest
-            generator: "MinGW Makefiles"
-          - os: ubuntu-latest
-            generator: "MinGW Makefiles"
-          - os: macos-latest
-            googletest: system
-          - os: windows-latest
-            googletest: system
-      env:
-        YAML_BUILD_SHARED_LIBS: ${{ matrix.build == 'shared' && 'ON' || 'OFF' }}
-        YAML_USE_SYSTEM_GTEST: ${{ matrix.googletest == 'system' && 'ON' || 'OFF' }}
-        CMAKE_GENERATOR: >-
-          ${{format(matrix.generator != 'Default Generator' && '-G "{0}"' || '', matrix.generator)}}
-        CMAKE_INSTALL_PREFIX: "${{ github.workspace }}/install-prefix"
-        CMAKE_BUILD_TYPE: Debug
-        CMAKE_CXX_FLAGS_DEBUG: ${{ matrix.googletest == 'build' && '-g -D_GLIBCXX_DEBUG -D_GLIBCXX_DEBUG_PEDANTIC' || '-g' }} 
-      runs-on: ${{ matrix.os }}
-      steps:
-
-        - uses: awalsh128/cache-apt-pkgs-action@latest
-          if: matrix.os == 'ubuntu-latest'
-          with:
-            packages: googletest libgmock-dev libgtest-dev
-            version: 1.0
-
-        - uses: actions/checkout@v4
-
-        - name: Configure
-          run: |
-            cmake \
-              ${{ env.CMAKE_GENERATOR }} \
-              -S "${{ github.workspace }}" \
-              -B build \
-              -D CMAKE_CXX_STANDARD=${{ matrix.cxx_standard }} \
-              -D CMAKE_INSTALL_PREFIX="${{ env.CMAKE_INSTALL_PREFIX }}" \
-              -D CMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} \
-              -D CMAKE_CXX_FLAGS_DEBUG="${{ env.CMAKE_CXX_FLAGS_DEBUG }}" \
-              -D YAML_BUILD_SHARED_LIBS=${{ env.YAML_BUILD_SHARED_LIBS }} \
-              -D YAML_USE_SYSTEM_GTEST=${{ env.YAML_USE_SYSTEM_GTEST }} \
-              -D YAML_CPP_BUILD_TESTS=ON
-
-        - name: Build
-          run: |
-            cmake \
-              --build build \
-              --config ${{ env.CMAKE_BUILD_TYPE }} \
-              --verbose \
-              --parallel
-
-        - name: Run Tests
-          shell: bash
-          run: |
-            ctest \
-              --test-dir build \
-              --build-config ${{ env.CMAKE_BUILD_TYPE }} \
-              --output-on-failure \
-              --verbose
-
-        - name: Install
-          run: cmake --install build --config ${{ env.CMAKE_BUILD_TYPE }}
-
-        - name: Configure CMake package test
-          run: |
-            cmake \
-              ${{ env.CMAKE_GENERATOR }} \
-              -S "${{ github.workspace }}/test/cmake" \
-              -B consumer-build \
-              -D CMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} \
-              -D CMAKE_PREFIX_PATH="${{ env.CMAKE_INSTALL_PREFIX }}"
-
-        - name: Build CMake package test
-          run: |
-            cmake \
-              --build consumer-build \
-              --config ${{ env.CMAKE_BUILD_TYPE }} \
-              --verbose
-
-  bazel-build:
-      strategy:
-        matrix:
-          os: [ubuntu-latest, windows-latest, macos-latest]
-      runs-on: ${{ matrix.os }}
-      steps:
-        - uses: actions/checkout@v4
-
-        - name: Build
-          run: |
-            cd "${{ github.workspace }}"
-            bazel build :all
-
-        - name: Test
-          run: |
-            cd "${{ github.workspace }}"
-            bazel test test
-
-  bzlmod-build:
-      strategy:
-        matrix:
-          os: [ubuntu-latest, windows-latest, macos-latest]
-      runs-on: ${{ matrix.os }}
-      steps:
-        - uses: actions/checkout@v4
-
-        - name: Build
-          shell: bash
-          run: |
-            cd "${{ github.workspace }}"
-            bazel build --enable_bzlmod :all
-
-        - name: Test
-          shell: bash
-          run: |
-            cd "${{ github.workspace }}"
-            bazel test --enable_bzlmod test
--- a/.github/workflows/bzlmod-archive.yml
+++ b/.github/workflows/bzlmod-archive.yml
@ -1,19 +0,0 @@
-name: Bazel Release
-
-on:
-  release:
-    types: [published]
-
-jobs:
-  # A release archive is required for bzlmod
-  # See: https://blog.bazel.build/2023/02/15/github-archive-checksum.html
-  bazel-release-archive:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    steps:
-      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      - run: git archive $GITHUB_REF -o "yaml-cpp-${GITHUB_REF:10}.tar.gz"
-      - run: gh release upload ${GITHUB_REF:10} "yaml-cpp-${GITHUB_REF:10}.tar.gz"
-        env:
-          GH_TOKEN: ${{ github.token }}
--- a/.travis.yml
+++ b/.travis.yml
@ -0,0 +1,37 @@
+language: c++
+
+matrix:
+  include:
+    - os: linux
+      compiler: gcc
+    - os: osx
+      compiler: clang
+    - os: osx
+      compiler: gcc
+env:
+  - CTEST_OUTPUT_ON_FAILURE=1
+
+before_script:
+  - mkdir build
+  - cd build
+  - cmake ..
+  - cd ..
+script:
+  - cmake --build build
+  - cmake --build build --target test
+
+addons:
+  apt:
+    sources:
+    - ubuntu-toolchain-r-test
+    - llvm-toolchain-precise-3.9
+    packages:
+    - g++-4.9
+    - clang-3.9
+    update: true
+  homebrew:
+    packages:
+    - ccache
+    - gcc@4.9
+    - llvm@4
+    update: true
--- a/BUILD.bazel
+++ b/BUILD.bazel
@ -1,9 +1,3 @@
-yaml_cpp_defines = select({
-    # On Windows, ensure static linking is used.
-    "@platforms//os:windows": ["YAML_CPP_STATIC_DEFINE", "YAML_CPP_NO_CONTRIB"],
-    "//conditions:default": [],
-})
-
 cc_library(
    name = "yaml-cpp_internal",
    visibility = ["//:__subpackages__"],
@ -17,5 +11,4 @@ cc_library(
    includes = ["include"],
    hdrs = glob(["include/**/*.h"]),
    srcs = glob(["src/**/*.cpp", "src/**/*.h"]),
-    defines = yaml_cpp_defines,
 )
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,19 +1,6 @@
-# 3.5 is actually available almost everywhere, but this a good minimum.
-# 3.14 as the upper policy limit avoids CMake deprecation warnings.
-cmake_minimum_required(VERSION 3.4...3.14)
-
-# enable MSVC_RUNTIME_LIBRARY target property
-# see https://cmake.org/cmake/help/latest/policy/CMP0091.html
-if(POLICY CMP0091)
-  cmake_policy(SET CMP0091 NEW)
-endif()
-
-project(YAML_CPP VERSION 0.8.0 LANGUAGES CXX)
-
-set(YAML_CPP_MAIN_PROJECT OFF)
-if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-  set(YAML_CPP_MAIN_PROJECT ON)
-endif()
+# 3.5 is actually available almost everywhere, but this a good minimum
+cmake_minimum_required(VERSION 3.4)
+project(YAML_CPP VERSION 0.7.0 LANGUAGES CXX)

 include(CMakePackageConfigHelpers)
 include(CMakeDependentOption)
@ -21,44 +8,36 @@ include(CheckCXXCompilerFlag)
 include(GNUInstallDirs)
 include(CTest)

+find_program(YAML_CPP_CLANG_FORMAT_EXE NAMES clang-format)
+
 option(YAML_CPP_BUILD_CONTRIB "Enable yaml-cpp contrib in library" ON)
 option(YAML_CPP_BUILD_TOOLS "Enable parse tools" ON)
 option(YAML_BUILD_SHARED_LIBS "Build yaml-cpp shared library" ${BUILD_SHARED_LIBS})
-option(YAML_CPP_INSTALL "Enable generation of yaml-cpp install targets" ${YAML_CPP_MAIN_PROJECT})
-option(YAML_CPP_FORMAT_SOURCE "Format source" ${YAML_CPP_MAIN_PROJECT})
-option(YAML_CPP_DISABLE_UNINSTALL  "Disable uninstallation of yaml-cpp" OFF)
-option(YAML_USE_SYSTEM_GTEST "Use system googletest if found" OFF)
-option(YAML_ENABLE_PIC "Use Position-Independent Code " ON)

 cmake_dependent_option(YAML_CPP_BUILD_TESTS
-  "Enable yaml-cpp tests" OFF
-  "BUILD_TESTING;YAML_CPP_MAIN_PROJECT" OFF)
+  "Enable yaml-cpp tests" ON
+  "BUILD_TESTING;CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR" OFF)
+cmake_dependent_option(YAML_CPP_INSTALL
+  "Enable generation of yaml-cpp install targets" ON
+  "CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR" OFF)
 cmake_dependent_option(YAML_MSVC_SHARED_RT
  "MSVC: Build yaml-cpp with shared runtime libs (/MD)" ON
-  "CMAKE_SYSTEM_NAME MATCHES Windows" OFF)
-set(YAML_CPP_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/yaml-cpp"
-  CACHE STRING "Path to install the CMake package to")
- 
-if (YAML_CPP_FORMAT_SOURCE)
-    find_program(YAML_CPP_CLANG_FORMAT_EXE NAMES clang-format)
-endif()
+  "MSVC" OFF)

+set(yaml-cpp-type STATIC)
+set(yaml-cpp-label-postfix "static")
 if (YAML_BUILD_SHARED_LIBS)
  set(yaml-cpp-type SHARED)
  set(yaml-cpp-label-postfix "shared")
-else()
-  set(yaml-cpp-type STATIC)
-  set(yaml-cpp-label-postfix "static")
 endif()

 set(build-shared $<BOOL:${YAML_BUILD_SHARED_LIBS}>)
 set(build-windows-dll $<AND:$<BOOL:${CMAKE_HOST_WIN32}>,${build-shared}>)
 set(not-msvc $<NOT:$<CXX_COMPILER_ID:MSVC>>)
-set(msvc-shared_rt $<BOOL:${YAML_MSVC_SHARED_RT}>)

 if (NOT DEFINED CMAKE_MSVC_RUNTIME_LIBRARY)
  set(CMAKE_MSVC_RUNTIME_LIBRARY
-    MultiThreaded$<$<CONFIG:Debug>:Debug>$<${msvc-shared_rt}:DLL>)
+    MultiThreaded$<$<CONFIG:Debug>:Debug>$<${build-shared}:DLL>)
 endif()

 set(contrib-pattern "src/contrib/*.cpp")
@ -91,10 +70,6 @@ set_property(TARGET yaml-cpp
  PROPERTY
    CXX_STANDARD_REQUIRED ON)

-if (NOT YAML_BUILD_SHARED_LIBS)
-      set_property(TARGET yaml-cpp PROPERTY POSITION_INDEPENDENT_CODE ${YAML_ENABLE_PIC})
-endif()
-
 target_include_directories(yaml-cpp
  PUBLIC
    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
@ -108,15 +83,11 @@ if (NOT DEFINED CMAKE_CXX_STANDARD)
      CXX_STANDARD 11)
 endif()

-if(YAML_CPP_MAIN_PROJECT)
-  target_compile_options(yaml-cpp
-    PRIVATE
-      $<${not-msvc}:-Wall -Wextra -Wshadow -Weffc++ -Wno-long-long>
-      $<${not-msvc}:-pedantic -pedantic-errors>)
-endif()
-
 target_compile_options(yaml-cpp
  PRIVATE
+    $<${not-msvc}:-Wall -Wextra -Wshadow -Weffc++ -Wno-long-long>
+    $<${not-msvc}:-pedantic -pedantic-errors>
+
    $<$<AND:${backport-msvc-runtime},${msvc-rt-mtd-static}>:-MTd>
    $<$<AND:${backport-msvc-runtime},${msvc-rt-mt-static}>:-MT>
    $<$<AND:${backport-msvc-runtime},${msvc-rt-mtd-dll}>:-MDd>
@ -129,8 +100,6 @@ target_compile_options(yaml-cpp
    $<$<CXX_COMPILER_ID:MSVC>:/W3 /wd4127 /wd4355>)

 target_compile_definitions(yaml-cpp
-  PUBLIC
-    $<$<NOT:$<BOOL:${YAML_BUILD_SHARED_LIBS}>>:YAML_CPP_STATIC_DEFINE>
  PRIVATE
    $<${build-windows-dll}:${PROJECT_NAME}_DLL>
    $<$<NOT:$<BOOL:${YAML_CPP_BUILD_CONTRIB}>>:YAML_CPP_NO_CONTRIB>)
@ -140,23 +109,16 @@ target_sources(yaml-cpp
    $<$<BOOL:${YAML_CPP_BUILD_CONTRIB}>:${yaml-cpp-contrib-sources}>
    ${yaml-cpp-sources})

-if (NOT DEFINED CMAKE_DEBUG_POSTFIX)
-  set(CMAKE_DEBUG_POSTFIX "d")
-endif()
-
 set_target_properties(yaml-cpp PROPERTIES
  VERSION "${PROJECT_VERSION}"
  SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}"
  PROJECT_LABEL "yaml-cpp ${yaml-cpp-label-postfix}"
-  DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}")
+  DEBUG_POSTFIX d)

-set(EXPORT_TARGETS yaml-cpp::yaml-cpp)
 configure_package_config_file(
  "${PROJECT_SOURCE_DIR}/yaml-cpp-config.cmake.in"
  "${PROJECT_BINARY_DIR}/yaml-cpp-config.cmake"
-  INSTALL_DESTINATION "${YAML_CPP_INSTALL_CMAKEDIR}"
-  PATH_VARS CMAKE_INSTALL_INCLUDEDIR CMAKE_INSTALL_LIBDIR)
-unset(EXPORT_TARGETS)
+  INSTALL_DESTINATION "${CMAKE_INSTALL_DATADIR}/cmake/yaml-cpp")

 write_basic_package_version_file(
  "${PROJECT_BINARY_DIR}/yaml-cpp-config-version.cmake"
@ -165,48 +127,35 @@ write_basic_package_version_file(
 configure_file(yaml-cpp.pc.in yaml-cpp.pc @ONLY)

 if (YAML_CPP_INSTALL)
-  install(TARGETS yaml-cpp
+	install(TARGETS yaml-cpp
    EXPORT yaml-cpp-targets
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-  install(DIRECTORY ${PROJECT_SOURCE_DIR}/include/
+	install(DIRECTORY ${PROJECT_SOURCE_DIR}/include/
    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
-                FILES_MATCHING PATTERN "*.h")
+		FILES_MATCHING PATTERN "*.h")
  install(EXPORT yaml-cpp-targets
-    NAMESPACE yaml-cpp::
-    DESTINATION "${YAML_CPP_INSTALL_CMAKEDIR}")
-  install(FILES
-      "${PROJECT_BINARY_DIR}/yaml-cpp-config.cmake"
-      "${PROJECT_BINARY_DIR}/yaml-cpp-config-version.cmake"
-    DESTINATION "${YAML_CPP_INSTALL_CMAKEDIR}")
+    DESTINATION "${CMAKE_INSTALL_DATADIR}/cmake/yaml-cpp")
+	install(FILES
+		"${PROJECT_BINARY_DIR}/yaml-cpp-config.cmake"
+		"${PROJECT_BINARY_DIR}/yaml-cpp-config-version.cmake"
+    DESTINATION "${CMAKE_INSTALL_DATADIR}/cmake/yaml-cpp")
  install(FILES "${PROJECT_BINARY_DIR}/yaml-cpp.pc"
-    DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+    DESTINATION ${CMAKE_INSTALL_DATADIR}/pkgconfig)
 endif()

 if(YAML_CPP_BUILD_TESTS)
-  add_subdirectory(test)
+	add_subdirectory(test)
 endif()

 if(YAML_CPP_BUILD_TOOLS)
-  add_subdirectory(util)
+	add_subdirectory(util)
 endif()

-if (YAML_CPP_FORMAT_SOURCE AND YAML_CPP_CLANG_FORMAT_EXE)
+if (YAML_CPP_CLANG_FORMAT_EXE)
  add_custom_target(format
    COMMAND clang-format --style=file -i $<TARGET_PROPERTY:yaml-cpp,SOURCES>
-    COMMAND_EXPAND_LISTS
    COMMENT "Running clang-format"
    VERBATIM)
 endif()
-
-# uninstall target
-if(YAML_CPP_INSTALL AND NOT YAML_CPP_DISABLE_UNINSTALL AND NOT TARGET uninstall)
-  configure_file(
-    "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
-    "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
-    IMMEDIATE @ONLY)
-
-  add_custom_target(uninstall
-    COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
-endif()
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -17,7 +17,7 @@ Commit messages should be in the imperative mood, as described in the [Git contr

 # Tests

-Please verify the tests pass by running the target `test/yaml-cpp-tests`.
+Please verify the tests pass by running the target `tests/run_tests`.

 If you are adding functionality, add tests accordingly.

--- a/MODULE.bazel
+++ b/MODULE.bazel
@ -1,14 +0,0 @@
-"""
-yaml-cpp is a YAML parser and emitter in c++ matching the YAML specification.
-"""
-
-module(
-    name = "yaml-cpp",
-    compatibility_level = 1,
-    version = "0.8.0",
-)
-
-bazel_dep(name = "platforms", version = "0.0.7")
-bazel_dep(name = "rules_cc", version = "0.0.8")
-
-bazel_dep(name = "googletest", version = "1.14.0", dev_dependency = True)
--- a/README.md
+++ b/README.md
@ -1,80 +1,50 @@
-# yaml-cpp ![Build Status](https://github.com/jbeder/yaml-cpp/actions/workflows/build.yml/badge.svg) [![Documentation](https://codedocs.xyz/jbeder/yaml-cpp.svg)](https://codedocs.xyz/jbeder/yaml-cpp/)
+# yaml-cpp [![Build Status](https://travis-ci.org/jbeder/yaml-cpp.svg?branch=master)](https://travis-ci.org/jbeder/yaml-cpp) [![Documentation](https://codedocs.xyz/jbeder/yaml-cpp.svg)](https://codedocs.xyz/jbeder/yaml-cpp/)

-`yaml-cpp` is a [YAML](http://www.yaml.org/) parser and emitter in C++ matching the [YAML 1.2 spec](http://www.yaml.org/spec/1.2/spec.html).
+yaml-cpp is a [YAML](http://www.yaml.org/) parser and emitter in C++ matching the [YAML 1.2 spec](http://www.yaml.org/spec/1.2/spec.html).

-## Usage
+To get a feel for how it can be used, see the [Tutorial](https://github.com/jbeder/yaml-cpp/wiki/Tutorial) or [How to Emit YAML](https://github.com/jbeder/yaml-cpp/wiki/How-To-Emit-YAML). For the old API (version < 0.5.0), see [How To Parse A Document](https://github.com/jbeder/yaml-cpp/wiki/How-To-Parse-A-Document-(Old-API)).

-See [Tutorial](https://github.com/jbeder/yaml-cpp/wiki/Tutorial) and [How to Emit YAML](https://github.com/jbeder/yaml-cpp/wiki/How-To-Emit-YAML) for reference. For the old API (until 0.5.0), see [How To Parse A Document](https://github.com/jbeder/yaml-cpp/wiki/How-To-Parse-A-Document-(Old-API)).
-
-## Any Problems?
+# Problems? #

 If you find a bug, post an [issue](https://github.com/jbeder/yaml-cpp/issues)! If you have questions about how to use yaml-cpp, please post it on http://stackoverflow.com and tag it [`yaml-cpp`](http://stackoverflow.com/questions/tagged/yaml-cpp).

-## How to Build
+# How to Build #

-`yaml-cpp` uses [CMake](http://www.cmake.org) to support cross-platform building. Install [CMake](http://www.cmake.org) _(Resources -> Download)_ before proceeding. The basic steps to build are:
+yaml-cpp uses [CMake](http://www.cmake.org) to support cross-platform building. The basic steps to build are:

-**Note:** If you don't use the provided installer for your platform, make sure that you add `CMake`'s bin folder to your path.
+1. Download and install [CMake](http://www.cmake.org) (Resources -> Download).

-#### 1. Navigate into the source directory, create build folder and run `CMake`:
+**Note:** If you don't use the provided installer for your platform, make sure that you add CMake's bin folder to your path.

-```sh
+2. Navigate into the source directory, and type:
+
+```
 mkdir build
 cd build
-cmake [-G generator] [-DYAML_BUILD_SHARED_LIBS=on|OFF] ..
 ```

-  * The `generator` option is the build system you'd like to use. Run `cmake` without arguments to see a full list of available generators.
-    * On Windows, you might use "Visual Studio 12 2013" (VS 2013 32-bits), or "Visual Studio 14 2015 Win64" (VS 2015 64-bits).
-    * On OS X, you might use "Xcode".
-    * On a UNIX-like system, omit the option (for a Makefile).
+3. Run CMake. The basic syntax is:

-  * `yaml-cpp` builds a static library by default, you may want to build a shared library by specifying `-DYAML_BUILD_SHARED_LIBS=ON`.
+```
+cmake [-G generator] [-DYAML_BUILD_SHARED_LIBS=ON|OFF] ..
+```

-  * [Debug mode of the GNU standard C++
-    library](https://gcc.gnu.org/onlinedocs/libstdc++/manual/debug_mode.html)
-    can be used when both `yaml-cpp` and client code is compiled with the
-    `_GLIBCXX_DEBUG` flag (e.g. by calling CMake with `-D
-    CMAKE_CXX_FLAGS_DEBUG='-g -D_GLIBCXX_DEBUG'` option).
+  * The `generator` is whatever type of build system you'd like to use. To see a full list of generators on your platform, just run `cmake` (with no arguments). For example:
+    * On Windows, you might use "Visual Studio 12 2013" to generate a Visual Studio 2013 solution or "Visual Studio 14 2015 Win64" to generate a 64-bit Visual Studio 2015 solution.
+    * On OS X, you might use "Xcode" to generate an Xcode project
+    * On a UNIX-y system, simply omit the option to generate a makefile

-    Note that for `yaml-cpp` unit tests to run successfully, the _GoogleTest_
-    library also must be built with this flag, i.e. the system one cannot be
-    used (the _YAML_USE_SYSTEM_GTEST_ CMake option must be _OFF_, which is the
-    default).
+  * yaml-cpp defaults to building a static library, but you may build a shared library by specifying `-DYAML_BUILD_SHARED_LIBS=ON`.

  * For more options on customizing the build, see the [CMakeLists.txt](https://github.com/jbeder/yaml-cpp/blob/master/CMakeLists.txt) file.

-#### 2. Build it!
-  * The command you'll need to run depends on the generator you chose earlier.
+4. Build it!

-**Note:** To clean up, just remove the `build` directory.
+5. To clean up, just remove the `build` directory.

-## How to Integrate it within your project using CMake
+# Recent Release #

-You can use for example FetchContent :
-
-```cmake
-include(FetchContent)
-
-FetchContent_Declare(
-  yaml-cpp
-  GIT_REPOSITORY https://github.com/jbeder/yaml-cpp.git
-  GIT_TAG <tag_name> # Can be a tag (yaml-cpp-x.x.x), a commit hash, or a branch name (master)
-)
-FetchContent_GetProperties(yaml-cpp)
-
-if(NOT yaml-cpp_POPULATED)
-  message(STATUS "Fetching yaml-cpp...")
-  FetchContent_Populate(yaml-cpp)
-  add_subdirectory(${yaml-cpp_SOURCE_DIR} ${yaml-cpp_BINARY_DIR})
-endif()
-
-target_link_libraries(YOUR_LIBRARY PUBLIC yaml-cpp::yaml-cpp) # The library or executable that require yaml-cpp library
-```
-
-## Recent Releases
-
-[yaml-cpp 0.6.0](https://github.com/jbeder/yaml-cpp/releases/tag/yaml-cpp-0.6.0) released! This release requires C++11, and no longer depends on Boost.
+[yaml-cpp 0.6.0](https://github.com/jbeder/yaml-cpp/releases/tag/yaml-cpp-0.6.0) has been released! This release requires C++11, and no longer depends on Boost.

 [yaml-cpp 0.3.0](https://github.com/jbeder/yaml-cpp/releases/tag/release-0.3.0) is still available if you want the old API.

@ -83,10 +53,3 @@ target_link_libraries(YOUR_LIBRARY PUBLIC yaml-cpp::yaml-cpp) # The library or e
 # API Documentation 

 The autogenerated API reference is hosted on [CodeDocs](https://codedocs.xyz/jbeder/yaml-cpp/index.html)
-
-# Third Party Integrations
-
-The following projects are not officially supported:
-
- [Qt wrapper](https://gist.github.com/brcha/d392b2fe5f1e427cc8a6)
- [UnrealEngine Wrapper](https://github.com/jwindgassen/UnrealYAML)
--- a/SECURITY.md
+++ b/SECURITY.md
@ -1,13 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-Security updates are applied only to the latest release.
-
-## Reporting a Vulnerability
-
-If you have discovered a security vulnerability in this project, please report it privately. **Do not disclose it as a public issue.** This gives us time to work with you to fix the issue before public exposure, reducing the chance that the exploit will be used before a patch is released.
-
-Please disclose it at [security advisory](https://github.com/jbeder/yaml-cpp/security/advisories/new).
-
-This project is maintained by a team of volunteers on a reasonable-effort basis. As such, vulnerabilities will be disclosed in a best effort base.
--- a/cmake_uninstall.cmake.in
+++ b/cmake_uninstall.cmake.in
@ -1,21 +0,0 @@
-if(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt")
-  message(FATAL_ERROR "Cannot find install manifest: @CMAKE_BINARY_DIR@/install_manifest.txt")
-endif()
-
-file(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files)
-string(REGEX REPLACE "\n" ";" files "${files}")
-foreach(file ${files})
-  message(STATUS "Uninstalling $ENV{DESTDIR}${file}")
-  if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
-    exec_program(
-      "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
-      OUTPUT_VARIABLE rm_out
-      RETURN_VALUE rm_retval
-      )
-    if(NOT "${rm_retval}" STREQUAL 0)
-      message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}")
-    endif()
-  else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
-    message(STATUS "File $ENV{DESTDIR}${file} does not exist.")
-  endif()
-endforeach()
--- a/docs/Breaking-Changes.md
+++ b/docs/Breaking-Changes.md
@ -1,52 +0,0 @@
-# The following is a list of breaking changes to yaml-cpp, by version #
-
-# New API #
-
-## HEAD ##
-
-  * Throws an exception when trying to parse a negative number as an unsigned integer.
-  * Supports the `as<int8_t>`/`as<uint8_t>`, which throws an exception when the value exceeds the range of `int8_t`/`uint8_t`.
-
-## 0.6.0 ##
-
-  * Requires C++11.
-
-## 0.5.3 ##
-
-_none_
-
-## 0.5.2 ##
-
-_none_
-
-## 0.5.1 ##
-
-  * `Node::clear` was replaced by `Node::reset`, which takes an optional node, similar to smart pointers.
-
-## 0.5.0 ##
-
-Initial version of the new API.
-
-# Old API #
-
-## 0.3.0 ##
-
-_none_
-
-## 0.2.7 ##
-
-  * `YAML::Binary` now takes `const unsigned char *` for the binary data (instead of `const char *`).
-
-## 0.2.6 ##
-
-  * `Node::GetType()` is now `Node::Type()`, and returns an enum `NodeType::value`, where:
-> > ` struct NodeType { enum value { Null, Scalar, Sequence, Map }; }; `
-  * `Node::GetTag()` is now `Node::Tag()`
-  * `Node::Identity()` is removed, and `Node::IsAlias()` and `Node::IsReferenced()` have been merged into `Node::IsAliased()`. The reason: there's no reason to distinguish an alias node from its anchor - whichever happens to be emitted first will be the anchor, and the rest will be aliases.
-  * `Node::Read<T>` is now `Node::to<T>`. This wasn't a documented function, so it shouldn't break anything.
-  * `Node`'s comparison operators (for example, `operator == (const Node&, const T&)`) have all been removed. These weren't documented either (they were just used for the tests), so this shouldn't break anything either.
-  * The emitter no longer produces the document start by default - if you want it, you can supply it with the manipulator `YAML::BeginDoc`.
-
-## 0.2.5 ##
-
-This wiki was started with v0.2.5.
--- a/docs/How-To-Emit-YAML.md
+++ b/docs/How-To-Emit-YAML.md
@ -1,224 +0,0 @@
-## Contents ##
-
-
-
-# Basic Emitting #
-
-The model for emitting YAML is `std::ostream` manipulators. A `YAML::Emitter` objects acts as an output stream, and its output can be retrieved through the `c_str()` function (as in `std::string`). For a simple example:
-
-```cpp
-#include "yaml-cpp/yaml.h"
-
-int main()
-{
-   YAML::Emitter out;
-   out << "Hello, World!";
-   
-   std::cout << "Here's the output YAML:\n" << out.c_str(); // prints "Hello, World!"
-   return 0;
-}
-```
-
-# Simple Lists and Maps #
-
-A `YAML::Emitter` object acts as a state machine, and we use manipulators to move it between states. Here's a simple sequence:
-
-```cpp
-YAML::Emitter out;
-out << YAML::BeginSeq;
-out << "eggs";
-out << "bread";
-out << "milk";
-out << YAML::EndSeq;
-```
-
-produces
-
-```yaml
- eggs
- bread
- milk
-```
-
-A simple map:
-
-```cpp
-YAML::Emitter out;
-out << YAML::BeginMap;
-out << YAML::Key << "name";
-out << YAML::Value << "Ryan Braun";
-out << YAML::Key << "position";
-out << YAML::Value << "LF";
-out << YAML::EndMap;
-```
-
-produces
-
-```yaml
-name: Ryan Braun
-position: LF
-```
-
-These elements can, of course, be nested:
-
-```cpp
-YAML::Emitter out;
-out << YAML::BeginMap;
-out << YAML::Key << "name";
-out << YAML::Value << "Barack Obama";
-out << YAML::Key << "children";
-out << YAML::Value << YAML::BeginSeq << "Sasha" << "Malia" << YAML::EndSeq;
-out << YAML::EndMap;
-```
-
-produces
-
-```yaml
-name: Barack Obama
-children:
-  - Sasha
-  - Malia
-```
-
-# Using Manipulators #
-
-To deviate from standard formatting, you can use manipulators to modify the output format. For example,
-
-```cpp
-YAML::Emitter out;
-out << YAML::Literal << "A\n B\n  C";
-```
-
-produces
-
-```yaml
-|
-A
- B
-  C
-```
-and
-
-```cpp
-YAML::Emitter out;
-out << YAML::Flow;
-out << YAML::BeginSeq << 2 << 3 << 5 << 7 << 11 << YAML::EndSeq;
-```
-
-produces
-
-```yaml
-[2, 3, 5, 7, 11]
-```
-
-Comments act like manipulators:
-
-```cpp
-YAML::Emitter out;
-out << YAML::BeginMap;
-out << YAML::Key << "method";
-out << YAML::Value << "least squares";
-out << YAML::Comment("should we change this method?");
-out << YAML::EndMap;
-```
-
-produces
-
-```yaml
-method: least squares  # should we change this method?
-```
-
-And so do aliases/anchors:
-
-```cpp
-YAML::Emitter out;
-out << YAML::BeginSeq;
-out << YAML::Anchor("fred");
-out << YAML::BeginMap;
-out << YAML::Key << "name" << YAML::Value << "Fred";
-out << YAML::Key << "age" << YAML::Value << "42";
-out << YAML::EndMap;
-out << YAML::Alias("fred");
-out << YAML::EndSeq;
-```
-
-produces
-
-```yaml
- &fred
-  name: Fred
-  age: 42
- *fred
-```
-
-# STL Containers, and Other Overloads #
-We overload `operator <<` for `std::vector`, `std::list`, and `std::map`, so you can write stuff like:
-
-```cpp
-std::vector <int> squares = {1, 4, 9, 16};
-
-std::map <std::string, int> ages = {{"Daniel", 26}, {"Jesse", 24}};
-
-YAML::Emitter out;
-out << YAML::BeginSeq;
-out << YAML::Flow << squares;
-out << ages;
-out << YAML::EndSeq;
-```
-
-produces
-
-```yaml
- [1, 4, 9, 16]
-
-  Daniel: 26
-  Jesse: 24
-```
-
-Of course, you can overload `operator <<` for your own types:
-
-```cpp
-struct Vec3 { int x; int y; int z; };
-YAML::Emitter& operator << (YAML::Emitter& out, const Vec3& v) {
-	out << YAML::Flow;
-	out << YAML::BeginSeq << v.x << v.y << v.z << YAML::EndSeq;
-	return out;
-}
-```
-and it'll play nicely with everything else.
-
-# Using Existing Nodes #
-
-We also overload `operator << ` for `YAML::Node`s in both APIs, so you can output existing Nodes. Of course, Nodes in the old API are read-only, so it's tricky to emit them if you want to modify them. So use the new API!
-
-# Output Encoding #
-
-The output is always UTF-8. By default, yaml-cpp will output as much as it can without escaping any characters. If you want to restrict the output to ASCII, use the manipulator `YAML::EscapeNonAscii`:
-
-```cpp
-emitter.SetOutputCharset(YAML::EscapeNonAscii);
-```
-
-# Lifetime of Manipulators #
-
-Manipulators affect the **next** output item in the stream. If that item is a `BeginSeq` or `BeginMap`, the manipulator lasts until the corresponding `EndSeq` or `EndMap`. (However, within that sequence or map, you can override the manipulator locally, etc.; in effect, there's a "manipulator stack" behind the scenes.)
-
-If you want to permanently change a setting, there are global setters corresponding to each manipulator, e.g.:
-
-```cpp
-YAML::Emitter out;
-out.SetIndent(4);
-out.SetMapStyle(YAML::Flow);
-```
-
-# When Something Goes Wrong #
-
-If something goes wrong when you're emitting a document, it must be something like forgetting a `YAML::EndSeq`, or a misplaced `YAML::Key`. In this case, emitting silently fails (no more output is emitted) and an error flag is set. For example:
-
-```cpp
-YAML::Emitter out;
-assert(out.good());
-out << YAML::Key;
-assert(!out.good());
-std::cout << "Emitter error: " << out.GetLastError() << "\n";
-```
--- a/docs/How-To-Parse-A-Document-(Old-API).md
+++ b/docs/How-To-Parse-A-Document-(Old-API).md
@ -1,265 +0,0 @@
-_The following describes the old API. For the new API, see the [Tutorial](https://github.com/jbeder/yaml-cpp/wiki/Tutorial)._
-
-## Contents ##
-
-
-# Basic Parsing #
-
-The parser accepts streams, not file names, so you need to first load the file. Since a YAML file can contain many documents, you can grab them one-by-one. A simple way to parse a YAML file might be:
-
-```
-#include <fstream>
-#include "yaml-cpp/yaml.h"
-
-int main()
-{
-    std::ifstream fin("test.yaml");
-    YAML::Parser parser(fin);
-
-    YAML::Node doc;
-    while(parser.GetNextDocument(doc)) {
-       // ...
-    }
-
-    return 0;
-}
-```
-
-# Reading From the Document #
-
-Suppose we have a document consisting only of a scalar. We can read that scalar like this:
-
-```
-YAML::Node doc;    // let's say we've already parsed this document
-std::string scalar;
-doc >> scalar;
-std::cout << "That scalar was: " << scalar << std::endl;
-```
-
-How about sequences? Let's say our document now consists only of a sequences of scalars. We can use an iterator:
-
-```
-YAML::Node doc;    // already parsed
-for(YAML::Iterator it=doc.begin();it!=doc.end();++it) {
-    std::string scalar;
-    *it >> scalar;
-    std::cout << "Found scalar: " << scalar << std::endl;
-}
-```
-
-... or we can just loop through:
-
-```
-YAML::Node doc;    // already parsed
-for(unsigned i=0;i<doc.size();i++) {
-    std::string scalar;
-    doc[i] >> scalar;
-    std::cout << "Found scalar: " << scalar << std::endl;
-}
-```
-
-And finally maps. For now, let's say our document is a map with all keys/values being scalars. Again, we can iterate:
-
-```
-YAML::Node doc;    // already parsed
-for(YAML::Iterator it=doc.begin();it!=doc.end();++it) {
-    std::string key, value;
-    it.first() >> key;
-    it.second() >> value;
-    std::cout << "Key: " << key << ", value: " << value << std::endl;
-}
-```
-
-Note that dereferencing a map iterator is undefined; instead, use the `first` and `second` methods to get the key and value nodes, respectively.
-
-Alternatively, we can pick off the values one-by-one, if we know the keys:
-
-```
-YAML::Node doc;    // already parsed
-std::string name;
-doc["name"] >> name;
-int age;
-doc["age"] >> age;
-std::cout << "Found entry with name '" << name << "' and age '" << age << "'\n";
-```
-
-One thing to be keep in mind: reading a map by key (as immediately above) requires looping through all entries until we find the right key, which is an O(n) operation. So if you're reading the entire map this way, it'll be O(n^2). For small n, this isn't a big deal, but I wouldn't recommend reading maps with a very large number of entries (>100, say) this way.
-
-## Optional Keys ##
-
-If you try to access a key that doesn't exist, `yaml-cpp` throws an exception (see [When Something Goes Wrong](https://github.com/jbeder/yaml-cpp/wiki/How-To-Parse-A-Document-(Old-API)#When_Something_Goes_Wrong). If you have optional keys, it's often easier to use `FindValue` instead of `operator[]`:
-
-```
-YAML::Node doc;    // already parsed
-if(const YAML::Node *pName = doc.FindValue("name")) {
-    std::string name;
-    *pName >> name;
-    std::cout << "Key 'name' exists, with value '" << name << "'\n";
-} else {
-    std::cout << "Key 'name' doesn't exist\n";
-}
-```
-
-# Getting More Complicated #
-
-The above three methods can be combined to read from an arbitrary document. But we can make life a lot easier. Suppose we're reading 3-vectors (i.e., vectors with three components), so we've got a structure looking like this:
-
-```
-struct Vec3 {
-    float x, y, z;
-};
-```
-
-We can read this in one operation by overloading the extraction (>>) operator:
-
-```
-void operator >> (const YAML::Node& node, Vec3& v)
-{
-    node[0] >> v.x;
-    node[1] >> v.y;
-    node[2] >> v.z;
-}
-
-// now it's a piece of cake to read it
-YAML::Node doc;    // already parsed
-Vec3 v;
-doc >> v;
-std::cout << "Here's the vector: (" << v.x << ", " << v.y << ", " << v.z << ")\n";
-```
-
-# A Complete Example #
-
-Here's a complete example of how to parse a complex YAML file:
-
-`monsters.yaml`
-
-```
- name: Ogre
-  position: [0, 5, 0]
-  powers:
-    - name: Club
-      damage: 10
-    - name: Fist
-      damage: 8
- name: Dragon
-  position: [1, 0, 10]
-  powers:
-    - name: Fire Breath
-      damage: 25
-    - name: Claws
-      damage: 15
- name: Wizard
-  position: [5, -3, 0]
-  powers:
-    - name: Acid Rain
-      damage: 50
-    - name: Staff
-      damage: 3
-```
-
-`main.cpp`
-
-```
-#include "yaml-cpp/yaml.h"
-#include <iostream>
-#include <fstream>
-#include <string>
-#include <vector>
-
-// our data types
-struct Vec3 {
-   float x, y, z;
-};
-
-struct Power {
-   std::string name;
-   int damage;
-};
-
-struct Monster {
-   std::string name;
-   Vec3 position;
-   std::vector <Power> powers;
-};
-
-// now the extraction operators for these types
-void operator >> (const YAML::Node& node, Vec3& v) {
-   node[0] >> v.x;
-   node[1] >> v.y;
-   node[2] >> v.z;
-}
-
-void operator >> (const YAML::Node& node, Power& power) {
-   node["name"] >> power.name;
-   node["damage"] >> power.damage;
-}
-
-void operator >> (const YAML::Node& node, Monster& monster) {
-   node["name"] >> monster.name;
-   node["position"] >> monster.position;
-   const YAML::Node& powers = node["powers"];
-   for(unsigned i=0;i<powers.size();i++) {
-      Power power;
-      powers[i] >> power;
-      monster.powers.push_back(power);
-   }
-}
-
-int main()
-{
-   std::ifstream fin("monsters.yaml");
-   YAML::Parser parser(fin);
-   YAML::Node doc;
-   parser.GetNextDocument(doc);
-   for(unsigned i=0;i<doc.size();i++) {
-      Monster monster;
-      doc[i] >> monster;
-      std::cout << monster.name << "\n";
-   }
-
-   return 0;
-}
-```
-
-# When Something Goes Wrong #
-
-... we throw an exception (all exceptions are derived from `YAML::Exception`). If there's a parsing exception (i.e., a malformed YAML document), we throw a `YAML::ParserException`:
-
-```
-try {
-    std::ifstream fin("test.yaml");
-    YAML::Parser parser(fin);
-    YAML::Node doc;
-    parser.GetNextDocument(doc);
-    // do stuff
-} catch(YAML::ParserException& e) {
-    std::cout << e.what() << "\n";
-}
-```
-
-If you make a programming error (say, trying to read a scalar from a sequence node, or grabbing a key that doesn't exist), we throw some kind of `YAML::RepresentationException`. To prevent this, you can check what kind of node something is:
-
-```
-    YAML::Node node;
-    YAML::NodeType::value type = node.Type();  // should be:
-                                               // YAML::NodeType::Null
-                                               // YAML::NodeType::Scalar
-                                               // YAML::NodeType::Sequence
-                                               // YAML::NodeType::Map
-```
-
-# Note about copying `YAML::Node` #
-
-Currently `YAML::Node` is non-copyable, so you need to do something like
-
-```
-    const YAML::Node& node = doc["whatever"];
-```
-
-This is intended behavior. If you want to copy a node, use the `Clone` function:
-
-```
-    std::auto_ptr<YAML::Node> pCopy = myOtherNode.Clone();
-```
-
-The intent is that if you'd like to keep a `YAML::Node` around for longer than the document will stay in scope, you can clone it and store it as long as you like.
--- a/docs/Strings.md
+++ b/docs/Strings.md
@ -1,18 +0,0 @@
-# Encodings and `yaml-cpp` #
-
-`yaml-cpp` will parse any file as specified by the [YAML 1.2 spec](http://www.yaml.org/spec/1.2/spec.html#id2570322). Internally, it stores all strings in UTF-8, and representation is done with UTF-8. This means that in
-
-```
-std::string str;
-node >> str;
-```
-
-`str` will be UTF-8. Similarly, if you're accessing a map by string key, you need to pass the key in UTF-8. If your application uses a different encoding, you need to convert to and from UTF-8 to work with `yaml-cpp`. (It's possible we'll add some small conversion functions, but for now it's restricted.)
-
---
-
-For convenience, Richard Weeks has kindly provided a google gadget that converts Unicode to a string literal. It's a Google Gadget, so unfortunately it does not work on GitHub. Patches welcome to port it to a usable format here:
-
-```
-<wiki:gadget url="http://hosting.gmodules.com/ig/gadgets/file/111180078345548400783/c-style-utf8-encoder.xml"/>
-```
--- a/docs/Tutorial.md
+++ b/docs/Tutorial.md
@ -1,201 +0,0 @@
-# Introduction #
-
-A typical example, loading a configuration file, might look like this:
-
-```cpp
-YAML::Node config = YAML::LoadFile("config.yaml");
-
-if (config["lastLogin"]) {
-  std::cout << "Last logged in: " << config["lastLogin"].as<DateTime>() << "\n";
-}
-
-const std::string username = config["username"].as<std::string>();
-const std::string password = config["password"].as<std::string>();
-login(username, password);
-config["lastLogin"] = getCurrentDateTime();
-
-std::ofstream fout("config.yaml");
-fout << config;
-```
-
-# Basic Parsing and Node Editing #
-
-All nodes in a YAML document (including the root) are represented by `YAML::Node`. You can check what kind it is:
-
-```cpp
-YAML::Node node = YAML::Load("[1, 2, 3]");
-assert(node.Type() == YAML::NodeType::Sequence);
-assert(node.IsSequence());  // a shortcut!
-```
-
-Collection nodes (sequences and maps) act somewhat like STL vectors and maps:
-
-```cpp
-YAML::Node primes = YAML::Load("[2, 3, 5, 7, 11]");
-for (std::size_t i=0;i<primes.size();i++) {
-  std::cout << primes[i].as<int>() << "\n";
-}
-// or:
-for (YAML::const_iterator it=primes.begin();it!=primes.end();++it) {
-  std::cout << it->as<int>() << "\n";
-}
-
-primes.push_back(13);
-assert(primes.size() == 6);
-```
-
-and
-
-```cpp
-YAML::Node lineup = YAML::Load("{1B: Prince Fielder, 2B: Rickie Weeks, LF: Ryan Braun}");
-for(YAML::const_iterator it=lineup.begin();it!=lineup.end();++it) {
-  std::cout << "Playing at " << it->first.as<std::string>() << " is " << it->second.as<std::string>() << "\n";
-}
-
-lineup["RF"] = "Corey Hart";
-lineup["C"] = "Jonathan Lucroy";
-assert(lineup.size() == 5);
-```
-
-Querying for keys does **not** create them automatically (this makes handling optional map entries very easy)
-
-```cpp
-YAML::Node node = YAML::Load("{name: Brewers, city: Milwaukee}");
-if (node["name"]) {
-  std::cout << node["name"].as<std::string>() << "\n";
-}
-if (node["mascot"]) {
-  std::cout << node["mascot"].as<std::string>() << "\n";
-}
-assert(node.size() == 2); // the previous call didn't create a node
-```
-
-If you're not sure what kind of data you're getting, you can query the type of a node:
-
-```cpp
-switch (node.Type()) {
-  case Null: // ...
-  case Scalar: // ...
-  case Sequence: // ...
-  case Map: // ...
-  case Undefined: // ...
-}
-```
-
-or ask directly whether it's a particular type, e.g.:
-
-```cpp
-if (node.IsSequence()) {
-  // ...
-}
-```
-
-# Building Nodes #
-
-You can build `YAML::Node` from scratch:
-
-```cpp
-YAML::Node node;  // starts out as null
-node["key"] = "value";  // it now is a map node
-node["seq"].push_back("first element");  // node["seq"] automatically becomes a sequence
-node["seq"].push_back("second element");
-
-node["mirror"] = node["seq"][0];  // this creates an alias
-node["seq"][0] = "1st element";  // this also changes node["mirror"]
-node["mirror"] = "element #1";  // and this changes node["seq"][0] - they're really the "same" node
-
-node["self"] = node;  // you can even create self-aliases
-node[node["mirror"]] = node["seq"];  // and strange loops :)
-```
-
-The above node is now:
-
-```yaml
-&1
-key: value
-&2 seq: [&3 "element #1", second element]
-mirror: *3
-self: *1
-*3 : *2
-```
-
-# How Sequences Turn Into Maps #
-
-Sequences can be turned into maps by asking for non-integer keys. For example,
-
-```cpp
-YAML::Node node  = YAML::Load("[1, 2, 3]");
-node[1] = 5;  // still a sequence, [1, 5, 3]
-node.push_back(-3) // still a sequence, [1, 5, 3, -3]
-node["key"] = "value"; // now it's a map! {0: 1, 1: 5, 2: 3, 3: -3, key: value}
-```
-
-Indexing a sequence node by an index that's not in its range will _usually_ turn it into a map, but if the index is one past the end of the sequence, then the sequence will grow by one to accommodate it. (That's the **only** exception to this rule.) For example,
-
-```cpp
-YAML::Node node = YAML::Load("[1, 2, 3]");
-node[3] = 4; // still a sequence, [1, 2, 3, 4]
-node[10] = 10;  // now it's a map! {0: 1, 1: 2, 2: 3, 3: 4, 10: 10}
-```
-
-# Converting To/From Native Data Types #
-
-Yaml-cpp has built-in conversion to and from most built-in data types, as well as `std::vector`, `std::list`, and `std::map`. The following examples demonstrate when those conversions are used:
-
-```cpp
-YAML::Node node = YAML::Load("{pi: 3.14159, [0, 1]: integers}");
-
-// this needs the conversion from Node to double
-double pi = node["pi"].as<double>();
-
-// this needs the conversion from double to Node
-node["e"] = 2.71828;
-
-// this needs the conversion from Node to std::vector<int> (*not* the other way around!)
-std::vector<int> v;
-v.push_back(0);
-v.push_back(1);
-std::string str = node[v].as<std::string>();
-```
-
-To use yaml-cpp with your own data types, you need to specialize the YAML::convert<> template class. For example, suppose you had a simple `Vec3` class:
-
-```cpp
-struct Vec3 { double x, y, z; /* etc - make sure you have overloaded operator== */ };
-```
-
-You could write
-
-```cpp
-namespace YAML {
-template<>
-struct convert<Vec3> {
-  static Node encode(const Vec3& rhs) {
-    Node node;
-    node.push_back(rhs.x);
-    node.push_back(rhs.y);
-    node.push_back(rhs.z);
-    return node;
-  }
-
-  static bool decode(const Node& node, Vec3& rhs) {
-    if(!node.IsSequence() || node.size() != 3) {
-      return false;
-    }
-
-    rhs.x = node[0].as<double>();
-    rhs.y = node[1].as<double>();
-    rhs.z = node[2].as<double>();
-    return true;
-  }
-};
-}
-```
-
-Then you could use `Vec3` wherever you could use any other type:
-
-```cpp
-YAML::Node node = YAML::Load("start: [1, 3, 0]");
-Vec3 v = node["start"].as<Vec3>();
-node["end"] = Vec3(2, -1, 0);
-```
--- a/docs/_config.yml
+++ b/docs/_config.yml
@ -1 +0,0 @@
-theme: jekyll-theme-slate
--- a/docs/index.md
+++ b/docs/index.md
@ -1 +0,0 @@
-To learn how to use the library, see the [Tutorial](https://github.com/jbeder/yaml-cpp/wiki/Tutorial) and [How To Emit YAML](https://github.com/jbeder/yaml-cpp/wiki/How-To-Emit-YAML)
--- a/include/yaml-cpp/depthguard.h
+++ b/include/yaml-cpp/depthguard.h
@ -1,77 +0,0 @@
-#ifndef DEPTH_GUARD_H_00000000000000000000000000000000000000000000000000000000
-#define DEPTH_GUARD_H_00000000000000000000000000000000000000000000000000000000
-
-#if defined(_MSC_VER) ||                                            \
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
-#pragma once
-#endif
-
-#include "exceptions.h"
-
-namespace YAML {
-
-/**
- * @brief The DeepRecursion class
- *  An exception class which is thrown by DepthGuard. Ideally it should be
- * a member of DepthGuard. However, DepthGuard is a templated class which means
- * that any catch points would then need to know the template parameters. It is
- * simpler for clients to not have to know at the catch point what was the
- * maximum depth.
- */
-class DeepRecursion : public ParserException {
-public:
-  virtual ~DeepRecursion() = default;
-
-  DeepRecursion(int depth, const Mark& mark_, const std::string& msg_);
-
-  // Returns the recursion depth when the exception was thrown
-  int depth() const {
-    return m_depth;
-  }
-
-private:
-  int m_depth = 0;
-};
-
-/**
- * @brief The DepthGuard class
- *  DepthGuard takes a reference to an integer. It increments the integer upon
- * construction of DepthGuard and decrements the integer upon destruction.
- *
- * If the integer would be incremented past max_depth, then an exception is
- * thrown. This is ideally geared toward guarding against deep recursion.
- *
- * @param max_depth
- *  compile-time configurable maximum depth.
- */
-template <int max_depth = 2000>
-class DepthGuard final {
-public:
-  DepthGuard(int & depth_, const Mark& mark_, const std::string& msg_) : m_depth(depth_) {
-    ++m_depth;
-    if ( max_depth <= m_depth ) {
-        throw DeepRecursion{m_depth, mark_, msg_};
-    }
-  }
-
-  DepthGuard(const DepthGuard & copy_ctor) = delete;
-  DepthGuard(DepthGuard && move_ctor) = delete;
-  DepthGuard & operator=(const DepthGuard & copy_assign) = delete;
-  DepthGuard & operator=(DepthGuard && move_assign) = delete;
-
-  ~DepthGuard() {
-    --m_depth;
-  }
-
-  int current_depth() const {
-    return m_depth;
-  }
-
-private:
-    int & m_depth;
-};
-
-} // namespace YAML
-
-#endif // DEPTH_GUARD_H_00000000000000000000000000000000000000000000000000000000
--- a/include/yaml-cpp/dll.h
+++ b/include/yaml-cpp/dll.h
@ -1,61 +1,33 @@
 #ifndef DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

-// Definition YAML_CPP_STATIC_DEFINE using to building YAML-CPP as static
-// library (definition created by CMake or defined manually)
-
-// Definition yaml_cpp_EXPORTS using to building YAML-CPP as dll/so library
-// (definition created by CMake or defined manually)
-
-#ifdef YAML_CPP_STATIC_DEFINE
-#  define YAML_CPP_API
-#  define YAML_CPP_NO_EXPORT
-#else
-#  if defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__)
-#    ifndef YAML_CPP_API
-#      ifdef yaml_cpp_EXPORTS
-         /* We are building this library */
-#        pragma message( "Defining YAML_CPP_API for DLL export" )
-#        define YAML_CPP_API __declspec(dllexport)
-#      else
-         /* We are using this library */
-#        pragma message( "Defining YAML_CPP_API for DLL import" )
-#        define YAML_CPP_API __declspec(dllimport)
-#      endif
-#    endif
-#    ifndef YAML_CPP_NO_EXPORT
-#      define YAML_CPP_NO_EXPORT
-#    endif
-#  else /* No _MSC_VER */
-#    ifndef YAML_CPP_API
-#      ifdef yaml_cpp_EXPORTS
-         /* We are building this library */
-#        define YAML_CPP_API __attribute__((visibility("default")))
-#      else
-         /* We are using this library */
-#        define YAML_CPP_API __attribute__((visibility("default")))
-#      endif
-#    endif
-#    ifndef YAML_CPP_NO_EXPORT
-#      define YAML_CPP_NO_EXPORT __attribute__((visibility("hidden")))
-#    endif
-#  endif /* _MSC_VER */
-#endif   /* YAML_CPP_STATIC_DEFINE */
-
-#ifndef YAML_CPP_DEPRECATED
-#  ifdef _MSC_VER
-#    define YAML_CPP_DEPRECATED __declspec(deprecated)
-#  else
-#    define YAML_CPP_DEPRECATED __attribute__ ((__deprecated__))
-#  endif
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
 #endif

-#ifndef YAML_CPP_DEPRECATED_EXPORT
-#  define YAML_CPP_DEPRECATED_EXPORT YAML_CPP_API YAML_CPP_DEPRECATED
-#endif
+// The following ifdef block is the standard way of creating macros which make
+// exporting from a DLL simpler. All files within this DLL are compiled with the
+// yaml_cpp_EXPORTS symbol defined on the command line. This symbol should not
+// be defined on any project that uses this DLL. This way any other project
+// whose source files include this file see YAML_CPP_API functions as being
+// imported from a DLL, whereas this DLL sees symbols defined with this macro as
+// being exported.
+#undef YAML_CPP_API

-#ifndef YAML_CPP_DEPRECATED_NO_EXPORT
-#  define YAML_CPP_DEPRECATED_NO_EXPORT YAML_CPP_NO_EXPORT YAML_CPP_DEPRECATED
-#endif
+#ifdef YAML_CPP_DLL      // Using or Building YAML-CPP DLL (definition defined
+                         // manually)
+#ifdef yaml_cpp_EXPORTS  // Building YAML-CPP DLL (definition created by CMake
+                         // or defined manually)
+//	#pragma message( "Defining YAML_CPP_API for DLL export" )
+#define YAML_CPP_API __declspec(dllexport)
+#else  // yaml_cpp_EXPORTS
+//	#pragma message( "Defining YAML_CPP_API for DLL import" )
+#define YAML_CPP_API __declspec(dllimport)
+#endif  // yaml_cpp_EXPORTS
+#else   // YAML_CPP_DLL
+#define YAML_CPP_API
+#endif  // YAML_CPP_DLL

-#endif /* DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 */
+#endif  // DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/include/yaml-cpp/emitfromevents.h
+++ b/include/yaml-cpp/emitfromevents.h
@ -23,7 +23,6 @@ class Emitter;
 class EmitFromEvents : public EventHandler {
 public:
  EmitFromEvents(Emitter& emitter);
-  ~EmitFromEvents() override = default;

  void OnDocumentStart(const Mark& mark) override;
  void OnDocumentEnd() override;
--- a/include/yaml-cpp/emitter.h
+++ b/include/yaml-cpp/emitter.h
@ -50,7 +50,6 @@ class YAML_CPP_API Emitter {
  bool SetOutputCharset(EMITTER_MANIP value);
  bool SetStringFormat(EMITTER_MANIP value);
  bool SetBoolFormat(EMITTER_MANIP value);
-  bool SetNullFormat(EMITTER_MANIP value);
  bool SetIntBase(EMITTER_MANIP value);
  bool SetSeqFormat(EMITTER_MANIP value);
  bool SetMapFormat(EMITTER_MANIP value);
@ -59,7 +58,6 @@ class YAML_CPP_API Emitter {
  bool SetPostCommentIndent(std::size_t n);
  bool SetFloatPrecision(std::size_t n);
  bool SetDoublePrecision(std::size_t n);
-  void RestoreGlobalModifiedSettings();

  // local setters
  Emitter& SetLocalValue(EMITTER_MANIP value);
@ -125,7 +123,6 @@ class YAML_CPP_API Emitter {
  void SpaceOrIndentTo(bool requireSpace, std::size_t indent);

  const char* ComputeFullBoolName(bool b) const;
-  const char* ComputeNullName() const;
  bool CanEmitNewline() const;

 private:
--- a/include/yaml-cpp/emittermanip.h
+++ b/include/yaml-cpp/emittermanip.h
@ -19,7 +19,6 @@ enum EMITTER_MANIP {
  // output character set
  EmitNonAscii,
  EscapeNonAscii,
-  EscapeAsJson,

  // string manipulators
  // Auto, // duplicate
@ -27,12 +26,6 @@ enum EMITTER_MANIP {
  DoubleQuoted,
  Literal,

-  // null manipulators
-  LowerNull,
-  UpperNull,
-  CamelNull,
-  TildeNull,
-
  // bool manipulators
  YesNoBool,      // yes, no
  TrueFalseBool,  // true, false
--- a/include/yaml-cpp/exceptions.h
+++ b/include/yaml-cpp/exceptions.h
@ -65,7 +65,7 @@ const char* const ZERO_INDENT_IN_BLOCK =
 const char* const CHAR_IN_BLOCK = "unexpected character in block scalar";
 const char* const AMBIGUOUS_ANCHOR =
    "cannot assign the same alias to multiple nodes";
-const char* const UNKNOWN_ANCHOR = "the referenced anchor is not defined: ";
+const char* const UNKNOWN_ANCHOR = "the referenced anchor is not defined";

 const char* const INVALID_NODE =
    "invalid node; this may result from using a map iterator as a sequence "
@ -100,12 +100,6 @@ inline const std::string KEY_NOT_FOUND_WITH_KEY(const std::string& key) {
  return stream.str();
 }

-inline const std::string KEY_NOT_FOUND_WITH_KEY(const char* key) {
-  std::stringstream stream;
-  stream << KEY_NOT_FOUND << ": " << key;
-  return stream.str();
-}
-
 template <typename T>
 inline const std::string KEY_NOT_FOUND_WITH_KEY(
    const T& key, typename enable_if<is_numeric<T>>::type* = 0) {
@ -126,12 +120,6 @@ inline const std::string BAD_SUBSCRIPT_WITH_KEY(const std::string& key) {
  return stream.str();
 }

-inline const std::string BAD_SUBSCRIPT_WITH_KEY(const char* key) {
-  std::stringstream stream;
-  stream << BAD_SUBSCRIPT << " (key: \"" << key << "\")";
-  return stream.str();
-}
-
 template <typename T>
 inline const std::string BAD_SUBSCRIPT_WITH_KEY(
    const T& key, typename enable_if<is_numeric<T>>::type* = nullptr) {
@ -148,7 +136,7 @@ inline const std::string INVALID_NODE_WITH_KEY(const std::string& key) {
  stream << "invalid node; first invalid key: \"" << key << "\"";
  return stream.str();
 }
-}  // namespace ErrorMsg
+}

 class YAML_CPP_API Exception : public std::runtime_error {
 public:
@ -261,7 +249,8 @@ class YAML_CPP_API BadSubscript : public RepresentationException {
 public:
  template <typename Key>
  BadSubscript(const Mark& mark_, const Key& key)
-      : RepresentationException(mark_, ErrorMsg::BAD_SUBSCRIPT_WITH_KEY(key)) {}
+      : RepresentationException(mark_,
+                                ErrorMsg::BAD_SUBSCRIPT_WITH_KEY(key)) {}
  BadSubscript(const BadSubscript&) = default;
  ~BadSubscript() YAML_CPP_NOEXCEPT override;
 };
@ -292,12 +281,10 @@ class YAML_CPP_API EmitterException : public Exception {

 class YAML_CPP_API BadFile : public Exception {
 public:
-  explicit BadFile(const std::string& filename)
-      : Exception(Mark::null_mark(),
-                  std::string(ErrorMsg::BAD_FILE) + ": " + filename) {}
+  BadFile() : Exception(Mark::null_mark(), ErrorMsg::BAD_FILE) {}
  BadFile(const BadFile&) = default;
  ~BadFile() YAML_CPP_NOEXCEPT override;
 };
-}  // namespace YAML
+}

 #endif  // EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/include/yaml-cpp/node/convert.h
+++ b/include/yaml-cpp/node/convert.h
@ -12,16 +12,10 @@
 #include <limits>
 #include <list>
 #include <map>
-#include <unordered_map>
 #include <sstream>
 #include <type_traits>
-#include <valarray>
 #include <vector>

-#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
-#include <string_view>
-#endif
-
 #include "yaml-cpp/binary.h"
 #include "yaml-cpp/node/impl.h"
 #include "yaml-cpp/node/iterator.h"
@ -80,33 +74,14 @@ struct convert<std::string> {
 // C-strings can only be encoded
 template <>
 struct convert<const char*> {
-  static Node encode(const char* rhs) { return Node(rhs); }
-};
-
-template <>
-struct convert<char*> {
-  static Node encode(const char* rhs) { return Node(rhs); }
+  static Node encode(const char*& rhs) { return Node(rhs); }
 };

 template <std::size_t N>
-struct convert<char[N]> {
-  static Node encode(const char* rhs) { return Node(rhs); }
+struct convert<const char[N]> {
+  static Node encode(const char(&rhs)[N]) { return Node(rhs); }
 };

-#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
-template <>
-struct convert<std::string_view> {
-  static Node encode(std::string_view rhs) { return Node(std::string(rhs)); }
-
-  static bool decode(const Node& node, std::string_view& rhs) {
-    if (!node.IsScalar())
-      return false;
-    rhs = node.Scalar();
-    return true;
-  }
-};
-#endif
-
 template <>
 struct convert<_Null> {
  static Node encode(const _Null& /* rhs */) { return Node(); }
@ -138,31 +113,6 @@ typename std::enable_if<!std::is_floating_point<T>::value, void>::type
 inner_encode(const T& rhs, std::stringstream& stream){
  stream << rhs;
 }
-
-template <typename T>
-typename std::enable_if<(std::is_same<T, unsigned char>::value ||
-                         std::is_same<T, signed char>::value), bool>::type
-ConvertStreamTo(std::stringstream& stream, T& rhs) {
-  int num;
-  if ((stream >> std::noskipws >> num) && (stream >> std::ws).eof()) {
-    if (num >= (std::numeric_limits<T>::min)() &&
-        num <= (std::numeric_limits<T>::max)()) {
-      rhs = static_cast<T>(num);
-      return true;
-    }
-  }
-  return false;
-}
-
-template <typename T>
-typename std::enable_if<!(std::is_same<T, unsigned char>::value ||
-                          std::is_same<T, signed char>::value), bool>::type
-ConvertStreamTo(std::stringstream& stream, T& rhs) {
-  if ((stream >> std::noskipws >> rhs) && (stream >> std::ws).eof()) {
-    return true;
-  }
-  return false;
-}
 }

 #define YAML_DEFINE_CONVERT_STREAMABLE(type, negative_op)                  \
@ -183,10 +133,7 @@ ConvertStreamTo(std::stringstream& stream, T& rhs) {
      const std::string& input = node.Scalar();                            \
      std::stringstream stream(input);                                     \
      stream.unsetf(std::ios::dec);                                        \
-      if ((stream.peek() == '-') && std::is_unsigned<type>::value) {       \
-        return false;                                                      \
-      }                                                                    \
-      if (conversion::ConvertStreamTo(stream, rhs)) {                      \
+      if ((stream >> std::noskipws >> rhs) && (stream >> std::ws).eof()) { \
        return true;                                                       \
      }                                                                    \
      if (std::numeric_limits<type>::has_infinity) {                       \
@ -246,104 +193,81 @@ struct convert<bool> {
 };

 // std::map
-template <typename K, typename V, typename C, typename A>
-struct convert<std::map<K, V, C, A>> {
-  static Node encode(const std::map<K, V, C, A>& rhs) {
+template <typename K, typename V>
+struct convert<std::map<K, V>> {
+  static Node encode(const std::map<K, V>& rhs) {
    Node node(NodeType::Map);
-    for (const auto& element : rhs)
-      node.force_insert(element.first, element.second);
+    for (typename std::map<K, V>::const_iterator it = rhs.begin();
+         it != rhs.end(); ++it)
+      node.force_insert(it->first, it->second);
    return node;
  }

-  static bool decode(const Node& node, std::map<K, V, C, A>& rhs) {
+  static bool decode(const Node& node, std::map<K, V>& rhs) {
    if (!node.IsMap())
      return false;

    rhs.clear();
-    for (const auto& element : node)
+    for (const_iterator it = node.begin(); it != node.end(); ++it)
 #if defined(__GNUC__) && __GNUC__ < 4
      // workaround for GCC 3:
-      rhs[element.first.template as<K>()] = element.second.template as<V>();
+      rhs[it->first.template as<K>()] = it->second.template as<V>();
 #else
-      rhs[element.first.as<K>()] = element.second.as<V>();
-#endif
-    return true;
-  }
-};
-
-// std::unordered_map
-template <typename K, typename V, typename H, typename P, typename A>
-struct convert<std::unordered_map<K, V, H, P, A>> {
-  static Node encode(const std::unordered_map<K, V, H, P, A>& rhs) {
-    Node node(NodeType::Map);
-    for (const auto& element : rhs)
-      node.force_insert(element.first, element.second);
-    return node;
-  }
-
-  static bool decode(const Node& node, std::unordered_map<K, V, H, P, A>& rhs) {
-    if (!node.IsMap())
-      return false;
-
-    rhs.clear();
-    for (const auto& element : node)
-#if defined(__GNUC__) && __GNUC__ < 4
-      // workaround for GCC 3:
-      rhs[element.first.template as<K>()] = element.second.template as<V>();
-#else
-      rhs[element.first.as<K>()] = element.second.as<V>();
+      rhs[it->first.as<K>()] = it->second.as<V>();
 #endif
    return true;
  }
 };

 // std::vector
-template <typename T, typename A>
-struct convert<std::vector<T, A>> {
-  static Node encode(const std::vector<T, A>& rhs) {
+template <typename T>
+struct convert<std::vector<T>> {
+  static Node encode(const std::vector<T>& rhs) {
    Node node(NodeType::Sequence);
-    for (const auto& element : rhs)
-      node.push_back(element);
+    for (typename std::vector<T>::const_iterator it = rhs.begin();
+         it != rhs.end(); ++it)
+      node.push_back(*it);
    return node;
  }

-  static bool decode(const Node& node, std::vector<T, A>& rhs) {
+  static bool decode(const Node& node, std::vector<T>& rhs) {
    if (!node.IsSequence())
      return false;

    rhs.clear();
-    for (const auto& element : node)
+    for (const_iterator it = node.begin(); it != node.end(); ++it)
 #if defined(__GNUC__) && __GNUC__ < 4
      // workaround for GCC 3:
-      rhs.push_back(element.template as<T>());
+      rhs.push_back(it->template as<T>());
 #else
-      rhs.push_back(element.as<T>());
+      rhs.push_back(it->as<T>());
 #endif
    return true;
  }
 };

 // std::list
-template <typename T, typename A>
-struct convert<std::list<T,A>> {
-  static Node encode(const std::list<T,A>& rhs) {
+template <typename T>
+struct convert<std::list<T>> {
+  static Node encode(const std::list<T>& rhs) {
    Node node(NodeType::Sequence);
-    for (const auto& element : rhs)
-      node.push_back(element);
+    for (typename std::list<T>::const_iterator it = rhs.begin();
+         it != rhs.end(); ++it)
+      node.push_back(*it);
    return node;
  }

-  static bool decode(const Node& node, std::list<T,A>& rhs) {
+  static bool decode(const Node& node, std::list<T>& rhs) {
    if (!node.IsSequence())
      return false;

    rhs.clear();
-    for (const auto& element : node)
+    for (const_iterator it = node.begin(); it != node.end(); ++it)
 #if defined(__GNUC__) && __GNUC__ < 4
      // workaround for GCC 3:
-      rhs.push_back(element.template as<T>());
+      rhs.push_back(it->template as<T>());
 #else
-      rhs.push_back(element.as<T>());
+      rhs.push_back(it->as<T>());
 #endif
    return true;
  }
@ -382,37 +306,6 @@ struct convert<std::array<T, N>> {
  }
 };

-
-// std::valarray
-template <typename T>
-struct convert<std::valarray<T>> {
-  static Node encode(const std::valarray<T>& rhs) {
-    Node node(NodeType::Sequence);
-    for (const auto& element : rhs) {
-      node.push_back(element);
-    }
-    return node;
-  }
-
-  static bool decode(const Node& node, std::valarray<T>& rhs) {
-    if (!node.IsSequence()) {
-      return false;
-    }
-
-    rhs.resize(node.size());
-    for (auto i = 0u; i < node.size(); ++i) {
-#if defined(__GNUC__) && __GNUC__ < 4
-      // workaround for GCC 3:
-      rhs[i] = node[i].template as<T>();
-#else
-      rhs[i] = node[i].as<T>();
-#endif
-    }
-    return true;
-  }
-};
-
-
 // std::pair
 template <typename T, typename U>
 struct convert<std::pair<T, U>> {
--- a/include/yaml-cpp/node/detail/impl.h
+++ b/include/yaml-cpp/node/detail/impl.h
@ -9,8 +9,6 @@

 #include "yaml-cpp/node/detail/node.h"
 #include "yaml-cpp/node/detail/node_data.h"
-
-#include <algorithm>
 #include <type_traits>

 namespace YAML {
@ -106,11 +104,7 @@ inline bool node::equals(const T& rhs, shared_memory_holder pMemory) {
 }

 inline bool node::equals(const char* rhs, shared_memory_holder pMemory) {
-  std::string lhs;
-  if (convert<std::string>::decode(Node(*this, std::move(pMemory)), lhs)) {
-    return lhs == rhs;
-  }
-  return false;
+  return equals<std::string>(rhs, pMemory);
 }

 // indexing
@ -131,11 +125,13 @@ inline node* node_data::get(const Key& key,
      throw BadSubscript(m_mark, key);
  }

-  auto it = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) {
-    return m.first->equals(key, pMemory);
-  });
+  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
+    if (it->first->equals(key, pMemory)) {
+      return it->second;
+    }
+  }

-  return it != m_map.end() ? it->second : nullptr;
+  return nullptr;
 }

 template <typename Key>
@ -157,12 +153,10 @@ inline node& node_data::get(const Key& key, shared_memory_holder pMemory) {
      throw BadSubscript(m_mark, key);
  }

-  auto it = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) {
-    return m.first->equals(key, pMemory);
-  });
-
-  if (it != m_map.end()) {
-    return *it->second;
+  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
+    if (it->first->equals(key, pMemory)) {
+      return *it->second;
+    }
  }

  node& k = convert_to_node(key, pMemory);
@ -175,9 +169,7 @@ template <typename Key>
 inline bool node_data::remove(const Key& key, shared_memory_holder pMemory) {
  if (m_type == NodeType::Sequence) {
    return remove_idx<Key>::remove(m_sequence, key, m_seqSize);
-  }
-
-  if (m_type == NodeType::Map) {
+  } else if (m_type == NodeType::Map) {
    kv_pairs::iterator it = m_undefinedPairs.begin();
    while (it != m_undefinedPairs.end()) {
      kv_pairs::iterator jt = std::next(it);
@ -187,13 +179,11 @@ inline bool node_data::remove(const Key& key, shared_memory_holder pMemory) {
      it = jt;
    }

-    auto iter = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) {
-      return m.first->equals(key, pMemory);
-    });
-
-    if (iter != m_map.end()) {
-      m_map.erase(iter);
-      return true;
+    for (node_map::iterator iter = m_map.begin(); iter != m_map.end(); ++iter) {
+      if (iter->first->equals(key, pMemory)) {
+        m_map.erase(iter);
+        return true;
+      }
    }
  }

--- a/include/yaml-cpp/node/detail/node.h
+++ b/include/yaml-cpp/node/detail/node.h
@ -20,11 +20,11 @@ namespace detail {
 class node {
 private:
  struct less {
-    bool operator ()(const node* l, const node* r) const {return l->m_index < r->m_index;}
+    bool operator ()(const node* l, const node* r) {return l->m_index < r->m_index;}
  };

 public:
-  node() : m_pRef(new node_ref), m_dependencies{}, m_index{} {}
+  node() : m_pRef(new node_ref), m_dependencies{} {}
  node(const node&) = delete;
  node& operator=(const node&) = delete;

@ -169,7 +169,7 @@ class node {
  using nodes = std::set<node*, less>;
  nodes m_dependencies;
  size_t m_index;
-  static YAML_CPP_API std::atomic<size_t> m_amount;
+  static std::atomic<size_t> m_amount;
 };
 }  // namespace detail
 }  // namespace YAML
--- a/include/yaml-cpp/node/detail/node_data.h
+++ b/include/yaml-cpp/node/detail/node_data.h
@ -60,8 +60,8 @@ class YAML_CPP_API node_data {
  node_iterator end();

  // sequence
-  void push_back(node& node, const shared_memory_holder& pMemory);
-  void insert(node& key, node& value, const shared_memory_holder& pMemory);
+  void push_back(node& node, shared_memory_holder pMemory);
+  void insert(node& key, node& value, shared_memory_holder pMemory);

  // indexing
  template <typename Key>
@ -71,9 +71,9 @@ class YAML_CPP_API node_data {
  template <typename Key>
  bool remove(const Key& key, shared_memory_holder pMemory);

-  node* get(node& key, const shared_memory_holder& pMemory) const;
-  node& get(node& key, const shared_memory_holder& pMemory);
-  bool remove(node& key, const shared_memory_holder& pMemory);
+  node* get(node& key, shared_memory_holder pMemory) const;
+  node& get(node& key, shared_memory_holder pMemory);
+  bool remove(node& key, shared_memory_holder pMemory);

  // map
  template <typename Key, typename Value>
@ -91,8 +91,8 @@ class YAML_CPP_API node_data {
  void reset_map();

  void insert_map_pair(node& key, node& value);
-  void convert_to_map(const shared_memory_holder& pMemory);
-  void convert_sequence_to_map(const shared_memory_holder& pMemory);
+  void convert_to_map(shared_memory_holder pMemory);
+  void convert_sequence_to_map(shared_memory_holder pMemory);

  template <typename T>
  static node& convert_to_node(const T& rhs, shared_memory_holder pMemory);
--- a/include/yaml-cpp/node/impl.h
+++ b/include/yaml-cpp/node/impl.h
@ -42,7 +42,7 @@ inline Node::Node(const detail::iterator_value& rhs)
      m_pMemory(rhs.m_pMemory),
      m_pNode(rhs.m_pNode) {}

-inline Node::Node(const Node&) = default;
+inline Node::Node(const Node& rhs) = default;

 inline Node::Node(Zombie)
    : m_isValid(false), m_invalidKey{}, m_pMemory{}, m_pNode(nullptr) {}
@ -97,7 +97,7 @@ struct as_if {
    if (!node.m_pNode)
      return fallback;

-    T t = fallback;
+    T t;
    if (convert<T>::decode(node, t))
      return t;
    return fallback;
@ -110,8 +110,6 @@ struct as_if<std::string, S> {
  const Node& node;

  std::string operator()(const S& fallback) const {
-    if (node.Type() == NodeType::Null)
-      return "null";
    if (node.Type() != NodeType::Scalar)
      return fallback;
    return node.Scalar();
@ -140,8 +138,6 @@ struct as_if<std::string, void> {
  const Node& node;

  std::string operator()() const {
-    if (node.Type() == NodeType::Null)
-      return "null";
    if (node.Type() != NodeType::Scalar)
      throw TypedBadConversion<std::string>(node.Mark());
    return node.Scalar();
@ -315,6 +311,51 @@ inline void Node::push_back(const Node& rhs) {
  m_pMemory->merge(*rhs.m_pMemory);
 }

+// helpers for indexing
+namespace detail {
+template <typename T>
+struct to_value_t {
+  explicit to_value_t(const T& t_) : t(t_) {}
+  const T& t;
+  using return_type = const T &;
+
+  const T& operator()() const { return t; }
+};
+
+template <>
+struct to_value_t<const char*> {
+  explicit to_value_t(const char* t_) : t(t_) {}
+  const char* t;
+  using return_type = std::string;
+
+  const std::string operator()() const { return t; }
+};
+
+template <>
+struct to_value_t<char*> {
+  explicit to_value_t(char* t_) : t(t_) {}
+  const char* t;
+  using return_type = std::string;
+
+  const std::string operator()() const { return t; }
+};
+
+template <std::size_t N>
+struct to_value_t<char[N]> {
+  explicit to_value_t(const char* t_) : t(t_) {}
+  const char* t;
+  using return_type = std::string;
+
+  const std::string operator()() const { return t; }
+};
+
+// converts C-strings to std::strings so they can be copied
+template <typename T>
+inline typename to_value_t<T>::return_type to_value(const T& t) {
+  return to_value_t<T>(t)();
+}
+}  // namespace detail
+
 template<typename Key>
 std::string key_to_string(const Key& key) {
  return streamable_to_string<Key, is_streamable<std::stringstream, Key>::value>().impl(key);
@ -324,8 +365,8 @@ std::string key_to_string(const Key& key) {
 template <typename Key>
 inline const Node Node::operator[](const Key& key) const {
  EnsureNodeExists();
-  detail::node* value =
-      static_cast<const detail::node&>(*m_pNode).get(key, m_pMemory);
+  detail::node* value = static_cast<const detail::node&>(*m_pNode).get(
+      detail::to_value(key), m_pMemory);
  if (!value) {
    return Node(ZombieNode, key_to_string(key));
  }
@ -335,14 +376,14 @@ inline const Node Node::operator[](const Key& key) const {
 template <typename Key>
 inline Node Node::operator[](const Key& key) {
  EnsureNodeExists();
-  detail::node& value = m_pNode->get(key, m_pMemory);
+  detail::node& value = m_pNode->get(detail::to_value(key), m_pMemory);
  return Node(value, m_pMemory);
 }

 template <typename Key>
 inline bool Node::remove(const Key& key) {
  EnsureNodeExists();
-  return m_pNode->remove(key, m_pMemory);
+  return m_pNode->remove(detail::to_value(key), m_pMemory);
 }

 inline const Node Node::operator[](const Node& key) const {
@ -375,7 +416,8 @@ inline bool Node::remove(const Node& key) {
 template <typename Key, typename Value>
 inline void Node::force_insert(const Key& key, const Value& value) {
  EnsureNodeExists();
-  m_pNode->force_insert(key, value, m_pMemory);
+  m_pNode->force_insert(detail::to_value(key), detail::to_value(value),
+                        m_pMemory);
 }

 // free functions
--- a/include/yaml-cpp/node/iterator.h
+++ b/include/yaml-cpp/node/iterator.h
@ -15,9 +15,6 @@
 #include <utility>
 #include <vector>

-// Assert in place so gcc + libc++ combination properly builds
-static_assert(std::is_constructible<YAML::Node, const YAML::Node&>::value, "Node must be copy constructable");
-
 namespace YAML {
 namespace detail {
 struct iterator_value : public Node, std::pair<Node, Node> {
--- a/include/yaml-cpp/node/ptr.h
+++ b/include/yaml-cpp/node/ptr.h
@ -7,6 +7,7 @@
 #pragma once
 #endif

+#include "yaml-cpp/dll.h"
 #include <memory>

 namespace YAML {
--- a/include/yaml-cpp/stlemitter.h
+++ b/include/yaml-cpp/stlemitter.h
@ -16,8 +16,8 @@ namespace YAML {
 template <typename Seq>
 inline Emitter& EmitSeq(Emitter& emitter, const Seq& seq) {
  emitter << BeginSeq;
-  for (const auto& v : seq)
-    emitter << v;
+  for (typename Seq::const_iterator it = seq.begin(); it != seq.end(); ++it)
+    emitter << *it;
  emitter << EndSeq;
  return emitter;
 }
@ -39,9 +39,10 @@ inline Emitter& operator<<(Emitter& emitter, const std::set<T>& v) {

 template <typename K, typename V>
 inline Emitter& operator<<(Emitter& emitter, const std::map<K, V>& m) {
+  typedef typename std::map<K, V> map;
  emitter << BeginMap;
-  for (const auto& v : m)
-    emitter << Key << v.first << Value << v.second;
+  for (typename map::const_iterator it = m.begin(); it != m.end(); ++it)
+    emitter << Key << it->first << Value << it->second;
  emitter << EndMap;
  return emitter;
 }
--- a/include/yaml-cpp/traits.h
+++ b/include/yaml-cpp/traits.h
@ -107,9 +107,9 @@ struct disable_if : public disable_if_c<Cond::value, T> {};

 template <typename S, typename T>
 struct is_streamable {
-  template <typename StreamT, typename ValueT>
+  template <typename SS, typename TT>
  static auto test(int)
-      -> decltype(std::declval<StreamT&>() << std::declval<ValueT>(), std::true_type());
+      -> decltype(std::declval<SS&>() << std::declval<TT>(), std::true_type());

  template <typename, typename>
  static auto test(...) -> std::false_type;
--- a/src/binary.cpp
+++ b/src/binary.cpp
@ -75,11 +75,11 @@ std::vector<unsigned char> DecodeBase64(const std::string &input) {

  unsigned value = 0;
  for (std::size_t i = 0, cnt = 0; i < input.size(); i++) {
-    if (std::isspace(static_cast<unsigned char>(input[i]))) {
+    if (std::isspace(input[i])) {
      // skip newlines
      continue;
    }
-    unsigned char d = decoding[static_cast<unsigned char>(input[i])];
+    unsigned char d = decoding[static_cast<unsigned>(input[i])];
    if (d == 255)
      return ret_type();

@ -97,4 +97,4 @@ std::vector<unsigned char> DecodeBase64(const std::string &input) {
  ret.resize(out - &ret[0]);
  return ret;
 }
-}  // namespace YAML
+}
--- a/src/contrib/graphbuilder.cpp
+++ b/src/contrib/graphbuilder.cpp
@ -10,7 +10,8 @@ void* BuildGraphOfNextDocument(Parser& parser,
  GraphBuilderAdapter eventHandler(graphBuilder);
  if (parser.HandleNextDocument(eventHandler)) {
    return eventHandler.RootNode();
+  } else {
+    return nullptr;
  }
-  return nullptr;
 }
-}  // namespace YAML
+}
--- a/src/contrib/graphbuilderadapter.cpp
+++ b/src/contrib/graphbuilderadapter.cpp
@ -91,4 +91,4 @@ void GraphBuilderAdapter::DispositionNode(void *pNode) {
    m_builder.AppendToSequence(pContainer, pNode);
  }
 }
-}  // namespace YAML
+}
--- a/src/contrib/graphbuilderadapter.h
+++ b/src/contrib/graphbuilderadapter.h
@ -13,6 +13,7 @@

 #include "yaml-cpp/anchor.h"
 #include "yaml-cpp/contrib/anchordict.h"
+#include "yaml-cpp/contrib/graphbuilder.h"
 #include "yaml-cpp/emitterstyle.h"
 #include "yaml-cpp/eventhandler.h"

--- a/src/convert.cpp
+++ b/src/convert.cpp
@ -16,7 +16,11 @@ std::string tolower(const std::string& str) {

 template <typename T>
 bool IsEntirely(const std::string& str, T func) {
-  return std::all_of(str.begin(), str.end(), [=](char ch) { return func(ch); });
+  for (char ch : str)
+    if (!func(ch))
+      return false;
+
+  return true;
 }

 // IsFlexibleCase
--- a/src/depthguard.cpp
+++ b/src/depthguard.cpp
@ -1,9 +0,0 @@
-#include "yaml-cpp/depthguard.h"
-
-namespace YAML {
-
-DeepRecursion::DeepRecursion(int depth, const Mark& mark_,
-                             const std::string& msg_)
-    : ParserException(mark_, msg_), m_depth(depth) {}
-
-}  // namespace YAML
--- a/src/directives.cpp
+++ b/src/directives.cpp
@ -3,9 +3,9 @@
 namespace YAML {
 Directives::Directives() : version{true, 1, 2}, tags{} {}

-std::string Directives::TranslateTagHandle(
+const std::string Directives::TranslateTagHandle(
    const std::string& handle) const {
-  auto it = tags.find(handle);
+  std::map<std::string, std::string>::const_iterator it = tags.find(handle);
  if (it == tags.end()) {
    if (handle == "!!")
      return "tag:yaml.org,2002:";
--- a/src/directives.h
+++ b/src/directives.h
@ -19,7 +19,7 @@ struct Version {
 struct Directives {
  Directives();

-  std::string TranslateTagHandle(const std::string& handle) const;
+  const std::string TranslateTagHandle(const std::string& handle) const;

  Version version;
  std::map<std::string, std::string> tags;
--- a/src/emit.cpp
+++ b/src/emit.cpp
@ -1,7 +1,7 @@
 #include "yaml-cpp/node/emit.h"
-#include "nodeevents.h"
 #include "yaml-cpp/emitfromevents.h"
 #include "yaml-cpp/emitter.h"
+#include "nodeevents.h"

 namespace YAML {
 Emitter& operator<<(Emitter& out, const Node& node) {
--- a/src/emitfromevents.cpp
+++ b/src/emitfromevents.cpp
@ -59,8 +59,6 @@ void EmitFromEvents::OnSequenceStart(const Mark&, const std::string& tag,
    default:
      break;
  }
-  // Restore the global settings to eliminate the override from node style
-  m_emitter.RestoreGlobalModifiedSettings();
  m_emitter << BeginSeq;
  m_stateStack.push(State::WaitingForSequenceEntry);
 }
@ -85,8 +83,6 @@ void EmitFromEvents::OnMapStart(const Mark&, const std::string& tag,
    default:
      break;
  }
-  // Restore the global settings to eliminate the override from node style
-  m_emitter.RestoreGlobalModifiedSettings();
  m_emitter << BeginMap;
  m_stateStack.push(State::WaitingForKey);
 }
--- a/src/emitter.cpp
+++ b/src/emitter.cpp
@ -49,10 +49,6 @@ bool Emitter::SetBoolFormat(EMITTER_MANIP value) {
  return ok;
 }

-bool Emitter::SetNullFormat(EMITTER_MANIP value) {
-  return m_pState->SetNullFormat(value, FmtScope::Global);
-}
-
 bool Emitter::SetIntBase(EMITTER_MANIP value) {
  return m_pState->SetIntFormat(value, FmtScope::Global);
 }
@ -90,10 +86,6 @@ bool Emitter::SetDoublePrecision(std::size_t n) {
  return m_pState->SetDoublePrecision(n, FmtScope::Global);
 }

-void Emitter::RestoreGlobalModifiedSettings() {
-  m_pState->RestoreGlobalModifiedSettings();
-}
-
 // SetLocalValue
 // . Either start/end a group, or set a modifier locally
 Emitter& Emitter::SetLocalValue(EMITTER_MANIP value) {
@ -205,7 +197,6 @@ void Emitter::EmitBeginSeq() {
 void Emitter::EmitEndSeq() {
  if (!good())
    return;
-  FlowType::value originalType = m_pState->CurGroupFlowType();

  if (m_pState->CurGroupChildCount() == 0)
    m_pState->ForceFlow();
@ -213,14 +204,9 @@ void Emitter::EmitEndSeq() {
  if (m_pState->CurGroupFlowType() == FlowType::Flow) {
    if (m_stream.comment())
      m_stream << "\n";
-    if (originalType == FlowType::Block || m_pState->HasBegunNode())
-      m_stream << IndentTo(m_pState->CurIndent());
-    if (originalType == FlowType::Block) {
+    m_stream << IndentTo(m_pState->CurIndent());
+    if (m_pState->CurGroupChildCount() == 0)
      m_stream << "[";
-    } else {
-      if (m_pState->CurGroupChildCount() == 0 && !m_pState->HasBegunNode())
-        m_stream << "[";
-    }
    m_stream << "]";
  }

@ -241,7 +227,6 @@ void Emitter::EmitBeginMap() {
 void Emitter::EmitEndMap() {
  if (!good())
    return;
-  FlowType::value originalType = m_pState->CurGroupFlowType();

  if (m_pState->CurGroupChildCount() == 0)
    m_pState->ForceFlow();
@ -250,12 +235,8 @@ void Emitter::EmitEndMap() {
    if (m_stream.comment())
      m_stream << "\n";
    m_stream << IndentTo(m_pState->CurIndent());
-    if (originalType == FlowType::Block) {
+    if (m_pState->CurGroupChildCount() == 0)
      m_stream << "{";
-    } else {
-      if (m_pState->CurGroupChildCount() == 0 && !m_pState->HasBegunNode())
-        m_stream << "{";
-    }
    m_stream << "}";
  }

@ -505,9 +486,6 @@ void Emitter::FlowMapPrepareSimpleKeyValue(EmitterNodeType::value child) {
    if (m_stream.comment())
      m_stream << "\n";
    m_stream << IndentTo(lastIndent);
-    if (m_pState->HasAlias()) {
-      m_stream << " ";
-    }
    m_stream << ":";
  }

@ -534,8 +512,7 @@ void Emitter::BlockMapPrepareNode(EmitterNodeType::value child) {
    if (m_pState->GetMapKeyFormat() == LongKey)
      m_pState->SetLongKey();
    if (child == EmitterNodeType::BlockSeq ||
-        child == EmitterNodeType::BlockMap ||
-        child == EmitterNodeType::Property)
+        child == EmitterNodeType::BlockMap)
      m_pState->SetLongKey();

    if (m_pState->CurGroupLongKey())
@ -579,8 +556,6 @@ void Emitter::BlockMapPrepareLongKey(EmitterNodeType::value child) {
      break;
    case EmitterNodeType::BlockSeq:
    case EmitterNodeType::BlockMap:
-      if (m_pState->HasBegunContent())
-        m_stream << "\n";
      break;
  }
 }
@ -604,12 +579,8 @@ void Emitter::BlockMapPrepareLongKeyValue(EmitterNodeType::value child) {
    case EmitterNodeType::Scalar:
    case EmitterNodeType::FlowSeq:
    case EmitterNodeType::FlowMap:
-      SpaceOrIndentTo(true, curIndent + 1);
-      break;
    case EmitterNodeType::BlockSeq:
    case EmitterNodeType::BlockMap:
-      if (m_pState->HasBegunContent())
-        m_stream << "\n";
      SpaceOrIndentTo(true, curIndent + 1);
      break;
  }
@ -648,9 +619,6 @@ void Emitter::BlockMapPrepareSimpleKeyValue(EmitterNodeType::value child) {
  const std::size_t nextIndent = curIndent + m_pState->CurGroupIndent();

  if (!m_pState->HasBegunNode()) {
-    if (m_pState->HasAlias()) {
-      m_stream << " ";
-    }
    m_stream << ":";
  }

@ -704,29 +672,16 @@ void Emitter::StartedScalar() { m_pState->StartedScalar(); }
 // *******************************************************************************************
 // overloads of Write

-StringEscaping::value GetStringEscapingStyle(const EMITTER_MANIP emitterManip) {
-  switch (emitterManip) {
-    case EscapeNonAscii:
-      return StringEscaping::NonAscii;
-    case EscapeAsJson:
-      return StringEscaping::JSON;
-    default:
-      return StringEscaping::None;
-      break;
-  }
-}
-
 Emitter& Emitter::Write(const std::string& str) {
  if (!good())
    return *this;

-  StringEscaping::value stringEscaping = GetStringEscapingStyle(m_pState->GetOutputCharset());
-
+  const bool escapeNonAscii = m_pState->GetOutputCharset() == EscapeNonAscii;
  const StringFormat::value strFormat =
      Utils::ComputeStringFormat(str, m_pState->GetStringFormat(),
-                                 m_pState->CurGroupFlowType(), stringEscaping == StringEscaping::NonAscii);
+                                 m_pState->CurGroupFlowType(), escapeNonAscii);

-  if (strFormat == StringFormat::Literal || str.size() > 1024)
+  if (strFormat == StringFormat::Literal)
    m_pState->SetMapKeyFormat(YAML::LongKey, FmtScope::Local);

  PrepareNode(EmitterNodeType::Scalar);
@ -739,7 +694,7 @@ Emitter& Emitter::Write(const std::string& str) {
      Utils::WriteSingleQuotedString(m_stream, str);
      break;
    case StringFormat::DoubleQuoted:
-      Utils::WriteDoubleQuotedString(m_stream, str, stringEscaping);
+      Utils::WriteDoubleQuotedString(m_stream, str, escapeNonAscii);
      break;
    case StringFormat::Literal:
      Utils::WriteLiteralString(m_stream, str,
@ -809,21 +764,6 @@ const char* Emitter::ComputeFullBoolName(bool b) const {
                         // these answers
 }

-const char* Emitter::ComputeNullName() const {
-  switch (m_pState->GetNullFormat()) {
-    case LowerNull:
-      return "null";
-    case UpperNull:
-      return "NULL";
-    case CamelNull:
-      return "Null";
-    case TildeNull:
-      // fallthrough
-    default:
-      return "~";
-  }
-}
-
 Emitter& Emitter::Write(bool b) {
  if (!good())
    return *this;
@ -845,10 +785,8 @@ Emitter& Emitter::Write(char ch) {
  if (!good())
    return *this;

-
-
  PrepareNode(EmitterNodeType::Scalar);
-  Utils::WriteChar(m_stream, ch, GetStringEscapingStyle(m_pState->GetOutputCharset()));
+  Utils::WriteChar(m_stream, ch);
  StartedScalar();

  return *this;
@ -872,8 +810,6 @@ Emitter& Emitter::Write(const _Alias& alias) {

  StartedScalar();

-  m_pState->SetAlias();
-
  return *this;
 }

@ -951,7 +887,7 @@ Emitter& Emitter::Write(const _Null& /*null*/) {

  PrepareNode(EmitterNodeType::Scalar);

-  m_stream << ComputeNullName();
+  m_stream << "~";

  StartedScalar();

--- a/src/emitterstate.cpp
+++ b/src/emitterstate.cpp
@ -13,7 +13,6 @@ EmitterState::EmitterState()
      m_boolFmt(TrueFalseBool),
      m_boolLengthFmt(LongBool),
      m_boolCaseFmt(LowerCase),
-      m_nullFmt(TildeNull),
      m_intFmt(Dec),
      m_indent(2),
      m_preCommentIndent(2),
@ -29,7 +28,6 @@ EmitterState::EmitterState()
      m_groups{},
      m_curIndent(0),
      m_hasAnchor(false),
-      m_hasAlias(false),
      m_hasTag(false),
      m_hasNonContent(false),
      m_docCount(0) {}
@ -45,7 +43,6 @@ void EmitterState::SetLocalValue(EMITTER_MANIP value) {
  SetBoolFormat(value, FmtScope::Local);
  SetBoolCaseFormat(value, FmtScope::Local);
  SetBoolLengthFormat(value, FmtScope::Local);
-  SetNullFormat(value, FmtScope::Local);
  SetIntFormat(value, FmtScope::Local);
  SetFlowType(GroupType::Seq, value, FmtScope::Local);
  SetFlowType(GroupType::Map, value, FmtScope::Local);
@ -54,8 +51,6 @@ void EmitterState::SetLocalValue(EMITTER_MANIP value) {

 void EmitterState::SetAnchor() { m_hasAnchor = true; }

-void EmitterState::SetAlias() { m_hasAlias = true; }
-
 void EmitterState::SetTag() { m_hasTag = true; }

 void EmitterState::SetNonContent() { m_hasNonContent = true; }
@ -90,7 +85,6 @@ void EmitterState::StartedNode() {
  }

  m_hasAnchor = false;
-  m_hasAlias = false;
  m_hasTag = false;
  m_hasNonContent = false;
 }
@ -100,13 +94,15 @@ EmitterNodeType::value EmitterState::NextGroupType(
  if (type == GroupType::Seq) {
    if (GetFlowType(type) == Block)
      return EmitterNodeType::BlockSeq;
-    return EmitterNodeType::FlowSeq;
+    else
+      return EmitterNodeType::FlowSeq;
+  } else {
+    if (GetFlowType(type) == Block)
+      return EmitterNodeType::BlockMap;
+    else
+      return EmitterNodeType::FlowMap;
  }

-  if (GetFlowType(type) == Block)
-    return EmitterNodeType::BlockMap;
-  return EmitterNodeType::FlowMap;
-
  // can't happen
  assert(false);
  return EmitterNodeType::NoType;
@ -160,15 +156,9 @@ void EmitterState::EndedGroup(GroupType::value type) {
  if (m_groups.empty()) {
    if (type == GroupType::Seq) {
      return SetError(ErrorMsg::UNEXPECTED_END_SEQ);
+    } else {
+      return SetError(ErrorMsg::UNEXPECTED_END_MAP);
    }
-    return SetError(ErrorMsg::UNEXPECTED_END_MAP);
-  }
-
-  if (m_hasTag) {
-    SetError(ErrorMsg::INVALID_TAG);
-  }
-  if (m_hasAnchor) {
-    SetError(ErrorMsg::INVALID_ANCHOR);
  }

  // get rid of the current group
@ -190,9 +180,6 @@ void EmitterState::EndedGroup(GroupType::value type) {
  m_globalModifiedSettings.restore();

  ClearModifiedSettings();
-  m_hasAnchor = false;
-  m_hasTag = false;
-  m_hasNonContent = false;
 }

 EmitterNodeType::value EmitterState::CurGroupNodeType() const {
@ -233,16 +220,11 @@ std::size_t EmitterState::LastIndent() const {

 void EmitterState::ClearModifiedSettings() { m_modifiedSettings.clear(); }

-void EmitterState::RestoreGlobalModifiedSettings() {
-  m_globalModifiedSettings.restore();
-}
-
 bool EmitterState::SetOutputCharset(EMITTER_MANIP value,
                                    FmtScope::value scope) {
  switch (value) {
    case EmitNonAscii:
    case EscapeNonAscii:
-    case EscapeAsJson:
      _Set(m_charset, value, scope);
      return true;
    default:
@ -300,19 +282,6 @@ bool EmitterState::SetBoolCaseFormat(EMITTER_MANIP value,
  }
 }

-bool EmitterState::SetNullFormat(EMITTER_MANIP value, FmtScope::value scope) {
-  switch (value) {
-    case LowerNull:
-    case UpperNull:
-    case CamelNull:
-    case TildeNull:
-      _Set(m_nullFmt, value, scope);
-      return true;
-    default:
-      return false;
-  }
-}
-
 bool EmitterState::SetIntFormat(EMITTER_MANIP value, FmtScope::value scope) {
  switch (value) {
    case Dec:
--- a/src/emitterstate.h
+++ b/src/emitterstate.h
@ -43,7 +43,6 @@ class EmitterState {

  // node handling
  void SetAnchor();
-  void SetAlias();
  void SetTag();
  void SetNonContent();
  void SetLongKey();
@ -66,7 +65,6 @@ class EmitterState {
  std::size_t LastIndent() const;
  std::size_t CurIndent() const { return m_curIndent; }
  bool HasAnchor() const { return m_hasAnchor; }
-  bool HasAlias() const { return m_hasAlias; }
  bool HasTag() const { return m_hasTag; }
  bool HasBegunNode() const {
    return m_hasAnchor || m_hasTag || m_hasNonContent;
@ -74,7 +72,6 @@ class EmitterState {
  bool HasBegunContent() const { return m_hasAnchor || m_hasTag; }

  void ClearModifiedSettings();
-  void RestoreGlobalModifiedSettings();

  // formatters
  void SetLocalValue(EMITTER_MANIP value);
@ -94,9 +91,6 @@ class EmitterState {
  bool SetBoolCaseFormat(EMITTER_MANIP value, FmtScope::value scope);
  EMITTER_MANIP GetBoolCaseFormat() const { return m_boolCaseFmt.get(); }

-  bool SetNullFormat(EMITTER_MANIP value, FmtScope::value scope);
-  EMITTER_MANIP GetNullFormat() const { return m_nullFmt.get(); }
-
  bool SetIntFormat(EMITTER_MANIP value, FmtScope::value scope);
  EMITTER_MANIP GetIntFormat() const { return m_intFmt.get(); }

@ -137,7 +131,6 @@ class EmitterState {
  Setting<EMITTER_MANIP> m_boolFmt;
  Setting<EMITTER_MANIP> m_boolLengthFmt;
  Setting<EMITTER_MANIP> m_boolCaseFmt;
-  Setting<EMITTER_MANIP> m_nullFmt;
  Setting<EMITTER_MANIP> m_intFmt;
  Setting<std::size_t> m_indent;
  Setting<std::size_t> m_preCommentIndent, m_postCommentIndent;
@ -189,7 +182,6 @@ class EmitterState {
  std::vector<std::unique_ptr<Group>> m_groups;
  std::size_t m_curIndent;
  bool m_hasAnchor;
-  bool m_hasAlias;
  bool m_hasTag;
  bool m_hasNonContent;
  std::size_t m_docCount;
--- a/src/emitterutils.cpp
+++ b/src/emitterutils.cpp
@ -1,4 +1,3 @@
-#include <algorithm>
 #include <iomanip>
 #include <sstream>

@ -176,11 +175,11 @@ bool IsValidPlainScalar(const std::string& str, FlowType::value flowType,
  static const RegEx& disallowed_flow =
      Exp::EndScalarInFlow() | (Exp::BlankOrBreak() + Exp::Comment()) |
      Exp::NotPrintable() | Exp::Utf8_ByteOrderMark() | Exp::Break() |
-      Exp::Tab() | Exp::Ampersand();
+      Exp::Tab();
  static const RegEx& disallowed_block =
      Exp::EndScalar() | (Exp::BlankOrBreak() + Exp::Comment()) |
      Exp::NotPrintable() | Exp::Utf8_ByteOrderMark() | Exp::Break() |
-      Exp::Tab() | Exp::Ampersand();
+      Exp::Tab();
  const RegEx& disallowed =
      flowType == FlowType::Flow ? disallowed_flow : disallowed_block;

@ -200,10 +199,15 @@ bool IsValidPlainScalar(const std::string& str, FlowType::value flowType,

 bool IsValidSingleQuotedScalar(const std::string& str, bool escapeNonAscii) {
  // TODO: check for non-printable characters?
-  return std::none_of(str.begin(), str.end(), [=](char ch) {
-    return (escapeNonAscii && (0x80 <= static_cast<unsigned char>(ch))) ||
-           (ch == '\n');
-  });
+  for (char ch : str) {
+    if (escapeNonAscii && (0x80 <= static_cast<unsigned char>(ch))) {
+      return false;
+    }
+    if (ch == '\n') {
+      return false;
+    }
+  }
+  return true;
 }

 bool IsValidLiteralScalar(const std::string& str, FlowType::value flowType,
@ -213,39 +217,28 @@ bool IsValidLiteralScalar(const std::string& str, FlowType::value flowType,
  }

  // TODO: check for non-printable characters?
-  return std::none_of(str.begin(), str.end(), [=](char ch) {
-    return (escapeNonAscii && (0x80 <= static_cast<unsigned char>(ch)));
-  });
+  for (char ch : str) {
+    if (escapeNonAscii && (0x80 <= static_cast<unsigned char>(ch))) {
+      return false;
+    }
+  }
+  return true;
 }

-std::pair<uint16_t, uint16_t> EncodeUTF16SurrogatePair(int codePoint) {
-  const uint32_t leadOffset = 0xD800 - (0x10000 >> 10);
-
-  return {
-    leadOffset | (codePoint >> 10),
-    0xDC00 | (codePoint & 0x3FF),
-  };
-}
-
-void WriteDoubleQuoteEscapeSequence(ostream_wrapper& out, int codePoint, StringEscaping::value stringEscapingStyle) {
+void WriteDoubleQuoteEscapeSequence(ostream_wrapper& out, int codePoint) {
  static const char hexDigits[] = "0123456789abcdef";

  out << "\\";
  int digits = 8;
-  if (codePoint < 0xFF && stringEscapingStyle != StringEscaping::JSON) {
+  if (codePoint < 0xFF) {
    out << "x";
    digits = 2;
  } else if (codePoint < 0xFFFF) {
    out << "u";
    digits = 4;
-  } else if (stringEscapingStyle != StringEscaping::JSON) {
+  } else {
    out << "U";
    digits = 8;
-  } else {
-    auto surrogatePair = EncodeUTF16SurrogatePair(codePoint);
-    WriteDoubleQuoteEscapeSequence(out, surrogatePair.first, stringEscapingStyle);
-    WriteDoubleQuoteEscapeSequence(out, surrogatePair.second, stringEscapingStyle);
-    return;
  }

  // Write digits into the escape sequence
@ -317,7 +310,7 @@ bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str) {
 }

 bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
-                             StringEscaping::value stringEscaping) {
+                             bool escapeNonAscii) {
  out << "\"";
  int codePoint;
  for (std::string::const_iterator i = str.begin();
@ -341,19 +334,16 @@ bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
      case '\b':
        out << "\\b";
        break;
-      case '\f':
-        out << "\\f";
-        break;
      default:
        if (codePoint < 0x20 ||
            (codePoint >= 0x80 &&
             codePoint <= 0xA0)) {  // Control characters and non-breaking space
-          WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping);
+          WriteDoubleQuoteEscapeSequence(out, codePoint);
        } else if (codePoint == 0xFEFF) {  // Byte order marks (ZWNS) should be
                                           // escaped (YAML 1.2, sec. 5.2)
-          WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping);
-        } else if (stringEscaping == StringEscaping::NonAscii && codePoint > 0x7E) {
-          WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping);
+          WriteDoubleQuoteEscapeSequence(out, codePoint);
+        } else if (escapeNonAscii && codePoint > 0x7E) {
+          WriteDoubleQuoteEscapeSequence(out, codePoint);
        } else {
          WriteCodePoint(out, codePoint);
        }
@ -366,41 +356,37 @@ bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
 bool WriteLiteralString(ostream_wrapper& out, const std::string& str,
                        std::size_t indent) {
  out << "|\n";
+  out << IndentTo(indent);
  int codePoint;
  for (std::string::const_iterator i = str.begin();
       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
    if (codePoint == '\n') {
-      out << "\n";
+      out << "\n" << IndentTo(indent);
    } else {
-      out<< IndentTo(indent);
      WriteCodePoint(out, codePoint);
    }
  }
  return true;
 }

-bool WriteChar(ostream_wrapper& out, char ch, StringEscaping::value stringEscapingStyle) {
+bool WriteChar(ostream_wrapper& out, char ch) {
  if (('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z')) {
    out << ch;
  } else if (ch == '\"') {
-    out << R"("\"")";
+    out << "\"\\\"\"";
  } else if (ch == '\t') {
-    out << R"("\t")";
+    out << "\"\\t\"";
  } else if (ch == '\n') {
-    out << R"("\n")";
+    out << "\"\\n\"";
  } else if (ch == '\b') {
-    out << R"("\b")";
-  } else if (ch == '\r') {
-    out << R"("\r")";
-  } else if (ch == '\f') {
-    out << R"("\f")";
+    out << "\"\\b\"";
  } else if (ch == '\\') {
-    out << R"("\\")";
+    out << "\"\\\\\"";
  } else if (0x20 <= ch && ch <= 0x7e) {
    out << "\"" << ch << "\"";
  } else {
    out << "\"";
-    WriteDoubleQuoteEscapeSequence(out, ch, stringEscapingStyle);
+    WriteDoubleQuoteEscapeSequence(out, ch);
    out << "\"";
  }
  return true;
@ -490,7 +476,7 @@ bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix,

 bool WriteBinary(ostream_wrapper& out, const Binary& binary) {
  WriteDoubleQuotedString(out, EncodeBase64(binary.data(), binary.size()),
-                          StringEscaping::None);
+                          false);
  return true;
 }
 }  // namespace Utils
--- a/src/emitterutils.h
+++ b/src/emitterutils.h
@ -24,10 +24,6 @@ struct StringFormat {
  enum value { Plain, SingleQuoted, DoubleQuoted, Literal };
 };

-struct StringEscaping {
-  enum value { None, NonAscii, JSON };
-};
-
 namespace Utils {
 StringFormat::value ComputeStringFormat(const std::string& str,
                                        EMITTER_MANIP strFormat,
@ -36,11 +32,10 @@ StringFormat::value ComputeStringFormat(const std::string& str,

 bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str);
 bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
-                             StringEscaping::value stringEscaping);
+                             bool escapeNonAscii);
 bool WriteLiteralString(ostream_wrapper& out, const std::string& str,
                        std::size_t indent);
-bool WriteChar(ostream_wrapper& out, char ch,
-               StringEscaping::value stringEscapingStyle);
+bool WriteChar(ostream_wrapper& out, char ch);
 bool WriteComment(ostream_wrapper& out, const std::string& str,
                  std::size_t postCommentIndent);
 bool WriteAlias(ostream_wrapper& out, const std::string& str);
--- a/src/exceptions.cpp
+++ b/src/exceptions.cpp
@ -17,4 +17,4 @@ BadPushback::~BadPushback() YAML_CPP_NOEXCEPT = default;
 BadInsert::~BadInsert() YAML_CPP_NOEXCEPT = default;
 EmitterException::~EmitterException() YAML_CPP_NOEXCEPT = default;
 BadFile::~BadFile() YAML_CPP_NOEXCEPT = default;
-}  // namespace YAML
+}
--- a/src/exp.cpp
+++ b/src/exp.cpp
@ -54,16 +54,14 @@ std::string Escape(Stream& in, int codeLength) {
  // now break it up into chars
  if (value <= 0x7F)
    return Str(value);
-
-  if (value <= 0x7FF)
+  else if (value <= 0x7FF)
    return Str(0xC0 + (value >> 6)) + Str(0x80 + (value & 0x3F));
-
-  if (value <= 0xFFFF)
+  else if (value <= 0xFFFF)
    return Str(0xE0 + (value >> 12)) + Str(0x80 + ((value >> 6) & 0x3F)) +
           Str(0x80 + (value & 0x3F));
-
-  return Str(0xF0 + (value >> 18)) + Str(0x80 + ((value >> 12) & 0x3F)) +
-         Str(0x80 + ((value >> 6) & 0x3F)) + Str(0x80 + (value & 0x3F));
+  else
+    return Str(0xF0 + (value >> 18)) + Str(0x80 + ((value >> 12) & 0x3F)) +
+           Str(0x80 + ((value >> 6) & 0x3F)) + Str(0x80 + (value & 0x3F));
 }

 // Escape
@ -105,7 +103,7 @@ std::string Escape(Stream& in) {
    case 'e':
      return "\x1B";
    case ' ':
-      return R"( )";
+      return "\x20";
    case '\"':
      return "\"";
    case '\'':
--- a/src/exp.h
+++ b/src/exp.h
@ -37,7 +37,7 @@ inline const RegEx& Blank() {
  return e;
 }
 inline const RegEx& Break() {
-  static const RegEx e = RegEx('\n') | RegEx("\r\n") | RegEx('\r');
+  static const RegEx e = RegEx('\n') | RegEx("\r\n");
  return e;
 }
 inline const RegEx& BlankOrBreak() {
@ -110,17 +110,13 @@ inline const RegEx& Value() {
  return e;
 }
 inline const RegEx& ValueInFlow() {
-  static const RegEx e = RegEx(':') + (BlankOrBreak() | RegEx(",]}", REGEX_OR));
+  static const RegEx e = RegEx(':') + (BlankOrBreak() | RegEx(",}", REGEX_OR));
  return e;
 }
 inline const RegEx& ValueInJSONFlow() {
  static const RegEx e = RegEx(':');
  return e;
 }
-inline const RegEx& Ampersand() {
-  static const RegEx e = RegEx('&');
-  return e;
-}
 inline const RegEx Comment() {
  static const RegEx e = RegEx('#');
  return e;
@ -159,7 +155,7 @@ inline const RegEx& PlainScalar() {
 inline const RegEx& PlainScalarInFlow() {
  static const RegEx e =
      !(BlankOrBreak() | RegEx("?,[]{}#&*!|>\'\"%@`", REGEX_OR) |
-        (RegEx("-:", REGEX_OR) + (Blank() | RegEx())));
+        (RegEx("-:", REGEX_OR) + Blank()));
  return e;
 }
 inline const RegEx& EndScalar() {
--- a/src/memory.cpp
+++ b/src/memory.cpp
@ -22,5 +22,5 @@ node& memory::create_node() {
 void memory::merge(const memory& rhs) {
  m_nodes.insert(rhs.m_nodes.begin(), rhs.m_nodes.end());
 }
-}  // namespace detail
-}  // namespace YAML
+}
+}
--- a/src/node.cpp
+++ b/src/node.cpp
@ -9,4 +9,4 @@ Node Clone(const Node& node) {
  events.Emit(builder);
  return builder.Root();
 }
-}  // namespace YAML
+}
--- a/src/node_data.cpp
+++ b/src/node_data.cpp
@ -1,4 +1,3 @@
-#include <algorithm>
 #include <cassert>
 #include <iterator>
 #include <sstream>
@ -13,7 +12,7 @@

 namespace YAML {
 namespace detail {
-YAML_CPP_API std::atomic<size_t> node::m_amount{0};
+std::atomic<size_t> node::m_amount{0};

 const std::string& node_data::empty_scalar() {
  static const std::string svalue;
@ -110,9 +109,9 @@ void node_data::compute_seq_size() const {
 }

 void node_data::compute_map_size() const {
-  auto it = m_undefinedPairs.begin();
+  kv_pairs::iterator it = m_undefinedPairs.begin();
  while (it != m_undefinedPairs.end()) {
-    auto jt = std::next(it);
+    kv_pairs::iterator jt = std::next(it);
    if (it->first->is_defined() && it->second->is_defined())
      m_undefinedPairs.erase(it);
    it = jt;
@ -121,7 +120,7 @@ void node_data::compute_map_size() const {

 const_node_iterator node_data::begin() const {
  if (!m_isDefined)
-    return {};
+    return const_node_iterator();

  switch (m_type) {
    case NodeType::Sequence:
@ -129,13 +128,13 @@ const_node_iterator node_data::begin() const {
    case NodeType::Map:
      return const_node_iterator(m_map.begin(), m_map.end());
    default:
-      return {};
+      return const_node_iterator();
  }
 }

 node_iterator node_data::begin() {
  if (!m_isDefined)
-    return {};
+    return node_iterator();

  switch (m_type) {
    case NodeType::Sequence:
@ -143,13 +142,13 @@ node_iterator node_data::begin() {
    case NodeType::Map:
      return node_iterator(m_map.begin(), m_map.end());
    default:
-      return {};
+      return node_iterator();
  }
 }

 const_node_iterator node_data::end() const {
  if (!m_isDefined)
-    return {};
+    return const_node_iterator();

  switch (m_type) {
    case NodeType::Sequence:
@ -157,13 +156,13 @@ const_node_iterator node_data::end() const {
    case NodeType::Map:
      return const_node_iterator(m_map.end(), m_map.end());
    default:
-      return {};
+      return const_node_iterator();
  }
 }

 node_iterator node_data::end() {
  if (!m_isDefined)
-    return {};
+    return node_iterator();

  switch (m_type) {
    case NodeType::Sequence:
@ -171,13 +170,12 @@ node_iterator node_data::end() {
    case NodeType::Map:
      return node_iterator(m_map.end(), m_map.end());
    default:
-      return {};
+      return node_iterator();
  }
 }

 // sequence
-void node_data::push_back(node& node,
-                          const shared_memory_holder& /* pMemory */) {
+void node_data::push_back(node& node, shared_memory_holder /* pMemory */) {
  if (m_type == NodeType::Undefined || m_type == NodeType::Null) {
    m_type = NodeType::Sequence;
    reset_sequence();
@ -189,8 +187,7 @@ void node_data::push_back(node& node,
  m_sequence.push_back(&node);
 }

-void node_data::insert(node& key, node& value,
-                       const shared_memory_holder& pMemory) {
+void node_data::insert(node& key, node& value, shared_memory_holder pMemory) {
  switch (m_type) {
    case NodeType::Map:
      break;
@ -207,21 +204,20 @@ void node_data::insert(node& key, node& value,
 }

 // indexing
-node* node_data::get(node& key,
-                     const shared_memory_holder& /* pMemory */) const {
+node* node_data::get(node& key, shared_memory_holder /* pMemory */) const {
  if (m_type != NodeType::Map) {
    return nullptr;
  }

-  for (const auto& it : m_map) {
-    if (it.first->is(key))
-      return it.second;
+  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
+    if (it->first->is(key))
+      return it->second;
  }

  return nullptr;
 }

-node& node_data::get(node& key, const shared_memory_holder& pMemory) {
+node& node_data::get(node& key, shared_memory_holder pMemory) {
  switch (m_type) {
    case NodeType::Map:
      break;
@ -234,9 +230,9 @@ node& node_data::get(node& key, const shared_memory_holder& pMemory) {
      throw BadSubscript(m_mark, key);
  }

-  for (const auto& it : m_map) {
-    if (it.first->is(key))
-      return *it.second;
+  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
+    if (it->first->is(key))
+      return *it->second;
  }

  node& value = pMemory->create_node();
@ -244,26 +240,23 @@ node& node_data::get(node& key, const shared_memory_holder& pMemory) {
  return value;
 }

-bool node_data::remove(node& key, const shared_memory_holder& /* pMemory */) {
+bool node_data::remove(node& key, shared_memory_holder /* pMemory */) {
  if (m_type != NodeType::Map)
    return false;

-  for (auto it = m_undefinedPairs.begin(); it != m_undefinedPairs.end();) {
-    auto jt = std::next(it);
+  for (kv_pairs::iterator it = m_undefinedPairs.begin();
+       it != m_undefinedPairs.end();) {
+    kv_pairs::iterator jt = std::next(it);
    if (it->first->is(key))
      m_undefinedPairs.erase(it);
    it = jt;
  }

-  auto it =
-      std::find_if(m_map.begin(), m_map.end(),
-                   [&](std::pair<YAML::detail::node*, YAML::detail::node*> j) {
-                     return (j.first->is(key));
-                   });
-
-  if (it != m_map.end()) {
-    m_map.erase(it);
-    return true;
+  for (node_map::iterator it = m_map.begin(); it != m_map.end(); ++it) {
+    if (it->first->is(key)) {
+      m_map.erase(it);
+      return true;
+    }
  }

  return false;
@ -286,7 +279,7 @@ void node_data::insert_map_pair(node& key, node& value) {
    m_undefinedPairs.emplace_back(&key, &value);
 }

-void node_data::convert_to_map(const shared_memory_holder& pMemory) {
+void node_data::convert_to_map(shared_memory_holder pMemory) {
  switch (m_type) {
    case NodeType::Undefined:
    case NodeType::Null:
@ -304,7 +297,7 @@ void node_data::convert_to_map(const shared_memory_holder& pMemory) {
  }
 }

-void node_data::convert_sequence_to_map(const shared_memory_holder& pMemory) {
+void node_data::convert_sequence_to_map(shared_memory_holder pMemory) {
  assert(m_type == NodeType::Sequence);

  reset_map();
--- a/src/nodebuilder.cpp
+++ b/src/nodebuilder.cpp
@ -92,7 +92,7 @@ void NodeBuilder::Push(detail::node& node) {

  m_stack.push_back(&node);
  if (needsKey)
-    m_keys.emplace_back(&node, false);
+    m_keys.push_back(PushedKey(&node, false));
 }

 void NodeBuilder::Pop() {
--- a/src/nodeevents.cpp
+++ b/src/nodeevents.cpp
@ -13,7 +13,7 @@ void NodeEvents::AliasManager::RegisterReference(const detail::node& node) {

 anchor_t NodeEvents::AliasManager::LookupAnchor(
    const detail::node& node) const {
-  auto it = m_anchorByIdentity.find(node.ref());
+  AnchorByIdentity::const_iterator it = m_anchorByIdentity.find(node.ref());
  if (it == m_anchorByIdentity.end())
    return 0;
  return it->second;
@ -32,12 +32,13 @@ void NodeEvents::Setup(const detail::node& node) {
    return;

  if (node.type() == NodeType::Sequence) {
-    for (auto element : node)
-      Setup(*element);
+    for (detail::const_node_iterator it = node.begin(); it != node.end(); ++it)
+      Setup(**it);
  } else if (node.type() == NodeType::Map) {
-    for (auto element : node) {
-      Setup(*element.first);
-      Setup(*element.second);
+    for (detail::const_node_iterator it = node.begin(); it != node.end();
+         ++it) {
+      Setup(*it->first);
+      Setup(*it->second);
    }
  }
 }
@ -76,15 +77,17 @@ void NodeEvents::Emit(const detail::node& node, EventHandler& handler,
      break;
    case NodeType::Sequence:
      handler.OnSequenceStart(Mark(), node.tag(), anchor, node.style());
-      for (auto element : node)
-        Emit(*element, handler, am);
+      for (detail::const_node_iterator it = node.begin(); it != node.end();
+           ++it)
+        Emit(**it, handler, am);
      handler.OnSequenceEnd();
      break;
    case NodeType::Map:
      handler.OnMapStart(Mark(), node.tag(), anchor, node.style());
-      for (auto element : node) {
-        Emit(*element.first, handler, am);
-        Emit(*element.second, handler, am);
+      for (detail::const_node_iterator it = node.begin(); it != node.end();
+           ++it) {
+        Emit(*it->first, handler, am);
+        Emit(*it->second, handler, am);
      }
      handler.OnMapEnd();
      break;
@ -92,7 +95,7 @@ void NodeEvents::Emit(const detail::node& node, EventHandler& handler,
 }

 bool NodeEvents::IsAliased(const detail::node& node) const {
-  auto it = m_refCount.find(node.ref());
+  RefCount::const_iterator it = m_refCount.find(node.ref());
  return it != m_refCount.end() && it->second > 1;
 }
 }  // namespace YAML
--- a/src/null.cpp
+++ b/src/null.cpp
@ -7,4 +7,4 @@ bool IsNullString(const std::string& str) {
  return str.empty() || str == "~" || str == "null" || str == "Null" ||
         str == "NULL";
 }
-}  // namespace YAML
+}
--- a/src/parse.cpp
+++ b/src/parse.cpp
@ -3,10 +3,10 @@
 #include <fstream>
 #include <sstream>

-#include "nodebuilder.h"
-#include "yaml-cpp/node/impl.h"
 #include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/impl.h"
 #include "yaml-cpp/parser.h"
+#include "nodebuilder.h"

 namespace YAML {
 Node Load(const std::string& input) {
@ -30,9 +30,9 @@ Node Load(std::istream& input) {
 }

 Node LoadFile(const std::string& filename) {
-  std::ifstream fin(filename);
+  std::ifstream fin(filename.c_str());
  if (!fin) {
-    throw BadFile(filename);
+    throw BadFile();
  }
  return Load(fin);
 }
@ -51,7 +51,7 @@ std::vector<Node> LoadAll(std::istream& input) {
  std::vector<Node> docs;

  Parser parser(input);
-  while (true) {
+  while (1) {
    NodeBuilder builder;
    if (!parser.HandleNextDocument(builder)) {
      break;
@ -63,9 +63,9 @@ std::vector<Node> LoadAll(std::istream& input) {
 }

 std::vector<Node> LoadAllFromFile(const std::string& filename) {
-  std::ifstream fin(filename);
+  std::ifstream fin(filename.c_str());
  if (!fin) {
-    throw BadFile(filename);
+    throw BadFile();
  }
  return LoadAll(fin);
 }
--- a/src/parser.cpp
+++ b/src/parser.cpp
@ -17,7 +17,9 @@ Parser::Parser(std::istream& in) : Parser() { Load(in); }

 Parser::~Parser() = default;

-Parser::operator bool() const { return m_pScanner && !m_pScanner->empty(); }
+Parser::operator bool() const {
+  return m_pScanner && !m_pScanner->empty();
+}

 void Parser::Load(std::istream& in) {
  m_pScanner.reset(new Scanner(in));
--- a/src/scanner.cpp
+++ b/src/scanner.cpp
@ -51,7 +51,7 @@ Token& Scanner::peek() {
 Mark Scanner::mark() const { return INPUT.mark(); }

 void Scanner::EnsureTokensInQueue() {
-  while (true) {
+  while (1) {
    if (!m_tokens.empty()) {
      Token& token = m_tokens.front();

@ -88,7 +88,7 @@ void Scanner::ScanNextToken() {
    return StartStream();
  }

-  // get rid of whitespace, etc. (in between tokens it should be irrelevant)
+  // get rid of whitespace, etc. (in between tokens it should be irrelevent)
  ScanToNextToken();

  // maybe need to end some blocks
@ -174,7 +174,7 @@ void Scanner::ScanNextToken() {
 }

 void Scanner::ScanToNextToken() {
-  while (true) {
+  while (1) {
    // first eat whitespace
    while (INPUT && IsWhitespaceToBeEaten(INPUT.peek())) {
      if (InBlockContext() && Exp::Tab().Matches(INPUT)) {
--- a/src/scanner.h
+++ b/src/scanner.h
@ -9,7 +9,9 @@

 #include <cstddef>
 #include <ios>
+#include <map>
 #include <queue>
+#include <set>
 #include <stack>
 #include <string>

--- a/src/scanscalar.cpp
+++ b/src/scanscalar.cpp
@ -47,8 +47,7 @@ std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) {
      if (INPUT.column() == 0 && Exp::DocIndicator().Matches(INPUT)) {
        if (params.onDocIndicator == BREAK) {
          break;
-        }
-        if (params.onDocIndicator == THROW) {
+        } else if (params.onDocIndicator == THROW) {
          throw ParserException(INPUT.mark(), ErrorMsg::DOC_IN_SCALAR);
        }
      }
@ -204,7 +203,7 @@ std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) {

  // post-processing
  if (params.trimTrailingSpaces) {
-    std::size_t pos = scalar.find_last_not_of(" \t");
+    std::size_t pos = scalar.find_last_not_of(' ');
    if (lastEscapedChar != std::string::npos) {
      if (pos < lastEscapedChar || pos == std::string::npos) {
        pos = lastEscapedChar;
@ -248,4 +247,4 @@ std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) {

  return scalar;
 }
-}  // namespace YAML
+}
--- a/src/scanscalar.h
+++ b/src/scanscalar.h
@ -57,7 +57,7 @@ struct ScanScalarParams {
  bool leadingSpaces;
 };

-std::string ScanScalar(Stream& INPUT, ScanScalarParams& params);
+std::string ScanScalar(Stream& INPUT, ScanScalarParams& info);
 }

 #endif  // SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/src/scantag.cpp
+++ b/src/scantag.cpp
@ -78,4 +78,4 @@ const std::string ScanTagSuffix(Stream& INPUT) {

  return tag;
 }
-}  // namespace YAML
+}
--- a/src/scantoken.cpp
+++ b/src/scantoken.cpp
@ -37,7 +37,7 @@ void Scanner::ScanDirective() {
    token.value += INPUT.get();

  // read parameters
-  while (true) {
+  while (1) {
    // first get rid of whitespace
    while (Exp::Blank().Matches(INPUT))
      INPUT.eat(1);
@ -171,7 +171,7 @@ void Scanner::ScanBlockEntry() {

 // Key
 void Scanner::ScanKey() {
-  // handle keys differently in the block context (and manage indents)
+  // handle keys diffently in the block context (and manage indents)
  if (InBlockContext()) {
    if (!m_simpleKeyAllowed)
      throw ParserException(INPUT.mark(), ErrorMsg::MAP_KEY);
@ -199,7 +199,7 @@ void Scanner::ScanValue() {
    // seems fine)
    m_simpleKeyAllowed = false;
  } else {
-    // handle values differently in the block context (and manage indents)
+    // handle values diffently in the block context (and manage indents)
    if (InBlockContext()) {
      if (!m_simpleKeyAllowed)
        throw ParserException(INPUT.mark(), ErrorMsg::MAP_VALUE);
--- a/src/setting.h
+++ b/src/setting.h
@ -83,8 +83,9 @@ class SettingChanges {
  }

  void restore() YAML_CPP_NOEXCEPT {
-    for (const auto& setting : m_settingChanges)
-      setting->pop();
+    for (setting_changes::const_iterator it = m_settingChanges.begin();
+         it != m_settingChanges.end(); ++it)
+      (*it)->pop();
  }

  void push(std::unique_ptr<SettingChangeBase> pSettingChange) {
--- a/src/simplekey.cpp
+++ b/src/simplekey.cpp
@ -5,11 +5,7 @@ namespace YAML {
 struct Mark;

 Scanner::SimpleKey::SimpleKey(const Mark& mark_, std::size_t flowLevel_)
-    : mark(mark_),
-      flowLevel(flowLevel_),
-      pIndent(nullptr),
-      pMapStart(nullptr),
-      pKey(nullptr) {}
+    : mark(mark_), flowLevel(flowLevel_), pIndent(nullptr), pMapStart(nullptr), pKey(nullptr) {}

 void Scanner::SimpleKey::Validate() {
  // Note: pIndent will *not* be garbage here;
@ -129,4 +125,4 @@ void Scanner::PopAllSimpleKeys() {
  while (!m_simpleKeys.empty())
    m_simpleKeys.pop();
 }
-}  // namespace YAML
+}
--- a/src/singledocparser.cpp
+++ b/src/singledocparser.cpp
@ -7,7 +7,6 @@
 #include "singledocparser.h"
 #include "tag.h"
 #include "token.h"
-#include "yaml-cpp/depthguard.h"
 #include "yaml-cpp/emitterstyle.h"
 #include "yaml-cpp/eventhandler.h"
 #include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
@ -48,8 +47,6 @@ void SingleDocParser::HandleDocument(EventHandler& eventHandler) {
 }

 void SingleDocParser::HandleNode(EventHandler& eventHandler) {
-  DepthGuard<500> depthguard(depth, m_scanner.mark(), ErrorMsg::BAD_FILE);
-
  // an empty node *is* a possibility
  if (m_scanner.empty()) {
    eventHandler.OnNull(m_scanner.mark(), NullAnchor);
@ -90,17 +87,16 @@ void SingleDocParser::HandleNode(EventHandler& eventHandler) {

  const Token& token = m_scanner.peek();

-  // add non-specific tags
-  if (tag.empty())
-    tag = (token.type == Token::NON_PLAIN_SCALAR ? "!" : "?");
-  
-  if (token.type == Token::PLAIN_SCALAR 
-      && tag.compare("?") == 0 && IsNullString(token.value)) {
+  if (token.type == Token::PLAIN_SCALAR && IsNullString(token.value)) {
    eventHandler.OnNull(mark, anchor);
    m_scanner.pop();
    return;
  }

+  // add non-specific tags
+  if (tag.empty())
+    tag = (token.type == Token::NON_PLAIN_SCALAR ? "!" : "?");
+
  // now split based on what kind of node we should be
  switch (token.type) {
    case Token::PLAIN_SCALAR:
@ -167,7 +163,7 @@ void SingleDocParser::HandleBlockSequence(EventHandler& eventHandler) {
  m_scanner.pop();
  m_pCollectionStack->PushCollectionType(CollectionType::BlockSeq);

-  while (true) {
+  while (1) {
    if (m_scanner.empty())
      throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ);

@ -200,7 +196,7 @@ void SingleDocParser::HandleFlowSequence(EventHandler& eventHandler) {
  m_scanner.pop();
  m_pCollectionStack->PushCollectionType(CollectionType::FlowSeq);

-  while (true) {
+  while (1) {
    if (m_scanner.empty())
      throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ_FLOW);

@ -253,7 +249,7 @@ void SingleDocParser::HandleBlockMap(EventHandler& eventHandler) {
  m_scanner.pop();
  m_pCollectionStack->PushCollectionType(CollectionType::BlockMap);

-  while (true) {
+  while (1) {
    if (m_scanner.empty())
      throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP);

@ -292,7 +288,7 @@ void SingleDocParser::HandleFlowMap(EventHandler& eventHandler) {
  m_scanner.pop();
  m_pCollectionStack->PushCollectionType(CollectionType::FlowMap);

-  while (true) {
+  while (1) {
    if (m_scanner.empty())
      throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP_FLOW);

@ -377,7 +373,7 @@ void SingleDocParser::ParseProperties(std::string& tag, anchor_t& anchor,
  anchor_name.clear();
  anchor = NullAnchor;

-  while (true) {
+  while (1) {
    if (m_scanner.empty())
      return;

@ -423,12 +419,9 @@ anchor_t SingleDocParser::RegisterAnchor(const std::string& name) {

 anchor_t SingleDocParser::LookupAnchor(const Mark& mark,
                                       const std::string& name) const {
-  auto it = m_anchors.find(name);
-  if (it == m_anchors.end()) {
-    std::stringstream ss;
-    ss << ErrorMsg::UNKNOWN_ANCHOR << name;
-    throw ParserException(mark, ss.str());
-  }
+  Anchors::const_iterator it = m_anchors.find(name);
+  if (it == m_anchors.end())
+    throw ParserException(mark, ErrorMsg::UNKNOWN_ANCHOR);

  return it->second;
 }
--- a/src/singledocparser.h
+++ b/src/singledocparser.h
@ -15,7 +15,6 @@

 namespace YAML {
 class CollectionStack;
-template <int> class DepthGuard; // depthguard.h
 class EventHandler;
 class Node;
 class Scanner;
@ -56,7 +55,6 @@ class SingleDocParser {
  anchor_t LookupAnchor(const Mark& mark, const std::string& name) const;

 private:
-  int depth = 0;
  Scanner& m_scanner;
  const Directives& m_directives;
  std::unique_ptr<CollectionStack> m_pCollectionStack;
--- a/src/stream.cpp
+++ b/src/stream.cpp
@ -151,8 +151,7 @@ inline UtfIntroCharType IntroCharTypeOf(std::istream::int_type ch) {

 inline char Utf8Adjust(unsigned long ch, unsigned char lead_bits,
                       unsigned char rshift) {
-  const unsigned char header =
-      static_cast<unsigned char>(((1 << lead_bits) - 1) << (8 - lead_bits));
+  const unsigned char header = static_cast<unsigned char>(((1 << lead_bits) - 1) << (8 - lead_bits));
  const unsigned char mask = (0xFF >> (lead_bits + 1));
  return static_cast<char>(
      static_cast<unsigned char>(header | ((ch >> rshift) & mask)));
@ -274,7 +273,7 @@ char Stream::get() {
 // . Extracts 'n' characters from the stream and updates our position
 std::string Stream::get(int n) {
  std::string ret;
-  if (n > 0) {
+  if(n > 0) {
    ret.reserve(static_cast<std::string::size_type>(n));
    for (int i = 0; i < n; i++)
      ret += get();
@ -350,9 +349,7 @@ void Stream::StreamInUtf16() const {
    // Trailing (low) surrogate...ugh, wrong order
    QueueUnicodeCodepoint(m_readahead, CP_REPLACEMENT_CHARACTER);
    return;
-  }
-
-  if (ch >= 0xD800 && ch < 0xDC00) {
+  } else if (ch >= 0xD800 && ch < 0xDC00) {
    // ch is a leading (high) surrogate

    // Four byte UTF-8 code point
@ -377,10 +374,11 @@ void Stream::StreamInUtf16() const {
          // Easiest case: queue the codepoint and return
          QueueUnicodeCodepoint(m_readahead, ch);
          return;
+        } else {
+          // Start the loop over with the new high surrogate
+          ch = chLow;
+          continue;
        }
-        // Start the loop over with the new high surrogate
-        ch = chLow;
-        continue;
      }

      // Select the payload bits from the high surrogate
--- a/src/tag.cpp
+++ b/src/tag.cpp
@ -29,7 +29,7 @@ Tag::Tag(const Token& token)
  }
 }

-std::string Tag::Translate(const Directives& directives) {
+const std::string Tag::Translate(const Directives& directives) {
  switch (type) {
    case VERBATIM:
      return value;
--- a/src/tag.h
+++ b/src/tag.h
@ -23,7 +23,7 @@ struct Tag {
  };

  Tag(const Token& token);
-  std::string Translate(const Directives& directives);
+  const std::string Translate(const Directives& directives);

  TYPE type;
  std::string handle, value;
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@ -4,17 +4,11 @@ set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
 set(BUILD_MOCK ON CACHE BOOL "" FORCE)
 set(CMAKE_POLICY_DEFAULT_CMP0048 NEW)

-if(YAML_USE_SYSTEM_GTEST)
-  find_package(GTest)
-  if (NOT GTEST_FOUND)
-    message(FATAL_ERROR "system googletest was requested but not found")
-  endif()
-else()
-    add_subdirectory(
-      "${CMAKE_CURRENT_SOURCE_DIR}/gtest-1.11.0"
-      "${CMAKE_CURRENT_BINARY_DIR}/prefix")
-    include_directories(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/gtest-1.11.0/googletest/include")
-endif()
+add_subdirectory(
+  "${CMAKE_CURRENT_SOURCE_DIR}/gtest-1.10.0"
+  "${CMAKE_CURRENT_BINARY_DIR}/prefix")
+
+include_directories(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/gtest-1.10.0/googletest/include")

 set(test-new-api-pattern "new-api/*.cpp")
 set(test-source-pattern "*.cpp" "integration/*.cpp" "node/*.cpp")
@ -39,12 +33,11 @@ target_include_directories(yaml-cpp-tests
 target_compile_options(yaml-cpp-tests
  PRIVATE
    $<$<CXX_COMPILER_ID:Clang>:-Wno-c99-extensions -Wno-variadic-macros -Wno-sign-compare>
-    $<$<CXX_COMPILER_ID:GNU>:-Wno-variadic-macros -Wno-sign-compare -Wno-narrowing>)
+    $<$<CXX_COMPILER_ID:GNU>:-Wno-variadic-macros -Wno-sign-compare>)
 target_link_libraries(yaml-cpp-tests
  PRIVATE
    Threads::Threads
    yaml-cpp
-    gtest
    gmock)

 set_property(TARGET yaml-cpp-tests PROPERTY CXX_STANDARD_REQUIRED ON)
@ -53,11 +46,4 @@ if (NOT DEFINED CMAKE_CXX_STANDARD)
 endif()


-add_test(NAME yaml-cpp::test COMMAND yaml-cpp-tests)
-
-if (build-windows-dll)
-  add_custom_command(
-    TARGET yaml-cpp-tests
-    POST_BUILD COMMAND ${CMAKE_COMMAND} -E
-    copy_if_different "$<TARGET_FILE:yaml-cpp>" "$<TARGET_FILE_DIR:yaml-cpp-tests>")
-endif()
+add_test(yaml-cpp::test yaml-cpp-tests)
--- a/test/binary_test.cpp
+++ b/test/binary_test.cpp
@ -1,14 +0,0 @@
-#include "gtest/gtest.h"
-#include <yaml-cpp/binary.h>
-
-TEST(BinaryTest, DecodingSimple) {
-  std::string input{90, 71, 86, 104, 90, 71, 74, 108, 90, 87, 89, 61};
-  const std::vector<unsigned char> &result = YAML::DecodeBase64(input);
-  EXPECT_EQ(std::string(result.begin(), result.end()), "deadbeef");
-}
-
-TEST(BinaryTest, DecodingNoCrashOnNegative) {
-  std::string input{-58, -1, -99, 109};
-  const std::vector<unsigned char> &result = YAML::DecodeBase64(input);
-  EXPECT_TRUE(result.empty());
-}
--- a/test/cmake/CMakeLists.txt
+++ b/test/cmake/CMakeLists.txt
@ -1,21 +0,0 @@
-cmake_minimum_required(VERSION 3.5)
-project(yaml-cpp-consumer LANGUAGES CXX)
-
-find_package(yaml-cpp CONFIG REQUIRED)
-get_target_property(LIBRARY_TYPE yaml-cpp::yaml-cpp TYPE)
-
-if(LIBRARY_TYPE STREQUAL "SHARED_LIBRARY")
-  if(NOT YAML_CPP_SHARED_LIBS_BUILT)
-    message(FATAL_ERROR "Library type (${LIBRARY_TYPE}) contradicts config: ${YAML_CPP_SHARED_LIBS_BUILT}")
-  endif()
-else()
-  if(YAML_CPP_SHARED_LIBS_BUILT)
-    message(FATAL_ERROR "Library type (${LIBRARY_TYPE}) contradicts config: ${YAML_CPP_SHARED_LIBS_BUILT}")
-  endif()
-endif()
-
-add_executable(main main.cpp)
-if (NOT DEFINED CMAKE_CXX_STANDARD)
-  set_target_properties(main PROPERTIES CXX_STANDARD 11)
-endif()
-target_link_libraries(main PRIVATE ${YAML_CPP_LIBRARIES})
--- a/test/cmake/main.cpp
+++ b/test/cmake/main.cpp
@ -1,3 +0,0 @@
-#include "yaml-cpp/yaml.h"
-
-int main(int, char**) { YAML::Parser foo{}; }
--- a/test/gtest-1.10.0/.clang-format
+++ b/test/gtest-1.10.0/.clang-format
--- a/test/gtest-1.10.0/.gitignore
+++ b/test/gtest-1.10.0/.gitignore
--- a/test/gtest-1.10.0/.travis.yml
+++ b/test/gtest-1.10.0/.travis.yml
@ -0,0 +1,73 @@
+# Build matrix / environment variable are explained on:
+# https://docs.travis-ci.com/user/customizing-the-build/
+# This file can be validated on:
+# http://lint.travis-ci.org/
+
+language: cpp
+
+# Define the matrix explicitly, manually expanding the combinations of (os, compiler, env).
+# It is more tedious, but grants us far more flexibility.
+matrix:
+  include:
+    - os: linux
+      before_install: chmod -R +x ./ci/*platformio.sh
+      install: ./ci/install-platformio.sh
+      script: ./ci/build-platformio.sh
+    - os: linux
+      dist: xenial
+      compiler: gcc
+      install: ./ci/install-linux.sh && ./ci/log-config.sh
+      script: ./ci/build-linux-bazel.sh
+    - os: linux
+      dist: xenial
+      compiler: clang
+      install: ./ci/install-linux.sh && ./ci/log-config.sh
+      script: ./ci/build-linux-bazel.sh
+    - os: linux
+      compiler: gcc
+      env: BUILD_TYPE=Debug VERBOSE=1 CXX_FLAGS=-std=c++11
+    - os: linux
+      compiler: clang
+      env: BUILD_TYPE=Release VERBOSE=1 CXX_FLAGS=-std=c++11 -Wgnu-zero-variadic-macro-arguments
+    - os: linux
+      compiler: clang
+      env: BUILD_TYPE=Release VERBOSE=1 CXX_FLAGS=-std=c++11 NO_EXCEPTION=ON NO_RTTI=ON COMPILER_IS_GNUCXX=ON
+    - os: osx
+      compiler: gcc
+      env: BUILD_TYPE=Release VERBOSE=1 CXX_FLAGS=-std=c++11 HOMEBREW_LOGS=~/homebrew-logs HOMEBREW_TEMP=~/homebrew-temp
+    - os: osx
+      compiler: clang
+      env: BUILD_TYPE=Release VERBOSE=1 CXX_FLAGS=-std=c++11 HOMEBREW_LOGS=~/homebrew-logs HOMEBREW_TEMP=~/homebrew-temp
+
+# These are the install and build (script) phases for the most common entries in the matrix.  They could be included
+# in each entry in the matrix, but that is just repetitive.
+install:
+  - ./ci/install-${TRAVIS_OS_NAME}.sh
+  - . ./ci/env-${TRAVIS_OS_NAME}.sh
+  - ./ci/log-config.sh
+
+script: ./ci/travis.sh
+
+# This section installs the necessary dependencies.
+addons:
+  apt:
+    # List of whitelisted in travis packages for ubuntu-precise can be found here:
+    #   https://github.com/travis-ci/apt-package-whitelist/blob/master/ubuntu-precise
+    # List of whitelisted in travis apt-sources:
+    #   https://github.com/travis-ci/apt-source-whitelist/blob/master/ubuntu.json
+    sources:
+    - ubuntu-toolchain-r-test
+    - llvm-toolchain-precise-3.9
+    packages:
+    - g++-4.9
+    - clang-3.9
+    update: true
+  homebrew:
+    packages:
+    - ccache
+    - gcc@4.9
+    - llvm@4
+    update: true
+
+notifications:
+  email: false
--- a/test/gtest-1.10.0/BUILD.bazel
+++ b/test/gtest-1.10.0/BUILD.bazel
@ -36,19 +36,9 @@ package(default_visibility = ["//visibility:public"])

 licenses(["notice"])

-exports_files(["LICENSE"])
-
 config_setting(
    name = "windows",
-    constraint_values = ["@platforms//os:windows"],
-)
-
-config_setting(
-    name = "msvc_compiler",
-    flag_values = {
-        "@bazel_tools//tools/cpp:compiler": "msvc-cl",
-    },
-    visibility = [":__subpackages__"],
+    constraint_values = ["@bazel_tools//platforms:windows"],
 )

 config_setting(
@ -113,7 +103,6 @@ cc_library(
            "@com_google_absl//absl/debugging:stacktrace",
            "@com_google_absl//absl/debugging:symbolize",
            "@com_google_absl//absl/strings",
-            "@com_google_absl//absl/types:any",
            "@com_google_absl//absl/types:optional",
            "@com_google_absl//absl/types:variant",
        ],
--- a/test/gtest-1.10.0/CMakeLists.txt
+++ b/test/gtest-1.10.0/CMakeLists.txt
@ -1,17 +1,21 @@
 # Note: CMake support is community-based. The maintainers do not use CMake
 # internally.

-cmake_minimum_required(VERSION 2.8.12)
+cmake_minimum_required(VERSION 2.8.8)

 if (POLICY CMP0048)
  cmake_policy(SET CMP0048 NEW)
 endif (POLICY CMP0048)

 project(googletest-distribution)
-set(GOOGLETEST_VERSION 1.11.0)
+set(GOOGLETEST_VERSION 1.10.0)

-if (CMAKE_VERSION VERSION_GREATER "3.0.2")
-  if(NOT CYGWIN AND NOT MSYS AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL QNX)
+if (CMAKE_VERSION VERSION_LESS "3.1")
+  add_definitions(-std=c++11)
+else()
+  set(CMAKE_CXX_STANDARD 11)
+  set(CMAKE_CXX_STANDARD_REQUIRED ON)
+  if(NOT CYGWIN)
    set(CMAKE_CXX_EXTENSIONS OFF)
  endif()
 endif()
--- a/test/gtest-1.10.0/CONTRIBUTING.md
+++ b/test/gtest-1.10.0/CONTRIBUTING.md
@ -28,7 +28,7 @@ PR is acceptable as an alternative.
 ## Contributing A Patch

 1.  Submit an issue describing your proposed change to the
-    [issue tracker](https://github.com/google/googletest/issues).
+    [issue tracker](https://github.com/google/googletest).
 2.  Please don't mix more than one logical change per submittal, because it
    makes the history hard to follow. If you want to make a change that doesn't
    have a corresponding issue in the issue tracker, please create one.
@ -80,7 +80,7 @@ fairly rigid coding style, as defined by the
 will be expected to conform to the style outlined
 [here](https://google.github.io/styleguide/cppguide.html). Use
 [.clang-format](https://github.com/google/googletest/blob/master/.clang-format)
-to check your formatting.
+to check your formatting

 ## Requirements for Contributors

@ -89,7 +89,7 @@ and their own tests from a git checkout, which has further requirements:

 *   [Python](https://www.python.org/) v2.3 or newer (for running some of the
    tests and re-generating certain source files from templates)
-*   [CMake](https://cmake.org/) v2.8.12 or newer
+*   [CMake](https://cmake.org/) v2.6.4 or newer

 ## Developing Google Test and Google Mock

@ -128,3 +128,15 @@ To run the tests, do
    make test

 All tests should pass.
+
+### Regenerating Source Files
+
+Some of Google Test's source files are generated from templates (not in the C++
+sense) using a script. For example, the file
+include/gtest/internal/gtest-type-util.h.pump is used to generate
+gtest-type-util.h in the same directory.
+
+You don't need to worry about regenerating the source files unless you need to
+modify them. You would then modify the corresponding `.pump` files and run the
+'[pump.py](googletest/scripts/pump.py)' generator script. See the
+[Pump Manual](googletest/docs/pump_manual.md).
--- a/test/gtest-1.10.0/LICENSE
+++ b/test/gtest-1.10.0/LICENSE
--- a/test/gtest-1.10.0/README.md
+++ b/test/gtest-1.10.0/README.md
@ -0,0 +1,134 @@
+# Google Test
+
+#### OSS Builds Status:
+
+[![Build Status](https://api.travis-ci.org/google/googletest.svg?branch=master)](https://travis-ci.org/google/googletest)
+[![Build status](https://ci.appveyor.com/api/projects/status/4o38plt0xbo1ubc8/branch/master?svg=true)](https://ci.appveyor.com/project/GoogleTestAppVeyor/googletest/branch/master)
+
+### Future Plans
+
+#### 1.8.x Release:
+
+[the 1.8.x](https://github.com/google/googletest/releases/tag/release-1.8.1) is
+the last release that works with pre-C++11 compilers. The 1.8.x will not accept
+any requests for any new features and any bugfix requests will only be accepted
+if proven "critical"
+
+#### Post 1.8.x:
+
+On-going work to improve/cleanup/pay technical debt. When this work is completed
+there will be a 1.9.x tagged release
+
+#### Post 1.9.x
+
+Post 1.9.x googletest will follow
+[Abseil Live at Head philosophy](https://abseil.io/about/philosophy)
+
+## Welcome to **Google Test**, Google's C++ test framework!
+
+This repository is a merger of the formerly separate GoogleTest and GoogleMock
+projects. These were so closely related that it makes sense to maintain and
+release them together.
+
+Please subscribe to the mailing list at googletestframework@googlegroups.com for
+questions, discussions, and development.
+
+### Getting started:
+
+The information for **Google Test** is available in the
+[Google Test Primer](googletest/docs/primer.md) documentation.
+
+**Google Mock** is an extension to Google Test for writing and using C++ mock
+classes. See the separate [Google Mock documentation](googlemock/README.md).
+
+More detailed documentation for googletest is in its interior
+[googletest/README.md](googletest/README.md) file.
+
+## Features
+
+*   An [xUnit](https://en.wikipedia.org/wiki/XUnit) test framework.
+*   Test discovery.
+*   A rich set of assertions.
+*   User-defined assertions.
+*   Death tests.
+*   Fatal and non-fatal failures.
+*   Value-parameterized tests.
+*   Type-parameterized tests.
+*   Various options for running the tests.
+*   XML test report generation.
+
+## Platforms
+
+Google test has been used on a variety of platforms:
+
+*   Linux
+*   Mac OS X
+*   Windows
+*   Cygwin
+*   MinGW
+*   Windows Mobile
+*   Symbian
+*   PlatformIO
+
+## Who Is Using Google Test?
+
+In addition to many internal projects at Google, Google Test is also used by the
+following notable projects:
+
+*   The [Chromium projects](http://www.chromium.org/) (behind the Chrome browser
+    and Chrome OS).
+*   The [LLVM](http://llvm.org/) compiler.
+*   [Protocol Buffers](https://github.com/google/protobuf), Google's data
+    interchange format.
+*   The [OpenCV](http://opencv.org/) computer vision library.
+*   [tiny-dnn](https://github.com/tiny-dnn/tiny-dnn): header only,
+    dependency-free deep learning framework in C++11.
+
+## Related Open Source Projects
+
+[GTest Runner](https://github.com/nholthaus/gtest-runner) is a Qt5 based
+automated test-runner and Graphical User Interface with powerful features for
+Windows and Linux platforms.
+
+[Google Test UI](https://github.com/ospector/gtest-gbar) is test runner that
+runs your test binary, allows you to track its progress via a progress bar, and
+displays a list of test failures. Clicking on one shows failure text. Google
+Test UI is written in C#.
+
+[GTest TAP Listener](https://github.com/kinow/gtest-tap-listener) is an event
+listener for Google Test that implements the
+[TAP protocol](https://en.wikipedia.org/wiki/Test_Anything_Protocol) for test
+result output. If your test runner understands TAP, you may find it useful.
+
+[gtest-parallel](https://github.com/google/gtest-parallel) is a test runner that
+runs tests from your binary in parallel to provide significant speed-up.
+
+[GoogleTest Adapter](https://marketplace.visualstudio.com/items?itemName=DavidSchuldenfrei.gtest-adapter)
+is a VS Code extension allowing to view Google Tests in a tree view, and
+run/debug your tests.
+
+## Requirements
+
+Google Test is designed to have fairly minimal requirements to build and use
+with your projects, but there are some. If you notice any problems on your
+platform, please notify
+[googletestframework@googlegroups.com](https://groups.google.com/forum/#!forum/googletestframework).
+Patches for fixing them are welcome!
+
+### Build Requirements
+
+These are the base requirements to build and use Google Test from a source
+package:
+
+*   [Bazel](https://bazel.build/) or [CMake](https://cmake.org/). NOTE: Bazel is
+    the build system that googletest is using internally and tests against.
+    CMake is community-supported.
+
+*   a C++11-standard-compliant compiler
+
+## Contributing change
+
+Please read the [`CONTRIBUTING.md`](CONTRIBUTING.md) for details on how to
+contribute to this project.
+
+Happy testing!
--- a/test/gtest-1.10.0/WORKSPACE
+++ b/test/gtest-1.10.0/WORKSPACE
@ -0,0 +1,23 @@
+workspace(name = "com_google_googletest")
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+# Abseil
+http_archive(
+     name = "com_google_absl",
+     urls = ["https://github.com/abseil/abseil-cpp/archive/master.zip"],
+     strip_prefix = "abseil-cpp-master",
+)
+
+http_archive(
+    name = "rules_cc",
+    strip_prefix = "rules_cc-master",
+    urls = ["https://github.com/bazelbuild/rules_cc/archive/master.zip"],
+)
+
+http_archive(
+    name = "rules_python",
+    strip_prefix = "rules_python-master",
+    urls = ["https://github.com/bazelbuild/rules_python/archive/master.zip"],
+)
+
--- a/test/gtest-1.10.0/appveyor.yml
+++ b/test/gtest-1.10.0/appveyor.yml
@ -0,0 +1,154 @@
+version: '{build}'
+
+os: Visual Studio 2015
+
+environment:
+  matrix:
+    - compiler: msvc-15-seh
+      generator: "Visual Studio 15 2017"
+      build_system: cmake
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+
+    - compiler: msvc-15-seh
+      generator: "Visual Studio 15 2017 Win64"
+      build_system: cmake
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      enabled_on_pr: yes
+
+    - compiler: msvc-15-seh
+      build_system: bazel
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      enabled_on_pr: yes
+
+    - compiler: msvc-14-seh
+      build_system: cmake
+      generator: "Visual Studio 14 2015"
+      enabled_on_pr: yes
+
+    - compiler: msvc-14-seh
+      build_system: cmake
+      generator: "Visual Studio 14 2015 Win64"
+
+    - compiler: gcc-6.3.0-posix
+      build_system: cmake
+      generator: "MinGW Makefiles"
+      cxx_path: 'C:\mingw-w64\i686-6.3.0-posix-dwarf-rt_v5-rev1\mingw32\bin'
+      enabled_on_pr: yes
+
+configuration:
+  - Debug
+
+build:
+  verbosity: minimal
+
+install:
+- ps: |
+    Write-Output "Compiler: $env:compiler"
+    Write-Output "Generator: $env:generator"
+    Write-Output "Env:Configuation: $env:configuration"
+    Write-Output "Env: $env"
+    if (-not (Test-Path env:APPVEYOR_PULL_REQUEST_NUMBER)) {
+      Write-Output "This is *NOT* a pull request build"
+    } else {
+      Write-Output "This is a pull request build"
+      if (-not (Test-Path env:enabled_on_pr) -or $env:enabled_on_pr -ne "yes") {
+        Write-Output "PR builds are *NOT* explicitly enabled"
+      }
+    }
+
+    # install Bazel
+    if ($env:build_system -eq "bazel") {
+        appveyor DownloadFile https://github.com/bazelbuild/bazel/releases/download/0.28.1/bazel-0.28.1-windows-x86_64.exe -FileName bazel.exe
+    }
+
+    if ($env:build_system -eq "cmake") {
+        # git bash conflicts with MinGW makefiles
+        if ($env:generator -eq "MinGW Makefiles") {
+            $env:path = $env:path.replace("C:\Program Files\Git\usr\bin;", "")
+            if ($env:cxx_path -ne "") {
+                $env:path += ";$env:cxx_path"
+            }
+        }
+    }
+
+before_build:
+- ps: |
+     $env:root=$env:APPVEYOR_BUILD_FOLDER
+     Write-Output "env:root: $env:root"
+
+build_script:
+- ps: |
+    # Only enable some builds for pull requests, the AppVeyor queue is too long.
+    if ((Test-Path env:APPVEYOR_PULL_REQUEST_NUMBER) -And (-not (Test-Path env:enabled_on_pr) -or $env:enabled_on_pr -ne "yes")) {
+      return
+    } else {
+        # special case - build with Bazel
+        if ($env:build_system -eq "bazel") {
+            & $env:root\bazel.exe build -c opt //:gtest_samples
+            if ($LastExitCode -eq 0) { # bazel writes to StdErr and PowerShell interprets it as an error
+                $host.SetShouldExit(0)
+            } else { # a real error
+                throw "Exec: $ErrorMessage"
+            }
+            return
+        }
+    }
+    # by default build with CMake
+    md _build -Force | Out-Null
+    cd _build
+
+    $conf = if ($env:generator -eq "MinGW Makefiles") {"-DCMAKE_BUILD_TYPE=$env:configuration"} else {"-DCMAKE_CONFIGURATION_TYPES=Debug;Release"}
+    # Disable test for MinGW (gtest tests fail, gmock tests can not build)
+    $gtest_build_tests = if ($env:generator -eq "MinGW Makefiles") {"-Dgtest_build_tests=OFF"} else {"-Dgtest_build_tests=ON"}
+    $gmock_build_tests = if ($env:generator -eq "MinGW Makefiles") {"-Dgmock_build_tests=OFF"} else {"-Dgmock_build_tests=ON"}
+    & cmake -G "$env:generator" $conf -Dgtest_build_samples=ON $gtest_build_tests $gmock_build_tests ..
+    if ($LastExitCode -ne 0) {
+        throw "Exec: $ErrorMessage"
+    }
+    $cmake_parallel = if ($env:generator -eq "MinGW Makefiles") {"-j2"} else  {"/m"}
+    & cmake --build . --config $env:configuration -- $cmake_parallel
+    if ($LastExitCode -ne 0) {
+        throw "Exec: $ErrorMessage"
+    }
+
+
+skip_commits:
+  files:
+    - '**/*.md'
+
+test_script:
+- ps: |
+    # Only enable some builds for pull requests, the AppVeyor queue is too long.
+    if ((Test-Path env:APPVEYOR_PULL_REQUEST_NUMBER) -And (-not (Test-Path env:enabled_on_pr) -or $env:enabled_on_pr -ne "yes")) {
+      return
+    }
+    if ($env:build_system -eq "bazel") {
+        # special case - testing with Bazel
+        & $env:root\bazel.exe test //:gtest_samples
+        if ($LastExitCode -eq 0) { # bazel writes to StdErr and PowerShell interprets it as an error
+            $host.SetShouldExit(0)
+        } else { # a real error
+            throw "Exec: $ErrorMessage"
+        }
+    }
+    if ($env:build_system -eq "cmake") {
+        # built with CMake - test with CTest
+        if ($env:generator -eq "MinGW Makefiles") {
+            return # No test available for MinGW
+        }
+
+        & ctest -C $env:configuration --timeout 600 --output-on-failure
+        if ($LastExitCode -ne 0) {
+            throw "Exec: $ErrorMessage"
+        }
+    }
+
+artifacts:
+  - path: '_build/CMakeFiles/*.log'
+    name: logs
+  - path: '_build/Testing/**/*.xml'
+    name: test_results
+  - path: 'bazel-testlogs/**/test.log'
+    name: test_logs
+  - path: 'bazel-testlogs/**/test.xml'
+    name: test_results
--- a/test/gtest-1.10.0/ci/build-linux-bazel.sh
+++ b/test/gtest-1.10.0/ci/build-linux-bazel.sh
@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+# Copyright 2017 Google Inc.
+# All Rights Reserved.
+#
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+set -e
+
+bazel version
+bazel build --curses=no //...:all
+bazel test --curses=no //...:all
+bazel test --curses=no //...:all --define absl=1
--- a/test/gtest-1.10.0/ci/build-platformio.sh
+++ b/test/gtest-1.10.0/ci/build-platformio.sh
@ -0,0 +1,2 @@
+# run PlatformIO builds
+platformio run
--- a/test/gtest-1.10.0/ci/env-linux.sh
+++ b/test/gtest-1.10.0/ci/env-linux.sh
@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# Copyright 2017 Google Inc.
+# All Rights Reserved.
+#
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#
+# This file should be sourced, and not executed as a standalone script.
+#
+
+# TODO() - we can check if this is being sourced using $BASH_VERSION and $BASH_SOURCE[0] != ${0}.
+
+if [ "${TRAVIS_OS_NAME}" = "linux" ]; then
+    if [ "$CXX" = "g++" ]; then export CXX="g++-4.9" CC="gcc-4.9"; fi
+    if [ "$CXX" = "clang++" ]; then export CXX="clang++-3.9" CC="clang-3.9"; fi
+fi
--- a/test/gtest-1.11.0/googletest/test/gtest_skip_check_output_test.py
+++ b/test/gtest-1.11.0/googletest/test/gtest_skip_check_output_test.py
@ -1,6 +1,7 @@
-#!/usr/bin/env python
+#!/usr/bin/env bash
+# Copyright 2017 Google Inc.
+# All Rights Reserved.
 #
-# Copyright 2019 Google LLC.  All Rights Reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
@ -27,33 +28,20 @@
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-"""Tests Google Test's gtest skip in environment setup  behavior.

-This script invokes gtest_skip_in_environment_setup_test_ and verifies its
-output.
-"""
+#
+# This file should be sourced, and not executed as a standalone script.
+#

-import re
+# TODO() - we can check if this is being sourced using $BASH_VERSION and $BASH_SOURCE[0] != ${0}.
+#

-import gtest_test_utils
-
-# Path to the gtest_skip_in_environment_setup_test binary
-EXE_PATH = gtest_test_utils.GetTestExecutablePath('gtest_skip_test')
-
-OUTPUT = gtest_test_utils.Subprocess([EXE_PATH]).output
-
-
-# Test.
-class SkipEntireEnvironmentTest(gtest_test_utils.TestCase):
-
-  def testSkipEntireEnvironmentTest(self):
-    self.assertIn('Skipped\nskipping single test\n', OUTPUT)
-    skip_fixture = 'Skipped\nskipping all tests for this fixture\n'
-    self.assertIsNotNone(
-        re.search(skip_fixture + '.*' + skip_fixture, OUTPUT, flags=re.DOTALL),
-        repr(OUTPUT))
-    self.assertNotIn('FAILED', OUTPUT)
-
-
-if __name__ == '__main__':
-  gtest_test_utils.Main()
+if [ "${TRAVIS_OS_NAME}" = "osx" ]; then
+    if [ "$CXX" = "clang++" ]; then
+        # $PATH needs to be adjusted because the llvm tap doesn't install the
+        # package to /usr/local/bin, etc, like the gcc tap does.
+        # See: https://github.com/Homebrew/legacy-homebrew/issues/29733
+        clang_version=3.9
+        export PATH="/usr/local/opt/llvm@${clang_version}/bin:$PATH";
+    fi
+fi
--- a/test/gtest-1.10.0/ci/get-nprocessors.sh
+++ b/test/gtest-1.10.0/ci/get-nprocessors.sh
@ -1,7 +1,7 @@
-#!/bin/bash
+#!/usr/bin/env bash
+# Copyright 2017 Google Inc.
+# All Rights Reserved.
 #
-# Copyright 2020, Google Inc.
-# All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
@ -29,45 +29,20 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

-set -euox pipefail
-
-if [[ -z ${GTEST_ROOT:-} ]]; then
-  GTEST_ROOT="$(realpath $(dirname ${0})/..)"
-fi
-
-# Test the CMake build
-for cmake_off_on in OFF ON; do
-  BUILD_DIR=$(mktemp -d build_dir.XXXXXXXX)
-  cd ${BUILD_DIR}
-  time cmake ${GTEST_ROOT} \
-    -DCMAKE_CXX_STANDARD=11 \
-    -Dgtest_build_samples=ON \
-    -Dgtest_build_tests=ON \
-    -Dgmock_build_tests=ON \
-    -Dcxx_no_exception=${cmake_off_on} \
-    -Dcxx_no_rtti=${cmake_off_on}
-  time make
-  time ctest -j$(nproc) --output-on-failure
-done
-
-# Test the Bazel build
-
-# If we are running on Kokoro, check for a versioned Bazel binary.
-KOKORO_GFILE_BAZEL_BIN="bazel-3.7.0-darwin-x86_64"
-if [[ ${KOKORO_GFILE_DIR:-} ]] && [[ -f ${KOKORO_GFILE_DIR}/${KOKORO_GFILE_BAZEL_BIN} ]]; then
-  BAZEL_BIN="${KOKORO_GFILE_DIR}/${KOKORO_GFILE_BAZEL_BIN}"
-  chmod +x ${BAZEL_BIN}
+# This file is typically sourced by another script.
+# if possible, ask for the precise number of processors,
+# otherwise take 2 processors as reasonable default; see
+# https://docs.travis-ci.com/user/speeding-up-the-build/#Makefile-optimization
+if [ -x /usr/bin/getconf ]; then
+    NPROCESSORS=$(/usr/bin/getconf _NPROCESSORS_ONLN)
 else
-  BAZEL_BIN="bazel"
+    NPROCESSORS=2
 fi

-cd ${GTEST_ROOT}
-for absl in 0 1; do
-  ${BAZEL_BIN} test ... \
-    --copt="-Wall" \
-    --copt="-Werror" \
-    --define="absl=${absl}" \
-    --keep_going \
-    --show_timestamps \
-    --test_output=errors
-done
+# as of 2017-09-04 Travis CI reports 32 processors, but GCC build
+# crashes if parallelized too much (maybe memory consumption problem),
+# so limit to 4 processors for the time being.
+if [ $NPROCESSORS -gt 4 ] ; then
+	echo "$0:Note: Limiting processors to use by make from $NPROCESSORS to 4."
+	NPROCESSORS=4
+fi
--- a/test/gtest-1.10.0/ci/install-linux.sh
+++ b/test/gtest-1.10.0/ci/install-linux.sh
@ -0,0 +1,49 @@
+#!/usr/bin/env bash
+# Copyright 2017 Google Inc.
+# All Rights Reserved.
+#
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+set -eu
+
+if [ "${TRAVIS_OS_NAME}" != linux ]; then
+    echo "Not a Linux build; skipping installation"
+    exit 0
+fi
+
+
+if [ "${TRAVIS_SUDO}" = "true" ]; then
+    echo "deb [arch=amd64] http://storage.googleapis.com/bazel-apt stable jdk1.8" | \
+        sudo tee /etc/apt/sources.list.d/bazel.list
+    curl https://bazel.build/bazel-release.pub.gpg | sudo apt-key add -
+    sudo apt-get update && sudo apt-get install -y bazel gcc-4.9 g++-4.9 clang-3.9
+elif [ "${CXX}" = "clang++" ]; then
+    # Use ccache, assuming $HOME/bin is in the path, which is true in the Travis build environment.
+    ln -sf /usr/bin/ccache $HOME/bin/${CXX};
+    ln -sf /usr/bin/ccache $HOME/bin/${CC};
+fi
--- a/test/gtest-1.10.0/ci/install-osx.sh
+++ b/test/gtest-1.10.0/ci/install-osx.sh
@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+# Copyright 2017 Google Inc.
+# All Rights Reserved.
+#
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+set -eu
+
+if [ "${TRAVIS_OS_NAME}" != "osx" ]; then
+    echo "Not a macOS build; skipping installation"
+    exit 0
+fi
+
+brew update
+brew install ccache gcc@4.9
--- a/test/gtest-1.10.0/ci/install-platformio.sh
+++ b/test/gtest-1.10.0/ci/install-platformio.sh
@ -0,0 +1,5 @@
+# install PlatformIO
+sudo pip install -U platformio
+
+# update PlatformIO
+platformio update
--- a/test/gtest-1.11.0/googletest/test/googletest-setuptestsuite-test.py
+++ b/test/gtest-1.11.0/googletest/test/googletest-setuptestsuite-test.py
@ -1,7 +1,7 @@
-#!/usr/bin/env python
+#!/usr/bin/env bash
+# Copyright 2017 Google Inc.
+# All Rights Reserved.
 #
-# Copyright 2019, Google Inc.
-# All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
@ -29,26 +29,23 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

-"""Verifies that SetUpTestSuite and TearDownTestSuite errors are noticed."""
+set -e

-import gtest_test_utils
+# ccache on OS X needs installation first
+# reset ccache statistics
+ccache --zero-stats

-COMMAND = gtest_test_utils.GetTestExecutablePath(
-    'googletest-setuptestsuite-test_')
+echo PATH=${PATH}

+echo "Compiler configuration:"
+echo CXX=${CXX}
+echo CC=${CC}
+echo CXXFLAGS=${CXXFLAGS}

-class GTestSetUpTestSuiteTest(gtest_test_utils.TestCase):
+echo "C++ compiler version:"
+${CXX} --version || echo "${CXX} does not seem to support the --version flag"
+${CXX} -v || echo "${CXX} does not seem to support the -v flag"

-  def testSetupErrorAndTearDownError(self):
-    p = gtest_test_utils.Subprocess(COMMAND)
-    self.assertNotEqual(p.exit_code, 0, msg=p.output)
-
-    self.assertIn(
-        '[  FAILED  ] SetupFailTest: SetUpTestSuite or TearDownTestSuite\n'
-        '[  FAILED  ] TearDownFailTest: SetUpTestSuite or TearDownTestSuite\n'
-        '\n'
-        ' 2 FAILED TEST SUITES\n',
-        p.output)
-
-if __name__ == '__main__':
-  gtest_test_utils.Main()
+echo "C compiler version:"
+${CC} --version || echo "${CXX} does not seem to support the --version flag"
+${CC} -v || echo "${CXX} does not seem to support the -v flag"
--- a/test/gtest-1.10.0/ci/travis.sh
+++ b/test/gtest-1.10.0/ci/travis.sh
@ -0,0 +1,44 @@
+#!/usr/bin/env sh
+set -evx
+
+. ci/get-nprocessors.sh
+
+# if possible, ask for the precise number of processors,
+# otherwise take 2 processors as reasonable default; see
+# https://docs.travis-ci.com/user/speeding-up-the-build/#Makefile-optimization
+if [ -x /usr/bin/getconf ]; then
+    NPROCESSORS=$(/usr/bin/getconf _NPROCESSORS_ONLN)
+else
+    NPROCESSORS=2
+fi
+# as of 2017-09-04 Travis CI reports 32 processors, but GCC build
+# crashes if parallelized too much (maybe memory consumption problem),
+# so limit to 4 processors for the time being.
+if [ $NPROCESSORS -gt 4 ] ; then
+	echo "$0:Note: Limiting processors to use by make from $NPROCESSORS to 4."
+	NPROCESSORS=4
+fi
+# Tell make to use the processors. No preceding '-' required.
+MAKEFLAGS="j${NPROCESSORS}"
+export MAKEFLAGS
+
+env | sort
+
+# Set default values to OFF for these variables if not specified.
+: "${NO_EXCEPTION:=OFF}"
+: "${NO_RTTI:=OFF}"
+: "${COMPILER_IS_GNUCXX:=OFF}"
+
+mkdir build || true
+cd build
+cmake -Dgtest_build_samples=ON \
+      -Dgtest_build_tests=ON \
+      -Dgmock_build_tests=ON \
+      -Dcxx_no_exception=$NO_EXCEPTION \
+      -Dcxx_no_rtti=$NO_RTTI \
+      -DCMAKE_COMPILER_IS_GNUCXX=$COMPILER_IS_GNUCXX \
+      -DCMAKE_CXX_FLAGS=$CXX_FLAGS \
+      -DCMAKE_BUILD_TYPE=$BUILD_TYPE \
+      ..
+make
+CTEST_OUTPUT_ON_FAILURE=1 make test
--- a/test/gtest-1.10.0/googlemock/CMakeLists.txt
+++ b/test/gtest-1.10.0/googlemock/CMakeLists.txt
@ -42,7 +42,7 @@ else()
  cmake_policy(SET CMP0048 NEW)
  project(gmock VERSION ${GOOGLETEST_VERSION} LANGUAGES CXX C)
 endif()
-cmake_minimum_required(VERSION 2.8.12)
+cmake_minimum_required(VERSION 2.6.4)

 if (COMMAND set_up_hermetic_build)
  set_up_hermetic_build()
@ -100,10 +100,8 @@ if (MSVC)
 else()
  cxx_library(gmock "${cxx_strict}" src/gmock-all.cc)
  target_link_libraries(gmock PUBLIC gtest)
-  set_target_properties(gmock PROPERTIES VERSION ${GOOGLETEST_VERSION})
  cxx_library(gmock_main "${cxx_strict}" src/gmock_main.cc)
  target_link_libraries(gmock_main PUBLIC gmock)
-  set_target_properties(gmock_main PROPERTIES VERSION ${GOOGLETEST_VERSION})
 endif()
 # If the CMake version supports it, attach header directory information
 # to the targets for when we are part of a parent build (ie being pulled
@ -138,6 +136,20 @@ if (gmock_build_tests)
  # 'make test' or ctest.
  enable_testing()

+  if (WIN32)
+    file(GENERATE OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>/RunTest.ps1"
+         CONTENT
+"$project_bin = \"${CMAKE_BINARY_DIR}/bin/$<CONFIG>\"
+$env:Path = \"$project_bin;$env:Path\"
+& $args")
+  elseif (MINGW OR CYGWIN)
+    file(GENERATE OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/RunTest.ps1"
+         CONTENT
+"$project_bin = (cygpath --windows ${CMAKE_BINARY_DIR}/bin)
+$env:Path = \"$project_bin;$env:Path\"
+& $args")
+  endif()
+
  if (MINGW OR CYGWIN)
    if (CMAKE_VERSION VERSION_LESS "2.8.12")
      add_compile_options("-Wa,-mbig-obj")
@ -153,6 +165,9 @@ if (gmock_build_tests)
  cxx_test(gmock-cardinalities_test gmock_main)
  cxx_test(gmock_ex_test gmock_main)
  cxx_test(gmock-function-mocker_test gmock_main)
+  cxx_test(gmock-generated-actions_test gmock_main)
+  cxx_test(gmock-generated-function-mockers_test gmock_main)
+  cxx_test(gmock-generated-matchers_test gmock_main)
  cxx_test(gmock-internal-utils_test gmock_main)
  cxx_test(gmock-matchers_test gmock_main)
  cxx_test(gmock-more-actions_test gmock_main)
--- a/test/gtest-1.10.0/googlemock/CONTRIBUTORS
+++ b/test/gtest-1.10.0/googlemock/CONTRIBUTORS
@ -0,0 +1,40 @@
+# This file contains a list of people who've made non-trivial
+# contribution to the Google C++ Mocking Framework project.  People
+# who commit code to the project are encouraged to add their names
+# here.  Please keep the list sorted by first names.
+
+Benoit Sigoure <tsuna@google.com>
+Bogdan Piloca <boo@google.com>
+Chandler Carruth <chandlerc@google.com>
+Dave MacLachlan <dmaclach@gmail.com>
+David Anderson <danderson@google.com>
+Dean Sturtevant
+Gene Volovich <gv@cite.com>
+Hal Burch <gmock@hburch.com>
+Jeffrey Yasskin <jyasskin@google.com>
+Jim Keller <jimkeller@google.com>
+Joe Walnes <joe@truemesh.com>
+Jon Wray <jwray@google.com>
+Keir Mierle <mierle@gmail.com>
+Keith Ray <keith.ray@gmail.com>
+Kostya Serebryany <kcc@google.com>
+Lev Makhlis
+Manuel Klimek <klimek@google.com>
+Mario Tanev <radix@google.com>
+Mark Paskin
+Markus Heule <markus.heule@gmail.com>
+Matthew Simmons <simmonmt@acm.org>
+Mike Bland <mbland@google.com>
+Neal Norwitz <nnorwitz@gmail.com>
+Nermin Ozkiranartli <nermin@google.com>
+Owen Carlsen <ocarlsen@google.com>
+Paneendra Ba <paneendra@google.com>
+Paul Menage <menage@google.com>
+Piotr Kaminski <piotrk@google.com>
+Russ Rufer <russ@pentad.com>
+Sverre Sundsdal <sundsdal@gmail.com>
+Takeshi Yoshino <tyoshino@google.com>
+Vadim Berman <vadimb@google.com>
+Vlad Losev <vladl@google.com>
+Wolfgang Klier <wklier@google.com>
+Zhanyong Wan <wan@google.com>
--- a/test/gtest-1.10.0/googlemock/LICENSE
+++ b/test/gtest-1.10.0/googlemock/LICENSE
@ -0,0 +1,28 @@
+Copyright 2008, Google Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+    * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jesse Beder	33bdf167e0	Update build to 0.7.0.	2021-07-10 10:49:09 -05:00
Jesse Beder	b43575f89c	Update travis config to use updated versions of OS and compilers. This fixes the linux/gcc error building Google Test with gcc 4.7: https://travis-ci.org/github/jbeder/yaml-cpp/jobs/668233706	2020-04-07 22:27:32 -05:00
				`@ -1 +0,0 @@`
				`To learn how to use the library, see the [Tutorial](https://github.com/jbeder/yaml-cpp/wiki/Tutorial) and [How To Emit YAML](https://github.com/jbeder/yaml-cpp/wiki/How-To-Emit-YAML)`