Removed extra script_reportdata

Terminate the script when SCRIPT_CMD_FAILURE is returned

.git-blame-ignore-revs

@@ -1,9 +0,0 @@
-# Massive EOL normalization & 'svn:eol-style native' flag setting for all txt/conf/h/c files.
-# https://github.com/rathena/rathena/commit/637ae9a4dcde0d5885a18841d2f3875e06893c30
-637ae9a4dcde0d5885a18841d2f3875e06893c30
-# Applied AStyle code formating as discussed on tid:74602.
-# https://github.com/rathena/rathena/commit/a7c32653f70bd420bdf5a621acdf3aea5c6e6002
-a7c32653f70bd420bdf5a621acdf3aea5c6e6002
-# Undid r16968: SVN Replaced with source:/trunk/src/@16966 (tid:74924).
-# https://github.com/rathena/rathena/commit/a2bdc47dafb32f6d18ed350d8bbe79b8f679a049
-a2bdc47dafb32f6d18ed350d8bbe79b8f679a049

.github/workflows/analysis_codeql.yml

@@ -38,11 +38,11 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3
+        uses: github/codeql-action/init@v2
         with:
            # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
            # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
@@ -74,7 +74,7 @@ jobs:
       #- name: Autobuild
       #  uses: github/codeql-action/autobuild@v2
 
-      # ?? If the Autobuild fails above, remove it and uncomment the following
+      # ✏️ If the Autobuild fails above, remove it and uncomment the following
       #    three lines and modify them (or add more) to build your code if your
       #    project uses a compiled language
       - name: Command - configure
@@ -89,4 +89,4 @@ jobs:
         run: make server
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3
+        uses: github/codeql-action/analyze@v2

.github/workflows/build_servers_clang.yml

@@ -34,7 +34,7 @@ jobs:
           clang: ['6.0', '7', '8', '9', '10', '11'] #, '12', '13']
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
 
       - name: Set up Clang
         uses: egor-tensin/setup-clang@v1

.github/workflows/build_servers_cmake.yml

@@ -18,8 +18,6 @@ on:
       # This workflow should run when a file in a source directory has been modified.
       - 'src/**'
       - '3rdparty/**'
-      # This workflow should run whenever a CMake related file has been modified
-      - '**/CMakeLists.txt'
 
 jobs:
   build:
@@ -34,7 +32,7 @@ jobs:
           os: [ubuntu-latest]
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
 
       # Install latest CMake.
       - uses: lukka/get-cmake@latest

.github/workflows/build_servers_gcc.yml

@@ -31,14 +31,10 @@ jobs:
           # Available: ubuntu-22.04, ubuntu-20.04
           os: [ubuntu-latest]
           # Older versions of GCC are not available via unaltered aptitude repo lists.
-          gcc: ['9', '10', '11', '12']
+          gcc: ['9', '10', '11']
-          # GCC 13 was removed from 22.04, include it as a separate job
-          include:
-            - os: ubuntu-24.04
-              gcc: 13
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
 
       - name: Update & Install packages
         # Ubuntu runners already have most of the packages rAthena requires to build.
@@ -49,10 +45,8 @@ jobs:
 
       - name: Command - configure
         env:
-            CONFIGURE_FLAGS: 'CC=gcc-${{ matrix.gcc }} CXX=g++-${{ matrix.gcc }}'
+            CONFIGURE_FLAGS: 'CC=gcc-${{ matrix.gcc }} CXX=g++-${{ matrix.gcc }} --enable-buildbot=yes'
-        # -Werror: to treat all warnings as errors
+        run: ./configure $CONFIGURE_FLAGS
-        # -Wno-error=builtin-declaration-mismatch: otherwise ./configure checks fail
-        run: ./configure $CONFIGURE_FLAGS --enable-buildbot=yes CXXFLAGS='-Werror -Wno-error=builtin-declaration-mismatch'
       
       - name: Command - make clean
         run: make clean

.github/workflows/build_servers_modes.yml

@@ -36,7 +36,7 @@ jobs:
           mode: ['PRE','RE']
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
 
       # A simple 'yes' and 'no' can be confusing, so we use names to display in the current job then convert them for use in the compiler.
       - name: Variable Parsing - PRE

.github/workflows/build_servers_msbuild.yml

@@ -34,15 +34,15 @@ jobs:
           mode: ['PRE', 'RE']
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
 
       - name: Add msbuild to PATH
-        uses: microsoft/setup-msbuild@v2
+        uses: microsoft/setup-msbuild@v1.1
 
       - name: Build solution in Debug
         if: ${{ matrix.mode == 'PRE' }}
-        run: msbuild rAthena.sln -t:rebuild -property:Configuration=Debug /p:DefineConstants="BUILDBOT%3BPRERE" /warnaserror
+        run: msbuild rAthena.sln -t:rebuild -property:Configuration=Debug /p:DefineConstants="BUILDBOT%3BPRERE"
 
       - name: Build solution in Debug
         if: ${{ matrix.mode == 'RE' }}
-        run: msbuild rAthena.sln -t:rebuild -property:Configuration=Debug /p:DefineConstants="BUILDBOT" /warnaserror
+        run: msbuild rAthena.sln -t:rebuild -property:Configuration=Debug /p:DefineConstants="BUILDBOT"

.github/workflows/build_servers_packetversions.yml

@@ -38,7 +38,7 @@ jobs:
           packetver: ['20211103', '20200902', '20200401', '20180620', '20151104']
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
 
       # A simple 'yes' and 'no' can be confusing, so we use names to display in the current job then convert them for use in the compiler.
       - name: Variable Parsing - PRE

.github/workflows/build_servers_vip.yml

@@ -36,7 +36,7 @@ jobs:
           mode: ['PRE', 'RE']
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
 
       # A simple 'yes' and 'no' can be confusing, so we use names to display in the current job then convert them for use in the compiler.
       - name: Variable Parsing - PRE

.github/workflows/npc_db_validation.yml

@@ -39,7 +39,7 @@ jobs:
           mode: ['PRE', 'RE']
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
       
       # A simple 'yes' and 'no' can be confusing, so we use names to display in the current job then convert them for use in the compiler.
       - name: Variable Parsing - PRE

3rdparty/README.txt

@@ -7,4 +7,3 @@ mysql - library for MySQL Community Server (http://www.mysql.com)
 pcre - library for Perl Compatible Regular Expressions (http://www.pcre.org)
 zlib - library for DEFLATE lossless compression algorithm (http://www.zlib.net)
 json - library for nlohmann json (https://github.com/nlohmann/json/tree/4b2c8ce6bcfe7f39f2bb9e680c1e7a4d67c2dd48)
-yaml-cpp - library for yaml (https://github.com/jbeder/yaml-cpp/tree/0e6e28d1a38224fc8172fae0109ea7f673c096db)

3rdparty/httplib/httplib.vcxproj

@@ -98,7 +98,6 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;WIN32;_DEBUG;_LIB;_ITERATOR_DEBUG_LEVEL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -113,7 +112,6 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;_DEBUG;_LIB;_ITERATOR_DEBUG_LEVEL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -130,7 +128,6 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -149,7 +146,6 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>

3rdparty/libconfig/libconfig.vcxproj

@@ -108,7 +108,6 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>YY_USE_CONST;LIBCONFIG_STATIC;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;WIN32;_DEBUG;_LIB;_ITERATOR_DEBUG_LEVEL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -123,7 +122,6 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>YY_USE_CONST;LIBCONFIG_STATIC;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;_DEBUG;_LIB;_ITERATOR_DEBUG_LEVEL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -140,7 +138,6 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>YY_USE_CONST;LIBCONFIG_STATIC;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -159,7 +156,6 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>YY_USE_CONST;LIBCONFIG_STATIC;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>

3rdparty/libconfig/scanner.c

@@ -2,11 +2,6 @@
 
 #line 4 "scanner.c"
 
-#ifdef _MSC_VER
-	#pragma warning( push )
-	#pragma warning( disable : 4267 )
-#endif
-
 #define  YY_INT_ALIGNED short int
 
 /* A lexical scanner generated by flex */
@@ -2370,7 +2365,3 @@ void libconfig_yyfree (void * ptr , yyscan_t yyscanner)
 #define YYTABLES_NAME "yytables"
 
 #line 192 "scanner.l"
-
-#ifdef _MSC_VER
-	#pragma warning( pop )
-#endif

3rdparty/rapidyaml/ryml.vcxproj

@@ -103,7 +103,6 @@
       <PreprocessorDefinitions>WIN32;_WINDOWS;CMAKE_INTDIR="Debug";_ITERATOR_DEBUG_LEVEL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ObjectFileName>$(IntDir)</ObjectFileName>
       <LanguageStandard>stdcpp17</LanguageStandard>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
     <ResourceCompile>
       <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;CMAKE_INTDIR=\"Debug\";%(PreprocessorDefinitions)</PreprocessorDefinitions>
@@ -139,7 +138,6 @@
       <PreprocessorDefinitions>WIN32;_WINDOWS;CMAKE_INTDIR="Debug";_ITERATOR_DEBUG_LEVEL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ObjectFileName>$(IntDir)</ObjectFileName>
       <LanguageStandard>stdcpp17</LanguageStandard>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
     <ResourceCompile>
       <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;CMAKE_INTDIR=\"Debug\";%(PreprocessorDefinitions)</PreprocessorDefinitions>
@@ -175,7 +173,6 @@
       <DebugInformationFormat>
       </DebugInformationFormat>
       <LanguageStandard>stdcpp17</LanguageStandard>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
     <ResourceCompile>
       <PreprocessorDefinitions>WIN32;_WINDOWS;NDEBUG;CMAKE_INTDIR=\"Release\";%(PreprocessorDefinitions)</PreprocessorDefinitions>
@@ -211,7 +208,6 @@
       <DebugInformationFormat>
       </DebugInformationFormat>
       <LanguageStandard>stdcpp17</LanguageStandard>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
     <ResourceCompile>
       <PreprocessorDefinitions>WIN32;_WINDOWS;NDEBUG;CMAKE_INTDIR=\"Release\";%(PreprocessorDefinitions)</PreprocessorDefinitions>

3rdparty/yaml-cpp/CMakeLists.txt

@@ -21,7 +21,6 @@ set( YAML_HEADERS
     "${YAML_INCLUDE_DIRS}/yaml-cpp/ostream_wrapper.h"
     "${YAML_INCLUDE_DIRS}/yaml-cpp/null.h"
     "${YAML_INCLUDE_DIRS}/yaml-cpp/noncopyable.h"
-    "${YAML_INCLUDE_DIRS}/yaml-cpp/noexcept.h"
     "${YAML_INCLUDE_DIRS}/yaml-cpp/mark.h"
     "${YAML_INCLUDE_DIRS}/yaml-cpp/exceptions.h"
     "${YAML_INCLUDE_DIRS}/yaml-cpp/eventhandler.h"
@@ -31,7 +30,6 @@ set( YAML_HEADERS
     "${YAML_INCLUDE_DIRS}/yaml-cpp/emitterdef.h"
     "${YAML_INCLUDE_DIRS}/yaml-cpp/emitfromevents.h"
     "${YAML_INCLUDE_DIRS}/yaml-cpp/dll.h"
-    "${YAML_INCLUDE_DIRS}/yaml-cpp/depthguard.h"
     "${YAML_INCLUDE_DIRS}/yaml-cpp/binary.h"
     "${YAML_INCLUDE_DIRS}/yaml-cpp/anchor.h"
     "${YAML_INCLUDE_DIRS}/yaml-cpp/node/type.h"
@@ -48,7 +46,6 @@ set( YAML_HEADERS
 set( YAML_SOURCES
 	"${YAML_SOURCE_DIR}/binary.cpp"
   "${YAML_SOURCE_DIR}/convert.cpp"
-  "${YAML_SOURCE_DIR}/depthguard.cpp"
   "${YAML_SOURCE_DIR}/directives.cpp"
   "${YAML_SOURCE_DIR}/emit.cpp"
   "${YAML_SOURCE_DIR}/emitfromevents.cpp"
@@ -84,4 +81,3 @@ set( YAML_DEFINITIONS
 include_directories(${YAML_INCLUDE_DIRS} ${YAML_SOURCE_DIR})
 #message(STATUS "YAML_INCLUDE_DIRS : ${YAML_INCLUDE_DIRS}, YAML_SOURCE_DIR=${YAML_SOURCE_DIR}")
 ADD_LIBRARY(${this_target} STATIC ${YAML_SOURCES} )
-target_compile_definitions(${this_target} PUBLIC "-DYAML_CPP_STATIC_DEFINE")

3rdparty/yaml-cpp/Makefile.in

@@ -4,7 +4,7 @@ YAML_CPP_DIR_OBJ = $(YAML_CPP_OBJ:%=obj/%)
 YAML_CPP_H =  $(shell find * -type f -name "*.h")
 YAML_CPP_AR = obj/yaml-cpp.a
 
-CXXFLAG =-std=c++17 -DYAML_CPP_STATIC_DEFINE
+CXXFLAG =-std=c++11
 INC=-Iinclude
 
 @SET_MAKE@

3rdparty/yaml-cpp/include/yaml-cpp/anchor.h

@@ -10,7 +10,7 @@
 #include <cstddef>
 
 namespace YAML {
-using anchor_t = std::size_t;
+typedef std::size_t anchor_t;
 const anchor_t NullAnchor = 0;
 }
 

3rdparty/yaml-cpp/include/yaml-cpp/binary.h

@@ -19,13 +19,9 @@ YAML_CPP_API std::vector<unsigned char> DecodeBase64(const std::string &input);
 
 class YAML_CPP_API Binary {
  public:
+  Binary() : m_unownedData(0), m_unownedSize(0) {}
   Binary(const unsigned char *data_, std::size_t size_)
-      : m_data{}, m_unownedData(data_), m_unownedSize(size_) {}
+      : m_unownedData(data_), m_unownedSize(size_) {}
-  Binary() : Binary(nullptr, 0) {}
-  Binary(const Binary &) = default;
-  Binary(Binary &&) = default;
-  Binary &operator=(const Binary &) = default;
-  Binary &operator=(Binary &&) = default;
 
   bool owned() const { return !m_unownedData; }
   std::size_t size() const { return owned() ? m_data.size() : m_unownedSize; }
@@ -39,7 +35,7 @@ class YAML_CPP_API Binary {
       rhs.clear();
       rhs.resize(m_unownedSize);
       std::copy(m_unownedData, m_unownedData + m_unownedSize, rhs.begin());
-      m_unownedData = nullptr;
+      m_unownedData = 0;
       m_unownedSize = 0;
     } else {
       m_data.swap(rhs);
@@ -66,6 +62,6 @@ class YAML_CPP_API Binary {
   const unsigned char *m_unownedData;
   std::size_t m_unownedSize;
 };
-}  // namespace YAML
+}
 
 #endif  // BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/include/yaml-cpp/contrib/anchordict.h

@@ -22,7 +22,6 @@ namespace YAML {
 template <class T>
 class AnchorDict {
  public:
-  AnchorDict() : m_data{} {}
   void Register(anchor_t anchor, T value) {
     if (anchor > m_data.size()) {
       m_data.resize(anchor);
@@ -35,6 +34,6 @@ class AnchorDict {
  private:
   std::vector<T> m_data;
 };
-}  // namespace YAML
+}
 
 #endif  // ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/include/yaml-cpp/contrib/graphbuilder.h

@@ -15,12 +15,10 @@ class Parser;
 
 // GraphBuilderInterface
 // . Abstraction of node creation
-// . pParentNode is always nullptr or the return value of one of the NewXXX()
+// . pParentNode is always NULL or the return value of one of the NewXXX()
 //   functions.
 class GraphBuilderInterface {
  public:
-  virtual ~GraphBuilderInterface() = 0;
-
   // Create and return a new node with a null value.
   virtual void *NewNull(const Mark &mark, void *pParentNode) = 0;
 
@@ -73,9 +71,9 @@ class GraphBuilder : public GraphBuilderInterface {
   typedef typename Impl::Map Map;
 
   GraphBuilder(Impl &impl) : m_impl(impl) {
-    Map *pMap = nullptr;
+    Map *pMap = NULL;
-    Sequence *pSeq = nullptr;
+    Sequence *pSeq = NULL;
-    Node *pNode = nullptr;
+    Node *pNode = NULL;
 
     // Type consistency checks
     pNode = pMap;

3rdparty/yaml-cpp/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

3rdparty/yaml-cpp/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
+#if defined(_MSC_VER) ||                                            \
-// library (definition created by CMake or defined manually)
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
-
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
-// Definition yaml_cpp_EXPORTS using to building YAML-CPP as dll/so library
+#pragma once
-// (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
 #endif
 
-#ifndef YAML_CPP_DEPRECATED_EXPORT
+// The following ifdef block is the standard way of creating macros which make
-#  define YAML_CPP_DEPRECATED_EXPORT YAML_CPP_API YAML_CPP_DEPRECATED
+// exporting from a DLL simpler. All files within this DLL are compiled with the
-#endif
+// 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
+#ifdef YAML_CPP_DLL      // Using or Building YAML-CPP DLL (definition defined
-#  define YAML_CPP_DEPRECATED_NO_EXPORT YAML_CPP_NO_EXPORT YAML_CPP_DEPRECATED
+                         // manually)
-#endif
+#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

3rdparty/yaml-cpp/include/yaml-cpp/emitfromevents.h

@@ -24,21 +24,21 @@ class EmitFromEvents : public EventHandler {
  public:
   EmitFromEvents(Emitter& emitter);
 
-  void OnDocumentStart(const Mark& mark) override;
+  virtual void OnDocumentStart(const Mark& mark);
-  void OnDocumentEnd() override;
+  virtual void OnDocumentEnd();
 
-  void OnNull(const Mark& mark, anchor_t anchor) override;
+  virtual void OnNull(const Mark& mark, anchor_t anchor);
-  void OnAlias(const Mark& mark, anchor_t anchor) override;
+  virtual void OnAlias(const Mark& mark, anchor_t anchor);
-  void OnScalar(const Mark& mark, const std::string& tag,
+  virtual void OnScalar(const Mark& mark, const std::string& tag,
-                        anchor_t anchor, const std::string& value) override;
+                        anchor_t anchor, const std::string& value);
 
-  void OnSequenceStart(const Mark& mark, const std::string& tag,
+  virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
-                               anchor_t anchor, EmitterStyle::value style) override;
+                               anchor_t anchor, EmitterStyle::value style);
-  void OnSequenceEnd() override;
+  virtual void OnSequenceEnd();
 
-  void OnMapStart(const Mark& mark, const std::string& tag,
+  virtual void OnMapStart(const Mark& mark, const std::string& tag,
-                          anchor_t anchor, EmitterStyle::value style) override;
+                          anchor_t anchor, EmitterStyle::value style);
-  void OnMapEnd() override;
+  virtual void OnMapEnd();
 
  private:
   void BeginNode();

3rdparty/yaml-cpp/include/yaml-cpp/emitter.h

@@ -7,18 +7,16 @@
 #pragma once
 #endif
 
-#include <cmath>
 #include <cstddef>
-#include <limits>
 #include <memory>
 #include <sstream>
 #include <string>
-#include <type_traits>
 
 #include "yaml-cpp/binary.h"
 #include "yaml-cpp/dll.h"
 #include "yaml-cpp/emitterdef.h"
 #include "yaml-cpp/emittermanip.h"
+#include "yaml-cpp/noncopyable.h"
 #include "yaml-cpp/null.h"
 #include "yaml-cpp/ostream_wrapper.h"
 
@@ -30,12 +28,10 @@ struct _Null;
 namespace YAML {
 class EmitterState;
 
-class YAML_CPP_API Emitter {
+class YAML_CPP_API Emitter : private noncopyable {
  public:
   Emitter();
   explicit Emitter(std::ostream& stream);
-  Emitter(const Emitter&) = delete;
-  Emitter& operator=(const Emitter&) = delete;
   ~Emitter();
 
   // output
@@ -59,7 +55,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 +120,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:
@@ -159,27 +153,7 @@ inline Emitter& Emitter::WriteStreamable(T value) {
 
   std::stringstream stream;
   SetStreamablePrecision<T>(stream);
-
-  bool special = false;
-  if (std::is_floating_point<T>::value) {
-    if ((std::numeric_limits<T>::has_quiet_NaN ||
-         std::numeric_limits<T>::has_signaling_NaN) &&
-        std::isnan(value)) {
-      special = true;
-      stream << ".nan";
-    } else if (std::numeric_limits<T>::has_infinity && std::isinf(value)) {
-      special = true;
-      if (std::signbit(value)) {
-        stream << "-.inf";
-      } else {
-        stream << ".inf";
-      }
-    }
-  }
-
-  if (!special) {
   stream << value;
-  }
   m_stream << stream.str();
 
   StartedScalar();
@@ -276,6 +250,6 @@ inline Emitter& operator<<(Emitter& emitter, _Indent indent) {
 inline Emitter& operator<<(Emitter& emitter, _Precision precision) {
   return emitter.SetLocalPrecision(precision);
 }
-}  // namespace YAML
+}
 
 #endif  // EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/include/yaml-cpp/emittermanip.h

@@ -27,12 +27,6 @@ enum EMITTER_MANIP {
   DoubleQuoted,
   Literal,
 
-  // null manipulators
-  LowerNull,
-  UpperNull,
-  CamelNull,
-  TildeNull,
-
   // bool manipulators
   YesNoBool,      // yes, no
   TrueFalseBool,  // true, false
@@ -43,6 +37,10 @@ enum EMITTER_MANIP {
   LongBool,       // yes, On
   ShortBool,      // y, t
 
+  // null manipulators
+  NullAsTilde,     // ~
+  NullAsNull,     // null
+
   // int manipulators
   Dec,
   Hex,
@@ -81,14 +79,14 @@ struct _Alias {
   std::string content;
 };
 
-inline _Alias Alias(const std::string& content) { return _Alias(content); }
+inline _Alias Alias(const std::string content) { return _Alias(content); }
 
 struct _Anchor {
   _Anchor(const std::string& content_) : content(content_) {}
   std::string content;
 };
 
-inline _Anchor Anchor(const std::string& content) { return _Anchor(content); }
+inline _Anchor Anchor(const std::string content) { return _Anchor(content); }
 
 struct _Tag {
   struct Type {
@@ -103,11 +101,11 @@ struct _Tag {
   Type::value type;
 };
 
-inline _Tag VerbatimTag(const std::string& content) {
+inline _Tag VerbatimTag(const std::string content) {
   return _Tag("", content, _Tag::Type::Verbatim);
 }
 
-inline _Tag LocalTag(const std::string& content) {
+inline _Tag LocalTag(const std::string content) {
   return _Tag("", content, _Tag::Type::PrimaryHandle);
 }
 
@@ -115,7 +113,7 @@ inline _Tag LocalTag(const std::string& prefix, const std::string content) {
   return _Tag(prefix, content, _Tag::Type::NamedHandle);
 }
 
-inline _Tag SecondaryTag(const std::string& content) {
+inline _Tag SecondaryTag(const std::string content) {
   return _Tag("", content, _Tag::Type::NamedHandle);
 }
 
@@ -124,7 +122,7 @@ struct _Comment {
   std::string content;
 };
 
-inline _Comment Comment(const std::string& content) { return _Comment(content); }
+inline _Comment Comment(const std::string content) { return _Comment(content); }
 
 struct _Precision {
   _Precision(int floatPrecision_, int doublePrecision_)

3rdparty/yaml-cpp/include/yaml-cpp/eventhandler.h

@@ -17,7 +17,7 @@ struct Mark;
 
 class EventHandler {
  public:
-  virtual ~EventHandler() = default;
+  virtual ~EventHandler() {}
 
   virtual void OnDocumentStart(const Mark& mark) = 0;
   virtual void OnDocumentEnd() = 0;
@@ -34,12 +34,7 @@ class EventHandler {
   virtual void OnMapStart(const Mark& mark, const std::string& tag,
                           anchor_t anchor, EmitterStyle::value style) = 0;
   virtual void OnMapEnd() = 0;
-
-  virtual void OnAnchor(const Mark& /*mark*/,
-                        const std::string& /*anchor_name*/) {
-    // empty default implementation for compatibility
-  }
 };
-}  // namespace YAML
+}
 
 #endif  // EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/include/yaml-cpp/exceptions.h

@@ -7,8 +7,19 @@
 #pragma once
 #endif
 
+#ifndef NOEXCEPT
+#ifdef _MSC_VER
+#ifdef _NOEXCEPT
+#define NOEXCEPT _NOEXCEPT
+#else
+#define NOEXCEPT
+#endif // ifdef _NOEXCEPT
+#else
+#define NOEXCEPT noexcept
+#endif // ifdef _MSC_VER
+#endif // ifdef NOEXCEPT
+
 #include "yaml-cpp/mark.h"
-#include "yaml-cpp/noexcept.h"
 #include "yaml-cpp/traits.h"
 #include <sstream>
 #include <stdexcept>
@@ -65,7 +76,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 +111,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) {
@@ -113,48 +118,13 @@ inline const std::string KEY_NOT_FOUND_WITH_KEY(
   stream << KEY_NOT_FOUND << ": " << key;
   return stream.str();
 }
-
-template <typename T>
-inline const std::string BAD_SUBSCRIPT_WITH_KEY(
-    const T&, typename disable_if<is_numeric<T>>::type* = nullptr) {
-  return BAD_SUBSCRIPT;
 }
 
-inline const std::string BAD_SUBSCRIPT_WITH_KEY(const std::string& key) {
-  std::stringstream stream;
-  stream << BAD_SUBSCRIPT << " (key: \"" << 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) {
-  std::stringstream stream;
-  stream << BAD_SUBSCRIPT << " (key: \"" << key << "\")";
-  return stream.str();
-}
-
-inline const std::string INVALID_NODE_WITH_KEY(const std::string& key) {
-  std::stringstream stream;
-  if (key.empty()) {
-    return INVALID_NODE;
-  }
-  stream << "invalid node; first invalid key: \"" << key << "\"";
-  return stream.str();
-}
-}  // namespace ErrorMsg
-
 class YAML_CPP_API Exception : public std::runtime_error {
  public:
   Exception(const Mark& mark_, const std::string& msg_)
       : std::runtime_error(build_what(mark_, msg_)), mark(mark_), msg(msg_) {}
-  ~Exception() YAML_CPP_NOEXCEPT override;
+  virtual ~Exception() NOEXCEPT;
 
   Exception(const Exception&) = default;
 
@@ -165,7 +135,7 @@ class YAML_CPP_API Exception : public std::runtime_error {
   static const std::string build_what(const Mark& mark,
                                       const std::string& msg) {
     if (mark.is_null()) {
-      return msg;
+      return msg.c_str();
     }
 
     std::stringstream output;
@@ -180,7 +150,7 @@ class YAML_CPP_API ParserException : public Exception {
   ParserException(const Mark& mark_, const std::string& msg_)
       : Exception(mark_, msg_) {}
   ParserException(const ParserException&) = default;
-  ~ParserException() YAML_CPP_NOEXCEPT override;
+  virtual ~ParserException() NOEXCEPT;
 };
 
 class YAML_CPP_API RepresentationException : public Exception {
@@ -188,7 +158,7 @@ class YAML_CPP_API RepresentationException : public Exception {
   RepresentationException(const Mark& mark_, const std::string& msg_)
       : Exception(mark_, msg_) {}
   RepresentationException(const RepresentationException&) = default;
-  ~RepresentationException() YAML_CPP_NOEXCEPT override;
+  virtual ~RepresentationException() NOEXCEPT;
 };
 
 // representation exceptions
@@ -197,7 +167,7 @@ class YAML_CPP_API InvalidScalar : public RepresentationException {
   InvalidScalar(const Mark& mark_)
       : RepresentationException(mark_, ErrorMsg::INVALID_SCALAR) {}
   InvalidScalar(const InvalidScalar&) = default;
-  ~InvalidScalar() YAML_CPP_NOEXCEPT override;
+  virtual ~InvalidScalar() NOEXCEPT;
 };
 
 class YAML_CPP_API KeyNotFound : public RepresentationException {
@@ -207,7 +177,7 @@ class YAML_CPP_API KeyNotFound : public RepresentationException {
       : RepresentationException(mark_, ErrorMsg::KEY_NOT_FOUND_WITH_KEY(key_)) {
   }
   KeyNotFound(const KeyNotFound&) = default;
-  ~KeyNotFound() YAML_CPP_NOEXCEPT override;
+  virtual ~KeyNotFound() NOEXCEPT;
 };
 
 template <typename T>
@@ -215,7 +185,7 @@ class YAML_CPP_API TypedKeyNotFound : public KeyNotFound {
  public:
   TypedKeyNotFound(const Mark& mark_, const T& key_)
       : KeyNotFound(mark_, key_), key(key_) {}
-  ~TypedKeyNotFound() YAML_CPP_NOEXCEPT override = default;
+  virtual ~TypedKeyNotFound() NOEXCEPT {}
 
   T key;
 };
@@ -228,11 +198,10 @@ inline TypedKeyNotFound<T> MakeTypedKeyNotFound(const Mark& mark,
 
 class YAML_CPP_API InvalidNode : public RepresentationException {
  public:
-  InvalidNode(const std::string& key)
+  InvalidNode()
-      : RepresentationException(Mark::null_mark(),
+      : RepresentationException(Mark::null_mark(), ErrorMsg::INVALID_NODE) {}
-                                ErrorMsg::INVALID_NODE_WITH_KEY(key)) {}
   InvalidNode(const InvalidNode&) = default;
-  ~InvalidNode() YAML_CPP_NOEXCEPT override;
+  virtual ~InvalidNode() NOEXCEPT;
 };
 
 class YAML_CPP_API BadConversion : public RepresentationException {
@@ -240,7 +209,7 @@ class YAML_CPP_API BadConversion : public RepresentationException {
   explicit BadConversion(const Mark& mark_)
       : RepresentationException(mark_, ErrorMsg::BAD_CONVERSION) {}
   BadConversion(const BadConversion&) = default;
-  ~BadConversion() YAML_CPP_NOEXCEPT override;
+  virtual ~BadConversion() NOEXCEPT;
 };
 
 template <typename T>
@@ -254,16 +223,15 @@ class YAML_CPP_API BadDereference : public RepresentationException {
   BadDereference()
       : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_DEREFERENCE) {}
   BadDereference(const BadDereference&) = default;
-  ~BadDereference() YAML_CPP_NOEXCEPT override;
+  virtual ~BadDereference() NOEXCEPT;
 };
 
 class YAML_CPP_API BadSubscript : public RepresentationException {
  public:
-  template <typename Key>
+  BadSubscript()
-  BadSubscript(const Mark& mark_, const Key& key)
+      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_SUBSCRIPT) {}
-      : RepresentationException(mark_, ErrorMsg::BAD_SUBSCRIPT_WITH_KEY(key)) {}
   BadSubscript(const BadSubscript&) = default;
-  ~BadSubscript() YAML_CPP_NOEXCEPT override;
+  virtual ~BadSubscript() NOEXCEPT;
 };
 
 class YAML_CPP_API BadPushback : public RepresentationException {
@@ -271,7 +239,7 @@ class YAML_CPP_API BadPushback : public RepresentationException {
   BadPushback()
       : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_PUSHBACK) {}
   BadPushback(const BadPushback&) = default;
-  ~BadPushback() YAML_CPP_NOEXCEPT override;
+  virtual ~BadPushback() NOEXCEPT;
 };
 
 class YAML_CPP_API BadInsert : public RepresentationException {
@@ -279,7 +247,7 @@ class YAML_CPP_API BadInsert : public RepresentationException {
   BadInsert()
       : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_INSERT) {}
   BadInsert(const BadInsert&) = default;
-  ~BadInsert() YAML_CPP_NOEXCEPT override;
+  virtual ~BadInsert() NOEXCEPT;
 };
 
 class YAML_CPP_API EmitterException : public Exception {
@@ -287,17 +255,15 @@ class YAML_CPP_API EmitterException : public Exception {
   EmitterException(const std::string& msg_)
       : Exception(Mark::null_mark(), msg_) {}
   EmitterException(const EmitterException&) = default;
-  ~EmitterException() YAML_CPP_NOEXCEPT override;
+  virtual ~EmitterException() NOEXCEPT;
 };
 
 class YAML_CPP_API BadFile : public Exception {
  public:
-  explicit BadFile(const std::string& filename)
+  BadFile() : Exception(Mark::null_mark(), ErrorMsg::BAD_FILE) {}
-      : Exception(Mark::null_mark(),
-                  std::string(ErrorMsg::BAD_FILE) + ": " + filename) {}
   BadFile(const BadFile&) = default;
-  ~BadFile() YAML_CPP_NOEXCEPT override;
+  virtual ~BadFile() NOEXCEPT;
 };
-}  // namespace YAML
+}
 
 #endif  // EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/include/yaml-cpp/node/convert.h

@@ -8,14 +8,10 @@
 #endif
 
 #include <array>
-#include <cmath>
 #include <limits>
 #include <list>
 #include <map>
-#include <unordered_map>
 #include <sstream>
-#include <type_traits>
-#include <valarray>
 #include <vector>
 
 #include "yaml-cpp/binary.h"
@@ -25,7 +21,6 @@
 #include "yaml-cpp/node/type.h"
 #include "yaml-cpp/null.h"
 
-
 namespace YAML {
 class Binary;
 struct _Null;
@@ -76,17 +71,12 @@ struct convert<std::string> {
 // C-strings can only be encoded
 template <>
 struct convert<const char*> {
-  static Node encode(const char* rhs) { return Node(rhs); }
+  static Node encode(const char*& rhs) { return Node(rhs); }
-};
-
-template <>
-struct convert<char*> {
-  static Node encode(const char* rhs) { return Node(rhs); }
 };
 
 template <std::size_t N>
-struct convert<char[N]> {
+struct convert<const char[N]> {
-  static Node encode(const char* rhs) { return Node(rhs); }
+  static Node encode(const char(&rhs)[N]) { return Node(rhs); }
 };
 
 template <>
@@ -98,79 +88,24 @@ struct convert<_Null> {
   }
 };
 
-namespace conversion {
-template <typename T>
-typename std::enable_if< std::is_floating_point<T>::value, void>::type
-inner_encode(const T& rhs, std::stringstream& stream){
-  if (std::isnan(rhs)) {
-    stream << ".nan";
-  } else if (std::isinf(rhs)) {
-    if (std::signbit(rhs)) {
-      stream << "-.inf";
-    } else {
-      stream << ".inf";
-    }
-  } else {
-    stream << rhs;
-  }
-}
-
-template <typename T>
-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)                \
   template <>                                                            \
   struct convert<type> {                                                 \
-                                                                           \
     static Node encode(const type& rhs) {                                \
       std::stringstream stream;                                          \
-      stream.precision(std::numeric_limits<type>::max_digits10);           \
+      stream.precision(std::numeric_limits<type>::digits10 + 1);         \
-      conversion::inner_encode(rhs, stream);                               \
+      stream << rhs;                                                     \
       return Node(stream.str());                                         \
     }                                                                    \
                                                                          \
     static bool decode(const Node& node, type& rhs) {                    \
-      if (node.Type() != NodeType::Scalar) {                               \
+      if (node.Type() != NodeType::Scalar)                               \
         return false;                                                    \
-      }                                                                    \
       const std::string& input = node.Scalar();                          \
       std::stringstream stream(input);                                   \
       stream.unsetf(std::ios::dec);                                      \
-      if ((stream.peek() == '-') && std::is_unsigned<type>::value) {       \
+      if ((stream >> std::noskipws >> rhs) && (stream >> std::ws).eof()) \
-        return false;                                                      \
-      }                                                                    \
-      if (conversion::ConvertStreamTo(stream, rhs)) {                      \
         return true;                                                     \
-      }                                                                    \
       if (std::numeric_limits<type>::has_infinity) {                     \
         if (conversion::IsInfinity(input)) {                             \
           rhs = std::numeric_limits<type>::infinity();                   \
@@ -181,11 +116,10 @@ ConvertStreamTo(std::stringstream& stream, T& rhs) {
         }                                                                \
       }                                                                  \
                                                                          \
-      if (std::numeric_limits<type>::has_quiet_NaN) {                      \
+      if (std::numeric_limits<type>::has_quiet_NaN &&                    \
-        if (conversion::IsNaN(input)) {                                    \
+          conversion::IsNaN(input)) {                                    \
         rhs = std::numeric_limits<type>::quiet_NaN();                    \
         return true;                                                     \
-        }                                                                  \
       }                                                                  \
                                                                          \
       return false;                                                      \
@@ -228,104 +162,81 @@ struct convert<bool> {
 };
 
 // std::map
-template <typename K, typename V, typename C, typename A>
+template <typename K, typename V>
-struct convert<std::map<K, V, C, A>> {
+struct convert<std::map<K, V>> {
-  static Node encode(const std::map<K, V, C, A>& rhs) {
+  static Node encode(const std::map<K, V>& rhs) {
     Node node(NodeType::Map);
-    for (const auto& element : rhs)
+    for (typename std::map<K, V>::const_iterator it = rhs.begin();
-      node.force_insert(element.first, element.second);
+         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>();
+      rhs[it->first.as<K>()] = it->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>();
 #endif
     return true;
   }
 };
 
 // std::vector
-template <typename T, typename A>
+template <typename T>
-struct convert<std::vector<T, A>> {
+struct convert<std::vector<T>> {
-  static Node encode(const std::vector<T, A>& rhs) {
+  static Node encode(const std::vector<T>& rhs) {
     Node node(NodeType::Sequence);
-    for (const auto& element : rhs)
+    for (typename std::vector<T>::const_iterator it = rhs.begin();
-      node.push_back(element);
+         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>
+template <typename T>
-struct convert<std::list<T,A>> {
+struct convert<std::list<T>> {
-  static Node encode(const std::list<T,A>& rhs) {
+  static Node encode(const std::list<T>& rhs) {
     Node node(NodeType::Sequence);
-    for (const auto& element : rhs)
+    for (typename std::list<T>::const_iterator it = rhs.begin();
-      node.push_back(element);
+         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;
   }
@@ -364,37 +275,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>> {

3rdparty/yaml-cpp/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 {
@@ -19,7 +17,7 @@ template <typename Key, typename Enable = void>
 struct get_idx {
   static node* get(const std::vector<node*>& /* sequence */,
                    const Key& /* key */, shared_memory_holder /* pMemory */) {
-    return nullptr;
+    return 0;
   }
 };
 
@@ -29,13 +27,13 @@ struct get_idx<Key,
                                        !std::is_same<Key, bool>::value>::type> {
   static node* get(const std::vector<node*>& sequence, const Key& key,
                    shared_memory_holder /* pMemory */) {
-    return key < sequence.size() ? sequence[key] : nullptr;
+    return key < sequence.size() ? sequence[key] : 0;
   }
 
   static node* get(std::vector<node*>& sequence, const Key& key,
                    shared_memory_holder pMemory) {
-    if (key > sequence.size() || (key > 0 && !sequence[key - 1]->is_defined()))
+   if (key > sequence.size() || (key > 0 && !sequence[key-1]->is_defined()))
-      return nullptr;
+      return 0;
     if (key == sequence.size())
       sequence.push_back(&pMemory->create_node());
     return sequence[key];
@@ -48,51 +46,13 @@ struct get_idx<Key, typename std::enable_if<std::is_signed<Key>::value>::type> {
                    shared_memory_holder pMemory) {
     return key >= 0 ? get_idx<std::size_t>::get(
                           sequence, static_cast<std::size_t>(key), pMemory)
-                    : nullptr;
+                    : 0;
   }
   static node* get(std::vector<node*>& sequence, const Key& key,
                    shared_memory_holder pMemory) {
     return key >= 0 ? get_idx<std::size_t>::get(
                           sequence, static_cast<std::size_t>(key), pMemory)
-                    : nullptr;
+                    : 0;
-  }
-};
-
-template <typename Key, typename Enable = void>
-struct remove_idx {
-  static bool remove(std::vector<node*>&, const Key&, std::size_t&) {
-    return false;
-  }
-};
-
-template <typename Key>
-struct remove_idx<
-    Key, typename std::enable_if<std::is_unsigned<Key>::value &&
-                                 !std::is_same<Key, bool>::value>::type> {
-
-  static bool remove(std::vector<node*>& sequence, const Key& key,
-                     std::size_t& seqSize) {
-    if (key >= sequence.size()) {
-      return false;
-    } else {
-      sequence.erase(sequence.begin() + key);
-      if (seqSize > key) {
-          --seqSize;
-      }
-      return true;
-    }
-  }
-};
-
-template <typename Key>
-struct remove_idx<Key,
-                  typename std::enable_if<std::is_signed<Key>::value>::type> {
-
-  static bool remove(std::vector<node*>& sequence, const Key& key,
-                     std::size_t& seqSize) {
-    return key >= 0 ? remove_idx<std::size_t>::remove(
-                          sequence, static_cast<std::size_t>(key), seqSize)
-                    : false;
   }
 };
 
@@ -106,11 +66,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;
+  return equals<std::string>(rhs, pMemory);
-  if (convert<std::string>::decode(Node(*this, std::move(pMemory)), lhs)) {
-    return lhs == rhs;
-  }
-  return false;
 }
 
 // indexing
@@ -122,20 +78,22 @@ inline node* node_data::get(const Key& key,
       break;
     case NodeType::Undefined:
     case NodeType::Null:
-      return nullptr;
+      return NULL;
     case NodeType::Sequence:
       if (node* pNode = get_idx<Key>::get(m_sequence, key, pMemory))
         return pNode;
-      return nullptr;
+      return NULL;
     case NodeType::Scalar:
-      throw BadSubscript(m_mark, key);
+      throw BadSubscript();
   }
 
-  auto it = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) {
+  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
-    return m.first->equals(key, pMemory);
+    if (it->first->equals(key, pMemory)) {
-  });
+      return it->second;
+    }
+  }
 
-  return it != m_map.end() ? it->second : nullptr;
+  return NULL;
 }
 
 template <typename Key>
@@ -154,16 +112,14 @@ inline node& node_data::get(const Key& key, shared_memory_holder pMemory) {
       convert_to_map(pMemory);
       break;
     case NodeType::Scalar:
-      throw BadSubscript(m_mark, key);
+      throw BadSubscript();
   }
 
-  auto it = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) {
+  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
-    return m.first->equals(key, pMemory);
+    if (it->first->equals(key, pMemory)) {
-  });
-
-  if (it != m_map.end()) {
       return *it->second;
     }
+  }
 
   node& k = convert_to_node(key, pMemory);
   node& v = pMemory->create_node();
@@ -173,26 +129,20 @@ inline node& node_data::get(const Key& key, shared_memory_holder pMemory) {
 
 template <typename Key>
 inline bool node_data::remove(const Key& key, shared_memory_holder pMemory) {
-  if (m_type == NodeType::Sequence) {
+  if (m_type != NodeType::Map)
-    return remove_idx<Key>::remove(m_sequence, key, m_seqSize);
+    return false;
-  }
 
-  if (m_type == NodeType::Map) {
+  for (kv_pairs::iterator it = m_undefinedPairs.begin();
-    kv_pairs::iterator it = m_undefinedPairs.begin();
+       it != m_undefinedPairs.end();) {
-    while (it != m_undefinedPairs.end()) {
     kv_pairs::iterator jt = std::next(it);
-      if (it->first->equals(key, pMemory)) {
+    if (it->first->equals(key, pMemory))
       m_undefinedPairs.erase(it);
-      }
     it = jt;
   }
 
-    auto iter = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) {
+  for (node_map::iterator it = m_map.begin(); it != m_map.end(); ++it) {
-      return m.first->equals(key, pMemory);
+    if (it->first->equals(key, pMemory)) {
-    });
+      m_map.erase(it);
-
-    if (iter != m_map.end()) {
-      m_map.erase(iter);
       return true;
     }
   }

3rdparty/yaml-cpp/include/yaml-cpp/node/detail/iterator.h

@@ -8,25 +8,24 @@
 #endif
 
 #include "yaml-cpp/dll.h"
-#include "yaml-cpp/node/detail/node_iterator.h"
-#include "yaml-cpp/node/node.h"
 #include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/detail/node_iterator.h"
 #include <cstddef>
 #include <iterator>
 
-
 namespace YAML {
 namespace detail {
 struct iterator_value;
 
 template <typename V>
-class iterator_base {
+class iterator_base : public std::iterator<std::forward_iterator_tag, V,
+                                           std::ptrdiff_t, V*, V> {
 
  private:
   template <typename>
   friend class iterator_base;
   struct enabler {};
-  using base_type = node_iterator;
+  typedef node_iterator base_type;
 
   struct proxy {
     explicit proxy(const V& x) : m_ref(x) {}
@@ -37,11 +36,7 @@ class iterator_base {
   };
 
  public:
-  using iterator_category = std::forward_iterator_tag;
+  typedef typename iterator_base::value_type value_type;
-  using value_type = V;
-  using difference_type = std::ptrdiff_t;
-  using pointer = V*;
-  using reference = V;
 
  public:
   iterator_base() : m_iterator(), m_pMemory() {}
@@ -90,7 +85,7 @@ class iterator_base {
   base_type m_iterator;
   shared_memory_holder m_pMemory;
 };
-}  // namespace detail
+}
-}  // namespace YAML
+}
 
 #endif  // VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/include/yaml-cpp/node/detail/iterator_fwd.h

@@ -20,8 +20,8 @@ template <typename V>
 class iterator_base;
 }
 
-using iterator = detail::iterator_base<detail::iterator_value>;
+typedef detail::iterator_base<detail::iterator_value> iterator;
-using const_iterator = detail::iterator_base<const detail::iterator_value>;
+typedef detail::iterator_base<const detail::iterator_value> const_iterator;
 }
 
 #endif  // VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/include/yaml-cpp/node/detail/memory.h

@@ -22,12 +22,11 @@ namespace YAML {
 namespace detail {
 class YAML_CPP_API memory {
  public:
-  memory() : m_nodes{} {}
   node& create_node();
   void merge(const memory& rhs);
 
  private:
-  using Nodes = std::set<shared_node>;
+  typedef std::set<shared_node> Nodes;
   Nodes m_nodes;
 };
 
@@ -41,7 +40,7 @@ class YAML_CPP_API memory_holder {
  private:
   shared_memory m_pMemory;
 };
-}  // namespace detail
+}
-}  // namespace YAML
+}
 
 #endif  // VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/include/yaml-cpp/node/detail/node.h

@@ -7,24 +7,18 @@
 #pragma once
 #endif
 
-#include "yaml-cpp/dll.h"
 #include "yaml-cpp/emitterstyle.h"
-#include "yaml-cpp/node/detail/node_ref.h"
+#include "yaml-cpp/dll.h"
-#include "yaml-cpp/node/ptr.h"
 #include "yaml-cpp/node/type.h"
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/detail/node_ref.h"
 #include <set>
-#include <atomic>
 
 namespace YAML {
 namespace detail {
 class node {
- private:
-  struct less {
-    bool operator ()(const node* l, const node* r) const {return l->m_index < r->m_index;}
-  };
-
  public:
-  node() : m_pRef(new node_ref), m_dependencies{}, m_index{} {}
+  node() : m_pRef(new node_ref) {}
   node(const node&) = delete;
   node& operator=(const node&) = delete;
 
@@ -48,8 +42,9 @@ class node {
       return;
 
     m_pRef->mark_defined();
-    for (node* dependency : m_dependencies)
+    for (nodes::iterator it = m_dependencies.begin();
-      dependency->mark_defined();
+         it != m_dependencies.end(); ++it)
+      (*it)->mark_defined();
     m_dependencies.clear();
   }
 
@@ -114,7 +109,6 @@ class node {
   void push_back(node& input, shared_memory_holder pMemory) {
     m_pRef->push_back(input, pMemory);
     input.add_dependency(*this);
-    m_index = m_amount.fetch_add(1);
   }
   void insert(node& key, node& value, shared_memory_holder pMemory) {
     m_pRef->insert(key, value, pMemory);
@@ -126,7 +120,7 @@ class node {
   template <typename Key>
   node* get(const Key& key, shared_memory_holder pMemory) const {
     // NOTE: this returns a non-const node so that the top-level Node can wrap
-    // it, and returns a pointer so that it can be nullptr (if there is no such
+    // it, and returns a pointer so that it can be NULL (if there is no such
     // key).
     return static_cast<const node_ref&>(*m_pRef).get(key, pMemory);
   }
@@ -143,7 +137,7 @@ class node {
 
   node* get(node& key, shared_memory_holder pMemory) const {
     // NOTE: this returns a non-const node so that the top-level Node can wrap
-    // it, and returns a pointer so that it can be nullptr (if there is no such
+    // it, and returns a pointer so that it can be NULL (if there is no such
     // key).
     return static_cast<const node_ref&>(*m_pRef).get(key, pMemory);
   }
@@ -166,12 +160,10 @@ class node {
 
  private:
   shared_node_ref m_pRef;
-  using nodes = std::set<node*, less>;
+  typedef std::set<node*> nodes;
   nodes m_dependencies;
-  size_t m_index;
-  static YAML_CPP_API std::atomic<size_t> m_amount;
 };
-}  // namespace detail
+}
-}  // namespace YAML
+}
 
 #endif  // NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/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 push_back(node& node, shared_memory_holder pMemory);
-  void insert(node& key, node& value, const 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, shared_memory_holder pMemory) const;
-  node& get(node& key, const shared_memory_holder& pMemory);
+  node& get(node& key, shared_memory_holder pMemory);
-  bool remove(node& key, const shared_memory_holder& pMemory);
+  bool remove(node& key, shared_memory_holder pMemory);
 
   // map
   template <typename Key, typename Value>
@@ -81,7 +81,7 @@ class YAML_CPP_API node_data {
                     shared_memory_holder pMemory);
 
  public:
-  static const std::string& empty_scalar();
+  static std::string empty_scalar;
 
  private:
   void compute_seq_size() const;
@@ -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_to_map(shared_memory_holder pMemory);
-  void convert_sequence_to_map(const 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);
@@ -108,17 +108,17 @@ class YAML_CPP_API node_data {
   std::string m_scalar;
 
   // sequence
-  using node_seq = std::vector<node *>;
+  typedef std::vector<node*> node_seq;
   node_seq m_sequence;
 
   mutable std::size_t m_seqSize;
 
   // map
-  using node_map = std::vector<std::pair<node*, node*>>;
+  typedef std::vector<std::pair<node*, node*>> node_map;
   node_map m_map;
 
-  using kv_pair = std::pair<node*, node*>;
+  typedef std::pair<node*, node*> kv_pair;
-  using kv_pairs = std::list<kv_pair>;
+  typedef std::list<kv_pair> kv_pairs;
   mutable kv_pairs m_undefinedPairs;
 };
 }

3rdparty/yaml-cpp/include/yaml-cpp/node/detail/node_iterator.h

@@ -19,16 +19,16 @@
 namespace YAML {
 namespace detail {
 struct iterator_type {
-  enum value { NoneType, Sequence, Map };
+  enum value { None, Sequence, Map };
 };
 
 template <typename V>
 struct node_iterator_value : public std::pair<V*, V*> {
-  using kv = std::pair<V*, V*>;
+  typedef std::pair<V*, V*> kv;
 
-  node_iterator_value() : kv(), pNode(nullptr) {}
+  node_iterator_value() : kv(), pNode(0) {}
   explicit node_iterator_value(V& rhs) : kv(), pNode(&rhs) {}
-  explicit node_iterator_value(V& key, V& value) : kv(&key, &value), pNode(nullptr) {}
+  explicit node_iterator_value(V& key, V& value) : kv(&key, &value), pNode(0) {}
 
   V& operator*() const { return *pNode; }
   V& operator->() const { return *pNode; }
@@ -36,23 +36,26 @@ struct node_iterator_value : public std::pair<V*, V*> {
   V* pNode;
 };
 
-using node_seq = std::vector<node *>;
+typedef std::vector<node*> node_seq;
-using node_map = std::vector<std::pair<node*, node*>>;
+typedef std::vector<std::pair<node*, node*>> node_map;
 
 template <typename V>
 struct node_iterator_type {
-  using seq = node_seq::iterator;
+  typedef node_seq::iterator seq;
-  using map = node_map::iterator;
+  typedef node_map::iterator map;
 };
 
 template <typename V>
 struct node_iterator_type<const V> {
-  using seq = node_seq::const_iterator;
+  typedef node_seq::const_iterator seq;
-  using map = node_map::const_iterator;
+  typedef node_map::const_iterator map;
 };
 
 template <typename V>
-class node_iterator_base {
+class node_iterator_base
+    : public std::iterator<std::forward_iterator_tag, node_iterator_value<V>,
+                           std::ptrdiff_t, node_iterator_value<V>*,
+                           node_iterator_value<V>> {
  private:
   struct enabler {};
 
@@ -65,16 +68,12 @@ class node_iterator_base {
   };
 
  public:
-  using iterator_category = std::forward_iterator_tag;
+  typedef typename node_iterator_type<V>::seq SeqIter;
-  using value_type = node_iterator_value<V>;
+  typedef typename node_iterator_type<V>::map MapIter;
-  using difference_type = std::ptrdiff_t;
+  typedef node_iterator_value<V> value_type;
-  using pointer = node_iterator_value<V>*;
-  using reference = node_iterator_value<V>;
-  using SeqIter = typename node_iterator_type<V>::seq;
-  using MapIter = typename node_iterator_type<V>::map;
 
   node_iterator_base()
-      : m_type(iterator_type::NoneType), m_seqIt(), m_mapIt(), m_mapEnd() {}
+      : m_type(iterator_type::None), m_seqIt(), m_mapIt(), m_mapEnd() {}
   explicit node_iterator_base(SeqIter seqIt)
       : m_type(iterator_type::Sequence),
         m_seqIt(seqIt),
@@ -106,7 +105,7 @@ class node_iterator_base {
       return false;
 
     switch (m_type) {
-      case iterator_type::NoneType:
+      case iterator_type::None:
         return true;
       case iterator_type::Sequence:
         return m_seqIt == rhs.m_seqIt;
@@ -123,7 +122,7 @@ class node_iterator_base {
 
   node_iterator_base<V>& operator++() {
     switch (m_type) {
-      case iterator_type::NoneType:
+      case iterator_type::None:
         break;
       case iterator_type::Sequence:
         ++m_seqIt;
@@ -144,7 +143,7 @@ class node_iterator_base {
 
   value_type operator*() const {
     switch (m_type) {
-      case iterator_type::NoneType:
+      case iterator_type::None:
         return value_type();
       case iterator_type::Sequence:
         return value_type(**m_seqIt);
@@ -173,8 +172,8 @@ class node_iterator_base {
   MapIter m_mapIt, m_mapEnd;
 };
 
-using node_iterator = node_iterator_base<node>;
+typedef node_iterator_base<node> node_iterator;
-using const_node_iterator = node_iterator_base<const node>;
+typedef node_iterator_base<const node> const_node_iterator;
 }
 }
 

3rdparty/yaml-cpp/include/yaml-cpp/node/impl.h

@@ -7,21 +7,18 @@
 #pragma once
 #endif
 
-#include "yaml-cpp/exceptions.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/iterator.h"
 #include "yaml-cpp/node/detail/memory.h"
 #include "yaml-cpp/node/detail/node.h"
-#include "yaml-cpp/node/iterator.h"
+#include "yaml-cpp/exceptions.h"
-#include "yaml-cpp/node/node.h"
-#include <sstream>
 #include <string>
 
 namespace YAML {
-inline Node::Node()
+inline Node::Node() : m_isValid(true), m_pNode(NULL) {}
-    : m_isValid(true), m_invalidKey{}, m_pMemory(nullptr), m_pNode(nullptr) {}
 
 inline Node::Node(NodeType::value type)
     : m_isValid(true),
-      m_invalidKey{},
       m_pMemory(new detail::memory_holder),
       m_pNode(&m_pMemory->create_node()) {
   m_pNode->set_type(type);
@@ -30,7 +27,6 @@ inline Node::Node(NodeType::value type)
 template <typename T>
 inline Node::Node(const T& rhs)
     : m_isValid(true),
-      m_invalidKey{},
       m_pMemory(new detail::memory_holder),
       m_pNode(&m_pMemory->create_node()) {
   Assign(rhs);
@@ -38,26 +34,24 @@ inline Node::Node(const T& rhs)
 
 inline Node::Node(const detail::iterator_value& rhs)
     : m_isValid(rhs.m_isValid),
-      m_invalidKey(rhs.m_invalidKey),
       m_pMemory(rhs.m_pMemory),
       m_pNode(rhs.m_pNode) {}
 
-inline Node::Node(const Node&) = default;
+inline Node::Node(const Node& rhs)
+    : m_isValid(rhs.m_isValid),
+      m_pMemory(rhs.m_pMemory),
+      m_pNode(rhs.m_pNode) {}
 
-inline Node::Node(Zombie)
+inline Node::Node(Zombie) : m_isValid(false), m_pNode(NULL) {}
-    : m_isValid(false), m_invalidKey{}, m_pMemory{}, m_pNode(nullptr) {}
-
-inline Node::Node(Zombie, const std::string& key)
-    : m_isValid(false), m_invalidKey(key), m_pMemory{}, m_pNode(nullptr) {}
 
 inline Node::Node(detail::node& node, detail::shared_memory_holder pMemory)
-    : m_isValid(true), m_invalidKey{}, m_pMemory(pMemory), m_pNode(&node) {}
+    : m_isValid(true), m_pMemory(pMemory), m_pNode(&node) {}
 
-inline Node::~Node() = default;
+inline Node::~Node() {}
 
 inline void Node::EnsureNodeExists() const {
   if (!m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw InvalidNode();
   if (!m_pNode) {
     m_pMemory.reset(new detail::memory_holder);
     m_pNode = &m_pMemory->create_node();
@@ -74,14 +68,14 @@ inline bool Node::IsDefined() const {
 
 inline Mark Node::Mark() const {
   if (!m_isValid) {
-    throw InvalidNode(m_invalidKey);
+    throw InvalidNode();
   }
   return m_pNode ? m_pNode->mark() : Mark::null_mark();
 }
 
 inline NodeType::value Node::Type() const {
   if (!m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw InvalidNode();
   return m_pNode ? m_pNode->type() : NodeType::Null;
 }
 
@@ -110,8 +104,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 +132,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();
@@ -152,7 +142,7 @@ struct as_if<std::string, void> {
 template <typename T>
 inline T Node::as() const {
   if (!m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw InvalidNode();
   return as_if<T, void>(*this)();
 }
 
@@ -165,28 +155,32 @@ inline T Node::as(const S& fallback) const {
 
 inline const std::string& Node::Scalar() const {
   if (!m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw InvalidNode();
-  return m_pNode ? m_pNode->scalar() : detail::node_data::empty_scalar();
+  return m_pNode ? m_pNode->scalar() : detail::node_data::empty_scalar;
 }
 
 inline const std::string& Node::Tag() const {
   if (!m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw InvalidNode();
-  return m_pNode ? m_pNode->tag() : detail::node_data::empty_scalar();
+  return m_pNode ? m_pNode->tag() : detail::node_data::empty_scalar;
 }
 
 inline void Node::SetTag(const std::string& tag) {
+  if (!m_isValid)
+    throw InvalidNode();
   EnsureNodeExists();
   m_pNode->set_tag(tag);
 }
 
 inline EmitterStyle::value Node::Style() const {
   if (!m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw InvalidNode();
   return m_pNode ? m_pNode->style() : EmitterStyle::Default;
 }
 
 inline void Node::SetStyle(EmitterStyle::value style) {
+  if (!m_isValid)
+    throw InvalidNode();
   EnsureNodeExists();
   m_pNode->set_style(style);
 }
@@ -194,7 +188,7 @@ inline void Node::SetStyle(EmitterStyle::value style) {
 // assignment
 inline bool Node::is(const Node& rhs) const {
   if (!m_isValid || !rhs.m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw InvalidNode();
   if (!m_pNode || !rhs.m_pNode)
     return false;
   return m_pNode->is(*rhs.m_pNode);
@@ -202,20 +196,15 @@ inline bool Node::is(const Node& rhs) const {
 
 template <typename T>
 inline Node& Node::operator=(const T& rhs) {
+  if (!m_isValid)
+    throw InvalidNode();
   Assign(rhs);
   return *this;
 }
 
-inline Node& Node::operator=(const Node& rhs) {
-  if (is(rhs))
-    return *this;
-  AssignNode(rhs);
-  return *this;
-}
-
 inline void Node::reset(const YAML::Node& rhs) {
   if (!m_isValid || !rhs.m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw InvalidNode();
   m_pMemory = rhs.m_pMemory;
   m_pNode = rhs.m_pNode;
 }
@@ -223,27 +212,44 @@ inline void Node::reset(const YAML::Node& rhs) {
 template <typename T>
 inline void Node::Assign(const T& rhs) {
   if (!m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw InvalidNode();
   AssignData(convert<T>::encode(rhs));
 }
 
 template <>
 inline void Node::Assign(const std::string& rhs) {
+  if (!m_isValid)
+    throw InvalidNode();
   EnsureNodeExists();
   m_pNode->set_scalar(rhs);
 }
 
 inline void Node::Assign(const char* rhs) {
+  if (!m_isValid)
+    throw InvalidNode();
   EnsureNodeExists();
   m_pNode->set_scalar(rhs);
 }
 
 inline void Node::Assign(char* rhs) {
+  if (!m_isValid)
+    throw InvalidNode();
   EnsureNodeExists();
   m_pNode->set_scalar(rhs);
 }
 
+inline Node& Node::operator=(const Node& rhs) {
+  if (!m_isValid || !rhs.m_isValid)
+    throw InvalidNode();
+  if (is(rhs))
+    return *this;
+  AssignNode(rhs);
+  return *this;
+}
+
 inline void Node::AssignData(const Node& rhs) {
+  if (!m_isValid || !rhs.m_isValid)
+    throw InvalidNode();
   EnsureNodeExists();
   rhs.EnsureNodeExists();
 
@@ -252,8 +258,8 @@ inline void Node::AssignData(const Node& rhs) {
 }
 
 inline void Node::AssignNode(const Node& rhs) {
-  if (!m_isValid)
+  if (!m_isValid || !rhs.m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw InvalidNode();
   rhs.EnsureNodeExists();
 
   if (!m_pNode) {
@@ -270,7 +276,7 @@ inline void Node::AssignNode(const Node& rhs) {
 // size/iterator
 inline std::size_t Node::size() const {
   if (!m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw InvalidNode();
   return m_pNode ? m_pNode->size() : 0;
 }
 
@@ -303,11 +309,13 @@ inline iterator Node::end() {
 template <typename T>
 inline void Node::push_back(const T& rhs) {
   if (!m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw InvalidNode();
   push_back(Node(rhs));
 }
 
 inline void Node::push_back(const Node& rhs) {
+  if (!m_isValid || !rhs.m_isValid)
+    throw InvalidNode();
   EnsureNodeExists();
   rhs.EnsureNodeExists();
 
@@ -315,49 +323,99 @@ inline void Node::push_back(const Node& rhs) {
   m_pMemory->merge(*rhs.m_pMemory);
 }
 
-template<typename Key>
+// helpers for indexing
-std::string key_to_string(const Key& key) {
+namespace detail {
-  return streamable_to_string<Key, is_streamable<std::stringstream, Key>::value>().impl(key);
+template <typename T>
+struct to_value_t {
+  explicit to_value_t(const T& t_) : t(t_) {}
+  const T& t;
+  typedef const T& return_type;
+
+  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;
+  typedef std::string return_type;
+
+  const std::string operator()() const { return t; }
+};
+
+template <>
+struct to_value_t<char*> {
+  explicit to_value_t(char* t_) : t(t_) {}
+  const char* t;
+  typedef std::string return_type;
+
+  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;
+  typedef std::string return_type;
+
+  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)();
+}
 }
 
 // indexing
 template <typename Key>
 inline const Node Node::operator[](const Key& key) const {
+  if (!m_isValid)
+    throw InvalidNode();
   EnsureNodeExists();
-  detail::node* value =
+  detail::node* value = static_cast<const detail::node&>(*m_pNode)
-      static_cast<const detail::node&>(*m_pNode).get(key, m_pMemory);
+                            .get(detail::to_value(key), m_pMemory);
   if (!value) {
-    return Node(ZombieNode, key_to_string(key));
+    return Node(ZombieNode);
   }
   return Node(*value, m_pMemory);
 }
 
 template <typename Key>
 inline Node Node::operator[](const Key& key) {
+  if (!m_isValid)
+    throw InvalidNode();
   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) {
+  if (!m_isValid)
+    throw InvalidNode();
   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 {
+  if (!m_isValid || !key.m_isValid)
+    throw InvalidNode();
   EnsureNodeExists();
   key.EnsureNodeExists();
   m_pMemory->merge(*key.m_pMemory);
   detail::node* value =
       static_cast<const detail::node&>(*m_pNode).get(*key.m_pNode, m_pMemory);
   if (!value) {
-    return Node(ZombieNode, key_to_string(key));
+    return Node(ZombieNode);
   }
   return Node(*value, m_pMemory);
 }
 
 inline Node Node::operator[](const Node& key) {
+  if (!m_isValid || !key.m_isValid)
+    throw InvalidNode();
   EnsureNodeExists();
   key.EnsureNodeExists();
   m_pMemory->merge(*key.m_pMemory);
@@ -366,6 +424,8 @@ inline Node Node::operator[](const Node& key) {
 }
 
 inline bool Node::remove(const Node& key) {
+  if (!m_isValid || !key.m_isValid)
+    throw InvalidNode();
   EnsureNodeExists();
   key.EnsureNodeExists();
   return m_pNode->remove(*key.m_pNode, m_pMemory);
@@ -374,12 +434,15 @@ inline bool Node::remove(const Node& key) {
 // map
 template <typename Key, typename Value>
 inline void Node::force_insert(const Key& key, const Value& value) {
+  if (!m_isValid)
+    throw InvalidNode();
   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
 inline bool operator==(const Node& lhs, const Node& rhs) { return lhs.is(rhs); }
-}  // namespace YAML
+}
 
 #endif  // NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/include/yaml-cpp/node/iterator.h

@@ -15,13 +15,10 @@
 #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> {
-  iterator_value() = default;
+  iterator_value() {}
   explicit iterator_value(const Node& rhs)
       : Node(rhs),
         std::pair<Node, Node>(Node(Node::ZombieNode), Node(Node::ZombieNode)) {}

3rdparty/yaml-cpp/include/yaml-cpp/node/node.h

@@ -8,11 +8,11 @@
 #endif
 
 #include <stdexcept>
-#include <string>
 
 #include "yaml-cpp/dll.h"
 #include "yaml-cpp/emitterstyle.h"
 #include "yaml-cpp/mark.h"
+#include "yaml-cpp/node/detail/bool_type.h"
 #include "yaml-cpp/node/detail/iterator_fwd.h"
 #include "yaml-cpp/node/ptr.h"
 #include "yaml-cpp/node/type.h"
@@ -38,8 +38,8 @@ class YAML_CPP_API Node {
   template <typename T, typename S>
   friend struct as_if;
 
-  using iterator = YAML::iterator;
+  typedef YAML::iterator iterator;
-  using const_iterator = YAML::const_iterator;
+  typedef YAML::const_iterator const_iterator;
 
   Node();
   explicit Node(NodeType::value type);
@@ -58,7 +58,7 @@ class YAML_CPP_API Node {
   bool IsMap() const { return Type() == NodeType::Map; }
 
   // bool conversions
-  explicit operator bool() const { return IsDefined(); }
+  YAML_CPP_OPERATOR_BOOL()
   bool operator!() const { return !IsDefined(); }
 
   // access
@@ -116,7 +116,6 @@ class YAML_CPP_API Node {
  private:
   enum Zombie { ZombieNode };
   explicit Node(Zombie);
-  explicit Node(Zombie, const std::string&);
   explicit Node(detail::node& node, detail::shared_memory_holder pMemory);
 
   void EnsureNodeExists() const;
@@ -131,8 +130,6 @@ class YAML_CPP_API Node {
 
  private:
   bool m_isValid;
-  // String representation of invalid key, if the node is invalid.
-  std::string m_invalidKey;
   mutable detail::shared_memory_holder m_pMemory;
   mutable detail::node* m_pNode;
 };

3rdparty/yaml-cpp/include/yaml-cpp/node/ptr.h

@@ -7,6 +7,7 @@
 #pragma once
 #endif
 
+#include "yaml-cpp/dll.h"
 #include <memory>
 
 namespace YAML {
@@ -17,11 +18,11 @@ class node_data;
 class memory;
 class memory_holder;
 
-using shared_node = std::shared_ptr<node>;
+typedef std::shared_ptr<node> shared_node;
-using shared_node_ref = std::shared_ptr<node_ref>;
+typedef std::shared_ptr<node_ref> shared_node_ref;
-using shared_node_data = std::shared_ptr<node_data>;
+typedef std::shared_ptr<node_data> shared_node_data;
-using shared_memory_holder = std::shared_ptr<memory_holder>;
+typedef std::shared_ptr<memory_holder> shared_memory_holder;
-using shared_memory = std::shared_ptr<memory>;
+typedef std::shared_ptr<memory> shared_memory;
 }
 }
 

3rdparty/yaml-cpp/include/yaml-cpp/noexcept.h

@@ -1,18 +0,0 @@
-#ifndef NOEXCEPT_H_768872DA_476C_11EA_88B8_90B11C0C0FF8
-#define NOEXCEPT_H_768872DA_476C_11EA_88B8_90B11C0C0FF8
-
-#if defined(_MSC_VER) ||                                            \
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
-#pragma once
-#endif
-
-// This is here for compatibility with older versions of Visual Studio
-// which don't support noexcept.
-#if defined(_MSC_VER) && _MSC_VER < 1900
-    #define YAML_CPP_NOEXCEPT _NOEXCEPT
-#else
-    #define YAML_CPP_NOEXCEPT noexcept
-#endif
-
-#endif

3rdparty/yaml-cpp/include/yaml-cpp/ostream_wrapper.h

@@ -17,10 +17,6 @@ class YAML_CPP_API ostream_wrapper {
  public:
   ostream_wrapper();
   explicit ostream_wrapper(std::ostream& stream);
-  ostream_wrapper(const ostream_wrapper&) = delete;
-  ostream_wrapper(ostream_wrapper&&) = delete;
-  ostream_wrapper& operator=(const ostream_wrapper&) = delete;
-  ostream_wrapper& operator=(ostream_wrapper&&) = delete;
   ~ostream_wrapper();
 
   void write(const std::string& str);
@@ -30,7 +26,7 @@ class YAML_CPP_API ostream_wrapper {
 
   const char* str() const {
     if (m_pStream) {
-      return nullptr;
+      return 0;
     } else {
       m_buffer[m_pos] = '\0';
       return &m_buffer[0];
@@ -56,7 +52,7 @@ class YAML_CPP_API ostream_wrapper {
 
 template <std::size_t N>
 inline ostream_wrapper& operator<<(ostream_wrapper& stream,
-                                   const char (&str)[N]) {
+                                   const char(&str)[N]) {
   stream.write(str, N - 1);
   return stream;
 }
@@ -71,6 +67,6 @@ inline ostream_wrapper& operator<<(ostream_wrapper& stream, char ch) {
   stream.write(&ch, 1);
   return stream;
 }
-}  // namespace YAML
+}
 
 #endif  // OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/include/yaml-cpp/parser.h

@@ -11,6 +11,7 @@
 #include <memory>
 
 #include "yaml-cpp/dll.h"
+#include "yaml-cpp/noncopyable.h"
 
 namespace YAML {
 class EventHandler;
@@ -23,16 +24,11 @@ struct Token;
  * A parser turns a stream of bytes into one stream of "events" per YAML
  * document in the input stream.
  */
-class YAML_CPP_API Parser {
+class YAML_CPP_API Parser : private noncopyable {
  public:
   /** Constructs an empty parser (with no input. */
   Parser();
 
-  Parser(const Parser&) = delete;
-  Parser(Parser&&) = delete;
-  Parser& operator=(const Parser&) = delete;
-  Parser& operator=(Parser&&) = delete;
-
   /**
    * Constructs a parser from the given input stream. The input stream must
    * live as long as the parser.
@@ -85,6 +81,6 @@ class YAML_CPP_API Parser {
   std::unique_ptr<Scanner> m_pScanner;
   std::unique_ptr<Directives> m_pDirectives;
 };
-}  // namespace YAML
+}
 
 #endif  // PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/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)
+  for (typename Seq::const_iterator it = seq.begin(); it != seq.end(); ++it)
-    emitter << v;
+    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)
+  for (typename map::const_iterator it = m.begin(); it != m.end(); ++it)
-    emitter << Key << v.first << Value << v.second;
+    emitter << Key << it->first << Value << it->second;
   emitter << EndMap;
   return emitter;
 }

3rdparty/yaml-cpp/include/yaml-cpp/traits.h

@@ -7,11 +7,6 @@
 #pragma once
 #endif
 
-#include <type_traits>
-#include <utility>
-#include <string>
-#include <sstream>
-
 namespace YAML {
 template <typename>
 struct is_numeric {
@@ -84,7 +79,7 @@ struct is_numeric<long double> {
 
 template <bool, class T = void>
 struct enable_if_c {
-  using type = T;
+  typedef T type;
 };
 
 template <class T>
@@ -95,7 +90,7 @@ struct enable_if : public enable_if_c<Cond::value, T> {};
 
 template <bool, class T = void>
 struct disable_if_c {
-  using type = T;
+  typedef T type;
 };
 
 template <class T>
@@ -105,31 +100,4 @@ template <class Cond, class T = void>
 struct disable_if : public disable_if_c<Cond::value, T> {};
 }
 
-template <typename S, typename T>
-struct is_streamable {
-  template <typename StreamT, typename ValueT>
-  static auto test(int)
-      -> decltype(std::declval<StreamT&>() << std::declval<ValueT>(), std::true_type());
-
-  template <typename, typename>
-  static auto test(...) -> std::false_type;
-
-  static const bool value = decltype(test<S, T>(0))::value;
-};
-
-template<typename Key, bool Streamable>
-struct streamable_to_string {
-  static std::string impl(const Key& key) {
-    std::stringstream ss;
-    ss << key;
-    return ss.str();
-  }
-};
-
-template<typename Key>
-struct streamable_to_string<Key, false> {
-  static std::string impl(const Key&) {
-    return "";
-  }
-};
 #endif  // TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/src/binary.cpp

@@ -1,7 +1,5 @@
 #include "yaml-cpp/binary.h"
 
-#include <cctype>
-
 namespace YAML {
 static const char encoding[] =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -66,7 +64,7 @@ static const unsigned char decoding[] = {
 };
 
 std::vector<unsigned char> DecodeBase64(const std::string &input) {
-  using ret_type = std::vector<unsigned char>;
+  typedef std::vector<unsigned char> ret_type;
   if (input.empty())
     return ret_type();
 
@@ -74,27 +72,22 @@ std::vector<unsigned char> DecodeBase64(const std::string &input) {
   unsigned char *out = &ret[0];
 
   unsigned value = 0;
-  for (std::size_t i = 0, cnt = 0; i < input.size(); i++) {
+  for (std::size_t i = 0; i < input.size(); i++) {
-    if (std::isspace(static_cast<unsigned char>(input[i]))) {
+    unsigned char d = decoding[static_cast<unsigned>(input[i])];
-      // skip newlines
-      continue;
-    }
-    unsigned char d = decoding[static_cast<unsigned char>(input[i])];
     if (d == 255)
       return ret_type();
 
     value = (value << 6) | d;
-    if (cnt % 4 == 3) {
+    if (i % 4 == 3) {
       *out++ = value >> 16;
       if (i > 0 && input[i - 1] != '=')
         *out++ = value >> 8;
       if (input[i] != '=')
         *out++ = value;
     }
-    ++cnt;
   }
 
   ret.resize(out - &ret[0]);
   return ret;
 }
-}  // namespace YAML
+}

3rdparty/yaml-cpp/src/collectionstack.h

@@ -7,8 +7,8 @@
 #pragma once
 #endif
 
-#include <cassert>
 #include <stack>
+#include <cassert>
 
 namespace YAML {
 struct CollectionType {
@@ -17,7 +17,6 @@ struct CollectionType {
 
 class CollectionStack {
  public:
-  CollectionStack() : collectionStack{} {}
   CollectionType::value GetCurCollectionType() const {
     if (collectionStack.empty())
       return CollectionType::NoCollection;
@@ -29,13 +28,12 @@ class CollectionStack {
   }
   void PopCollectionType(CollectionType::value type) {
     assert(type == GetCurCollectionType());
-    (void)type;
     collectionStack.pop();
   }
 
  private:
   std::stack<CollectionType::value> collectionStack;
 };
-}  // namespace YAML
+}
 
 #endif  // COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/src/contrib/graphbuilder.cpp

@@ -10,7 +10,8 @@ void* BuildGraphOfNextDocument(Parser& parser,
   GraphBuilderAdapter eventHandler(graphBuilder);
   if (parser.HandleNextDocument(eventHandler)) {
     return eventHandler.RootNode();
+  } else {
+    return NULL;
   }
-  return nullptr;
 }
-}  // namespace YAML
+}

3rdparty/yaml-cpp/src/contrib/graphbuilderadapter.cpp

@@ -49,7 +49,7 @@ void GraphBuilderAdapter::OnMapStart(const Mark &mark, const std::string &tag,
                                      EmitterStyle::value /* style */) {
   void *pNode = m_builder.NewMap(mark, tag, GetCurrentParent());
   m_containers.push(ContainerFrame(pNode, m_pKeyNode));
-  m_pKeyNode = nullptr;
+  m_pKeyNode = NULL;
   RegisterAnchor(anchor, pNode);
 }
 
@@ -62,7 +62,7 @@ void GraphBuilderAdapter::OnMapEnd() {
 
 void *GraphBuilderAdapter::GetCurrentParent() const {
   if (m_containers.empty()) {
-    return nullptr;
+    return NULL;
   }
   return m_containers.top().pContainer;
 }
@@ -83,7 +83,7 @@ void GraphBuilderAdapter::DispositionNode(void *pNode) {
   if (m_containers.top().isMap()) {
     if (m_pKeyNode) {
       m_builder.AssignInMap(pContainer, m_pKeyNode, pNode);
-      m_pKeyNode = nullptr;
+      m_pKeyNode = NULL;
     } else {
       m_pKeyNode = pNode;
     }
@@ -91,4 +91,4 @@ void GraphBuilderAdapter::DispositionNode(void *pNode) {
     m_builder.AppendToSequence(pContainer, pNode);
   }
 }
-}  // namespace YAML
+}

3rdparty/yaml-cpp/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"
 
@@ -25,15 +26,7 @@ namespace YAML {
 class GraphBuilderAdapter : public EventHandler {
  public:
   GraphBuilderAdapter(GraphBuilderInterface& builder)
-      : m_builder(builder),
+      : m_builder(builder), m_pRootNode(NULL), m_pKeyNode(NULL) {}
-        m_containers{},
-        m_anchors{},
-        m_pRootNode(nullptr),
-        m_pKeyNode(nullptr) {}
-  GraphBuilderAdapter(const GraphBuilderAdapter&) = delete;
-  GraphBuilderAdapter(GraphBuilderAdapter&&) = delete;
-  GraphBuilderAdapter& operator=(const GraphBuilderAdapter&) = delete;
-  GraphBuilderAdapter& operator=(GraphBuilderAdapter&&) = delete;
 
   virtual void OnDocumentStart(const Mark& mark) { (void)mark; }
   virtual void OnDocumentEnd() {}
@@ -57,8 +50,8 @@ class GraphBuilderAdapter : public EventHandler {
   struct ContainerFrame {
     ContainerFrame(void* pSequence)
         : pContainer(pSequence), pPrevKeyNode(&sequenceMarker) {}
-    ContainerFrame(void* pMap, void* pPreviousKeyNode)
+    ContainerFrame(void* pMap, void* pPrevKeyNode_)
-        : pContainer(pMap), pPrevKeyNode(pPreviousKeyNode) {}
+        : pContainer(pMap), pPrevKeyNode(pPrevKeyNode_) {}
 
     void* pContainer;
     void* pPrevKeyNode;
@@ -81,6 +74,6 @@ class GraphBuilderAdapter : public EventHandler {
   void RegisterAnchor(anchor_t anchor, void* pNode);
   void DispositionNode(void* pNode);
 };
-}  // namespace YAML
+}
 
 #endif  // GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/src/contrib/yaml-cpp.natvis

@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?> 
-<!-- MSVC Debugger visualization hints for YAML::Node and YAML::detail::node -->
-<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
-  <Type Name="YAML::Node">
-    <DisplayString Condition="!m_isValid">{{invalid}}</DisplayString>
-    <DisplayString Condition="!m_pNode">{{pNode==nullptr}}</DisplayString>
-    <DisplayString>{{ {*m_pNode} }}</DisplayString>
-    <Expand>
-      <Item Condition="m_pNode->m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Scalar" Name="scalar">m_pNode->m_pRef._Ptr->m_pData._Ptr->m_scalar</Item>
-      <Item Condition="m_pNode->m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Sequence" Name="sequence">m_pNode->m_pRef._Ptr->m_pData._Ptr->m_sequence</Item>
-      <Item Condition="m_pNode->m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Map" Name="map">m_pNode->m_pRef._Ptr->m_pData._Ptr->m_map</Item>
-      <Item Name="[details]" >m_pNode->m_pRef._Ptr->m_pData._Ptr</Item>
-    </Expand>
-  </Type>
-
-  <Type Name="YAML::detail::node">
-    <DisplayString Condition="!m_pRef._Ptr">{{node:pRef==nullptr}}</DisplayString>
-    <DisplayString Condition="!m_pRef._Ptr->m_pData._Ptr">{{node:pRef->pData==nullptr}}</DisplayString>
-    <DisplayString Condition="!m_pRef._Ptr->m_pData._Ptr->m_isDefined">{{undefined}}</DisplayString>
-    <DisplayString Condition="m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Scalar">{{{m_pRef._Ptr->m_pData._Ptr->m_scalar}}}</DisplayString>
-    <DisplayString Condition="m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Map">{{ Map {m_pRef._Ptr->m_pData._Ptr->m_map}}}</DisplayString>
-    <DisplayString Condition="m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Sequence">{{ Seq {m_pRef._Ptr->m_pData._Ptr->m_sequence}}}</DisplayString>
-    <DisplayString>{{{m_pRef._Ptr->m_pData._Ptr->m_type}}}</DisplayString>
-    <Expand>
-      <Item Condition="m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Scalar" Name="scalar">m_pRef._Ptr->m_pData._Ptr->m_scalar</Item>
-      <Item Condition="m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Sequence" Name="sequence">m_pRef._Ptr->m_pData._Ptr->m_sequence</Item>
-      <Item Condition="m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Map" Name="map">m_pRef._Ptr->m_pData._Ptr->m_map</Item>
-      <Item Name="[details]" >m_pRef._Ptr->m_pData._Ptr</Item>
-    </Expand>
-  </Type>
-
-</AutoVisualizer>

3rdparty/yaml-cpp/src/contrib/yaml-cpp.natvis.md

@@ -1,9 +0,0 @@
-# MSVC debugger visualizer for YAML::Node
-
-## How to use
-Add yaml-cpp.natvis to your Visual C++ project like any other source file.  It will be included in the debug information, and improve debugger display on YAML::Node and contained types. 
-
-## Compatibility and Troubleshooting
-
-This has been tested for MSVC 2017. It is expected to be compatible with VS 2015 and VS 2019. If you have any problems, you can open an issue here: https://github.com/peterchen-cp/yaml-cpp-natvis
-

3rdparty/yaml-cpp/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 (std::size_t i = 0; i < str.size(); i++)
+    if (!func(str[i]))
+      return false;
+
+  return true;
 }
 
 // IsFlexibleCase
@@ -35,7 +39,7 @@ bool IsFlexibleCase(const std::string& str) {
   std::string rest = str.substr(1);
   return firstcaps && (IsEntirely(rest, IsLower) || IsEntirely(rest, IsUpper));
 }
-}  // namespace
+}
 
 namespace YAML {
 bool convert<bool>::decode(const Node& node, bool& rhs) {
@@ -48,22 +52,19 @@ bool convert<bool>::decode(const Node& node, bool& rhs) {
   static const struct {
     std::string truename, falsename;
   } names[] = {
-      {"y", "n"},
+      {"y", "n"}, {"yes", "no"}, {"true", "false"}, {"on", "off"},
-      {"yes", "no"},
-      {"true", "false"},
-      {"on", "off"},
   };
 
   if (!IsFlexibleCase(node.Scalar()))
     return false;
 
-  for (const auto& name : names) {
+  for (unsigned i = 0; i < sizeof(names) / sizeof(names[0]); i++) {
-    if (name.truename == tolower(node.Scalar())) {
+    if (names[i].truename == tolower(node.Scalar())) {
       rhs = true;
       return true;
     }
 
-    if (name.falsename == tolower(node.Scalar())) {
+    if (names[i].falsename == tolower(node.Scalar())) {
       rhs = false;
       return true;
     }
@@ -71,4 +72,4 @@ bool convert<bool>::decode(const Node& node, bool& rhs) {
 
   return false;
 }
-}  // namespace YAML
+}

3rdparty/yaml-cpp/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

3rdparty/yaml-cpp/src/directives.cpp

@@ -1,11 +1,16 @@
 #include "directives.h"
 
 namespace YAML {
-Directives::Directives() : version{true, 1, 2}, tags{} {}
+Directives::Directives() {
+  // version
+  version.isDefault = true;
+  version.major = 1;
+  version.minor = 2;
+}
 
-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:";
@@ -14,4 +19,4 @@ std::string Directives::TranslateTagHandle(
 
   return it->second;
 }
-}  // namespace YAML
+}

3rdparty/yaml-cpp/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;

3rdparty/yaml-cpp/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) {

3rdparty/yaml-cpp/src/emitfromevents.cpp

@@ -16,11 +16,10 @@ std::string ToString(YAML::anchor_t anchor) {
   stream << anchor;
   return stream.str();
 }
-}  // namespace
+}
 
 namespace YAML {
-EmitFromEvents::EmitFromEvents(Emitter& emitter)
+EmitFromEvents::EmitFromEvents(Emitter& emitter) : m_emitter(emitter) {}
-    : m_emitter(emitter), m_stateStack{} {}
 
 void EmitFromEvents::OnDocumentStart(const Mark&) {}
 
@@ -59,8 +58,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 +82,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);
 }
@@ -121,4 +116,4 @@ void EmitFromEvents::EmitProps(const std::string& tag, anchor_t anchor) {
   if (anchor)
     m_emitter << Anchor(ToString(anchor));
 }
-}  // namespace YAML
+}

3rdparty/yaml-cpp/src/emitter.cpp

@@ -11,12 +11,12 @@ namespace YAML {
 class Binary;
 struct _Null;
 
-Emitter::Emitter() : m_pState(new EmitterState), m_stream{} {}
+Emitter::Emitter() : m_pState(new EmitterState) {}
 
 Emitter::Emitter(std::ostream& stream)
     : m_pState(new EmitterState), m_stream(stream) {}
 
-Emitter::~Emitter() = default;
+Emitter::~Emitter() {}
 
 const char* Emitter::c_str() const { return m_stream.str(); }
 
@@ -90,10 +90,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 +201,6 @@ void Emitter::EmitBeginSeq() {
 void Emitter::EmitEndSeq() {
   if (!good())
     return;
-  FlowType::value originalType = m_pState->CurGroupFlowType();
 
   if (m_pState->CurGroupChildCount() == 0)
     m_pState->ForceFlow();
@@ -214,12 +209,8 @@ void Emitter::EmitEndSeq() {
     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 << "]";
   }
 
@@ -240,7 +231,6 @@ void Emitter::EmitBeginMap() {
 void Emitter::EmitEndMap() {
   if (!good())
     return;
-  FlowType::value originalType = m_pState->CurGroupFlowType();
 
   if (m_pState->CurGroupChildCount() == 0)
     m_pState->ForceFlow();
@@ -249,12 +239,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 << "}";
   }
 
@@ -303,8 +289,10 @@ void Emitter::PrepareTopNode(EmitterNodeType::value child) {
   if (child == EmitterNodeType::NoType)
     return;
 
-  if (m_pState->CurGroupChildCount() > 0 && m_stream.col() > 0)
+  if (m_pState->CurGroupChildCount() > 0 && m_stream.col() > 0) {
+    if (child != EmitterNodeType::NoType)
       EmitBeginDoc();
+  }
 
   switch (child) {
     case EmitterNodeType::NoType:
@@ -504,9 +492,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 << ":";
   }
 
@@ -533,8 +518,7 @@ void Emitter::BlockMapPrepareNode(EmitterNodeType::value child) {
     if (m_pState->GetMapKeyFormat() == LongKey)
       m_pState->SetLongKey();
     if (child == EmitterNodeType::BlockSeq ||
-        child == EmitterNodeType::BlockMap ||
+        child == EmitterNodeType::BlockMap)
-        child == EmitterNodeType::Property)
       m_pState->SetLongKey();
 
     if (m_pState->CurGroupLongKey())
@@ -578,8 +562,6 @@ void Emitter::BlockMapPrepareLongKey(EmitterNodeType::value child) {
       break;
     case EmitterNodeType::BlockSeq:
     case EmitterNodeType::BlockMap:
-      if (m_pState->HasBegunContent())
-        m_stream << "\n";
       break;
   }
 }
@@ -603,12 +585,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;
   }
@@ -647,9 +625,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 << ":";
   }
 
@@ -703,29 +678,25 @@ 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());
+  StringEscaping::value stringEscaping = StringEscaping::None;
+  switch (m_pState->GetOutputCharset()) {
+    case EscapeNonAscii:
+      stringEscaping = StringEscaping::NonAscii;
+      break;
+    case EscapeAsJson:
+      stringEscaping = StringEscaping::JSON;
+      break;
+  }
 
   const StringFormat::value strFormat =
       Utils::ComputeStringFormat(str, m_pState->GetStringFormat(),
                                  m_pState->CurGroupFlowType(), stringEscaping == StringEscaping::NonAscii);
 
-  if (strFormat == StringFormat::Literal || str.size() > 1024)
+  if (strFormat == StringFormat::Literal)
     m_pState->SetMapKeyFormat(YAML::LongKey, FmtScope::Local);
 
   PrepareNode(EmitterNodeType::Scalar);
@@ -808,21 +779,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;
@@ -847,7 +803,7 @@ Emitter& Emitter::Write(char ch) {
   
 
   PrepareNode(EmitterNodeType::Scalar);
-  Utils::WriteChar(m_stream, ch, GetStringEscapingStyle(m_pState->GetOutputCharset()));
+  Utils::WriteChar(m_stream, ch, m_pState->GetOutputCharset() == EscapeAsJson);
   StartedScalar();
 
   return *this;
@@ -871,8 +827,6 @@ Emitter& Emitter::Write(const _Alias& alias) {
 
   StartedScalar();
 
-  m_pState->SetAlias();
-
   return *this;
 }
 
@@ -950,7 +904,10 @@ Emitter& Emitter::Write(const _Null& /*null*/) {
 
   PrepareNode(EmitterNodeType::Scalar);
 
-  m_stream << ComputeNullName();
+  if (m_pState->GetNullFormat() == NullAsNull)
+    m_stream << "null";
+  else
+    m_stream << "~";
 
   StartedScalar();
 
@@ -969,4 +926,4 @@ Emitter& Emitter::Write(const Binary& binary) {
 
   return *this;
 }
-}  // namespace YAML
+}

3rdparty/yaml-cpp/src/emitterstate.cpp

@@ -6,35 +6,30 @@
 namespace YAML {
 EmitterState::EmitterState()
     : m_isGood(true),
-      m_lastError{},
-      // default global manipulators
-      m_charset(EmitNonAscii),
-      m_strFmt(Auto),
-      m_boolFmt(TrueFalseBool),
-      m_boolLengthFmt(LongBool),
-      m_boolCaseFmt(LowerCase),
-      m_nullFmt(TildeNull),
-      m_intFmt(Dec),
-      m_indent(2),
-      m_preCommentIndent(2),
-      m_postCommentIndent(1),
-      m_seqFmt(Block),
-      m_mapFmt(Block),
-      m_mapKeyFmt(Auto),
-      m_floatPrecision(std::numeric_limits<float>::max_digits10),
-      m_doublePrecision(std::numeric_limits<double>::max_digits10),
-      //
-      m_modifiedSettings{},
-      m_globalModifiedSettings{},
-      m_groups{},
       m_curIndent(0),
       m_hasAnchor(false),
-      m_hasAlias(false),
       m_hasTag(false),
       m_hasNonContent(false),
-      m_docCount(0) {}
+      m_docCount(0) {
+  // set default global manipulators
+  m_charset.set(EmitNonAscii);
+  m_strFmt.set(Auto);
+  m_boolFmt.set(TrueFalseBool);
+  m_nullFmt.set(NullAsTilde);
+  m_boolLengthFmt.set(LongBool);
+  m_boolCaseFmt.set(LowerCase);
+  m_intFmt.set(Dec);
+  m_indent.set(2);
+  m_preCommentIndent.set(2);
+  m_postCommentIndent.set(1);
+  m_seqFmt.set(Block);
+  m_mapFmt.set(Block);
+  m_mapKeyFmt.set(Auto);
+  m_floatPrecision.set(std::numeric_limits<float>::digits10 + 1);
+  m_doublePrecision.set(std::numeric_limits<double>::digits10 + 1);
+}
 
-EmitterState::~EmitterState() = default;
+EmitterState::~EmitterState() {}
 
 // SetLocalValue
 // . We blindly tries to set all possible formatters to this value
@@ -54,8 +49,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 +83,6 @@ void EmitterState::StartedNode() {
   }
 
   m_hasAnchor = false;
-  m_hasAlias = false;
   m_hasTag = false;
   m_hasNonContent = false;
 }
@@ -100,12 +92,14 @@ EmitterNodeType::value EmitterState::NextGroupType(
   if (type == GroupType::Seq) {
     if (GetFlowType(type) == Block)
       return EmitterNodeType::BlockSeq;
+    else
       return EmitterNodeType::FlowSeq;
-  }
+  } else {
-
     if (GetFlowType(type) == Block)
       return EmitterNodeType::BlockMap;
+    else
       return EmitterNodeType::FlowMap;
+  }
 
   // can't happen
   assert(false);
@@ -160,15 +154,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);
     }
-
-  if (m_hasTag) {
-    SetError(ErrorMsg::INVALID_TAG);
-  }
-  if (m_hasAnchor) {
-    SetError(ErrorMsg::INVALID_ANCHOR);
   }
 
   // get rid of the current group
@@ -190,9 +178,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,10 +218,6 @@ 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) {
@@ -302,10 +283,8 @@ bool EmitterState::SetBoolCaseFormat(EMITTER_MANIP value,
 
 bool EmitterState::SetNullFormat(EMITTER_MANIP value, FmtScope::value scope) {
   switch (value) {
-    case LowerNull:
+  case NullAsTilde:
-    case UpperNull:
+  case NullAsNull:
-    case CamelNull:
-    case TildeNull:
     _Set(m_nullFmt, value, scope);
     return true;
   default:
@@ -384,7 +363,7 @@ bool EmitterState::SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope) {
 }
 
 bool EmitterState::SetFloatPrecision(std::size_t value, FmtScope::value scope) {
-  if (value > std::numeric_limits<float>::max_digits10)
+  if (value > std::numeric_limits<float>::digits10 + 1)
     return false;
   _Set(m_floatPrecision, value, scope);
   return true;
@@ -392,9 +371,9 @@ bool EmitterState::SetFloatPrecision(std::size_t value, FmtScope::value scope) {
 
 bool EmitterState::SetDoublePrecision(std::size_t value,
                                       FmtScope::value scope) {
-  if (value > std::numeric_limits<double>::max_digits10)
+  if (value > std::numeric_limits<double>::digits10 + 1)
     return false;
   _Set(m_doublePrecision, value, scope);
   return true;
 }
-}  // namespace YAML
+}

3rdparty/yaml-cpp/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);
@@ -135,9 +132,9 @@ class EmitterState {
   Setting<EMITTER_MANIP> m_charset;
   Setting<EMITTER_MANIP> m_strFmt;
   Setting<EMITTER_MANIP> m_boolFmt;
+  Setting<EMITTER_MANIP> m_nullFmt;
   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;
@@ -152,12 +149,7 @@ class EmitterState {
 
   struct Group {
     explicit Group(GroupType::value type_)
-        : type(type_),
+        : type(type_), indent(0), childCount(0), longKey(false) {}
-          flowType{},
-          indent(0),
-          childCount(0),
-          longKey(false),
-          modifiedSettings{} {}
 
     GroupType::value type;
     FlowType::value flowType;
@@ -189,7 +181,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;
@@ -211,6 +202,6 @@ void EmitterState::_Set(Setting<T>& fmt, T value, FmtScope::value scope) {
       assert(false);
   }
 }
-}  // namespace YAML
+}
 
 #endif  // EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/src/emitterutils.cpp

@@ -1,4 +1,3 @@
-#include <algorithm>
 #include <iomanip>
 #include <sstream>
 
@@ -9,8 +8,8 @@
 #include "regeximpl.h"
 #include "stringsource.h"
 #include "yaml-cpp/binary.h"  // IWYU pragma: keep
-#include "yaml-cpp/null.h"
 #include "yaml-cpp/ostream_wrapper.h"
+#include "yaml-cpp/null.h"
 
 namespace YAML {
 namespace Utils {
@@ -135,12 +134,12 @@ void WriteCodePoint(ostream_wrapper& out, int codePoint) {
   if (codePoint < 0 || codePoint > 0x10FFFF) {
     codePoint = REPLACEMENT_CHARACTER;
   }
-  if (codePoint <= 0x7F) {
+  if (codePoint < 0x7F) {
     out << static_cast<char>(codePoint);
-  } else if (codePoint <= 0x7FF) {
+  } else if (codePoint < 0x7FF) {
     out << static_cast<char>(0xC0 | (codePoint >> 6))
         << static_cast<char>(0x80 | (codePoint & 0x3F));
-  } else if (codePoint <= 0xFFFF) {
+  } else if (codePoint < 0xFFFF) {
     out << static_cast<char>(0xE0 | (codePoint >> 12))
         << static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F))
         << static_cast<char>(0x80 | (codePoint & 0x3F));
@@ -174,13 +173,13 @@ bool IsValidPlainScalar(const std::string& str, FlowType::value flowType,
 
   // then check until something is disallowed
   static const RegEx& disallowed_flow =
-      Exp::EndScalarInFlow() | (Exp::BlankOrBreak() + Exp::Comment()) |
+      Exp::EndScalarInFlow() || (Exp::BlankOrBreak() + Exp::Comment()) ||
-      Exp::NotPrintable() | Exp::Utf8_ByteOrderMark() | Exp::Break() |
+      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::EndScalar() || (Exp::BlankOrBreak() + Exp::Comment()) ||
-      Exp::NotPrintable() | Exp::Utf8_ByteOrderMark() | Exp::Break() |
+      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) {
+  for (std::size_t i = 0; i < str.size(); i++) {
-    return (escapeNonAscii && (0x80 <= static_cast<unsigned char>(ch))) ||
+    if (escapeNonAscii && (0x80 <= static_cast<unsigned char>(str[i]))) {
-           (ch == '\n');
+      return false;
-  });
+    }
+    if (str[i] == '\n') {
+      return false;
+    }
+  }
+  return true;
 }
 
 bool IsValidLiteralScalar(const std::string& str, FlowType::value flowType,
@@ -213,9 +217,12 @@ 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) {
+  for (std::size_t i = 0; i < str.size(); i++) {
-    return (escapeNonAscii && (0x80 <= static_cast<unsigned char>(ch)));
+    if (escapeNonAscii && (0x80 <= static_cast<unsigned char>(str[i]))) {
-  });
+      return false;
+    }
+  }
+  return true;
 }
 
 std::pair<uint16_t, uint16_t> EncodeUTF16SurrogatePair(int codePoint) {
@@ -227,24 +234,24 @@ std::pair<uint16_t, uint16_t> EncodeUTF16SurrogatePair(int codePoint) {
   };
 }
 
-void WriteDoubleQuoteEscapeSequence(ostream_wrapper& out, int codePoint, StringEscaping::value stringEscapingStyle) {
+void WriteDoubleQuoteEscapeSequence(ostream_wrapper& out, int codePoint, bool escapeAsJson) {
   static const char hexDigits[] = "0123456789abcdef";
 
   out << "\\";
   int digits = 8;
-  if (codePoint < 0xFF && stringEscapingStyle != StringEscaping::JSON) {
+  if (codePoint < 0xFF && !escapeAsJson) {
     out << "x";
     digits = 2;
   } else if (codePoint < 0xFFFF) {
     out << "u";
     digits = 4;
-  } else if (stringEscapingStyle != StringEscaping::JSON) {
+  } else if (!escapeAsJson) {
     out << "U";
     digits = 8;
   } else {
     auto surrogatePair = EncodeUTF16SurrogatePair(codePoint);
-    WriteDoubleQuoteEscapeSequence(out, surrogatePair.first, stringEscapingStyle);
+    WriteDoubleQuoteEscapeSequence(out, surrogatePair.first, true);
-    WriteDoubleQuoteEscapeSequence(out, surrogatePair.second, stringEscapingStyle);
+    WriteDoubleQuoteEscapeSequence(out, surrogatePair.second, true);
     return;
   }
 
@@ -265,7 +272,7 @@ bool WriteAliasName(ostream_wrapper& out, const std::string& str) {
   }
   return true;
 }
-}  // namespace
+}
 
 StringFormat::value ComputeStringFormat(const std::string& str,
                                         EMITTER_MANIP strFormat,
@@ -348,12 +355,12 @@ bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
         if (codePoint < 0x20 ||
             (codePoint >= 0x80 &&
              codePoint <= 0xA0)) {  // Control characters and non-breaking space
-          WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping);
+          WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping == StringEscaping::JSON);
         } else if (codePoint == 0xFEFF) {  // Byte order marks (ZWNS) should be
                                            // escaped (YAML 1.2, sec. 5.2)
-          WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping);
+          WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping == StringEscaping::JSON);
         } else if (stringEscaping == StringEscaping::NonAscii && codePoint > 0x7E) {
-          WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping);
+          WriteDoubleQuoteEscapeSequence(out, codePoint, false);
         } else {
           WriteCodePoint(out, codePoint);
         }
@@ -366,41 +373,41 @@ 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, bool escapeAsJson) {
   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")";
+    out << "\"\\b\"";
   } else if (ch == '\r') {
-    out << R"("\r")";
+    out << "\"\\r\"";
   } else if (ch == '\f') {
-    out << R"("\f")";
+    out << "\"\\f\"";
   } else if (ch == '\\') {
-    out << R"("\\")";
+    out << "\"\\\\\"";
-  } else if (0x20 <= ch && ch <= 0x7e) {
+  } else if ((0x20 <= ch && ch <= 0x7e) || ch == ' ') {
     out << "\"" << ch << "\"";
   } else {
     out << "\"";
-    WriteDoubleQuoteEscapeSequence(out, ch, stringEscapingStyle);
+    WriteDoubleQuoteEscapeSequence(out, ch, escapeAsJson);
     out << "\"";
   }
   return true;
@@ -415,8 +422,8 @@ bool WriteComment(ostream_wrapper& out, const std::string& str,
   for (std::string::const_iterator i = str.begin();
        GetNextCodePointAndAdvance(codePoint, i, str.end());) {
     if (codePoint == '\n') {
-      out << "\n"
+      out << "\n" << IndentTo(curIndent) << "#"
-          << IndentTo(curIndent) << "#" << Indentation(postCommentIndent);
+          << Indentation(postCommentIndent);
       out.set_comment();
     } else {
       WriteCodePoint(out, codePoint);
@@ -493,5 +500,5 @@ bool WriteBinary(ostream_wrapper& out, const Binary& binary) {
                           StringEscaping::None);
   return true;
 }
-}  // namespace Utils
+}
-}  // namespace YAML
+}

3rdparty/yaml-cpp/src/emitterutils.h

@@ -39,8 +39,7 @@ bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
                              StringEscaping::value stringEscaping);
 bool WriteLiteralString(ostream_wrapper& out, const std::string& str,
                         std::size_t indent);
-bool WriteChar(ostream_wrapper& out, char ch,
+bool WriteChar(ostream_wrapper& out, char ch, bool escapeAsJson);
-               StringEscaping::value stringEscapingStyle);
 bool WriteComment(ostream_wrapper& out, const std::string& str,
                   std::size_t postCommentIndent);
 bool WriteAlias(ostream_wrapper& out, const std::string& str);

3rdparty/yaml-cpp/src/exceptions.cpp

@@ -1,20 +1,19 @@
 #include "yaml-cpp/exceptions.h"
-#include "yaml-cpp/noexcept.h"
 
 namespace YAML {
 
 // These destructors are defined out-of-line so the vtable is only emitted once.
-Exception::~Exception() YAML_CPP_NOEXCEPT = default;
+Exception::~Exception() NOEXCEPT {}
-ParserException::~ParserException() YAML_CPP_NOEXCEPT = default;
+ParserException::~ParserException() NOEXCEPT {}
-RepresentationException::~RepresentationException() YAML_CPP_NOEXCEPT = default;
+RepresentationException::~RepresentationException() NOEXCEPT {}
-InvalidScalar::~InvalidScalar() YAML_CPP_NOEXCEPT = default;
+InvalidScalar::~InvalidScalar() NOEXCEPT {}
-KeyNotFound::~KeyNotFound() YAML_CPP_NOEXCEPT = default;
+KeyNotFound::~KeyNotFound() NOEXCEPT {}
-InvalidNode::~InvalidNode() YAML_CPP_NOEXCEPT = default;
+InvalidNode::~InvalidNode() NOEXCEPT {}
-BadConversion::~BadConversion() YAML_CPP_NOEXCEPT = default;
+BadConversion::~BadConversion() NOEXCEPT {}
-BadDereference::~BadDereference() YAML_CPP_NOEXCEPT = default;
+BadDereference::~BadDereference() NOEXCEPT {}
-BadSubscript::~BadSubscript() YAML_CPP_NOEXCEPT = default;
+BadSubscript::~BadSubscript() NOEXCEPT {}
-BadPushback::~BadPushback() YAML_CPP_NOEXCEPT = default;
+BadPushback::~BadPushback() NOEXCEPT {}
-BadInsert::~BadInsert() YAML_CPP_NOEXCEPT = default;
+BadInsert::~BadInsert() NOEXCEPT {}
-EmitterException::~EmitterException() YAML_CPP_NOEXCEPT = default;
+EmitterException::~EmitterException() NOEXCEPT {}
-BadFile::~BadFile() YAML_CPP_NOEXCEPT = default;
+BadFile::~BadFile() NOEXCEPT {}
-}  // namespace YAML
+}

3rdparty/yaml-cpp/src/exp.cpp

@@ -12,7 +12,8 @@ namespace YAML {
 namespace Exp {
 unsigned ParseHex(const std::string& str, const Mark& mark) {
   unsigned value = 0;
-  for (char ch : str) {
+  for (std::size_t i = 0; i < str.size(); i++) {
+    char ch = str[i];
     int digit = 0;
     if ('a' <= ch && ch <= 'f')
       digit = ch - 'a' + 10;
@@ -54,14 +55,12 @@ std::string Escape(Stream& in, int codeLength) {
   // now break it up into chars
   if (value <= 0x7F)
     return Str(value);
-
+  else if (value <= 0x7FF)
-  if (value <= 0x7FF)
     return Str(0xC0 + (value >> 6)) + Str(0x80 + (value & 0x3F));
-
+  else if (value <= 0xFFFF)
-  if (value <= 0xFFFF)
     return Str(0xE0 + (value >> 12)) + 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));
 }
@@ -105,7 +104,7 @@ std::string Escape(Stream& in) {
     case 'e':
       return "\x1B";
     case ' ':
-      return R"( )";
+      return "\x20";
     case '\"':
       return "\"";
     case '\'':
@@ -133,5 +132,5 @@ std::string Escape(Stream& in) {
   std::stringstream msg;
   throw ParserException(in.mark(), std::string(ErrorMsg::INVALID_ESCAPE) + ch);
 }
-}  // namespace Exp
+}
-}  // namespace YAML
+}

3rdparty/yaml-cpp/src/exp.h

@@ -33,15 +33,15 @@ inline const RegEx& Tab() {
   return e;
 }
 inline const RegEx& Blank() {
-  static const RegEx e = Space() | Tab();
+  static const RegEx e = Space() || Tab();
   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() {
-  static const RegEx e = Blank() | Break();
+  static const RegEx e = Blank() || Break();
   return e;
 }
 inline const RegEx& Digit() {
@@ -49,29 +49,29 @@ inline const RegEx& Digit() {
   return e;
 }
 inline const RegEx& Alpha() {
-  static const RegEx e = RegEx('a', 'z') | RegEx('A', 'Z');
+  static const RegEx e = RegEx('a', 'z') || RegEx('A', 'Z');
   return e;
 }
 inline const RegEx& AlphaNumeric() {
-  static const RegEx e = Alpha() | Digit();
+  static const RegEx e = Alpha() || Digit();
   return e;
 }
 inline const RegEx& Word() {
-  static const RegEx e = AlphaNumeric() | RegEx('-');
+  static const RegEx e = AlphaNumeric() || RegEx('-');
   return e;
 }
 inline const RegEx& Hex() {
-  static const RegEx e = Digit() | RegEx('A', 'F') | RegEx('a', 'f');
+  static const RegEx e = Digit() || RegEx('A', 'F') || RegEx('a', 'f');
   return e;
 }
 // Valid Unicode code points that are not part of c-printable (YAML 1.2, sec.
 // 5.1)
 inline const RegEx& NotPrintable() {
   static const RegEx e =
-      RegEx(0) |
+      RegEx(0) ||
-      RegEx("\x01\x02\x03\x04\x05\x06\x07\x08\x0B\x0C\x7F", REGEX_OR) |
+      RegEx("\x01\x02\x03\x04\x05\x06\x07\x08\x0B\x0C\x7F", REGEX_OR) ||
-      RegEx(0x0E, 0x1F) |
+      RegEx(0x0E, 0x1F) ||
-      (RegEx('\xC2') + (RegEx('\x80', '\x84') | RegEx('\x86', '\x9F')));
+      (RegEx('\xC2') + (RegEx('\x80', '\x84') || RegEx('\x86', '\x9F')));
   return e;
 }
 inline const RegEx& Utf8_ByteOrderMark() {
@@ -82,19 +82,19 @@ inline const RegEx& Utf8_ByteOrderMark() {
 // actual tags
 
 inline const RegEx& DocStart() {
-  static const RegEx e = RegEx("---") + (BlankOrBreak() | RegEx());
+  static const RegEx e = RegEx("---") + (BlankOrBreak() || RegEx());
   return e;
 }
 inline const RegEx& DocEnd() {
-  static const RegEx e = RegEx("...") + (BlankOrBreak() | RegEx());
+  static const RegEx e = RegEx("...") + (BlankOrBreak() || RegEx());
   return e;
 }
 inline const RegEx& DocIndicator() {
-  static const RegEx e = DocStart() | DocEnd();
+  static const RegEx e = DocStart() || DocEnd();
   return e;
 }
 inline const RegEx& BlockEntry() {
-  static const RegEx e = RegEx('-') + (BlankOrBreak() | RegEx());
+  static const RegEx e = RegEx('-') + (BlankOrBreak() || RegEx());
   return e;
 }
 inline const RegEx& Key() {
@@ -106,40 +106,36 @@ inline const RegEx& KeyInFlow() {
   return e;
 }
 inline const RegEx& Value() {
-  static const RegEx e = RegEx(':') + (BlankOrBreak() | RegEx());
+  static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx());
   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;
 }
 inline const RegEx& Anchor() {
-  static const RegEx e = !(RegEx("[]{},", REGEX_OR) | BlankOrBreak());
+  static const RegEx e = !(RegEx("[]{},", REGEX_OR) || BlankOrBreak());
   return e;
 }
 inline const RegEx& AnchorEnd() {
-  static const RegEx e = RegEx("?:,]}%@`", REGEX_OR) | BlankOrBreak();
+  static const RegEx e = RegEx("?:,]}%@`", REGEX_OR) || BlankOrBreak();
   return e;
 }
 inline const RegEx& URI() {
-  static const RegEx e = Word() | RegEx("#;/?:@&=+$,_.!~*'()[]", REGEX_OR) |
+  static const RegEx e = Word() || RegEx("#;/?:@&=+$,_.!~*'()[]", REGEX_OR) ||
                          (RegEx('%') + Hex() + Hex());
   return e;
 }
 inline const RegEx& Tag() {
-  static const RegEx e = Word() | RegEx("#;/?:@&=+$_.~*'()", REGEX_OR) |
+  static const RegEx e = Word() || RegEx("#;/?:@&=+$_.~*'", REGEX_OR) ||
                          (RegEx('%') + Hex() + Hex());
   return e;
 }
@@ -152,34 +148,34 @@ inline const RegEx& Tag() {
 // space.
 inline const RegEx& PlainScalar() {
   static const RegEx e =
-      !(BlankOrBreak() | RegEx(",[]{}#&*!|>\'\"%@`", REGEX_OR) |
+      !(BlankOrBreak() || RegEx(",[]{}#&*!|>\'\"%@`", REGEX_OR) ||
-        (RegEx("-?:", REGEX_OR) + (BlankOrBreak() | RegEx())));
+        (RegEx("-?:", REGEX_OR) + (BlankOrBreak() || RegEx())));
   return e;
 }
 inline const RegEx& PlainScalarInFlow() {
   static const RegEx e =
-      !(BlankOrBreak() | RegEx("?,[]{}#&*!|>\'\"%@`", REGEX_OR) |
+      !(BlankOrBreak() || RegEx("?,[]{}#&*!|>\'\"%@`", REGEX_OR) ||
-        (RegEx("-:", REGEX_OR) + (Blank() | RegEx())));
+        (RegEx("-:", REGEX_OR) + Blank()));
   return e;
 }
 inline const RegEx& EndScalar() {
-  static const RegEx e = RegEx(':') + (BlankOrBreak() | RegEx());
+  static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx());
   return e;
 }
 inline const RegEx& EndScalarInFlow() {
   static const RegEx e =
-      (RegEx(':') + (BlankOrBreak() | RegEx() | RegEx(",]}", REGEX_OR))) |
+      (RegEx(':') + (BlankOrBreak() || RegEx() || RegEx(",]}", REGEX_OR))) ||
       RegEx(",?[]{}", REGEX_OR);
   return e;
 }
 
 inline const RegEx& ScanScalarEndInFlow() {
-  static const RegEx e = (EndScalarInFlow() | (BlankOrBreak() + Comment()));
+  static const RegEx e = (EndScalarInFlow() || (BlankOrBreak() + Comment()));
   return e;
 }
 
 inline const RegEx& ScanScalarEnd() {
-  static const RegEx e = EndScalar() | (BlankOrBreak() + Comment());
+  static const RegEx e = EndScalar() || (BlankOrBreak() + Comment());
   return e;
 }
 inline const RegEx& EscSingleQuote() {
@@ -196,15 +192,15 @@ inline const RegEx& ChompIndicator() {
   return e;
 }
 inline const RegEx& Chomp() {
-  static const RegEx e = (ChompIndicator() + Digit()) |
+  static const RegEx e = (ChompIndicator() + Digit()) ||
-                         (Digit() + ChompIndicator()) | ChompIndicator() |
+                         (Digit() + ChompIndicator()) || ChompIndicator() ||
                          Digit();
   return e;
 }
 
 // and some functions
 std::string Escape(Stream& in);
-}  // namespace Exp
+}
 
 namespace Keys {
 const char Directive = '%';
@@ -220,7 +216,7 @@ const char LiteralScalar = '|';
 const char FoldedScalar = '>';
 const char VerbatimTagStart = '<';
 const char VerbatimTagEnd = '>';
-}  // namespace Keys
+}
-}  // namespace YAML
+}
 
 #endif  // EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/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
+}

3rdparty/yaml-cpp/src/node.cpp

@@ -9,4 +9,4 @@ Node Clone(const Node& node) {
   events.Emit(builder);
   return builder.Root();
 }
-}  // namespace YAML
+}

3rdparty/yaml-cpp/src/node_data.cpp

@@ -1,5 +1,4 @@
-#include <algorithm>
+#include <assert.h>
-#include <cassert>
 #include <iterator>
 #include <sstream>
 
@@ -13,24 +12,15 @@
 
 namespace YAML {
 namespace detail {
-YAML_CPP_API std::atomic<size_t> node::m_amount{0};
 
-const std::string& node_data::empty_scalar() {
+std::string node_data::empty_scalar;
-  static const std::string svalue;
-  return svalue;
-}
 
 node_data::node_data()
     : m_isDefined(false),
       m_mark(Mark::null_mark()),
       m_type(NodeType::Null),
-      m_tag{},
       m_style(EmitterStyle::Default),
-      m_scalar{},
+      m_seqSize(0) {}
-      m_sequence{},
-      m_seqSize(0),
-      m_map{},
-      m_undefinedPairs{} {}
 
 void node_data::mark_defined() {
   if (m_type == NodeType::Undefined)
@@ -110,9 +100,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 +111,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 +119,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 +133,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 +147,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 +161,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,
+void node_data::push_back(node& node, shared_memory_holder /* pMemory */) {
-                          const shared_memory_holder& /* pMemory */) {
   if (m_type == NodeType::Undefined || m_type == NodeType::Null) {
     m_type = NodeType::Sequence;
     reset_sequence();
@@ -189,8 +178,7 @@ void node_data::push_back(node& node,
   m_sequence.push_back(&node);
 }
 
-void node_data::insert(node& key, node& value,
+void node_data::insert(node& key, node& value, shared_memory_holder pMemory) {
-                       const shared_memory_holder& pMemory) {
   switch (m_type) {
     case NodeType::Map:
       break;
@@ -200,28 +188,27 @@ void node_data::insert(node& key, node& value,
       convert_to_map(pMemory);
       break;
     case NodeType::Scalar:
-      throw BadSubscript(m_mark, key);
+      throw BadSubscript();
   }
 
   insert_map_pair(key, value);
 }
 
 // indexing
-node* node_data::get(node& key,
+node* node_data::get(node& key, shared_memory_holder /* pMemory */) const {
-                     const shared_memory_holder& /* pMemory */) const {
   if (m_type != NodeType::Map) {
-    return nullptr;
+    return NULL;
   }
 
-  for (const auto& it : m_map) {
+  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
-    if (it.first->is(key))
+    if (it->first->is(key))
-      return it.second;
+      return it->second;
   }
 
-  return nullptr;
+  return NULL;
 }
 
-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;
@@ -231,12 +218,12 @@ node& node_data::get(node& key, const shared_memory_holder& pMemory) {
       convert_to_map(pMemory);
       break;
     case NodeType::Scalar:
-      throw BadSubscript(m_mark, key);
+      throw BadSubscript();
   }
 
-  for (const auto& it : m_map) {
+  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
-    if (it.first->is(key))
+    if (it->first->is(key))
-      return *it.second;
+      return *it->second;
   }
 
   node& value = pMemory->create_node();
@@ -244,27 +231,16 @@ 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();) {
+  for (node_map::iterator it = m_map.begin(); it != m_map.end(); ++it) {
-    auto jt = std::next(it);
+    if (it->first->is(key)) {
-    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;
     }
+  }
 
   return false;
 }
@@ -286,7 +262,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 +280,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();
@@ -320,5 +296,5 @@ void node_data::convert_sequence_to_map(const shared_memory_holder& pMemory) {
   reset_sequence();
   m_type = NodeType::Map;
 }
-}  // namespace detail
+}
-}  // namespace YAML
+}

3rdparty/yaml-cpp/src/nodebuilder.cpp

@@ -1,3 +1,4 @@
+#include <assert.h>
 #include <cassert>
 
 #include "nodebuilder.h"
@@ -10,16 +11,11 @@ namespace YAML {
 struct Mark;
 
 NodeBuilder::NodeBuilder()
-    : m_pMemory(new detail::memory_holder),
+    : m_pMemory(new detail::memory_holder), m_pRoot(0), m_mapDepth(0) {
-      m_pRoot(nullptr),
+  m_anchors.push_back(0);  // since the anchors start at 1
-      m_stack{},
-      m_anchors{},
-      m_keys{},
-      m_mapDepth(0) {
-  m_anchors.push_back(nullptr);  // since the anchors start at 1
 }
 
-NodeBuilder::~NodeBuilder() = default;
+NodeBuilder::~NodeBuilder() {}
 
 Node NodeBuilder::Root() {
   if (!m_pRoot)
@@ -92,7 +88,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() {
@@ -131,4 +127,4 @@ void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node) {
     m_anchors.push_back(&node);
   }
 }
-}  // namespace YAML
+}

3rdparty/yaml-cpp/src/nodebuilder.h

@@ -27,29 +27,25 @@ class Node;
 class NodeBuilder : public EventHandler {
  public:
   NodeBuilder();
-  NodeBuilder(const NodeBuilder&) = delete;
+  virtual ~NodeBuilder();
-  NodeBuilder(NodeBuilder&&) = delete;
-  NodeBuilder& operator=(const NodeBuilder&) = delete;
-  NodeBuilder& operator=(NodeBuilder&&) = delete;
-  ~NodeBuilder() override;
 
   Node Root();
 
-  void OnDocumentStart(const Mark& mark) override;
+  virtual void OnDocumentStart(const Mark& mark);
-  void OnDocumentEnd() override;
+  virtual void OnDocumentEnd();
 
-  void OnNull(const Mark& mark, anchor_t anchor) override;
+  virtual void OnNull(const Mark& mark, anchor_t anchor);
-  void OnAlias(const Mark& mark, anchor_t anchor) override;
+  virtual void OnAlias(const Mark& mark, anchor_t anchor);
-  void OnScalar(const Mark& mark, const std::string& tag,
+  virtual void OnScalar(const Mark& mark, const std::string& tag,
-                        anchor_t anchor, const std::string& value) override;
+                        anchor_t anchor, const std::string& value);
 
-  void OnSequenceStart(const Mark& mark, const std::string& tag,
+  virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
-                               anchor_t anchor, EmitterStyle::value style) override;
+                               anchor_t anchor, EmitterStyle::value style);
-  void OnSequenceEnd() override;
+  virtual void OnSequenceEnd();
 
-  void OnMapStart(const Mark& mark, const std::string& tag,
+  virtual void OnMapStart(const Mark& mark, const std::string& tag,
-                          anchor_t anchor, EmitterStyle::value style) override;
+                          anchor_t anchor, EmitterStyle::value style);
-  void OnMapEnd() override;
+  virtual void OnMapEnd();
 
  private:
   detail::node& Push(const Mark& mark, anchor_t anchor);
@@ -61,14 +57,14 @@ class NodeBuilder : public EventHandler {
   detail::shared_memory_holder m_pMemory;
   detail::node* m_pRoot;
 
-  using Nodes = std::vector<detail::node *>;
+  typedef std::vector<detail::node*> Nodes;
   Nodes m_stack;
   Nodes m_anchors;
 
-  using PushedKey = std::pair<detail::node*, bool>;
+  typedef std::pair<detail::node*, bool> PushedKey;
   std::vector<PushedKey> m_keys;
   std::size_t m_mapDepth;
 };
-}  // namespace YAML
+}
 
 #endif  // NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/src/nodeevents.cpp

@@ -13,14 +13,14 @@ 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;
 }
 
 NodeEvents::NodeEvents(const Node& node)
-    : m_pMemory(node.m_pMemory), m_root(node.m_pNode), m_refCount{} {
+    : m_pMemory(node.m_pMemory), m_root(node.m_pNode) {
   if (m_root)
     Setup(*m_root);
 }
@@ -32,12 +32,13 @@ void NodeEvents::Setup(const detail::node& node) {
     return;
 
   if (node.type() == NodeType::Sequence) {
-    for (auto element : node)
+    for (detail::const_node_iterator it = node.begin(); it != node.end(); ++it)
-      Setup(*element);
+      Setup(**it);
   } else if (node.type() == NodeType::Map) {
-    for (auto element : node) {
+    for (detail::const_node_iterator it = node.begin(); it != node.end();
-      Setup(*element.first);
+         ++it) {
-      Setup(*element.second);
+      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)
+      for (detail::const_node_iterator it = node.begin(); it != node.end();
-        Emit(*element, handler, am);
+           ++it)
+        Emit(**it, handler, am);
       handler.OnSequenceEnd();
       break;
     case NodeType::Map:
       handler.OnMapStart(Mark(), node.tag(), anchor, node.style());
-      for (auto element : node) {
+      for (detail::const_node_iterator it = node.begin(); it != node.end();
-        Emit(*element.first, handler, am);
+           ++it) {
-        Emit(*element.second, handler, am);
+        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
+}

3rdparty/yaml-cpp/src/nodeevents.h

@@ -26,17 +26,13 @@ class Node;
 class NodeEvents {
  public:
   explicit NodeEvents(const Node& node);
-  NodeEvents(const NodeEvents&) = delete;
-  NodeEvents(NodeEvents&&) = delete;
-  NodeEvents& operator=(const NodeEvents&) = delete;
-  NodeEvents& operator=(NodeEvents&&) = delete;
 
   void Emit(EventHandler& handler);
 
  private:
   class AliasManager {
    public:
-    AliasManager() : m_anchorByIdentity{}, m_curAnchor(0) {}
+    AliasManager() : m_curAnchor(0) {}
 
     void RegisterReference(const detail::node& node);
     anchor_t LookupAnchor(const detail::node& node) const;
@@ -45,7 +41,7 @@ class NodeEvents {
     anchor_t _CreateNewAnchor() { return ++m_curAnchor; }
 
    private:
-    using AnchorByIdentity = std::map<const detail::node_ref*, anchor_t>;
+    typedef std::map<const detail::node_ref*, anchor_t> AnchorByIdentity;
     AnchorByIdentity m_anchorByIdentity;
 
     anchor_t m_curAnchor;
@@ -60,9 +56,9 @@ class NodeEvents {
   detail::shared_memory_holder m_pMemory;
   detail::node* m_root;
 
-  using RefCount = std::map<const detail::node_ref*, int>;
+  typedef std::map<const detail::node_ref*, int> RefCount;
   RefCount m_refCount;
 };
-}  // namespace YAML
+}
 
 #endif  // NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/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
+}

3rdparty/yaml-cpp/src/ostream_wrapper.cpp

@@ -7,21 +7,16 @@
 namespace YAML {
 ostream_wrapper::ostream_wrapper()
     : m_buffer(1, '\0'),
-      m_pStream(nullptr),
+      m_pStream(0),
       m_pos(0),
       m_row(0),
       m_col(0),
       m_comment(false) {}
 
 ostream_wrapper::ostream_wrapper(std::ostream& stream)
-    : m_buffer{},
+    : m_pStream(&stream), m_pos(0), m_row(0), m_col(0), m_comment(false) {}
-      m_pStream(&stream),
-      m_pos(0),
-      m_row(0),
-      m_col(0),
-      m_comment(false) {}
 
-ostream_wrapper::~ostream_wrapper() = default;
+ostream_wrapper::~ostream_wrapper() {}
 
 void ostream_wrapper::write(const std::string& str) {
   if (m_pStream) {
@@ -31,8 +26,8 @@ void ostream_wrapper::write(const std::string& str) {
     std::copy(str.begin(), str.end(), m_buffer.begin() + m_pos);
   }
 
-  for (char ch : str) {
+  for (std::size_t i = 0; i < str.size(); i++) {
-    update_pos(ch);
+    update_pos(str[i]);
   }
 }
 
@@ -59,4 +54,4 @@ void ostream_wrapper::update_pos(char ch) {
     m_comment = false;
   }
 }
-}  // namespace YAML
+}

3rdparty/yaml-cpp/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) {
+  if (!fin || fin.bad()) {
-    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);
 }

3rdparty/yaml-cpp/src/parser.cpp

@@ -11,13 +11,15 @@
 namespace YAML {
 class EventHandler;
 
-Parser::Parser() : m_pScanner{}, m_pDirectives{} {}
+Parser::Parser() {}
 
-Parser::Parser(std::istream& in) : Parser() { Load(in); }
+Parser::Parser(std::istream& in) { Load(in); }
 
-Parser::~Parser() = default;
+Parser::~Parser() {}
 
-Parser::operator bool() const { return m_pScanner && !m_pScanner->empty(); }
+Parser::operator bool() const {
+  return m_pScanner.get() && !m_pScanner->empty();
+}
 
 void Parser::Load(std::istream& in) {
   m_pScanner.reset(new Scanner(in));
@@ -25,7 +27,7 @@ void Parser::Load(std::istream& in) {
 }
 
 bool Parser::HandleNextDocument(EventHandler& eventHandler) {
-  if (!m_pScanner)
+  if (!m_pScanner.get())
     return false;
 
   ParseDirectives();
@@ -41,7 +43,11 @@ bool Parser::HandleNextDocument(EventHandler& eventHandler) {
 void Parser::ParseDirectives() {
   bool readDirective = false;
 
-  while (!m_pScanner->empty()) {
+  while (1) {
+    if (m_pScanner->empty()) {
+      break;
+    }
+
     Token& token = m_pScanner->peek();
     if (token.type != Token::DIRECTIVE) {
       break;
@@ -107,13 +113,17 @@ void Parser::HandleTagDirective(const Token& token) {
 }
 
 void Parser::PrintTokens(std::ostream& out) {
-  if (!m_pScanner) {
+  if (!m_pScanner.get()) {
     return;
   }
 
-  while (!m_pScanner->empty()) {
+  while (1) {
+    if (m_pScanner->empty()) {
+      break;
+    }
+
     out << m_pScanner->peek() << "\n";
     m_pScanner->pop();
   }
 }
-}  // namespace YAML
+}

3rdparty/yaml-cpp/src/ptr_vector.h

@@ -12,17 +12,15 @@
 #include <memory>
 #include <vector>
 
+#include "yaml-cpp/noncopyable.h"
+
 namespace YAML {
 
 // TODO: This class is no longer needed
 template <typename T>
-class ptr_vector {
+class ptr_vector : private YAML::noncopyable {
  public:
-  ptr_vector() : m_data{} {}
+  ptr_vector() {}
-  ptr_vector(const ptr_vector&) = delete;
-  ptr_vector(ptr_vector&&) = default;
-  ptr_vector& operator=(const ptr_vector&) = delete;
-  ptr_vector& operator=(ptr_vector&&) = default;
 
   void clear() { m_data.clear(); }
 
@@ -40,6 +38,6 @@ class ptr_vector {
  private:
   std::vector<std::unique_ptr<T>> m_data;
 };
-}  // namespace YAML
+}
 
 #endif  // PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/src/regex_yaml.cpp

@@ -2,16 +2,18 @@
 
 namespace YAML {
 // constructors
+RegEx::RegEx() : m_op(REGEX_EMPTY) {}
 
-RegEx::RegEx(REGEX_OP op) : m_op(op), m_a(0), m_z(0), m_params{} {}
+RegEx::RegEx(REGEX_OP op) : m_op(op) {}
-RegEx::RegEx() : RegEx(REGEX_EMPTY) {}
 
-RegEx::RegEx(char ch) : m_op(REGEX_MATCH), m_a(ch), m_z(0), m_params{} {}
+RegEx::RegEx(char ch) : m_op(REGEX_MATCH), m_a(ch) {}
 
-RegEx::RegEx(char a, char z) : m_op(REGEX_RANGE), m_a(a), m_z(z), m_params{} {}
+RegEx::RegEx(char a, char z) : m_op(REGEX_RANGE), m_a(a), m_z(z) {}
 
-RegEx::RegEx(const std::string& str, REGEX_OP op)
+RegEx::RegEx(const std::string& str, REGEX_OP op) : m_op(op) {
-    : m_op(op), m_a(0), m_z(0), m_params(str.begin(), str.end()) {}
+  for (std::size_t i = 0; i < str.size(); i++)
+    m_params.push_back(RegEx(str[i]));
+}
 
 // combination constructors
 RegEx operator!(const RegEx& ex) {
@@ -20,14 +22,14 @@ RegEx operator!(const RegEx& ex) {
   return ret;
 }
 
-RegEx operator|(const RegEx& ex1, const RegEx& ex2) {
+RegEx operator||(const RegEx& ex1, const RegEx& ex2) {
   RegEx ret(REGEX_OR);
   ret.m_params.push_back(ex1);
   ret.m_params.push_back(ex2);
   return ret;
 }
 
-RegEx operator&(const RegEx& ex1, const RegEx& ex2) {
+RegEx operator&&(const RegEx& ex1, const RegEx& ex2) {
   RegEx ret(REGEX_AND);
   ret.m_params.push_back(ex1);
   ret.m_params.push_back(ex2);
@@ -40,4 +42,4 @@ RegEx operator+(const RegEx& ex1, const RegEx& ex2) {
   ret.m_params.push_back(ex2);
   return ret;
 }
-}  // namespace YAML
+}

3rdparty/yaml-cpp/src/regex_yaml.h

@@ -31,14 +31,14 @@ enum REGEX_OP {
 class YAML_CPP_API RegEx {
  public:
   RegEx();
-  explicit RegEx(char ch);
+  RegEx(char ch);
   RegEx(char a, char z);
   RegEx(const std::string& str, REGEX_OP op = REGEX_SEQ);
-  ~RegEx() = default;
+  ~RegEx() {}
 
   friend YAML_CPP_API RegEx operator!(const RegEx& ex);
-  friend YAML_CPP_API RegEx operator|(const RegEx& ex1, const RegEx& ex2);
+  friend YAML_CPP_API RegEx operator||(const RegEx& ex1, const RegEx& ex2);
-  friend YAML_CPP_API RegEx operator&(const RegEx& ex1, const RegEx& ex2);
+  friend YAML_CPP_API RegEx operator&&(const RegEx& ex1, const RegEx& ex2);
   friend YAML_CPP_API RegEx operator+(const RegEx& ex1, const RegEx& ex2);
 
   bool Matches(char ch) const;
@@ -53,7 +53,7 @@ class YAML_CPP_API RegEx {
   int Match(const Source& source) const;
 
  private:
-  explicit RegEx(REGEX_OP op);
+  RegEx(REGEX_OP op);
 
   template <typename Source>
   bool IsValidSource(const Source& source) const;
@@ -77,11 +77,10 @@ class YAML_CPP_API RegEx {
 
  private:
   REGEX_OP m_op;
-  char m_a{};
+  char m_a, m_z;
-  char m_z{};
   std::vector<RegEx> m_params;
 };
-}  // namespace YAML
+}
 
 #include "regeximpl.h"
 

3rdparty/yaml-cpp/src/regeximpl.h

@@ -8,8 +8,8 @@
 #endif
 
 #include "stream.h"
-#include "streamcharsource.h"
 #include "stringsource.h"
+#include "streamcharsource.h"
 
 namespace YAML {
 // query matches
@@ -106,8 +106,9 @@ inline int RegEx::MatchOpEmpty(const Source& source) const {
 template <>
 inline int RegEx::MatchOpEmpty<StringCharSource>(
     const StringCharSource& source) const {
-  return !source ? 0 : -1;  // the empty regex only is successful on the empty
+  return !source
-                            // string
+             ? 0
+             : -1;  // the empty regex only is successful on the empty string
 }
 
 // MatchOperator
@@ -129,8 +130,8 @@ inline int RegEx::MatchOpRange(const Source& source) const {
 // OrOperator
 template <typename Source>
 inline int RegEx::MatchOpOr(const Source& source) const {
-  for (const RegEx& param : m_params) {
+  for (std::size_t i = 0; i < m_params.size(); i++) {
-    int n = param.MatchUnchecked(source);
+    int n = m_params[i].MatchUnchecked(source);
     if (n >= 0)
       return n;
   }
@@ -168,8 +169,8 @@ inline int RegEx::MatchOpNot(const Source& source) const {
 template <typename Source>
 inline int RegEx::MatchOpSeq(const Source& source) const {
   int offset = 0;
-  for (const RegEx& param : m_params) {
+  for (std::size_t i = 0; i < m_params.size(); i++) {
-    int n = param.Match(source + offset);  // note Match, not
+    int n = m_params[i].Match(source + offset);  // note Match, not
                                                  // MatchUnchecked because we
                                                  // need to check validity after
                                                  // the offset
@@ -180,6 +181,6 @@ inline int RegEx::MatchOpSeq(const Source& source) const {
 
   return offset;
 }
-}  // namespace YAML
+}
 
 #endif  // REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/src/scanner.cpp

@@ -9,17 +9,12 @@
 namespace YAML {
 Scanner::Scanner(std::istream& in)
     : INPUT(in),
-      m_tokens{},
       m_startedStream(false),
       m_endedStream(false),
       m_simpleKeyAllowed(false),
-      m_canBeJSONFlow(false),
+      m_canBeJSONFlow(false) {}
-      m_simpleKeys{},
-      m_indents{},
-      m_indentRefs{},
-      m_flows{} {}
 
-Scanner::~Scanner() = default;
+Scanner::~Scanner() {}
 
 bool Scanner::empty() {
   EnsureTokensInQueue();
@@ -51,7 +46,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 +83,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 +169,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)) {
@@ -287,7 +282,7 @@ Scanner::IndentMarker* Scanner::PushIndentTo(int column,
                                              IndentMarker::INDENT_TYPE type) {
   // are we in flow?
   if (InFlowContext()) {
-    return nullptr;
+    return 0;
   }
 
   std::unique_ptr<IndentMarker> pIndent(new IndentMarker(column, type));
@@ -296,12 +291,12 @@ Scanner::IndentMarker* Scanner::PushIndentTo(int column,
 
   // is this actually an indentation?
   if (indent.column < lastIndent.column) {
-    return nullptr;
+    return 0;
   }
   if (indent.column == lastIndent.column &&
       !(indent.type == IndentMarker::SEQ &&
         lastIndent.type == IndentMarker::MAP)) {
-    return nullptr;
+    return 0;
   }
 
   // push a start token

3rdparty/yaml-cpp/src/scanner.h

@@ -9,7 +9,9 @@
 
 #include <cstddef>
 #include <ios>
+#include <map>
 #include <queue>
+#include <set>
 #include <stack>
 #include <string>
 
@@ -47,7 +49,7 @@ class Scanner {
     enum INDENT_TYPE { MAP, SEQ, NONE };
     enum STATUS { VALID, INVALID, UNKNOWN };
     IndentMarker(int column_, INDENT_TYPE type_)
-        : column(column_), type(type_), status(VALID), pStartToken(nullptr) {}
+        : column(column_), type(type_), status(VALID), pStartToken(0) {}
 
     int column;
     INDENT_TYPE type;

3rdparty/yaml-cpp/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;
-        }
+        } else if (params.onDocIndicator == THROW) {
-        if (params.onDocIndicator == THROW) {
           throw ParserException(INPUT.mark(), ErrorMsg::DOC_IN_SCALAR);
         }
       }
@@ -184,7 +183,7 @@ std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) {
         case FOLD_FLOW:
           if (nextEmptyLine) {
             scalar += "\n";
-          } else if (!emptyLine && !escapedNewline) {
+          } else if (!emptyLine && !nextEmptyLine && !escapedNewline) {
             scalar += " ";
           }
           break;
@@ -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
+}

3rdparty/yaml-cpp/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

3rdparty/yaml-cpp/src/scantag.cpp

@@ -78,4 +78,4 @@ const std::string ScanTagSuffix(Stream& INPUT) {
 
   return tag;
 }
-}  // namespace YAML
+}

3rdparty/yaml-cpp/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);
@@ -338,7 +338,7 @@ void Scanner::ScanQuotedScalar() {
 
   // setup the scanning parameters
   ScanScalarParams params;
-  RegEx end = (single ? RegEx(quote) & !Exp::EscSingleQuote() : RegEx(quote));
+  RegEx end = (single ? RegEx(quote) && !Exp::EscSingleQuote() : RegEx(quote));
   params.end = &end;
   params.eatEnd = true;
   params.escape = (single ? '\'' : '\\');
@@ -434,4 +434,4 @@ void Scanner::ScanBlockScalar() {
   token.value = scalar;
   m_tokens.push(token);
 }
-}  // namespace YAML
+}

3rdparty/yaml-cpp/src/setting.h

@@ -7,24 +7,17 @@
 #pragma once
 #endif
 
-#include "yaml-cpp/noexcept.h"
 #include <memory>
-#include <utility>
 #include <vector>
+#include "yaml-cpp/noncopyable.h"
 
 namespace YAML {
-
+class SettingChangeBase;
-class SettingChangeBase {
- public:
-  virtual ~SettingChangeBase() = default;
-  virtual void pop() = 0;
-};
 
 template <typename T>
 class Setting {
  public:
   Setting() : m_value() {}
-  Setting(const T& value) : m_value() { set(value); }
 
   const T get() const { return m_value; }
   std::unique_ptr<SettingChangeBase> set(const T& value);
@@ -34,19 +27,21 @@ class Setting {
   T m_value;
 };
 
+class SettingChangeBase {
+ public:
+  virtual ~SettingChangeBase() {}
+  virtual void pop() = 0;
+};
+
 template <typename T>
 class SettingChange : public SettingChangeBase {
  public:
-  SettingChange(Setting<T>* pSetting)
+  SettingChange(Setting<T>* pSetting) : m_pCurSetting(pSetting) {
-      : m_pCurSetting(pSetting),
+    // copy old setting to save its state
-        m_oldSetting(*pSetting)  // copy old setting to save its state
+    m_oldSetting = *pSetting;
-  {}
+  }
-  SettingChange(const SettingChange&) = delete;
-  SettingChange(SettingChange&&) = delete;
-  SettingChange& operator=(const SettingChange&) = delete;
-  SettingChange& operator=(SettingChange&&) = delete;
 
-  void pop() override { m_pCurSetting->restore(m_oldSetting); }
+  virtual void pop() { m_pCurSetting->restore(m_oldSetting); }
 
  private:
   Setting<T>* m_pCurSetting;
@@ -60,13 +55,28 @@ inline std::unique_ptr<SettingChangeBase> Setting<T>::set(const T& value) {
   return pChange;
 }
 
-class SettingChanges {
+class SettingChanges : private noncopyable {
  public:
-  SettingChanges() : m_settingChanges{} {}
+  SettingChanges() {}
-  SettingChanges(const SettingChanges&) = delete;
+  ~SettingChanges() { clear(); }
-  SettingChanges(SettingChanges&&) YAML_CPP_NOEXCEPT = default;
+
-  SettingChanges& operator=(const SettingChanges&) = delete;
+  void clear() {
-  SettingChanges& operator=(SettingChanges&& rhs) YAML_CPP_NOEXCEPT {
+    restore();
+    m_settingChanges.clear();
+  }
+
+  void restore() {
+    for (setting_changes::const_iterator it = m_settingChanges.begin();
+         it != m_settingChanges.end(); ++it)
+      (*it)->pop();
+  }
+
+  void push(std::unique_ptr<SettingChangeBase> pSettingChange) {
+    m_settingChanges.push_back(std::move(pSettingChange));
+  }
+
+  // like std::unique_ptr - assignment is transfer of ownership
+  SettingChanges& operator=(SettingChanges&& rhs) {
     if (this == &rhs)
       return *this;
 
@@ -75,26 +85,11 @@ class SettingChanges {
 
     return *this;
   }
-  ~SettingChanges() { clear(); }
-
-  void clear() YAML_CPP_NOEXCEPT {
-    restore();
-    m_settingChanges.clear();
-  }
-
-  void restore() YAML_CPP_NOEXCEPT {
-    for (const auto& setting : m_settingChanges)
-      setting->pop();
-  }
-
-  void push(std::unique_ptr<SettingChangeBase> pSettingChange) {
-    m_settingChanges.push_back(std::move(pSettingChange));
-  }
 
  private:
-  using setting_changes = std::vector<std::unique_ptr<SettingChangeBase>>;
+  typedef std::vector<std::unique_ptr<SettingChangeBase>> setting_changes;
   setting_changes m_settingChanges;
 };
-}  // namespace YAML
+}
 
 #endif  // SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/src/simplekey.cpp

@@ -5,11 +5,7 @@ namespace YAML {
 struct Mark;
 
 Scanner::SimpleKey::SimpleKey(const Mark& mark_, std::size_t flowLevel_)
-    : mark(mark_),
+    : mark(mark_), flowLevel(flowLevel_), pIndent(0), pMapStart(0), pKey(0) {}
-      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
+}

3rdparty/yaml-cpp/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
@@ -19,10 +18,9 @@ SingleDocParser::SingleDocParser(Scanner& scanner, const Directives& directives)
     : m_scanner(scanner),
       m_directives(directives),
       m_pCollectionStack(new CollectionStack),
-      m_anchors{},
       m_curAnchor(0) {}
 
-SingleDocParser::~SingleDocParser() = default;
+SingleDocParser::~SingleDocParser() {}
 
 // HandleDocument
 // . Handles the next document
@@ -48,8 +46,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);
@@ -75,32 +71,21 @@ void SingleDocParser::HandleNode(EventHandler& eventHandler) {
   }
 
   std::string tag;
-  std::string anchor_name;
   anchor_t anchor;
-  ParseProperties(tag, anchor, anchor_name);
+  ParseProperties(tag, anchor);
-
-  if (!anchor_name.empty())
-    eventHandler.OnAnchor(mark, anchor_name);
-
-  // after parsing properties, an empty node is again a possibility
-  if (m_scanner.empty()) {
-    eventHandler.OnNull(mark, anchor);
-    return;
-  }
 
   const Token& token = m_scanner.peek();
 
-  // add non-specific tags
+  if (token.type == Token::PLAIN_SCALAR && IsNullString(token.value)) {
-  if (tag.empty())
-    tag = (token.type == Token::NON_PLAIN_SCALAR ? "!" : "?");
-  
-  if (token.type == Token::PLAIN_SCALAR 
-      && tag.compare("?") == 0 && 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 +152,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);
 
@@ -181,10 +166,10 @@ void SingleDocParser::HandleBlockSequence(EventHandler& eventHandler) {
 
     // check for null
     if (!m_scanner.empty()) {
-      const Token& nextToken = m_scanner.peek();
+      const Token& token_ = m_scanner.peek();
-      if (nextToken.type == Token::BLOCK_ENTRY ||
+      if (token_.type == Token::BLOCK_ENTRY ||
-          nextToken.type == Token::BLOCK_SEQ_END) {
+          token_.type == Token::BLOCK_SEQ_END) {
-        eventHandler.OnNull(nextToken.mark, NullAnchor);
+        eventHandler.OnNull(token_.mark, NullAnchor);
         continue;
       }
     }
@@ -200,7 +185,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 +238,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 +277,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);
 
@@ -371,13 +356,11 @@ void SingleDocParser::HandleCompactMapWithNoKey(EventHandler& eventHandler) {
 
 // ParseProperties
 // . Grabs any tag or anchor tokens and deals with them.
-void SingleDocParser::ParseProperties(std::string& tag, anchor_t& anchor,
+void SingleDocParser::ParseProperties(std::string& tag, anchor_t& anchor) {
-                                      std::string& anchor_name) {
   tag.clear();
-  anchor_name.clear();
   anchor = NullAnchor;
 
-  while (true) {
+  while (1) {
     if (m_scanner.empty())
       return;
 
@@ -386,7 +369,7 @@ void SingleDocParser::ParseProperties(std::string& tag, anchor_t& anchor,
         ParseTag(tag);
         break;
       case Token::ANCHOR:
-        ParseAnchor(anchor, anchor_name);
+        ParseAnchor(anchor);
         break;
       default:
         return;
@@ -404,12 +387,11 @@ void SingleDocParser::ParseTag(std::string& tag) {
   m_scanner.pop();
 }
 
-void SingleDocParser::ParseAnchor(anchor_t& anchor, std::string& anchor_name) {
+void SingleDocParser::ParseAnchor(anchor_t& anchor) {
   Token& token = m_scanner.peek();
   if (anchor)
     throw ParserException(token.mark, ErrorMsg::MULTIPLE_ANCHORS);
 
-  anchor_name = token.value;
   anchor = RegisterAnchor(token.value);
   m_scanner.pop();
 }
@@ -423,13 +405,10 @@ 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);
+  Anchors::const_iterator it = m_anchors.find(name);
-  if (it == m_anchors.end()) {
+  if (it == m_anchors.end())
-    std::stringstream ss;
+    throw ParserException(mark, ErrorMsg::UNKNOWN_ANCHOR);
-    ss << ErrorMsg::UNKNOWN_ANCHOR << name;
-    throw ParserException(mark, ss.str());
-  }
 
   return it->second;
 }
-}  // namespace YAML
+}

3rdparty/yaml-cpp/src/singledocparser.h

@@ -12,10 +12,10 @@
 #include <string>
 
 #include "yaml-cpp/anchor.h"
+#include "yaml-cpp/noncopyable.h"
 
 namespace YAML {
 class CollectionStack;
-template <int> class DepthGuard; // depthguard.h
 class EventHandler;
 class Node;
 class Scanner;
@@ -23,13 +23,9 @@ struct Directives;
 struct Mark;
 struct Token;
 
-class SingleDocParser {
+class SingleDocParser : private noncopyable {
  public:
   SingleDocParser(Scanner& scanner, const Directives& directives);
-  SingleDocParser(const SingleDocParser&) = delete;
-  SingleDocParser(SingleDocParser&&) = delete;
-  SingleDocParser& operator=(const SingleDocParser&) = delete;
-  SingleDocParser& operator=(SingleDocParser&&) = delete;
   ~SingleDocParser();
 
   void HandleDocument(EventHandler& eventHandler);
@@ -47,25 +43,23 @@ class SingleDocParser {
   void HandleCompactMap(EventHandler& eventHandler);
   void HandleCompactMapWithNoKey(EventHandler& eventHandler);
 
-  void ParseProperties(std::string& tag, anchor_t& anchor,
+  void ParseProperties(std::string& tag, anchor_t& anchor);
-                       std::string& anchor_name);
   void ParseTag(std::string& tag);
-  void ParseAnchor(anchor_t& anchor, std::string& anchor_name);
+  void ParseAnchor(anchor_t& anchor);
 
   anchor_t RegisterAnchor(const std::string& name);
   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;
 
-  using Anchors = std::map<std::string, anchor_t>;
+  typedef std::map<std::string, anchor_t> Anchors;
   Anchors m_anchors;
 
   anchor_t m_curAnchor;
 };
-}  // namespace YAML
+}
 
 #endif  // SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/src/stream.cpp

@@ -111,15 +111,24 @@ static UtfIntroState s_introTransitions[][uictMax] = {
 
 static char s_introUngetCount[][uictMax] = {
     // uict00, uictBB, uictBF, uictEF, uictFE, uictFF, uictAscii, uictOther
-    {0, 1, 1, 0, 0, 0, 0, 1}, {0, 2, 2, 2, 2, 2, 2, 2},
+    {0, 1, 1, 0, 0, 0, 0, 1},
-    {3, 3, 3, 3, 0, 3, 3, 3}, {4, 4, 4, 4, 4, 0, 4, 4},
+    {0, 2, 2, 2, 2, 2, 2, 2},
-    {1, 1, 1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 1, 1, 1, 1},
+    {3, 3, 3, 3, 0, 3, 3, 3},
-    {2, 2, 2, 2, 2, 0, 2, 2}, {2, 2, 2, 2, 0, 2, 2, 2},
+    {4, 4, 4, 4, 4, 0, 4, 4},
-    {0, 1, 1, 1, 1, 1, 1, 1}, {0, 2, 2, 2, 2, 2, 2, 2},
+    {1, 1, 1, 1, 1, 1, 1, 1},
-    {1, 1, 1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 1, 1, 1, 1},
+    {1, 1, 1, 1, 1, 1, 1, 1},
-    {0, 2, 2, 2, 2, 2, 2, 2}, {0, 3, 3, 3, 3, 3, 3, 3},
+    {2, 2, 2, 2, 2, 0, 2, 2},
-    {4, 4, 4, 4, 4, 4, 4, 4}, {2, 0, 2, 2, 2, 2, 2, 2},
+    {2, 2, 2, 2, 0, 2, 2, 2},
-    {3, 3, 0, 3, 3, 3, 3, 3}, {1, 1, 1, 1, 1, 1, 1, 1},
+    {0, 1, 1, 1, 1, 1, 1, 1},
+    {0, 2, 2, 2, 2, 2, 2, 2},
+    {1, 1, 1, 1, 1, 1, 1, 1},
+    {1, 1, 1, 1, 1, 1, 1, 1},
+    {0, 2, 2, 2, 2, 2, 2, 2},
+    {0, 3, 3, 3, 3, 3, 3, 3},
+    {4, 4, 4, 4, 4, 4, 4, 4},
+    {2, 0, 2, 2, 2, 2, 2, 2},
+    {3, 3, 0, 3, 3, 3, 3, 3},
+    {1, 1, 1, 1, 1, 1, 1, 1},
 };
 
 inline UtfIntroCharType IntroCharTypeOf(std::istream::int_type ch) {
@@ -151,8 +160,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 =
+  const unsigned char header = ((1 << lead_bits) - 1) << (8 - lead_bits);
-      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)));
@@ -184,20 +192,17 @@ inline void QueueUnicodeCodepoint(std::deque<char>& q, unsigned long ch) {
 
 Stream::Stream(std::istream& input)
     : m_input(input),
-      m_mark{},
-      m_charSet{},
-      m_readahead{},
       m_pPrefetched(new unsigned char[YAML_PREFETCH_SIZE]),
       m_nPrefetchedAvailable(0),
       m_nPrefetchedUsed(0) {
-  using char_traits = std::istream::traits_type;
+  typedef std::istream::traits_type char_traits;
 
   if (!input)
     return;
 
   // Determine (or guess) the character-set by reading the BOM, if any.  See
   // the YAML specification for the determination algorithm.
-  char_traits::int_type intro[4]{};
+  char_traits::int_type intro[4];
   int nIntroUsed = 0;
   UtfIntroState state = uis_start;
   for (; !s_introFinalState[state];) {
@@ -274,11 +279,9 @@ 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) {
+  ret.reserve(n);
-    ret.reserve(static_cast<std::string::size_type>(n));
   for (int i = 0; i < n; i++)
     ret += get();
-  }
   return ret;
 }
 
@@ -329,7 +332,7 @@ bool Stream::_ReadAheadTo(size_t i) const {
 void Stream::StreamInUtf8() const {
   unsigned char b = GetNextByte();
   if (m_input.good()) {
-    m_readahead.push_back(static_cast<char>(b));
+    m_readahead.push_back(b);
   }
 }
 
@@ -350,9 +353,7 @@ void Stream::StreamInUtf16() const {
     // Trailing (low) surrogate...ugh, wrong order
     QueueUnicodeCodepoint(m_readahead, CP_REPLACEMENT_CHARACTER);
     return;
-  }
+  } else if (ch >= 0xD800 && ch < 0xDC00) {
-
-  if (ch >= 0xD800 && ch < 0xDC00) {
     // ch is a leading (high) surrogate
 
     // Four byte UTF-8 code point
@@ -377,11 +378,12 @@ 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;
         }
+      }
 
       // Select the payload bits from the high surrogate
       ch &= 0x3FF;
@@ -443,4 +445,4 @@ void Stream::StreamInUtf32() const {
 
   QueueUnicodeCodepoint(m_readahead, ch);
 }
-}  // namespace YAML
+}

3rdparty/yaml-cpp/src/stream.h

@@ -7,6 +7,7 @@
 #pragma once
 #endif
 
+#include "yaml-cpp/noncopyable.h"
 #include "yaml-cpp/mark.h"
 #include <cstddef>
 #include <deque>
@@ -16,18 +17,11 @@
 #include <string>
 
 namespace YAML {
-
+class Stream : private noncopyable {
-class StreamCharSource;
-
-class Stream {
  public:
   friend class StreamCharSource;
 
   Stream(std::istream& input);
-  Stream(const Stream&) = delete;
-  Stream(Stream&&) = delete;
-  Stream& operator=(const Stream&) = delete;
-  Stream& operator=(Stream&&) = delete;
   ~Stream();
 
   operator bool() const;
@@ -77,6 +71,6 @@ inline bool Stream::ReadAheadTo(size_t i) const {
     return true;
   return _ReadAheadTo(i);
 }
-}  // namespace YAML
+}
 
 #endif  // STREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/src/streamcharsource.h

@@ -7,20 +7,16 @@
 #pragma once
 #endif
 
-#include "yaml-cpp/noexcept.h"
+#include "yaml-cpp/noncopyable.h"
-#include "stream.h"
 #include <cstddef>
 
 namespace YAML {
-
 class StreamCharSource {
  public:
   StreamCharSource(const Stream& stream) : m_offset(0), m_stream(stream) {}
-  StreamCharSource(const StreamCharSource& source) = default;
+  StreamCharSource(const StreamCharSource& source)
-  StreamCharSource(StreamCharSource&&) YAML_CPP_NOEXCEPT = default;
+      : m_offset(source.m_offset), m_stream(source.m_stream) {}
-  StreamCharSource& operator=(const StreamCharSource&) = delete;
+  ~StreamCharSource() {}
-  StreamCharSource& operator=(StreamCharSource&&) = delete;
-  ~StreamCharSource() = default;
 
   operator bool() const;
   char operator[](std::size_t i) const { return m_stream.CharAt(m_offset + i); }
@@ -31,6 +27,8 @@ class StreamCharSource {
  private:
   std::size_t m_offset;
   const Stream& m_stream;
+
+  StreamCharSource& operator=(const StreamCharSource&);  // non-assignable
 };
 
 inline StreamCharSource::operator bool() const {
@@ -40,11 +38,11 @@ inline StreamCharSource::operator bool() const {
 inline const StreamCharSource StreamCharSource::operator+(int i) const {
   StreamCharSource source(*this);
   if (static_cast<int>(source.m_offset) + i >= 0)
-    source.m_offset += static_cast<std::size_t>(i);
+    source.m_offset += i;
   else
     source.m_offset = 0;
   return source;
 }
-}  // namespace YAML
+}
 
 #endif  // STREAMCHARSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/src/tag.cpp

@@ -6,8 +6,7 @@
 #include "token.h"
 
 namespace YAML {
-Tag::Tag(const Token& token)
+Tag::Tag(const Token& token) : type(static_cast<TYPE>(token.data)) {
-    : type(static_cast<TYPE>(token.data)), handle{}, value{} {
   switch (type) {
     case VERBATIM:
       value = token.value;
@@ -29,7 +28,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;
@@ -47,4 +46,4 @@ std::string Tag::Translate(const Directives& directives) {
   }
   throw std::runtime_error("yaml-cpp: internal error, bad tag type");
 }
-}  // namespace YAML
+}

3rdparty/yaml-cpp/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;

3rdparty/yaml-cpp/src/token.h

@@ -14,11 +14,10 @@
 
 namespace YAML {
 const std::string TokenNames[] = {
-    "DIRECTIVE",        "DOC_START",      "DOC_END",       "BLOCK_SEQ_START",
+    "DIRECTIVE", "DOC_START", "DOC_END", "BLOCK_SEQ_START", "BLOCK_MAP_START",
-    "BLOCK_MAP_START",  "BLOCK_SEQ_END",  "BLOCK_MAP_END", "BLOCK_ENTRY",
+    "BLOCK_SEQ_END", "BLOCK_MAP_END", "BLOCK_ENTRY", "FLOW_SEQ_START",
-    "FLOW_SEQ_START",   "FLOW_MAP_START", "FLOW_SEQ_END",  "FLOW_MAP_END",
+    "FLOW_MAP_START", "FLOW_SEQ_END", "FLOW_MAP_END", "FLOW_MAP_COMPACT",
-    "FLOW_MAP_COMPACT", "FLOW_ENTRY",     "KEY",           "VALUE",
+    "FLOW_ENTRY", "KEY", "VALUE", "ANCHOR", "ALIAS", "TAG", "SCALAR"};
-    "ANCHOR",           "ALIAS",          "TAG",           "SCALAR"};
 
 struct Token {
   // enums
@@ -49,12 +48,12 @@ struct Token {
 
   // data
   Token(TYPE type_, const Mark& mark_)
-      : status(VALID), type(type_), mark(mark_), value{}, params{}, data(0) {}
+      : status(VALID), type(type_), mark(mark_), data(0) {}
 
   friend std::ostream& operator<<(std::ostream& out, const Token& token) {
     out << TokenNames[token.type] << std::string(": ") << token.value;
-    for (const std::string& param : token.params)
+    for (std::size_t i = 0; i < token.params.size(); i++)
-      out << std::string(" ") << param;
+      out << std::string(" ") << token.params[i];
     return out;
   }
 
@@ -65,6 +64,6 @@ struct Token {
   std::vector<std::string> params;
   int data;
 };
-}  // namespace YAML
+}
 
 #endif  // TOKEN_H_62B23520_7C8E_11DE_8A39_0800200C9A66

3rdparty/yaml-cpp/yaml-cpp.vcxproj

@@ -95,9 +95,8 @@
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <InlineFunctionExpansion>Disabled</InlineFunctionExpansion>
       <AdditionalIncludeDirectories>$(SolutionDir)3rdparty\yaml-cpp\include\;$(SolutionDir)3rdparty\yaml-cpp\src\;</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>YAML_CPP_STATIC_DEFINE;WIN32;_WINDOWS;_DEBUG;_ITERATOR_DEBUG_LEVEL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;_WINDOWS;_DEBUG;_ITERATOR_DEBUG_LEVEL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@@ -108,9 +107,8 @@
       </SDLCheck>
       <AdditionalIncludeDirectories>$(SolutionDir)3rdparty\yaml-cpp\include\;$(SolutionDir)3rdparty\yaml-cpp\src\;</AdditionalIncludeDirectories>
       <InlineFunctionExpansion>Disabled</InlineFunctionExpansion>
-      <PreprocessorDefinitions>YAML_CPP_STATIC_DEFINE;WIN32;_WINDOWS;_DEBUG;_ITERATOR_DEBUG_LEVEL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;_WINDOWS;_DEBUG;_ITERATOR_DEBUG_LEVEL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -122,9 +120,8 @@
       <SDLCheck>
       </SDLCheck>
       <AdditionalIncludeDirectories>$(SolutionDir)3rdparty\yaml-cpp\include\;$(SolutionDir)3rdparty\yaml-cpp\src\;</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>YAML_CPP_STATIC_DEFINE;WIN32;_WINDOWS;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;_WINDOWS;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
     <Link>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
@@ -140,9 +137,8 @@
       <SDLCheck>
       </SDLCheck>
       <AdditionalIncludeDirectories>$(SolutionDir)3rdparty\yaml-cpp\include\;$(SolutionDir)3rdparty\yaml-cpp\src\;</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>YAML_CPP_STATIC_DEFINE;WIN32;_WINDOWS;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;_WINDOWS;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
     <Link>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
@@ -178,7 +174,6 @@
     <ClCompile Include="src\contrib\graphbuilder.cpp" />
     <ClCompile Include="src\contrib\graphbuilderadapter.cpp" />
     <ClCompile Include="src\convert.cpp" />
-    <ClCompile Include="src\depthguard.cpp" />
     <ClCompile Include="src\directives.cpp" />
     <ClCompile Include="src\emit.cpp" />
     <ClCompile Include="src\emitfromevents.cpp" />

3rdparty/yaml-cpp/yaml-cpp.vcxproj.filters

@@ -89,9 +89,6 @@
     <ClCompile Include="src\convert.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="src\depthguard.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="src\directives.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>

CMakeLists.txt

@@ -35,7 +35,7 @@ project( rAthena )
 if( CYGWIN )
 	unset( WIN32 )
 endif()
-set(CMAKE_CXX_STANDARD 17) # C++17...
+set(CMAKE_CXX_STANDARD 14) # C++14...
 set(CMAKE_CXX_STANDARD_REQUIRED ON) #...is required...
 #set(CMAKE_CXX_EXTENSIONS OFF) #...without compiler extensions like gnu++11
 
@@ -236,7 +236,7 @@ option( ENABLE_WEB_SERVER "Build web-server (default=ON)" ON )
 #
 TEST_BIG_ENDIAN( BIG_ENDIAN )
 if( NOT DEFINED BIG_ENDIAN )
-	message( WARNING "unable to determine endianness, only LITTLE ENDIAN is supported" )
+	message( WARNING "unable to determine endianess, only LITTLE ENDIAN is supported" )
 elseif( BIG_ENDIAN )
 	message( FATAL_ERROR "bigendian is not supported" )
 endif()
@@ -309,17 +309,6 @@ if( ENABLE_EXTRA_DEBUG_CODE )
 endif()
 
 
-#
-# Enable EPOLL (default=OFF)
-# Only for Linux
-#
-option( ENABLE_EXTRA_SOCKET_POLL "enable SOCKET_EPOLL (default=OFF)" OFF )
-if( ENABLE_EXTRA_SOCKET_POLL )
-	set_property( CACHE GLOBAL_DEFINITIONS  PROPERTY VALUE "${GLOBAL_DEFINITIONS} -DSOCKET_EPOLL" )
-	message( STATUS "Enabled SOCKET_EPOLL" )
-endif()
-
-
 #
 # Enable builtin memory manager (default=default)
 #