Properly remove movement restriction

* Remove the movement restriction from Longing for Freedom when it becomes active with an Ensemble skill.

.github/workflows/analysis_codeql.yml

@@ -6,6 +6,7 @@ concurrency:
   cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
 
 on:
+  workflow_dispatch:
   push:
     branches:
       - master

.github/workflows/build_servers_clang.yml

@@ -6,6 +6,7 @@ concurrency:
   cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
 
 on:
+  workflow_dispatch:
   push:
     branches:
       - master

.github/workflows/build_servers_cmake.yml

@@ -6,6 +6,7 @@ concurrency:
   cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
 
 on:
+  workflow_dispatch:
   push:
     branches:
       - master
@@ -17,6 +18,8 @@ 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:

.github/workflows/build_servers_gcc.yml

@@ -6,6 +6,7 @@ concurrency:
   cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
 
 on:
+  workflow_dispatch:
   push:
     branches:
       - master

.github/workflows/build_servers_modes.yml

@@ -6,6 +6,7 @@ concurrency:
   cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
 
 on:
+  workflow_dispatch:
   push:
     branches:
       - master

.github/workflows/build_servers_msbuild.yml

@@ -6,6 +6,7 @@ concurrency:
   cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
 
 on:
+  workflow_dispatch:
   push:
     branches:
       - master

.github/workflows/build_servers_packetversions.yml

@@ -6,6 +6,7 @@ concurrency:
   cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
 
 on:
+  workflow_dispatch:
   push:
     branches:
       - master

.github/workflows/build_servers_vip.yml

@@ -6,6 +6,7 @@ concurrency:
   cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
 
 on:
+  workflow_dispatch:
   push:
     branches:
       - master

.github/workflows/npc_db_validation.yml

@@ -9,6 +9,7 @@ concurrency:
   cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
 
 on:
+  workflow_dispatch:
   push:
     branches:
       - master

3rdparty/README.txt

@@ -7,3 +7,4 @@ 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/yaml-cpp/CMakeLists.txt

@@ -21,6 +21,7 @@ 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"
@@ -30,6 +31,7 @@ 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"
@@ -46,6 +48,7 @@ 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"
@@ -81,3 +84,4 @@ 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++11
+CXXFLAG =-std=c++17 -DYAML_CPP_STATIC_DEFINE
 INC=-Iinclude
 
 @SET_MAKE@

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

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

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

@@ -19,9 +19,13 @@ 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_unownedData(data_), m_unownedSize(size_) {}
+      : m_data{}, 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; }
@@ -35,7 +39,7 @@ class YAML_CPP_API Binary {
       rhs.clear();
       rhs.resize(m_unownedSize);
       std::copy(m_unownedData, m_unownedData + m_unownedSize, rhs.begin());
-      m_unownedData = 0;
+      m_unownedData = nullptr;
       m_unownedSize = 0;
     } else {
       m_data.swap(rhs);
@@ -62,6 +66,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,6 +22,7 @@ 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);
@@ -34,6 +35,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,10 +15,12 @@ class Parser;
 
 // GraphBuilderInterface
 // . Abstraction of node creation
-// . pParentNode is always NULL or the return value of one of the NewXXX()
+// . pParentNode is always nullptr 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;
 
@@ -71,9 +73,9 @@ class GraphBuilder : public GraphBuilderInterface {
   typedef typename Impl::Map Map;
 
   GraphBuilder(Impl &impl) : m_impl(impl) {
-    Map *pMap = NULL;
-    Sequence *pSeq = NULL;
-    Node *pNode = NULL;
+    Map *pMap = nullptr;
+    Sequence *pSeq = nullptr;
+    Node *pNode = nullptr;
 
     // Type consistency checks
     pNode = pMap;

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

@@ -0,0 +1,77 @@
+#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,33 +1,61 @@
 #ifndef DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
-#if defined(_MSC_VER) ||                                            \
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
-#pragma once
+// Definition YAML_CPP_STATIC_DEFINE using to building YAML-CPP as static
+// library (definition created by CMake or defined manually)
+
+// Definition yaml_cpp_EXPORTS using to building YAML-CPP as dll/so library
+// (definition created by CMake or defined manually)
+
+#ifdef YAML_CPP_STATIC_DEFINE
+#  define YAML_CPP_API
+#  define YAML_CPP_NO_EXPORT
+#else
+#  if defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__)
+#    ifndef YAML_CPP_API
+#      ifdef yaml_cpp_EXPORTS
+         /* We are building this library */
+#        pragma message( "Defining YAML_CPP_API for DLL export" )
+#        define YAML_CPP_API __declspec(dllexport)
+#      else
+         /* We are using this library */
+#        pragma message( "Defining YAML_CPP_API for DLL import" )
+#        define YAML_CPP_API __declspec(dllimport)
+#      endif
+#    endif
+#    ifndef YAML_CPP_NO_EXPORT
+#      define YAML_CPP_NO_EXPORT
+#    endif
+#  else /* No _MSC_VER */
+#    ifndef YAML_CPP_API
+#      ifdef yaml_cpp_EXPORTS
+         /* We are building this library */
+#        define YAML_CPP_API __attribute__((visibility("default")))
+#      else
+         /* We are using this library */
+#        define YAML_CPP_API __attribute__((visibility("default")))
+#      endif
+#    endif
+#    ifndef YAML_CPP_NO_EXPORT
+#      define YAML_CPP_NO_EXPORT __attribute__((visibility("hidden")))
+#    endif
+#  endif /* _MSC_VER */
+#endif   /* YAML_CPP_STATIC_DEFINE */
+
+#ifndef YAML_CPP_DEPRECATED
+#  ifdef _MSC_VER
+#    define YAML_CPP_DEPRECATED __declspec(deprecated)
+#  else
+#    define YAML_CPP_DEPRECATED __attribute__ ((__deprecated__))
+#  endif
 #endif
 
-// The following ifdef block is the standard way of creating macros which make
-// exporting from a DLL simpler. All files within this DLL are compiled with the
-// yaml_cpp_EXPORTS symbol defined on the command line. This symbol should not
-// be defined on any project that uses this DLL. This way any other project
-// whose source files include this file see YAML_CPP_API functions as being
-// imported from a DLL, whereas this DLL sees symbols defined with this macro as
-// being exported.
-#undef YAML_CPP_API
+#ifndef YAML_CPP_DEPRECATED_EXPORT
+#  define YAML_CPP_DEPRECATED_EXPORT YAML_CPP_API YAML_CPP_DEPRECATED
+#endif
 
-#ifdef YAML_CPP_DLL      // Using or Building YAML-CPP DLL (definition defined
-                         // manually)
-#ifdef yaml_cpp_EXPORTS  // Building YAML-CPP DLL (definition created by CMake
-                         // or defined manually)
-//	#pragma message( "Defining YAML_CPP_API for DLL export" )
-#define YAML_CPP_API __declspec(dllexport)
-#else  // yaml_cpp_EXPORTS
-//	#pragma message( "Defining YAML_CPP_API for DLL import" )
-#define YAML_CPP_API __declspec(dllimport)
-#endif  // yaml_cpp_EXPORTS
-#else   // YAML_CPP_DLL
-#define YAML_CPP_API
-#endif  // YAML_CPP_DLL
+#ifndef YAML_CPP_DEPRECATED_NO_EXPORT
+#  define YAML_CPP_DEPRECATED_NO_EXPORT YAML_CPP_NO_EXPORT YAML_CPP_DEPRECATED
+#endif
 
-#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);
 
-  virtual void OnDocumentStart(const Mark& mark);
-  virtual void OnDocumentEnd();
+  void OnDocumentStart(const Mark& mark) override;
+  void OnDocumentEnd() override;
 
-  virtual void OnNull(const Mark& mark, anchor_t anchor);
-  virtual void OnAlias(const Mark& mark, anchor_t anchor);
-  virtual void OnScalar(const Mark& mark, const std::string& tag,
-                        anchor_t anchor, const std::string& value);
+  void OnNull(const Mark& mark, anchor_t anchor) override;
+  void OnAlias(const Mark& mark, anchor_t anchor) override;
+  void OnScalar(const Mark& mark, const std::string& tag,
+                        anchor_t anchor, const std::string& value) override;
 
-  virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
-                               anchor_t anchor, EmitterStyle::value style);
-  virtual void OnSequenceEnd();
+  void OnSequenceStart(const Mark& mark, const std::string& tag,
+                               anchor_t anchor, EmitterStyle::value style) override;
+  void OnSequenceEnd() override;
 
-  virtual void OnMapStart(const Mark& mark, const std::string& tag,
-                          anchor_t anchor, EmitterStyle::value style);
-  virtual void OnMapEnd();
+  void OnMapStart(const Mark& mark, const std::string& tag,
+                          anchor_t anchor, EmitterStyle::value style) override;
+  void OnMapEnd() override;
 
  private:
   void BeginNode();

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

@@ -7,16 +7,18 @@
 #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"
 
@@ -28,10 +30,12 @@ struct _Null;
 namespace YAML {
 class EmitterState;
 
-class YAML_CPP_API Emitter : private noncopyable {
+class YAML_CPP_API Emitter {
  public:
   Emitter();
   explicit Emitter(std::ostream& stream);
+  Emitter(const Emitter&) = delete;
+  Emitter& operator=(const Emitter&) = delete;
   ~Emitter();
 
   // output
@@ -55,6 +59,7 @@ class YAML_CPP_API Emitter : private noncopyable {
   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);
@@ -120,6 +125,7 @@ class YAML_CPP_API Emitter : private noncopyable {
   void SpaceOrIndentTo(bool requireSpace, std::size_t indent);
 
   const char* ComputeFullBoolName(bool b) const;
+  const char* ComputeNullName() const;
   bool CanEmitNewline() const;
 
  private:
@@ -153,7 +159,27 @@ inline Emitter& Emitter::WriteStreamable(T value) {
 
   std::stringstream stream;
   SetStreamablePrecision<T>(stream);
-  stream << value;
+
+  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();
@@ -250,6 +276,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,6 +27,12 @@ enum EMITTER_MANIP {
   DoubleQuoted,
   Literal,
 
+  // null manipulators
+  LowerNull,
+  UpperNull,
+  CamelNull,
+  TildeNull,
+
   // bool manipulators
   YesNoBool,      // yes, no
   TrueFalseBool,  // true, false
@@ -37,10 +43,6 @@ enum EMITTER_MANIP {
   LongBool,       // yes, On
   ShortBool,      // y, t
 
-  // null manipulators
-  NullAsTilde,     // ~
-  NullAsNull,     // null
-
   // int manipulators
   Dec,
   Hex,
@@ -79,14 +81,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 {
@@ -101,11 +103,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);
 }
 
@@ -113,7 +115,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);
 }
 
@@ -122,7 +124,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() {}
+  virtual ~EventHandler() = default;
 
   virtual void OnDocumentStart(const Mark& mark) = 0;
   virtual void OnDocumentEnd() = 0;
@@ -34,7 +34,12 @@ 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,19 +7,8 @@
 #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>
@@ -76,7 +65,7 @@ const char* const ZERO_INDENT_IN_BLOCK =
 const char* const CHAR_IN_BLOCK = "unexpected character in block scalar";
 const char* const AMBIGUOUS_ANCHOR =
     "cannot assign the same alias to multiple nodes";
-const char* const UNKNOWN_ANCHOR = "the referenced anchor is not defined";
+const char* const UNKNOWN_ANCHOR = "the referenced anchor is not defined: ";
 
 const char* const INVALID_NODE =
     "invalid node; this may result from using a map iterator as a sequence "
@@ -111,6 +100,12 @@ 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) {
@@ -118,13 +113,48 @@ 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_) {}
-  virtual ~Exception() NOEXCEPT;
+  ~Exception() YAML_CPP_NOEXCEPT override;
 
   Exception(const Exception&) = default;
 
@@ -135,7 +165,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.c_str();
+      return msg;
     }
 
     std::stringstream output;
@@ -150,7 +180,7 @@ class YAML_CPP_API ParserException : public Exception {
   ParserException(const Mark& mark_, const std::string& msg_)
       : Exception(mark_, msg_) {}
   ParserException(const ParserException&) = default;
-  virtual ~ParserException() NOEXCEPT;
+  ~ParserException() YAML_CPP_NOEXCEPT override;
 };
 
 class YAML_CPP_API RepresentationException : public Exception {
@@ -158,7 +188,7 @@ class YAML_CPP_API RepresentationException : public Exception {
   RepresentationException(const Mark& mark_, const std::string& msg_)
       : Exception(mark_, msg_) {}
   RepresentationException(const RepresentationException&) = default;
-  virtual ~RepresentationException() NOEXCEPT;
+  ~RepresentationException() YAML_CPP_NOEXCEPT override;
 };
 
 // representation exceptions
@@ -167,7 +197,7 @@ class YAML_CPP_API InvalidScalar : public RepresentationException {
   InvalidScalar(const Mark& mark_)
       : RepresentationException(mark_, ErrorMsg::INVALID_SCALAR) {}
   InvalidScalar(const InvalidScalar&) = default;
-  virtual ~InvalidScalar() NOEXCEPT;
+  ~InvalidScalar() YAML_CPP_NOEXCEPT override;
 };
 
 class YAML_CPP_API KeyNotFound : public RepresentationException {
@@ -177,7 +207,7 @@ class YAML_CPP_API KeyNotFound : public RepresentationException {
       : RepresentationException(mark_, ErrorMsg::KEY_NOT_FOUND_WITH_KEY(key_)) {
   }
   KeyNotFound(const KeyNotFound&) = default;
-  virtual ~KeyNotFound() NOEXCEPT;
+  ~KeyNotFound() YAML_CPP_NOEXCEPT override;
 };
 
 template <typename T>
@@ -185,7 +215,7 @@ class YAML_CPP_API TypedKeyNotFound : public KeyNotFound {
  public:
   TypedKeyNotFound(const Mark& mark_, const T& key_)
       : KeyNotFound(mark_, key_), key(key_) {}
-  virtual ~TypedKeyNotFound() NOEXCEPT {}
+  ~TypedKeyNotFound() YAML_CPP_NOEXCEPT override = default;
 
   T key;
 };
@@ -198,10 +228,11 @@ inline TypedKeyNotFound<T> MakeTypedKeyNotFound(const Mark& mark,
 
 class YAML_CPP_API InvalidNode : public RepresentationException {
  public:
-  InvalidNode()
-      : RepresentationException(Mark::null_mark(), ErrorMsg::INVALID_NODE) {}
+  InvalidNode(const std::string& key)
+      : RepresentationException(Mark::null_mark(),
+                                ErrorMsg::INVALID_NODE_WITH_KEY(key)) {}
   InvalidNode(const InvalidNode&) = default;
-  virtual ~InvalidNode() NOEXCEPT;
+  ~InvalidNode() YAML_CPP_NOEXCEPT override;
 };
 
 class YAML_CPP_API BadConversion : public RepresentationException {
@@ -209,7 +240,7 @@ class YAML_CPP_API BadConversion : public RepresentationException {
   explicit BadConversion(const Mark& mark_)
       : RepresentationException(mark_, ErrorMsg::BAD_CONVERSION) {}
   BadConversion(const BadConversion&) = default;
-  virtual ~BadConversion() NOEXCEPT;
+  ~BadConversion() YAML_CPP_NOEXCEPT override;
 };
 
 template <typename T>
@@ -223,15 +254,16 @@ class YAML_CPP_API BadDereference : public RepresentationException {
   BadDereference()
       : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_DEREFERENCE) {}
   BadDereference(const BadDereference&) = default;
-  virtual ~BadDereference() NOEXCEPT;
+  ~BadDereference() YAML_CPP_NOEXCEPT override;
 };
 
 class YAML_CPP_API BadSubscript : public RepresentationException {
  public:
-  BadSubscript()
-      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_SUBSCRIPT) {}
+  template <typename Key>
+  BadSubscript(const Mark& mark_, const Key& key)
+      : RepresentationException(mark_, ErrorMsg::BAD_SUBSCRIPT_WITH_KEY(key)) {}
   BadSubscript(const BadSubscript&) = default;
-  virtual ~BadSubscript() NOEXCEPT;
+  ~BadSubscript() YAML_CPP_NOEXCEPT override;
 };
 
 class YAML_CPP_API BadPushback : public RepresentationException {
@@ -239,7 +271,7 @@ class YAML_CPP_API BadPushback : public RepresentationException {
   BadPushback()
       : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_PUSHBACK) {}
   BadPushback(const BadPushback&) = default;
-  virtual ~BadPushback() NOEXCEPT;
+  ~BadPushback() YAML_CPP_NOEXCEPT override;
 };
 
 class YAML_CPP_API BadInsert : public RepresentationException {
@@ -247,7 +279,7 @@ class YAML_CPP_API BadInsert : public RepresentationException {
   BadInsert()
       : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_INSERT) {}
   BadInsert(const BadInsert&) = default;
-  virtual ~BadInsert() NOEXCEPT;
+  ~BadInsert() YAML_CPP_NOEXCEPT override;
 };
 
 class YAML_CPP_API EmitterException : public Exception {
@@ -255,15 +287,17 @@ class YAML_CPP_API EmitterException : public Exception {
   EmitterException(const std::string& msg_)
       : Exception(Mark::null_mark(), msg_) {}
   EmitterException(const EmitterException&) = default;
-  virtual ~EmitterException() NOEXCEPT;
+  ~EmitterException() YAML_CPP_NOEXCEPT override;
 };
 
 class YAML_CPP_API BadFile : public Exception {
  public:
-  BadFile() : Exception(Mark::null_mark(), ErrorMsg::BAD_FILE) {}
+  explicit BadFile(const std::string& filename)
+      : Exception(Mark::null_mark(),
+                  std::string(ErrorMsg::BAD_FILE) + ": " + filename) {}
   BadFile(const BadFile&) = default;
-  virtual ~BadFile() NOEXCEPT;
+  ~BadFile() YAML_CPP_NOEXCEPT override;
 };
-}
+}  // namespace YAML
 
 #endif  // EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66

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

@@ -8,10 +8,14 @@
 #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"
@@ -21,6 +25,7 @@
 #include "yaml-cpp/node/type.h"
 #include "yaml-cpp/null.h"
 
+
 namespace YAML {
 class Binary;
 struct _Null;
@@ -71,12 +76,17 @@ 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<const char[N]> {
-  static Node encode(const char(&rhs)[N]) { return Node(rhs); }
+struct convert<char[N]> {
+  static Node encode(const char* rhs) { return Node(rhs); }
 };
 
 template <>
@@ -88,42 +98,98 @@ struct convert<_Null> {
   }
 };
 
-#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>::digits10 + 1);         \
-      stream << rhs;                                                     \
-      return Node(stream.str());                                         \
-    }                                                                    \
-                                                                         \
-    static bool decode(const Node& node, type& rhs) {                    \
-      if (node.Type() != NodeType::Scalar)                               \
-        return false;                                                    \
-      const std::string& input = node.Scalar();                          \
-      std::stringstream stream(input);                                   \
-      stream.unsetf(std::ios::dec);                                      \
-      if ((stream >> std::noskipws >> rhs) && (stream >> std::ws).eof()) \
-        return true;                                                     \
-      if (std::numeric_limits<type>::has_infinity) {                     \
-        if (conversion::IsInfinity(input)) {                             \
-          rhs = std::numeric_limits<type>::infinity();                   \
-          return true;                                                   \
-        } else if (conversion::IsNegativeInfinity(input)) {              \
-          rhs = negative_op std::numeric_limits<type>::infinity();       \
-          return true;                                                   \
-        }                                                                \
-      }                                                                  \
-                                                                         \
-      if (std::numeric_limits<type>::has_quiet_NaN &&                    \
-          conversion::IsNaN(input)) {                                    \
-        rhs = std::numeric_limits<type>::quiet_NaN();                    \
-        return true;                                                     \
-      }                                                                  \
-                                                                         \
-      return false;                                                      \
-    }                                                                    \
+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);           \
+      conversion::inner_encode(rhs, stream);                               \
+      return Node(stream.str());                                           \
+    }                                                                      \
+                                                                           \
+    static bool decode(const Node& node, type& rhs) {                      \
+      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) {       \
+        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();                     \
+          return true;                                                     \
+        } else if (conversion::IsNegativeInfinity(input)) {                \
+          rhs = negative_op std::numeric_limits<type>::infinity();         \
+          return true;                                                     \
+        }                                                                  \
+      }                                                                    \
+                                                                           \
+      if (std::numeric_limits<type>::has_quiet_NaN) {                      \
+        if (conversion::IsNaN(input)) {                                    \
+          rhs = std::numeric_limits<type>::quiet_NaN();                    \
+          return true;                                                     \
+        }                                                                  \
+      }                                                                    \
+                                                                           \
+      return false;                                                        \
+    }                                                                      \
   }
 
 #define YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(type) \
@@ -162,81 +228,104 @@ struct convert<bool> {
 };
 
 // std::map
-template <typename K, typename V>
-struct convert<std::map<K, V>> {
-  static Node encode(const std::map<K, V>& rhs) {
+template <typename K, typename V, typename C, typename A>
+struct convert<std::map<K, V, C, A>> {
+  static Node encode(const std::map<K, V, C, A>& rhs) {
     Node node(NodeType::Map);
-    for (typename std::map<K, V>::const_iterator it = rhs.begin();
-         it != rhs.end(); ++it)
-      node.force_insert(it->first, it->second);
+    for (const auto& element : rhs)
+      node.force_insert(element.first, element.second);
     return node;
   }
 
-  static bool decode(const Node& node, std::map<K, V>& rhs) {
+  static bool decode(const Node& node, std::map<K, V, C, A>& rhs) {
     if (!node.IsMap())
       return false;
 
     rhs.clear();
-    for (const_iterator it = node.begin(); it != node.end(); ++it)
+    for (const auto& element : node)
 #if defined(__GNUC__) && __GNUC__ < 4
       // workaround for GCC 3:
-      rhs[it->first.template as<K>()] = it->second.template as<V>();
+      rhs[element.first.template as<K>()] = element.second.template as<V>();
 #else
-      rhs[it->first.as<K>()] = it->second.as<V>();
+      rhs[element.first.as<K>()] = element.second.as<V>();
+#endif
+    return true;
+  }
+};
+
+// std::unordered_map
+template <typename K, typename V, typename H, typename P, typename A>
+struct convert<std::unordered_map<K, V, H, P, A>> {
+  static Node encode(const std::unordered_map<K, V, H, P, A>& rhs) {
+    Node node(NodeType::Map);
+    for (const auto& element : rhs)
+      node.force_insert(element.first, element.second);
+    return node;
+  }
+
+  static bool decode(const Node& node, std::unordered_map<K, V, H, P, A>& rhs) {
+    if (!node.IsMap())
+      return false;
+
+    rhs.clear();
+    for (const auto& element : node)
+#if defined(__GNUC__) && __GNUC__ < 4
+      // workaround for GCC 3:
+      rhs[element.first.template as<K>()] = element.second.template as<V>();
+#else
+      rhs[element.first.as<K>()] = element.second.as<V>();
 #endif
     return true;
   }
 };
 
 // std::vector
-template <typename T>
-struct convert<std::vector<T>> {
-  static Node encode(const std::vector<T>& rhs) {
+template <typename T, typename A>
+struct convert<std::vector<T, A>> {
+  static Node encode(const std::vector<T, A>& rhs) {
     Node node(NodeType::Sequence);
-    for (typename std::vector<T>::const_iterator it = rhs.begin();
-         it != rhs.end(); ++it)
-      node.push_back(*it);
+    for (const auto& element : rhs)
+      node.push_back(element);
     return node;
   }
 
-  static bool decode(const Node& node, std::vector<T>& rhs) {
+  static bool decode(const Node& node, std::vector<T, A>& rhs) {
     if (!node.IsSequence())
       return false;
 
     rhs.clear();
-    for (const_iterator it = node.begin(); it != node.end(); ++it)
+    for (const auto& element : node)
 #if defined(__GNUC__) && __GNUC__ < 4
       // workaround for GCC 3:
-      rhs.push_back(it->template as<T>());
+      rhs.push_back(element.template as<T>());
 #else
-      rhs.push_back(it->as<T>());
+      rhs.push_back(element.as<T>());
 #endif
     return true;
   }
 };
 
 // std::list
-template <typename T>
-struct convert<std::list<T>> {
-  static Node encode(const std::list<T>& rhs) {
+template <typename T, typename A>
+struct convert<std::list<T,A>> {
+  static Node encode(const std::list<T,A>& rhs) {
     Node node(NodeType::Sequence);
-    for (typename std::list<T>::const_iterator it = rhs.begin();
-         it != rhs.end(); ++it)
-      node.push_back(*it);
+    for (const auto& element : rhs)
+      node.push_back(element);
     return node;
   }
 
-  static bool decode(const Node& node, std::list<T>& rhs) {
+  static bool decode(const Node& node, std::list<T,A>& rhs) {
     if (!node.IsSequence())
       return false;
 
     rhs.clear();
-    for (const_iterator it = node.begin(); it != node.end(); ++it)
+    for (const auto& element : node)
 #if defined(__GNUC__) && __GNUC__ < 4
       // workaround for GCC 3:
-      rhs.push_back(it->template as<T>());
+      rhs.push_back(element.template as<T>());
 #else
-      rhs.push_back(it->as<T>());
+      rhs.push_back(element.as<T>());
 #endif
     return true;
   }
@@ -275,6 +364,37 @@ 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,6 +9,8 @@
 
 #include "yaml-cpp/node/detail/node.h"
 #include "yaml-cpp/node/detail/node_data.h"
+
+#include <algorithm>
 #include <type_traits>
 
 namespace YAML {
@@ -17,7 +19,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 0;
+    return nullptr;
   }
 };
 
@@ -27,13 +29,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] : 0;
+    return key < sequence.size() ? sequence[key] : nullptr;
   }
 
   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()))
-      return 0;
+    if (key > sequence.size() || (key > 0 && !sequence[key - 1]->is_defined()))
+      return nullptr;
     if (key == sequence.size())
       sequence.push_back(&pMemory->create_node());
     return sequence[key];
@@ -46,13 +48,51 @@ 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)
-                    : 0;
+                    : nullptr;
   }
   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)
-                    : 0;
+                    : nullptr;
+  }
+};
+
+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;
   }
 };
 
@@ -66,7 +106,11 @@ inline bool node::equals(const T& rhs, shared_memory_holder pMemory) {
 }
 
 inline bool node::equals(const char* rhs, shared_memory_holder pMemory) {
-  return equals<std::string>(rhs, pMemory);
+  std::string lhs;
+  if (convert<std::string>::decode(Node(*this, std::move(pMemory)), lhs)) {
+    return lhs == rhs;
+  }
+  return false;
 }
 
 // indexing
@@ -78,22 +122,20 @@ inline node* node_data::get(const Key& key,
       break;
     case NodeType::Undefined:
     case NodeType::Null:
-      return NULL;
+      return nullptr;
     case NodeType::Sequence:
       if (node* pNode = get_idx<Key>::get(m_sequence, key, pMemory))
         return pNode;
-      return NULL;
+      return nullptr;
     case NodeType::Scalar:
-      throw BadSubscript();
+      throw BadSubscript(m_mark, key);
   }
 
-  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
-    if (it->first->equals(key, pMemory)) {
-      return it->second;
-    }
-  }
+  auto it = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) {
+    return m.first->equals(key, pMemory);
+  });
 
-  return NULL;
+  return it != m_map.end() ? it->second : nullptr;
 }
 
 template <typename Key>
@@ -112,13 +154,15 @@ inline node& node_data::get(const Key& key, shared_memory_holder pMemory) {
       convert_to_map(pMemory);
       break;
     case NodeType::Scalar:
-      throw BadSubscript();
+      throw BadSubscript(m_mark, key);
   }
 
-  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
-    if (it->first->equals(key, pMemory)) {
-      return *it->second;
-    }
+  auto it = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) {
+    return m.first->equals(key, pMemory);
+  });
+
+  if (it != m_map.end()) {
+    return *it->second;
   }
 
   node& k = convert_to_node(key, pMemory);
@@ -129,20 +173,26 @@ 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::Map)
-    return false;
-
-  for (kv_pairs::iterator it = m_undefinedPairs.begin();
-       it != m_undefinedPairs.end();) {
-    kv_pairs::iterator jt = std::next(it);
-    if (it->first->equals(key, pMemory))
-      m_undefinedPairs.erase(it);
-    it = jt;
+  if (m_type == NodeType::Sequence) {
+    return remove_idx<Key>::remove(m_sequence, key, m_seqSize);
   }
 
-  for (node_map::iterator it = m_map.begin(); it != m_map.end(); ++it) {
-    if (it->first->equals(key, pMemory)) {
-      m_map.erase(it);
+  if (m_type == NodeType::Map) {
+    kv_pairs::iterator it = m_undefinedPairs.begin();
+    while (it != m_undefinedPairs.end()) {
+      kv_pairs::iterator jt = std::next(it);
+      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) {
+      return m.first->equals(key, pMemory);
+    });
+
+    if (iter != m_map.end()) {
+      m_map.erase(iter);
       return true;
     }
   }

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

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

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

@@ -22,11 +22,12 @@ namespace YAML {
 namespace detail {
 class YAML_CPP_API memory {
  public:
+  memory() : m_nodes{} {}
   node& create_node();
   void merge(const memory& rhs);
 
  private:
-  typedef std::set<shared_node> Nodes;
+  using Nodes = std::set<shared_node>;
   Nodes m_nodes;
 };
 
@@ -40,7 +41,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,18 +7,24 @@
 #pragma once
 #endif
 
-#include "yaml-cpp/emitterstyle.h"
 #include "yaml-cpp/dll.h"
-#include "yaml-cpp/node/type.h"
-#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/emitterstyle.h"
 #include "yaml-cpp/node/detail/node_ref.h"
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/type.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) {}
+  node() : m_pRef(new node_ref), m_dependencies{}, m_index{} {}
   node(const node&) = delete;
   node& operator=(const node&) = delete;
 
@@ -42,9 +48,8 @@ class node {
       return;
 
     m_pRef->mark_defined();
-    for (nodes::iterator it = m_dependencies.begin();
-         it != m_dependencies.end(); ++it)
-      (*it)->mark_defined();
+    for (node* dependency : m_dependencies)
+      dependency->mark_defined();
     m_dependencies.clear();
   }
 
@@ -109,6 +114,7 @@ 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);
@@ -120,7 +126,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 NULL (if there is no such
+    // it, and returns a pointer so that it can be nullptr (if there is no such
     // key).
     return static_cast<const node_ref&>(*m_pRef).get(key, pMemory);
   }
@@ -137,7 +143,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 NULL (if there is no such
+    // it, and returns a pointer so that it can be nullptr (if there is no such
     // key).
     return static_cast<const node_ref&>(*m_pRef).get(key, pMemory);
   }
@@ -160,10 +166,12 @@ class node {
 
  private:
   shared_node_ref m_pRef;
-  typedef std::set<node*> nodes;
+  using nodes = std::set<node*, less>;
   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, shared_memory_holder pMemory);
-  void insert(node& key, node& value, shared_memory_holder pMemory);
+  void push_back(node& node, const shared_memory_holder& pMemory);
+  void insert(node& key, node& value, const 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, shared_memory_holder pMemory) const;
-  node& get(node& key, shared_memory_holder pMemory);
-  bool remove(node& key, shared_memory_holder pMemory);
+  node* get(node& key, const shared_memory_holder& pMemory) const;
+  node& get(node& key, const shared_memory_holder& pMemory);
+  bool remove(node& key, const shared_memory_holder& pMemory);
 
   // map
   template <typename Key, typename Value>
@@ -81,7 +81,7 @@ class YAML_CPP_API node_data {
                     shared_memory_holder pMemory);
 
  public:
-  static std::string empty_scalar;
+  static const 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(shared_memory_holder pMemory);
-  void convert_sequence_to_map(shared_memory_holder pMemory);
+  void convert_to_map(const shared_memory_holder& pMemory);
+  void convert_sequence_to_map(const 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
-  typedef std::vector<node*> node_seq;
+  using node_seq = std::vector<node *>;
   node_seq m_sequence;
 
   mutable std::size_t m_seqSize;
 
   // map
-  typedef std::vector<std::pair<node*, node*>> node_map;
+  using node_map = std::vector<std::pair<node*, node*>>;
   node_map m_map;
 
-  typedef std::pair<node*, node*> kv_pair;
-  typedef std::list<kv_pair> kv_pairs;
+  using kv_pair = std::pair<node*, node*>;
+  using kv_pairs = std::list<kv_pair>;
   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 { None, Sequence, Map };
+  enum value { NoneType, Sequence, Map };
 };
 
 template <typename V>
 struct node_iterator_value : public std::pair<V*, V*> {
-  typedef std::pair<V*, V*> kv;
+  using kv = std::pair<V*, V*>;
 
-  node_iterator_value() : kv(), pNode(0) {}
+  node_iterator_value() : kv(), pNode(nullptr) {}
   explicit node_iterator_value(V& rhs) : kv(), pNode(&rhs) {}
-  explicit node_iterator_value(V& key, V& value) : kv(&key, &value), pNode(0) {}
+  explicit node_iterator_value(V& key, V& value) : kv(&key, &value), pNode(nullptr) {}
 
   V& operator*() const { return *pNode; }
   V& operator->() const { return *pNode; }
@@ -36,26 +36,23 @@ struct node_iterator_value : public std::pair<V*, V*> {
   V* pNode;
 };
 
-typedef std::vector<node*> node_seq;
-typedef std::vector<std::pair<node*, node*>> node_map;
+using node_seq = std::vector<node *>;
+using node_map = std::vector<std::pair<node*, node*>>;
 
 template <typename V>
 struct node_iterator_type {
-  typedef node_seq::iterator seq;
-  typedef node_map::iterator map;
+  using seq = node_seq::iterator;
+  using map = node_map::iterator;
 };
 
 template <typename V>
 struct node_iterator_type<const V> {
-  typedef node_seq::const_iterator seq;
-  typedef node_map::const_iterator map;
+  using seq = node_seq::const_iterator;
+  using map = node_map::const_iterator;
 };
 
 template <typename V>
-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>> {
+class node_iterator_base {
  private:
   struct enabler {};
 
@@ -68,12 +65,16 @@ class node_iterator_base
   };
 
  public:
-  typedef typename node_iterator_type<V>::seq SeqIter;
-  typedef typename node_iterator_type<V>::map MapIter;
-  typedef node_iterator_value<V> value_type;
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = node_iterator_value<V>;
+  using difference_type = std::ptrdiff_t;
+  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::None), m_seqIt(), m_mapIt(), m_mapEnd() {}
+      : m_type(iterator_type::NoneType), m_seqIt(), m_mapIt(), m_mapEnd() {}
   explicit node_iterator_base(SeqIter seqIt)
       : m_type(iterator_type::Sequence),
         m_seqIt(seqIt),
@@ -105,7 +106,7 @@ class node_iterator_base
       return false;
 
     switch (m_type) {
-      case iterator_type::None:
+      case iterator_type::NoneType:
         return true;
       case iterator_type::Sequence:
         return m_seqIt == rhs.m_seqIt;
@@ -122,7 +123,7 @@ class node_iterator_base
 
   node_iterator_base<V>& operator++() {
     switch (m_type) {
-      case iterator_type::None:
+      case iterator_type::NoneType:
         break;
       case iterator_type::Sequence:
         ++m_seqIt;
@@ -143,7 +144,7 @@ class node_iterator_base
 
   value_type operator*() const {
     switch (m_type) {
-      case iterator_type::None:
+      case iterator_type::NoneType:
         return value_type();
       case iterator_type::Sequence:
         return value_type(**m_seqIt);
@@ -172,8 +173,8 @@ class node_iterator_base
   MapIter m_mapIt, m_mapEnd;
 };
 
-typedef node_iterator_base<node> node_iterator;
-typedef node_iterator_base<const node> const_node_iterator;
+using node_iterator = node_iterator_base<node>;
+using const_node_iterator = node_iterator_base<const node>;
 }
 }
 

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

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

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

@@ -0,0 +1,18 @@
+#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,6 +17,10 @@ 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);
@@ -26,7 +30,7 @@ class YAML_CPP_API ostream_wrapper {
 
   const char* str() const {
     if (m_pStream) {
-      return 0;
+      return nullptr;
     } else {
       m_buffer[m_pos] = '\0';
       return &m_buffer[0];
@@ -52,7 +56,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;
 }
@@ -67,6 +71,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,7 +11,6 @@
 #include <memory>
 
 #include "yaml-cpp/dll.h"
-#include "yaml-cpp/noncopyable.h"
 
 namespace YAML {
 class EventHandler;
@@ -24,11 +23,16 @@ 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 : private noncopyable {
+class YAML_CPP_API Parser {
  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.
@@ -81,6 +85,6 @@ class YAML_CPP_API Parser : private noncopyable {
   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 (typename Seq::const_iterator it = seq.begin(); it != seq.end(); ++it)
-    emitter << *it;
+  for (const auto& v : seq)
+    emitter << v;
   emitter << EndSeq;
   return emitter;
 }
@@ -39,10 +39,9 @@ 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 (typename map::const_iterator it = m.begin(); it != m.end(); ++it)
-    emitter << Key << it->first << Value << it->second;
+  for (const auto& v : m)
+    emitter << Key << v.first << Value << v.second;
   emitter << EndMap;
   return emitter;
 }

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

@@ -7,6 +7,11 @@
 #pragma once
 #endif
 
+#include <type_traits>
+#include <utility>
+#include <string>
+#include <sstream>
+
 namespace YAML {
 template <typename>
 struct is_numeric {
@@ -79,7 +84,7 @@ struct is_numeric<long double> {
 
 template <bool, class T = void>
 struct enable_if_c {
-  typedef T type;
+  using type = T;
 };
 
 template <class T>
@@ -90,7 +95,7 @@ struct enable_if : public enable_if_c<Cond::value, T> {};
 
 template <bool, class T = void>
 struct disable_if_c {
-  typedef T type;
+  using type = T;
 };
 
 template <class T>
@@ -100,4 +105,31 @@ 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,5 +1,7 @@
 #include "yaml-cpp/binary.h"
 
+#include <cctype>
+
 namespace YAML {
 static const char encoding[] =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -64,7 +66,7 @@ static const unsigned char decoding[] = {
 };
 
 std::vector<unsigned char> DecodeBase64(const std::string &input) {
-  typedef std::vector<unsigned char> ret_type;
+  using ret_type = std::vector<unsigned char>;
   if (input.empty())
     return ret_type();
 
@@ -72,22 +74,27 @@ std::vector<unsigned char> DecodeBase64(const std::string &input) {
   unsigned char *out = &ret[0];
 
   unsigned value = 0;
-  for (std::size_t i = 0; i < input.size(); i++) {
-    unsigned char d = decoding[static_cast<unsigned>(input[i])];
+  for (std::size_t i = 0, cnt = 0; i < input.size(); i++) {
+    if (std::isspace(static_cast<unsigned char>(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 (i % 4 == 3) {
+    if (cnt % 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 <stack>
 #include <cassert>
+#include <stack>
 
 namespace YAML {
 struct CollectionType {
@@ -17,6 +17,7 @@ struct CollectionType {
 
 class CollectionStack {
  public:
+  CollectionStack() : collectionStack{} {}
   CollectionType::value GetCurCollectionType() const {
     if (collectionStack.empty())
       return CollectionType::NoCollection;
@@ -28,12 +29,13 @@ 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,8 +10,7 @@ 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 = NULL;
+  m_pKeyNode = nullptr;
   RegisterAnchor(anchor, pNode);
 }
 
@@ -62,7 +62,7 @@ void GraphBuilderAdapter::OnMapEnd() {
 
 void *GraphBuilderAdapter::GetCurrentParent() const {
   if (m_containers.empty()) {
-    return NULL;
+    return nullptr;
   }
   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 = NULL;
+      m_pKeyNode = nullptr;
     } 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,7 +13,6 @@
 
 #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"
 
@@ -26,7 +25,15 @@ namespace YAML {
 class GraphBuilderAdapter : public EventHandler {
  public:
   GraphBuilderAdapter(GraphBuilderInterface& builder)
-      : m_builder(builder), m_pRootNode(NULL), m_pKeyNode(NULL) {}
+      : m_builder(builder),
+        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() {}
@@ -50,8 +57,8 @@ class GraphBuilderAdapter : public EventHandler {
   struct ContainerFrame {
     ContainerFrame(void* pSequence)
         : pContainer(pSequence), pPrevKeyNode(&sequenceMarker) {}
-    ContainerFrame(void* pMap, void* pPrevKeyNode_)
-        : pContainer(pMap), pPrevKeyNode(pPrevKeyNode_) {}
+    ContainerFrame(void* pMap, void* pPreviousKeyNode)
+        : pContainer(pMap), pPrevKeyNode(pPreviousKeyNode) {}
 
     void* pContainer;
     void* pPrevKeyNode;
@@ -74,6 +81,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

@@ -0,0 +1,32 @@
+<?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

@@ -0,0 +1,9 @@
+# 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,11 +16,7 @@ std::string tolower(const std::string& str) {
 
 template <typename T>
 bool IsEntirely(const std::string& str, T func) {
-  for (std::size_t i = 0; i < str.size(); i++)
-    if (!func(str[i]))
-      return false;
-
-  return true;
+  return std::all_of(str.begin(), str.end(), [=](char ch) { return func(ch); });
 }
 
 // IsFlexibleCase
@@ -39,7 +35,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) {
@@ -52,19 +48,22 @@ bool convert<bool>::decode(const Node& node, bool& rhs) {
   static const struct {
     std::string truename, falsename;
   } names[] = {
-      {"y", "n"}, {"yes", "no"}, {"true", "false"}, {"on", "off"},
+      {"y", "n"},
+      {"yes", "no"},
+      {"true", "false"},
+      {"on", "off"},
   };
 
   if (!IsFlexibleCase(node.Scalar()))
     return false;
 
-  for (unsigned i = 0; i < sizeof(names) / sizeof(names[0]); i++) {
-    if (names[i].truename == tolower(node.Scalar())) {
+  for (const auto& name : names) {
+    if (name.truename == tolower(node.Scalar())) {
       rhs = true;
       return true;
     }
 
-    if (names[i].falsename == tolower(node.Scalar())) {
+    if (name.falsename == tolower(node.Scalar())) {
       rhs = false;
       return true;
     }
@@ -72,4 +71,4 @@ bool convert<bool>::decode(const Node& node, bool& rhs) {
 
   return false;
 }
-}
+}  // namespace YAML

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

@@ -0,0 +1,9 @@
+#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,16 +1,11 @@
 #include "directives.h"
 
 namespace YAML {
-Directives::Directives() {
-  // version
-  version.isDefault = true;
-  version.major = 1;
-  version.minor = 2;
-}
+Directives::Directives() : version{true, 1, 2}, tags{} {}
 
-const std::string Directives::TranslateTagHandle(
+std::string Directives::TranslateTagHandle(
     const std::string& handle) const {
-  std::map<std::string, std::string>::const_iterator it = tags.find(handle);
+  auto it = tags.find(handle);
   if (it == tags.end()) {
     if (handle == "!!")
       return "tag:yaml.org,2002:";
@@ -19,4 +14,4 @@ const std::string Directives::TranslateTagHandle(
 
   return it->second;
 }
-}
+}  // namespace YAML

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

@@ -19,7 +19,7 @@ struct Version {
 struct Directives {
   Directives();
 
-  const std::string TranslateTagHandle(const std::string& handle) 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,10 +16,11 @@ std::string ToString(YAML::anchor_t anchor) {
   stream << anchor;
   return stream.str();
 }
-}
+}  // namespace
 
 namespace YAML {
-EmitFromEvents::EmitFromEvents(Emitter& emitter) : m_emitter(emitter) {}
+EmitFromEvents::EmitFromEvents(Emitter& emitter)
+    : m_emitter(emitter), m_stateStack{} {}
 
 void EmitFromEvents::OnDocumentStart(const Mark&) {}
 
@@ -58,6 +59,8 @@ 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);
 }
@@ -82,6 +85,8 @@ 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);
 }
@@ -116,4 +121,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) {}
+Emitter::Emitter() : m_pState(new EmitterState), m_stream{} {}
 
 Emitter::Emitter(std::ostream& stream)
     : m_pState(new EmitterState), m_stream(stream) {}
 
-Emitter::~Emitter() {}
+Emitter::~Emitter() = default;
 
 const char* Emitter::c_str() const { return m_stream.str(); }
 
@@ -90,6 +90,10 @@ 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) {
@@ -201,6 +205,7 @@ void Emitter::EmitBeginSeq() {
 void Emitter::EmitEndSeq() {
   if (!good())
     return;
+  FlowType::value originalType = m_pState->CurGroupFlowType();
 
   if (m_pState->CurGroupChildCount() == 0)
     m_pState->ForceFlow();
@@ -209,8 +214,12 @@ void Emitter::EmitEndSeq() {
     if (m_stream.comment())
       m_stream << "\n";
     m_stream << IndentTo(m_pState->CurIndent());
-    if (m_pState->CurGroupChildCount() == 0)
+    if (originalType == FlowType::Block) {
       m_stream << "[";
+    } else {
+      if (m_pState->CurGroupChildCount() == 0 && !m_pState->HasBegunNode())
+        m_stream << "[";
+    }
     m_stream << "]";
   }
 
@@ -231,6 +240,7 @@ void Emitter::EmitBeginMap() {
 void Emitter::EmitEndMap() {
   if (!good())
     return;
+  FlowType::value originalType = m_pState->CurGroupFlowType();
 
   if (m_pState->CurGroupChildCount() == 0)
     m_pState->ForceFlow();
@@ -239,8 +249,12 @@ void Emitter::EmitEndMap() {
     if (m_stream.comment())
       m_stream << "\n";
     m_stream << IndentTo(m_pState->CurIndent());
-    if (m_pState->CurGroupChildCount() == 0)
+    if (originalType == FlowType::Block) {
       m_stream << "{";
+    } else {
+      if (m_pState->CurGroupChildCount() == 0 && !m_pState->HasBegunNode())
+        m_stream << "{";
+    }
     m_stream << "}";
   }
 
@@ -289,10 +303,8 @@ void Emitter::PrepareTopNode(EmitterNodeType::value child) {
   if (child == EmitterNodeType::NoType)
     return;
 
-  if (m_pState->CurGroupChildCount() > 0 && m_stream.col() > 0) {
-    if (child != EmitterNodeType::NoType)
-      EmitBeginDoc();
-  }
+  if (m_pState->CurGroupChildCount() > 0 && m_stream.col() > 0)
+    EmitBeginDoc();
 
   switch (child) {
     case EmitterNodeType::NoType:
@@ -492,6 +504,9 @@ 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 << ":";
   }
 
@@ -518,7 +533,8 @@ 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())
@@ -562,6 +578,8 @@ void Emitter::BlockMapPrepareLongKey(EmitterNodeType::value child) {
       break;
     case EmitterNodeType::BlockSeq:
     case EmitterNodeType::BlockMap:
+      if (m_pState->HasBegunContent())
+        m_stream << "\n";
       break;
   }
 }
@@ -585,8 +603,12 @@ 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;
   }
@@ -625,6 +647,9 @@ 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 << ":";
   }
 
@@ -678,25 +703,29 @@ 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 = StringEscaping::None;
-  switch (m_pState->GetOutputCharset()) {
-    case EscapeNonAscii:
-      stringEscaping = StringEscaping::NonAscii;
-      break;
-    case EscapeAsJson:
-      stringEscaping = StringEscaping::JSON;
-      break;
-  }
+  StringEscaping::value stringEscaping = GetStringEscapingStyle(m_pState->GetOutputCharset());
 
   const StringFormat::value strFormat =
       Utils::ComputeStringFormat(str, m_pState->GetStringFormat(),
                                  m_pState->CurGroupFlowType(), stringEscaping == StringEscaping::NonAscii);
 
-  if (strFormat == StringFormat::Literal)
+  if (strFormat == StringFormat::Literal || str.size() > 1024)
     m_pState->SetMapKeyFormat(YAML::LongKey, FmtScope::Local);
 
   PrepareNode(EmitterNodeType::Scalar);
@@ -779,6 +808,21 @@ 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;
@@ -800,10 +844,10 @@ Emitter& Emitter::Write(char ch) {
   if (!good())
     return *this;
 
-  
+
 
   PrepareNode(EmitterNodeType::Scalar);
-  Utils::WriteChar(m_stream, ch, m_pState->GetOutputCharset() == EscapeAsJson);
+  Utils::WriteChar(m_stream, ch, GetStringEscapingStyle(m_pState->GetOutputCharset()));
   StartedScalar();
 
   return *this;
@@ -827,6 +871,8 @@ Emitter& Emitter::Write(const _Alias& alias) {
 
   StartedScalar();
 
+  m_pState->SetAlias();
+
   return *this;
 }
 
@@ -904,10 +950,7 @@ Emitter& Emitter::Write(const _Null& /*null*/) {
 
   PrepareNode(EmitterNodeType::Scalar);
 
-  if (m_pState->GetNullFormat() == NullAsNull)
-    m_stream << "null";
-  else
-    m_stream << "~";
+  m_stream << ComputeNullName();
 
   StartedScalar();
 
@@ -926,4 +969,4 @@ Emitter& Emitter::Write(const Binary& binary) {
 
   return *this;
 }
-}
+}  // namespace YAML

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

@@ -6,30 +6,35 @@
 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) {
-  // 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);
-}
+      m_docCount(0) {}
 
-EmitterState::~EmitterState() {}
+EmitterState::~EmitterState() = default;
 
 // SetLocalValue
 // . We blindly tries to set all possible formatters to this value
@@ -49,6 +54,8 @@ 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; }
@@ -83,6 +90,7 @@ void EmitterState::StartedNode() {
   }
 
   m_hasAnchor = false;
+  m_hasAlias = false;
   m_hasTag = false;
   m_hasNonContent = false;
 }
@@ -92,15 +100,13 @@ 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;
+    return EmitterNodeType::FlowSeq;
   }
 
+  if (GetFlowType(type) == Block)
+    return EmitterNodeType::BlockMap;
+  return EmitterNodeType::FlowMap;
+
   // can't happen
   assert(false);
   return EmitterNodeType::NoType;
@@ -154,9 +160,15 @@ void EmitterState::EndedGroup(GroupType::value type) {
   if (m_groups.empty()) {
     if (type == GroupType::Seq) {
       return SetError(ErrorMsg::UNEXPECTED_END_SEQ);
-    } else {
-      return SetError(ErrorMsg::UNEXPECTED_END_MAP);
     }
+    return SetError(ErrorMsg::UNEXPECTED_END_MAP);
+  }
+
+  if (m_hasTag) {
+    SetError(ErrorMsg::INVALID_TAG);
+  }
+  if (m_hasAnchor) {
+    SetError(ErrorMsg::INVALID_ANCHOR);
   }
 
   // get rid of the current group
@@ -178,6 +190,9 @@ void EmitterState::EndedGroup(GroupType::value type) {
   m_globalModifiedSettings.restore();
 
   ClearModifiedSettings();
+  m_hasAnchor = false;
+  m_hasTag = false;
+  m_hasNonContent = false;
 }
 
 EmitterNodeType::value EmitterState::CurGroupNodeType() const {
@@ -218,6 +233,10 @@ 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) {
@@ -283,12 +302,14 @@ bool EmitterState::SetBoolCaseFormat(EMITTER_MANIP value,
 
 bool EmitterState::SetNullFormat(EMITTER_MANIP value, FmtScope::value scope) {
   switch (value) {
-  case NullAsTilde:
-  case NullAsNull:
-    _Set(m_nullFmt, value, scope);
-    return true;
-  default:
-    return false;
+    case LowerNull:
+    case UpperNull:
+    case CamelNull:
+    case TildeNull:
+      _Set(m_nullFmt, value, scope);
+      return true;
+    default:
+      return false;
   }
 }
 
@@ -363,7 +384,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>::digits10 + 1)
+  if (value > std::numeric_limits<float>::max_digits10)
     return false;
   _Set(m_floatPrecision, value, scope);
   return true;
@@ -371,9 +392,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>::digits10 + 1)
+  if (value > std::numeric_limits<double>::max_digits10)
     return false;
   _Set(m_doublePrecision, value, scope);
   return true;
 }
-}
+}  // namespace YAML

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

@@ -43,6 +43,7 @@ class EmitterState {
 
   // node handling
   void SetAnchor();
+  void SetAlias();
   void SetTag();
   void SetNonContent();
   void SetLongKey();
@@ -65,6 +66,7 @@ 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;
@@ -72,6 +74,7 @@ class EmitterState {
   bool HasBegunContent() const { return m_hasAnchor || m_hasTag; }
 
   void ClearModifiedSettings();
+  void RestoreGlobalModifiedSettings();
 
   // formatters
   void SetLocalValue(EMITTER_MANIP value);
@@ -132,9 +135,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;
@@ -149,7 +152,12 @@ class EmitterState {
 
   struct Group {
     explicit Group(GroupType::value type_)
-        : type(type_), indent(0), childCount(0), longKey(false) {}
+        : type(type_),
+          flowType{},
+          indent(0),
+          childCount(0),
+          longKey(false),
+          modifiedSettings{} {}
 
     GroupType::value type;
     FlowType::value flowType;
@@ -181,6 +189,7 @@ 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;
@@ -202,6 +211,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,3 +1,4 @@
+#include <algorithm>
 #include <iomanip>
 #include <sstream>
 
@@ -8,8 +9,8 @@
 #include "regeximpl.h"
 #include "stringsource.h"
 #include "yaml-cpp/binary.h"  // IWYU pragma: keep
-#include "yaml-cpp/ostream_wrapper.h"
 #include "yaml-cpp/null.h"
+#include "yaml-cpp/ostream_wrapper.h"
 
 namespace YAML {
 namespace Utils {
@@ -134,12 +135,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));
@@ -173,13 +174,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::NotPrintable() || Exp::Utf8_ByteOrderMark() || Exp::Break() ||
-      Exp::Tab();
+      Exp::EndScalarInFlow() | (Exp::BlankOrBreak() + Exp::Comment()) |
+      Exp::NotPrintable() | Exp::Utf8_ByteOrderMark() | Exp::Break() |
+      Exp::Tab() | Exp::Ampersand();
   static const RegEx& disallowed_block =
-      Exp::EndScalar() || (Exp::BlankOrBreak() + Exp::Comment()) ||
-      Exp::NotPrintable() || Exp::Utf8_ByteOrderMark() || Exp::Break() ||
-      Exp::Tab();
+      Exp::EndScalar() | (Exp::BlankOrBreak() + Exp::Comment()) |
+      Exp::NotPrintable() | Exp::Utf8_ByteOrderMark() | Exp::Break() |
+      Exp::Tab() | Exp::Ampersand();
   const RegEx& disallowed =
       flowType == FlowType::Flow ? disallowed_flow : disallowed_block;
 
@@ -199,15 +200,10 @@ bool IsValidPlainScalar(const std::string& str, FlowType::value flowType,
 
 bool IsValidSingleQuotedScalar(const std::string& str, bool escapeNonAscii) {
   // TODO: check for non-printable characters?
-  for (std::size_t i = 0; i < str.size(); i++) {
-    if (escapeNonAscii && (0x80 <= static_cast<unsigned char>(str[i]))) {
-      return false;
-    }
-    if (str[i] == '\n') {
-      return false;
-    }
-  }
-  return true;
+  return std::none_of(str.begin(), str.end(), [=](char ch) {
+    return (escapeNonAscii && (0x80 <= static_cast<unsigned char>(ch))) ||
+           (ch == '\n');
+  });
 }
 
 bool IsValidLiteralScalar(const std::string& str, FlowType::value flowType,
@@ -217,12 +213,9 @@ bool IsValidLiteralScalar(const std::string& str, FlowType::value flowType,
   }
 
   // TODO: check for non-printable characters?
-  for (std::size_t i = 0; i < str.size(); i++) {
-    if (escapeNonAscii && (0x80 <= static_cast<unsigned char>(str[i]))) {
-      return false;
-    }
-  }
-  return true;
+  return std::none_of(str.begin(), str.end(), [=](char ch) {
+    return (escapeNonAscii && (0x80 <= static_cast<unsigned char>(ch)));
+  });
 }
 
 std::pair<uint16_t, uint16_t> EncodeUTF16SurrogatePair(int codePoint) {
@@ -234,24 +227,24 @@ std::pair<uint16_t, uint16_t> EncodeUTF16SurrogatePair(int codePoint) {
   };
 }
 
-void WriteDoubleQuoteEscapeSequence(ostream_wrapper& out, int codePoint, bool escapeAsJson) {
+void WriteDoubleQuoteEscapeSequence(ostream_wrapper& out, int codePoint, StringEscaping::value stringEscapingStyle) {
   static const char hexDigits[] = "0123456789abcdef";
 
   out << "\\";
   int digits = 8;
-  if (codePoint < 0xFF && !escapeAsJson) {
+  if (codePoint < 0xFF && stringEscapingStyle != StringEscaping::JSON) {
     out << "x";
     digits = 2;
   } else if (codePoint < 0xFFFF) {
     out << "u";
     digits = 4;
-  } else if (!escapeAsJson) {
+  } else if (stringEscapingStyle != StringEscaping::JSON) {
     out << "U";
     digits = 8;
   } else {
     auto surrogatePair = EncodeUTF16SurrogatePair(codePoint);
-    WriteDoubleQuoteEscapeSequence(out, surrogatePair.first, true);
-    WriteDoubleQuoteEscapeSequence(out, surrogatePair.second, true);
+    WriteDoubleQuoteEscapeSequence(out, surrogatePair.first, stringEscapingStyle);
+    WriteDoubleQuoteEscapeSequence(out, surrogatePair.second, stringEscapingStyle);
     return;
   }
 
@@ -272,7 +265,7 @@ bool WriteAliasName(ostream_wrapper& out, const std::string& str) {
   }
   return true;
 }
-}
+}  // namespace
 
 StringFormat::value ComputeStringFormat(const std::string& str,
                                         EMITTER_MANIP strFormat,
@@ -355,12 +348,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 == StringEscaping::JSON);
+          WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping);
         } else if (codePoint == 0xFEFF) {  // Byte order marks (ZWNS) should be
                                            // escaped (YAML 1.2, sec. 5.2)
-          WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping == StringEscaping::JSON);
+          WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping);
         } else if (stringEscaping == StringEscaping::NonAscii && codePoint > 0x7E) {
-          WriteDoubleQuoteEscapeSequence(out, codePoint, false);
+          WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping);
         } else {
           WriteCodePoint(out, codePoint);
         }
@@ -373,41 +366,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" << IndentTo(indent);
+      out << "\n";
     } else {
+      out<< IndentTo(indent);
       WriteCodePoint(out, codePoint);
     }
   }
   return true;
 }
 
-bool WriteChar(ostream_wrapper& out, char ch, bool escapeAsJson) {
+bool WriteChar(ostream_wrapper& out, char ch, StringEscaping::value stringEscapingStyle) {
   if (('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z')) {
     out << ch;
   } else if (ch == '\"') {
-    out << "\"\\\"\"";
+    out << R"("\"")";
   } else if (ch == '\t') {
-    out << "\"\\t\"";
+    out << R"("\t")";
   } else if (ch == '\n') {
-    out << "\"\\n\"";
+    out << R"("\n")";
   } else if (ch == '\b') {
-    out << "\"\\b\"";
+    out << R"("\b")";
   } else if (ch == '\r') {
-    out << "\"\\r\"";
+    out << R"("\r")";
   } else if (ch == '\f') {
-    out << "\"\\f\"";
+    out << R"("\f")";
   } else if (ch == '\\') {
-    out << "\"\\\\\"";
-  } else if ((0x20 <= ch && ch <= 0x7e) || ch == ' ') {
+    out << R"("\\")";
+  } else if (0x20 <= ch && ch <= 0x7e) {
     out << "\"" << ch << "\"";
   } else {
     out << "\"";
-    WriteDoubleQuoteEscapeSequence(out, ch, escapeAsJson);
+    WriteDoubleQuoteEscapeSequence(out, ch, stringEscapingStyle);
     out << "\"";
   }
   return true;
@@ -422,8 +415,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" << IndentTo(curIndent) << "#"
-          << Indentation(postCommentIndent);
+      out << "\n"
+          << IndentTo(curIndent) << "#" << Indentation(postCommentIndent);
       out.set_comment();
     } else {
       WriteCodePoint(out, codePoint);
@@ -500,5 +493,5 @@ bool WriteBinary(ostream_wrapper& out, const Binary& binary) {
                           StringEscaping::None);
   return true;
 }
-}
-}
+}  // namespace Utils
+}  // namespace YAML

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

@@ -39,7 +39,8 @@ 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 escapeAsJson);
+bool WriteChar(ostream_wrapper& out, char ch,
+               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,19 +1,20 @@
 #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() NOEXCEPT {}
-ParserException::~ParserException() NOEXCEPT {}
-RepresentationException::~RepresentationException() NOEXCEPT {}
-InvalidScalar::~InvalidScalar() NOEXCEPT {}
-KeyNotFound::~KeyNotFound() NOEXCEPT {}
-InvalidNode::~InvalidNode() NOEXCEPT {}
-BadConversion::~BadConversion() NOEXCEPT {}
-BadDereference::~BadDereference() NOEXCEPT {}
-BadSubscript::~BadSubscript() NOEXCEPT {}
-BadPushback::~BadPushback() NOEXCEPT {}
-BadInsert::~BadInsert() NOEXCEPT {}
-EmitterException::~EmitterException() NOEXCEPT {}
-BadFile::~BadFile() NOEXCEPT {}
-}
+Exception::~Exception() YAML_CPP_NOEXCEPT = default;
+ParserException::~ParserException() YAML_CPP_NOEXCEPT = default;
+RepresentationException::~RepresentationException() YAML_CPP_NOEXCEPT = default;
+InvalidScalar::~InvalidScalar() YAML_CPP_NOEXCEPT = default;
+KeyNotFound::~KeyNotFound() YAML_CPP_NOEXCEPT = default;
+InvalidNode::~InvalidNode() YAML_CPP_NOEXCEPT = default;
+BadConversion::~BadConversion() YAML_CPP_NOEXCEPT = default;
+BadDereference::~BadDereference() YAML_CPP_NOEXCEPT = default;
+BadSubscript::~BadSubscript() YAML_CPP_NOEXCEPT = default;
+BadPushback::~BadPushback() YAML_CPP_NOEXCEPT = default;
+BadInsert::~BadInsert() YAML_CPP_NOEXCEPT = default;
+EmitterException::~EmitterException() YAML_CPP_NOEXCEPT = default;
+BadFile::~BadFile() YAML_CPP_NOEXCEPT = default;
+}  // namespace YAML

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

@@ -12,8 +12,7 @@ namespace YAML {
 namespace Exp {
 unsigned ParseHex(const std::string& str, const Mark& mark) {
   unsigned value = 0;
-  for (std::size_t i = 0; i < str.size(); i++) {
-    char ch = str[i];
+  for (char ch : str) {
     int digit = 0;
     if ('a' <= ch && ch <= 'f')
       digit = ch - 'a' + 10;
@@ -55,14 +54,16 @@ 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));
+
+  return Str(0xF0 + (value >> 18)) + Str(0x80 + ((value >> 12) & 0x3F)) +
+         Str(0x80 + ((value >> 6) & 0x3F)) + Str(0x80 + (value & 0x3F));
 }
 
 // Escape
@@ -104,7 +105,7 @@ std::string Escape(Stream& in) {
     case 'e':
       return "\x1B";
     case ' ':
-      return "\x20";
+      return R"( )";
     case '\"':
       return "\"";
     case '\'':
@@ -132,5 +133,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");
+  static const RegEx e = RegEx('\n') | RegEx("\r\n") | RegEx('\r');
   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("\x01\x02\x03\x04\x05\x06\x07\x08\x0B\x0C\x7F", REGEX_OR) ||
-      RegEx(0x0E, 0x1F) ||
-      (RegEx('\xC2') + (RegEx('\x80', '\x84') || RegEx('\x86', '\x9F')));
+      RegEx(0) |
+      RegEx("\x01\x02\x03\x04\x05\x06\x07\x08\x0B\x0C\x7F", REGEX_OR) |
+      RegEx(0x0E, 0x1F) |
+      (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,36 +106,40 @@ 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;
 }
@@ -148,34 +152,34 @@ inline const RegEx& Tag() {
 // space.
 inline const RegEx& PlainScalar() {
   static const RegEx e =
-      !(BlankOrBreak() || RegEx(",[]{}#&*!|>\'\"%@`", REGEX_OR) ||
-        (RegEx("-?:", REGEX_OR) + (BlankOrBreak() || RegEx())));
+      !(BlankOrBreak() | RegEx(",[]{}#&*!|>\'\"%@`", REGEX_OR) |
+        (RegEx("-?:", REGEX_OR) + (BlankOrBreak() | RegEx())));
   return e;
 }
 inline const RegEx& PlainScalarInFlow() {
   static const RegEx e =
-      !(BlankOrBreak() || RegEx("?,[]{}#&*!|>\'\"%@`", REGEX_OR) ||
-        (RegEx("-:", REGEX_OR) + Blank()));
+      !(BlankOrBreak() | RegEx("?,[]{}#&*!|>\'\"%@`", REGEX_OR) |
+        (RegEx("-:", REGEX_OR) + (Blank() | RegEx())));
   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() {
@@ -192,15 +196,15 @@ inline const RegEx& ChompIndicator() {
   return e;
 }
 inline const RegEx& Chomp() {
-  static const RegEx e = (ChompIndicator() + Digit()) ||
-                         (Digit() + ChompIndicator()) || ChompIndicator() ||
+  static const RegEx e = (ChompIndicator() + Digit()) |
+                         (Digit() + ChompIndicator()) | ChompIndicator() |
                          Digit();
   return e;
 }
 
 // and some functions
 std::string Escape(Stream& in);
-}
+}  // namespace Exp
 
 namespace Keys {
 const char Directive = '%';
@@ -216,7 +220,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,4 +1,5 @@
-#include <assert.h>
+#include <algorithm>
+#include <cassert>
 #include <iterator>
 #include <sstream>
 
@@ -12,15 +13,24 @@
 
 namespace YAML {
 namespace detail {
+YAML_CPP_API std::atomic<size_t> node::m_amount{0};
 
-std::string node_data::empty_scalar;
+const 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_seqSize(0) {}
+      m_scalar{},
+      m_sequence{},
+      m_seqSize(0),
+      m_map{},
+      m_undefinedPairs{} {}
 
 void node_data::mark_defined() {
   if (m_type == NodeType::Undefined)
@@ -100,9 +110,9 @@ void node_data::compute_seq_size() const {
 }
 
 void node_data::compute_map_size() const {
-  kv_pairs::iterator it = m_undefinedPairs.begin();
+  auto it = m_undefinedPairs.begin();
   while (it != m_undefinedPairs.end()) {
-    kv_pairs::iterator jt = std::next(it);
+    auto jt = std::next(it);
     if (it->first->is_defined() && it->second->is_defined())
       m_undefinedPairs.erase(it);
     it = jt;
@@ -111,7 +121,7 @@ void node_data::compute_map_size() const {
 
 const_node_iterator node_data::begin() const {
   if (!m_isDefined)
-    return const_node_iterator();
+    return {};
 
   switch (m_type) {
     case NodeType::Sequence:
@@ -119,13 +129,13 @@ const_node_iterator node_data::begin() const {
     case NodeType::Map:
       return const_node_iterator(m_map.begin(), m_map.end());
     default:
-      return const_node_iterator();
+      return {};
   }
 }
 
 node_iterator node_data::begin() {
   if (!m_isDefined)
-    return node_iterator();
+    return {};
 
   switch (m_type) {
     case NodeType::Sequence:
@@ -133,13 +143,13 @@ node_iterator node_data::begin() {
     case NodeType::Map:
       return node_iterator(m_map.begin(), m_map.end());
     default:
-      return node_iterator();
+      return {};
   }
 }
 
 const_node_iterator node_data::end() const {
   if (!m_isDefined)
-    return const_node_iterator();
+    return {};
 
   switch (m_type) {
     case NodeType::Sequence:
@@ -147,13 +157,13 @@ const_node_iterator node_data::end() const {
     case NodeType::Map:
       return const_node_iterator(m_map.end(), m_map.end());
     default:
-      return const_node_iterator();
+      return {};
   }
 }
 
 node_iterator node_data::end() {
   if (!m_isDefined)
-    return node_iterator();
+    return {};
 
   switch (m_type) {
     case NodeType::Sequence:
@@ -161,12 +171,13 @@ node_iterator node_data::end() {
     case NodeType::Map:
       return node_iterator(m_map.end(), m_map.end());
     default:
-      return node_iterator();
+      return {};
   }
 }
 
 // sequence
-void node_data::push_back(node& node, shared_memory_holder /* pMemory */) {
+void node_data::push_back(node& node,
+                          const shared_memory_holder& /* pMemory */) {
   if (m_type == NodeType::Undefined || m_type == NodeType::Null) {
     m_type = NodeType::Sequence;
     reset_sequence();
@@ -178,7 +189,8 @@ void node_data::push_back(node& node, shared_memory_holder /* pMemory */) {
   m_sequence.push_back(&node);
 }
 
-void node_data::insert(node& key, node& value, shared_memory_holder pMemory) {
+void node_data::insert(node& key, node& value,
+                       const shared_memory_holder& pMemory) {
   switch (m_type) {
     case NodeType::Map:
       break;
@@ -188,27 +200,28 @@ void node_data::insert(node& key, node& value, shared_memory_holder pMemory) {
       convert_to_map(pMemory);
       break;
     case NodeType::Scalar:
-      throw BadSubscript();
+      throw BadSubscript(m_mark, key);
   }
 
   insert_map_pair(key, value);
 }
 
 // indexing
-node* node_data::get(node& key, shared_memory_holder /* pMemory */) const {
+node* node_data::get(node& key,
+                     const shared_memory_holder& /* pMemory */) const {
   if (m_type != NodeType::Map) {
-    return NULL;
+    return nullptr;
   }
 
-  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
-    if (it->first->is(key))
-      return it->second;
+  for (const auto& it : m_map) {
+    if (it.first->is(key))
+      return it.second;
   }
 
-  return NULL;
+  return nullptr;
 }
 
-node& node_data::get(node& key, shared_memory_holder pMemory) {
+node& node_data::get(node& key, const shared_memory_holder& pMemory) {
   switch (m_type) {
     case NodeType::Map:
       break;
@@ -218,12 +231,12 @@ node& node_data::get(node& key, shared_memory_holder pMemory) {
       convert_to_map(pMemory);
       break;
     case NodeType::Scalar:
-      throw BadSubscript();
+      throw BadSubscript(m_mark, key);
   }
 
-  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
-    if (it->first->is(key))
-      return *it->second;
+  for (const auto& it : m_map) {
+    if (it.first->is(key))
+      return *it.second;
   }
 
   node& value = pMemory->create_node();
@@ -231,15 +244,26 @@ node& node_data::get(node& key, shared_memory_holder pMemory) {
   return value;
 }
 
-bool node_data::remove(node& key, shared_memory_holder /* pMemory */) {
+bool node_data::remove(node& key, const shared_memory_holder& /* pMemory */) {
   if (m_type != NodeType::Map)
     return false;
 
-  for (node_map::iterator it = m_map.begin(); it != m_map.end(); ++it) {
-    if (it->first->is(key)) {
-      m_map.erase(it);
-      return true;
-    }
+  for (auto it = m_undefinedPairs.begin(); it != m_undefinedPairs.end();) {
+    auto jt = std::next(it);
+    if (it->first->is(key))
+      m_undefinedPairs.erase(it);
+    it = jt;
+  }
+
+  auto it =
+      std::find_if(m_map.begin(), m_map.end(),
+                   [&](std::pair<YAML::detail::node*, YAML::detail::node*> j) {
+                     return (j.first->is(key));
+                   });
+
+  if (it != m_map.end()) {
+    m_map.erase(it);
+    return true;
   }
 
   return false;
@@ -262,7 +286,7 @@ void node_data::insert_map_pair(node& key, node& value) {
     m_undefinedPairs.emplace_back(&key, &value);
 }
 
-void node_data::convert_to_map(shared_memory_holder pMemory) {
+void node_data::convert_to_map(const shared_memory_holder& pMemory) {
   switch (m_type) {
     case NodeType::Undefined:
     case NodeType::Null:
@@ -280,7 +304,7 @@ void node_data::convert_to_map(shared_memory_holder pMemory) {
   }
 }
 
-void node_data::convert_sequence_to_map(shared_memory_holder pMemory) {
+void node_data::convert_sequence_to_map(const shared_memory_holder& pMemory) {
   assert(m_type == NodeType::Sequence);
 
   reset_map();
@@ -296,5 +320,5 @@ void node_data::convert_sequence_to_map(shared_memory_holder pMemory) {
   reset_sequence();
   m_type = NodeType::Map;
 }
-}
-}
+}  // namespace detail
+}  // namespace YAML

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

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

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

@@ -27,25 +27,29 @@ class Node;
 class NodeBuilder : public EventHandler {
  public:
   NodeBuilder();
-  virtual ~NodeBuilder();
+  NodeBuilder(const NodeBuilder&) = delete;
+  NodeBuilder(NodeBuilder&&) = delete;
+  NodeBuilder& operator=(const NodeBuilder&) = delete;
+  NodeBuilder& operator=(NodeBuilder&&) = delete;
+  ~NodeBuilder() override;
 
   Node Root();
 
-  virtual void OnDocumentStart(const Mark& mark);
-  virtual void OnDocumentEnd();
+  void OnDocumentStart(const Mark& mark) override;
+  void OnDocumentEnd() override;
 
-  virtual void OnNull(const Mark& mark, anchor_t anchor);
-  virtual void OnAlias(const Mark& mark, anchor_t anchor);
-  virtual void OnScalar(const Mark& mark, const std::string& tag,
-                        anchor_t anchor, const std::string& value);
+  void OnNull(const Mark& mark, anchor_t anchor) override;
+  void OnAlias(const Mark& mark, anchor_t anchor) override;
+  void OnScalar(const Mark& mark, const std::string& tag,
+                        anchor_t anchor, const std::string& value) override;
 
-  virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
-                               anchor_t anchor, EmitterStyle::value style);
-  virtual void OnSequenceEnd();
+  void OnSequenceStart(const Mark& mark, const std::string& tag,
+                               anchor_t anchor, EmitterStyle::value style) override;
+  void OnSequenceEnd() override;
 
-  virtual void OnMapStart(const Mark& mark, const std::string& tag,
-                          anchor_t anchor, EmitterStyle::value style);
-  virtual void OnMapEnd();
+  void OnMapStart(const Mark& mark, const std::string& tag,
+                          anchor_t anchor, EmitterStyle::value style) override;
+  void OnMapEnd() override;
 
  private:
   detail::node& Push(const Mark& mark, anchor_t anchor);
@@ -57,14 +61,14 @@ class NodeBuilder : public EventHandler {
   detail::shared_memory_holder m_pMemory;
   detail::node* m_pRoot;
 
-  typedef std::vector<detail::node*> Nodes;
+  using Nodes = std::vector<detail::node *>;
   Nodes m_stack;
   Nodes m_anchors;
 
-  typedef std::pair<detail::node*, bool> PushedKey;
+  using PushedKey = std::pair<detail::node*, bool>;
   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 {
-  AnchorByIdentity::const_iterator it = m_anchorByIdentity.find(node.ref());
+  auto 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_pMemory(node.m_pMemory), m_root(node.m_pNode), m_refCount{} {
   if (m_root)
     Setup(*m_root);
 }
@@ -32,13 +32,12 @@ void NodeEvents::Setup(const detail::node& node) {
     return;
 
   if (node.type() == NodeType::Sequence) {
-    for (detail::const_node_iterator it = node.begin(); it != node.end(); ++it)
-      Setup(**it);
+    for (auto element : node)
+      Setup(*element);
   } else if (node.type() == NodeType::Map) {
-    for (detail::const_node_iterator it = node.begin(); it != node.end();
-         ++it) {
-      Setup(*it->first);
-      Setup(*it->second);
+    for (auto element : node) {
+      Setup(*element.first);
+      Setup(*element.second);
     }
   }
 }
@@ -77,17 +76,15 @@ void NodeEvents::Emit(const detail::node& node, EventHandler& handler,
       break;
     case NodeType::Sequence:
       handler.OnSequenceStart(Mark(), node.tag(), anchor, node.style());
-      for (detail::const_node_iterator it = node.begin(); it != node.end();
-           ++it)
-        Emit(**it, handler, am);
+      for (auto element : node)
+        Emit(*element, handler, am);
       handler.OnSequenceEnd();
       break;
     case NodeType::Map:
       handler.OnMapStart(Mark(), node.tag(), anchor, node.style());
-      for (detail::const_node_iterator it = node.begin(); it != node.end();
-           ++it) {
-        Emit(*it->first, handler, am);
-        Emit(*it->second, handler, am);
+      for (auto element : node) {
+        Emit(*element.first, handler, am);
+        Emit(*element.second, handler, am);
       }
       handler.OnMapEnd();
       break;
@@ -95,7 +92,7 @@ void NodeEvents::Emit(const detail::node& node, EventHandler& handler,
 }
 
 bool NodeEvents::IsAliased(const detail::node& node) const {
-  RefCount::const_iterator it = m_refCount.find(node.ref());
+  auto it = m_refCount.find(node.ref());
   return it != m_refCount.end() && it->second > 1;
 }
-}
+}  // namespace YAML

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

@@ -26,13 +26,17 @@ 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_curAnchor(0) {}
+    AliasManager() : m_anchorByIdentity{}, m_curAnchor(0) {}
 
     void RegisterReference(const detail::node& node);
     anchor_t LookupAnchor(const detail::node& node) const;
@@ -41,7 +45,7 @@ class NodeEvents {
     anchor_t _CreateNewAnchor() { return ++m_curAnchor; }
 
    private:
-    typedef std::map<const detail::node_ref*, anchor_t> AnchorByIdentity;
+    using AnchorByIdentity = std::map<const detail::node_ref*, anchor_t>;
     AnchorByIdentity m_anchorByIdentity;
 
     anchor_t m_curAnchor;
@@ -56,9 +60,9 @@ class NodeEvents {
   detail::shared_memory_holder m_pMemory;
   detail::node* m_root;
 
-  typedef std::map<const detail::node_ref*, int> RefCount;
+  using RefCount = std::map<const detail::node_ref*, int>;
   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,16 +7,21 @@
 namespace YAML {
 ostream_wrapper::ostream_wrapper()
     : m_buffer(1, '\0'),
-      m_pStream(0),
+      m_pStream(nullptr),
       m_pos(0),
       m_row(0),
       m_col(0),
       m_comment(false) {}
 
 ostream_wrapper::ostream_wrapper(std::ostream& stream)
-    : m_pStream(&stream), m_pos(0), m_row(0), m_col(0), m_comment(false) {}
+    : m_buffer{},
+      m_pStream(&stream),
+      m_pos(0),
+      m_row(0),
+      m_col(0),
+      m_comment(false) {}
 
-ostream_wrapper::~ostream_wrapper() {}
+ostream_wrapper::~ostream_wrapper() = default;
 
 void ostream_wrapper::write(const std::string& str) {
   if (m_pStream) {
@@ -26,8 +31,8 @@ void ostream_wrapper::write(const std::string& str) {
     std::copy(str.begin(), str.end(), m_buffer.begin() + m_pos);
   }
 
-  for (std::size_t i = 0; i < str.size(); i++) {
-    update_pos(str[i]);
+  for (char ch : str) {
+    update_pos(ch);
   }
 }
 
@@ -54,4 +59,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 "yaml-cpp/node/node.h"
-#include "yaml-cpp/node/impl.h"
-#include "yaml-cpp/parser.h"
 #include "nodebuilder.h"
+#include "yaml-cpp/node/impl.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/parser.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.c_str());
-  if (!fin || fin.bad()) {
-    throw BadFile();
+  std::ifstream fin(filename);
+  if (!fin) {
+    throw BadFile(filename);
   }
   return Load(fin);
 }
@@ -51,7 +51,7 @@ std::vector<Node> LoadAll(std::istream& input) {
   std::vector<Node> docs;
 
   Parser parser(input);
-  while (1) {
+  while (true) {
     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.c_str());
+  std::ifstream fin(filename);
   if (!fin) {
-    throw BadFile();
+    throw BadFile(filename);
   }
   return LoadAll(fin);
 }

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

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

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

@@ -12,15 +12,17 @@
 #include <memory>
 #include <vector>
 
-#include "yaml-cpp/noncopyable.h"
-
 namespace YAML {
 
 // TODO: This class is no longer needed
 template <typename T>
-class ptr_vector : private YAML::noncopyable {
+class ptr_vector {
  public:
-  ptr_vector() {}
+  ptr_vector() : m_data{} {}
+  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(); }
 
@@ -38,6 +40,6 @@ class ptr_vector : private YAML::noncopyable {
  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,18 +2,16 @@
 
 namespace YAML {
 // constructors
-RegEx::RegEx() : m_op(REGEX_EMPTY) {}
 
-RegEx::RegEx(REGEX_OP op) : m_op(op) {}
+RegEx::RegEx(REGEX_OP op) : m_op(op), m_a(0), m_z(0), m_params{} {}
+RegEx::RegEx() : RegEx(REGEX_EMPTY) {}
 
-RegEx::RegEx(char ch) : m_op(REGEX_MATCH), m_a(ch) {}
+RegEx::RegEx(char ch) : m_op(REGEX_MATCH), m_a(ch), m_z(0), m_params{} {}
 
-RegEx::RegEx(char a, char z) : m_op(REGEX_RANGE), m_a(a), m_z(z) {}
+RegEx::RegEx(char a, char z) : m_op(REGEX_RANGE), m_a(a), m_z(z), m_params{} {}
 
-RegEx::RegEx(const std::string& str, REGEX_OP op) : m_op(op) {
-  for (std::size_t i = 0; i < str.size(); i++)
-    m_params.push_back(RegEx(str[i]));
-}
+RegEx::RegEx(const std::string& str, REGEX_OP op)
+    : m_op(op), m_a(0), m_z(0), m_params(str.begin(), str.end()) {}
 
 // combination constructors
 RegEx operator!(const RegEx& ex) {
@@ -22,14 +20,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);
@@ -42,4 +40,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();
-  RegEx(char ch);
+  explicit RegEx(char ch);
   RegEx(char a, char z);
   RegEx(const std::string& str, REGEX_OP op = REGEX_SEQ);
-  ~RegEx() {}
+  ~RegEx() = default;
 
   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:
-  RegEx(REGEX_OP op);
+  explicit RegEx(REGEX_OP op);
 
   template <typename Source>
   bool IsValidSource(const Source& source) const;
@@ -77,10 +77,11 @@ class YAML_CPP_API RegEx {
 
  private:
   REGEX_OP m_op;
-  char m_a, m_z;
+  char m_a{};
+  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 "stringsource.h"
 #include "streamcharsource.h"
+#include "stringsource.h"
 
 namespace YAML {
 // query matches
@@ -106,9 +106,8 @@ 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 string
+  return !source ? 0 : -1;  // the empty regex only is successful on the empty
+                            // string
 }
 
 // MatchOperator
@@ -130,8 +129,8 @@ inline int RegEx::MatchOpRange(const Source& source) const {
 // OrOperator
 template <typename Source>
 inline int RegEx::MatchOpOr(const Source& source) const {
-  for (std::size_t i = 0; i < m_params.size(); i++) {
-    int n = m_params[i].MatchUnchecked(source);
+  for (const RegEx& param : m_params) {
+    int n = param.MatchUnchecked(source);
     if (n >= 0)
       return n;
   }
@@ -169,11 +168,11 @@ inline int RegEx::MatchOpNot(const Source& source) const {
 template <typename Source>
 inline int RegEx::MatchOpSeq(const Source& source) const {
   int offset = 0;
-  for (std::size_t i = 0; i < m_params.size(); i++) {
-    int n = m_params[i].Match(source + offset);  // note Match, not
-                                                 // MatchUnchecked because we
-                                                 // need to check validity after
-                                                 // the offset
+  for (const RegEx& param : m_params) {
+    int n = param.Match(source + offset);  // note Match, not
+                                           // MatchUnchecked because we
+                                           // need to check validity after
+                                           // the offset
     if (n == -1)
       return -1;
     offset += n;
@@ -181,6 +180,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,12 +9,17 @@
 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() {}
+Scanner::~Scanner() = default;
 
 bool Scanner::empty() {
   EnsureTokensInQueue();
@@ -46,7 +51,7 @@ Token& Scanner::peek() {
 Mark Scanner::mark() const { return INPUT.mark(); }
 
 void Scanner::EnsureTokensInQueue() {
-  while (1) {
+  while (true) {
     if (!m_tokens.empty()) {
       Token& token = m_tokens.front();
 
@@ -83,7 +88,7 @@ void Scanner::ScanNextToken() {
     return StartStream();
   }
 
-  // get rid of whitespace, etc. (in between tokens it should be irrelevent)
+  // get rid of whitespace, etc. (in between tokens it should be irrelevant)
   ScanToNextToken();
 
   // maybe need to end some blocks
@@ -169,7 +174,7 @@ void Scanner::ScanNextToken() {
 }
 
 void Scanner::ScanToNextToken() {
-  while (1) {
+  while (true) {
     // first eat whitespace
     while (INPUT && IsWhitespaceToBeEaten(INPUT.peek())) {
       if (InBlockContext() && Exp::Tab().Matches(INPUT)) {
@@ -282,7 +287,7 @@ Scanner::IndentMarker* Scanner::PushIndentTo(int column,
                                              IndentMarker::INDENT_TYPE type) {
   // are we in flow?
   if (InFlowContext()) {
-    return 0;
+    return nullptr;
   }
 
   std::unique_ptr<IndentMarker> pIndent(new IndentMarker(column, type));
@@ -291,12 +296,12 @@ Scanner::IndentMarker* Scanner::PushIndentTo(int column,
 
   // is this actually an indentation?
   if (indent.column < lastIndent.column) {
-    return 0;
+    return nullptr;
   }
   if (indent.column == lastIndent.column &&
       !(indent.type == IndentMarker::SEQ &&
         lastIndent.type == IndentMarker::MAP)) {
-    return 0;
+    return nullptr;
   }
 
   // push a start token

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

@@ -9,9 +9,7 @@
 
 #include <cstddef>
 #include <ios>
-#include <map>
 #include <queue>
-#include <set>
 #include <stack>
 #include <string>
 
@@ -49,7 +47,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(0) {}
+        : column(column_), type(type_), status(VALID), pStartToken(nullptr) {}
 
     int column;
     INDENT_TYPE type;

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

@@ -47,7 +47,8 @@ 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);
         }
       }
@@ -183,7 +184,7 @@ std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) {
         case FOLD_FLOW:
           if (nextEmptyLine) {
             scalar += "\n";
-          } else if (!emptyLine && !nextEmptyLine && !escapedNewline) {
+          } else if (!emptyLine && !escapedNewline) {
             scalar += " ";
           }
           break;
@@ -203,7 +204,7 @@ std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) {
 
   // post-processing
   if (params.trimTrailingSpaces) {
-    std::size_t pos = scalar.find_last_not_of(' ');
+    std::size_t pos = scalar.find_last_not_of(" \t");
     if (lastEscapedChar != std::string::npos) {
       if (pos < lastEscapedChar || pos == std::string::npos) {
         pos = lastEscapedChar;
@@ -247,4 +248,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& info);
+std::string ScanScalar(Stream& INPUT, ScanScalarParams& params);
 }
 
 #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 (1) {
+  while (true) {
     // 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 diffently in the block context (and manage indents)
+  // handle keys differently 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 diffently in the block context (and manage indents)
+    // handle values differently 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,17 +7,24 @@
 #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);
@@ -27,21 +34,19 @@ 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) : m_pCurSetting(pSetting) {
-    // copy old setting to save its state
-    m_oldSetting = *pSetting;
-  }
+  SettingChange(Setting<T>* pSetting)
+      : m_pCurSetting(pSetting),
+        m_oldSetting(*pSetting)  // copy old setting to save its state
+  {}
+  SettingChange(const SettingChange&) = delete;
+  SettingChange(SettingChange&&) = delete;
+  SettingChange& operator=(const SettingChange&) = delete;
+  SettingChange& operator=(SettingChange&&) = delete;
 
-  virtual void pop() { m_pCurSetting->restore(m_oldSetting); }
+  void pop() override { m_pCurSetting->restore(m_oldSetting); }
 
  private:
   Setting<T>* m_pCurSetting;
@@ -55,28 +60,13 @@ inline std::unique_ptr<SettingChangeBase> Setting<T>::set(const T& value) {
   return pChange;
 }
 
-class SettingChanges : private noncopyable {
+class SettingChanges {
  public:
-  SettingChanges() {}
-  ~SettingChanges() { clear(); }
-
-  void clear() {
-    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) {
+  SettingChanges() : m_settingChanges{} {}
+  SettingChanges(const SettingChanges&) = delete;
+  SettingChanges(SettingChanges&&) YAML_CPP_NOEXCEPT = default;
+  SettingChanges& operator=(const SettingChanges&) = delete;
+  SettingChanges& operator=(SettingChanges&& rhs) YAML_CPP_NOEXCEPT {
     if (this == &rhs)
       return *this;
 
@@ -85,11 +75,26 @@ class SettingChanges : private noncopyable {
 
     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:
-  typedef std::vector<std::unique_ptr<SettingChangeBase>> setting_changes;
+  using setting_changes = std::vector<std::unique_ptr<SettingChangeBase>>;
   setting_changes m_settingChanges;
 };
-}
+}  // namespace YAML
 
 #endif  // SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66

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

@@ -5,7 +5,11 @@ namespace YAML {
 struct Mark;
 
 Scanner::SimpleKey::SimpleKey(const Mark& mark_, std::size_t flowLevel_)
-    : mark(mark_), flowLevel(flowLevel_), pIndent(0), pMapStart(0), pKey(0) {}
+    : mark(mark_),
+      flowLevel(flowLevel_),
+      pIndent(nullptr),
+      pMapStart(nullptr),
+      pKey(nullptr) {}
 
 void Scanner::SimpleKey::Validate() {
   // Note: pIndent will *not* be garbage here;
@@ -125,4 +129,4 @@ void Scanner::PopAllSimpleKeys() {
   while (!m_simpleKeys.empty())
     m_simpleKeys.pop();
 }
-}
+}  // namespace YAML

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

@@ -7,6 +7,7 @@
 #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
@@ -18,9 +19,10 @@ SingleDocParser::SingleDocParser(Scanner& scanner, const Directives& directives)
     : m_scanner(scanner),
       m_directives(directives),
       m_pCollectionStack(new CollectionStack),
+      m_anchors{},
       m_curAnchor(0) {}
 
-SingleDocParser::~SingleDocParser() {}
+SingleDocParser::~SingleDocParser() = default;
 
 // HandleDocument
 // . Handles the next document
@@ -46,6 +48,8 @@ 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);
@@ -71,20 +75,31 @@ void SingleDocParser::HandleNode(EventHandler& eventHandler) {
   }
 
   std::string tag;
+  std::string anchor_name;
   anchor_t anchor;
-  ParseProperties(tag, anchor);
+  ParseProperties(tag, anchor, anchor_name);
 
-  const Token& token = m_scanner.peek();
+  if (!anchor_name.empty())
+    eventHandler.OnAnchor(mark, anchor_name);
 
-  if (token.type == Token::PLAIN_SCALAR && IsNullString(token.value)) {
+  // after parsing properties, an empty node is again a possibility
+  if (m_scanner.empty()) {
     eventHandler.OnNull(mark, anchor);
-    m_scanner.pop();
     return;
   }
 
+  const Token& token = m_scanner.peek();
+
   // add non-specific tags
   if (tag.empty())
     tag = (token.type == Token::NON_PLAIN_SCALAR ? "!" : "?");
+  
+  if (token.type == Token::PLAIN_SCALAR 
+      && tag.compare("?") == 0 && IsNullString(token.value)) {
+    eventHandler.OnNull(mark, anchor);
+    m_scanner.pop();
+    return;
+  }
 
   // now split based on what kind of node we should be
   switch (token.type) {
@@ -152,7 +167,7 @@ void SingleDocParser::HandleBlockSequence(EventHandler& eventHandler) {
   m_scanner.pop();
   m_pCollectionStack->PushCollectionType(CollectionType::BlockSeq);
 
-  while (1) {
+  while (true) {
     if (m_scanner.empty())
       throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ);
 
@@ -166,10 +181,10 @@ void SingleDocParser::HandleBlockSequence(EventHandler& eventHandler) {
 
     // check for null
     if (!m_scanner.empty()) {
-      const Token& token_ = m_scanner.peek();
-      if (token_.type == Token::BLOCK_ENTRY ||
-          token_.type == Token::BLOCK_SEQ_END) {
-        eventHandler.OnNull(token_.mark, NullAnchor);
+      const Token& nextToken = m_scanner.peek();
+      if (nextToken.type == Token::BLOCK_ENTRY ||
+          nextToken.type == Token::BLOCK_SEQ_END) {
+        eventHandler.OnNull(nextToken.mark, NullAnchor);
         continue;
       }
     }
@@ -185,7 +200,7 @@ void SingleDocParser::HandleFlowSequence(EventHandler& eventHandler) {
   m_scanner.pop();
   m_pCollectionStack->PushCollectionType(CollectionType::FlowSeq);
 
-  while (1) {
+  while (true) {
     if (m_scanner.empty())
       throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ_FLOW);
 
@@ -238,7 +253,7 @@ void SingleDocParser::HandleBlockMap(EventHandler& eventHandler) {
   m_scanner.pop();
   m_pCollectionStack->PushCollectionType(CollectionType::BlockMap);
 
-  while (1) {
+  while (true) {
     if (m_scanner.empty())
       throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP);
 
@@ -277,7 +292,7 @@ void SingleDocParser::HandleFlowMap(EventHandler& eventHandler) {
   m_scanner.pop();
   m_pCollectionStack->PushCollectionType(CollectionType::FlowMap);
 
-  while (1) {
+  while (true) {
     if (m_scanner.empty())
       throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP_FLOW);
 
@@ -356,11 +371,13 @@ 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 (1) {
+  while (true) {
     if (m_scanner.empty())
       return;
 
@@ -369,7 +386,7 @@ void SingleDocParser::ParseProperties(std::string& tag, anchor_t& anchor) {
         ParseTag(tag);
         break;
       case Token::ANCHOR:
-        ParseAnchor(anchor);
+        ParseAnchor(anchor, anchor_name);
         break;
       default:
         return;
@@ -387,11 +404,12 @@ void SingleDocParser::ParseTag(std::string& tag) {
   m_scanner.pop();
 }
 
-void SingleDocParser::ParseAnchor(anchor_t& anchor) {
+void SingleDocParser::ParseAnchor(anchor_t& anchor, std::string& anchor_name) {
   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();
 }
@@ -405,10 +423,13 @@ anchor_t SingleDocParser::RegisterAnchor(const std::string& name) {
 
 anchor_t SingleDocParser::LookupAnchor(const Mark& mark,
                                        const std::string& name) const {
-  Anchors::const_iterator it = m_anchors.find(name);
-  if (it == m_anchors.end())
-    throw ParserException(mark, ErrorMsg::UNKNOWN_ANCHOR);
+  auto it = m_anchors.find(name);
+  if (it == m_anchors.end()) {
+    std::stringstream ss;
+    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,9 +23,13 @@ struct Directives;
 struct Mark;
 struct Token;
 
-class SingleDocParser : private noncopyable {
+class SingleDocParser {
  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);
@@ -43,23 +47,25 @@ class SingleDocParser : private noncopyable {
   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);
+  void ParseAnchor(anchor_t& anchor, std::string& anchor_name);
 
   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;
 
-  typedef std::map<std::string, anchor_t> Anchors;
+  using Anchors = std::map<std::string, anchor_t>;
   Anchors m_anchors;
 
   anchor_t m_curAnchor;
 };
-}
+}  // namespace YAML
 
 #endif  // SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

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

@@ -111,24 +111,15 @@ 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},
-    {3, 3, 3, 3, 0, 3, 3, 3},
-    {4, 4, 4, 4, 4, 0, 4, 4},
-    {1, 1, 1, 1, 1, 1, 1, 1},
-    {1, 1, 1, 1, 1, 1, 1, 1},
-    {2, 2, 2, 2, 2, 0, 2, 2},
-    {2, 2, 2, 2, 0, 2, 2, 2},
-    {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},
+    {0, 1, 1, 0, 0, 0, 0, 1}, {0, 2, 2, 2, 2, 2, 2, 2},
+    {3, 3, 3, 3, 0, 3, 3, 3}, {4, 4, 4, 4, 4, 0, 4, 4},
+    {1, 1, 1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 1, 1, 1, 1},
+    {2, 2, 2, 2, 2, 0, 2, 2}, {2, 2, 2, 2, 0, 2, 2, 2},
+    {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) {
@@ -160,7 +151,8 @@ 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 = ((1 << lead_bits) - 1) << (8 - lead_bits);
+  const unsigned char header =
+      static_cast<unsigned char>(((1 << lead_bits) - 1) << (8 - lead_bits));
   const unsigned char mask = (0xFF >> (lead_bits + 1));
   return static_cast<char>(
       static_cast<unsigned char>(header | ((ch >> rshift) & mask)));
@@ -192,17 +184,20 @@ 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) {
-  typedef std::istream::traits_type char_traits;
+  using char_traits = std::istream::traits_type;
 
   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];) {
@@ -279,9 +274,11 @@ char Stream::get() {
 // . Extracts 'n' characters from the stream and updates our position
 std::string Stream::get(int n) {
   std::string ret;
-  ret.reserve(n);
-  for (int i = 0; i < n; i++)
-    ret += get();
+  if (n > 0) {
+    ret.reserve(static_cast<std::string::size_type>(n));
+    for (int i = 0; i < n; i++)
+      ret += get();
+  }
   return ret;
 }
 
@@ -332,7 +329,7 @@ bool Stream::_ReadAheadTo(size_t i) const {
 void Stream::StreamInUtf8() const {
   unsigned char b = GetNextByte();
   if (m_input.good()) {
-    m_readahead.push_back(b);
+    m_readahead.push_back(static_cast<char>(b));
   }
 }
 
@@ -353,7 +350,9 @@ 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
@@ -378,11 +377,10 @@ void Stream::StreamInUtf16() const {
           // Easiest case: queue the codepoint and return
           QueueUnicodeCodepoint(m_readahead, ch);
           return;
-        } else {
-          // Start the loop over with the new high surrogate
-          ch = chLow;
-          continue;
         }
+        // Start the loop over with the new high surrogate
+        ch = chLow;
+        continue;
       }
 
       // Select the payload bits from the high surrogate
@@ -445,4 +443,4 @@ void Stream::StreamInUtf32() const {
 
   QueueUnicodeCodepoint(m_readahead, ch);
 }
-}
+}  // namespace YAML

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

@@ -7,7 +7,6 @@
 #pragma once
 #endif
 
-#include "yaml-cpp/noncopyable.h"
 #include "yaml-cpp/mark.h"
 #include <cstddef>
 #include <deque>
@@ -17,11 +16,18 @@
 #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;
@@ -71,6 +77,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,16 +7,20 @@
 #pragma once
 #endif
 
-#include "yaml-cpp/noncopyable.h"
+#include "yaml-cpp/noexcept.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)
-      : m_offset(source.m_offset), m_stream(source.m_stream) {}
-  ~StreamCharSource() {}
+  StreamCharSource(const StreamCharSource& source) = default;
+  StreamCharSource(StreamCharSource&&) YAML_CPP_NOEXCEPT = default;
+  StreamCharSource& operator=(const StreamCharSource&) = delete;
+  StreamCharSource& operator=(StreamCharSource&&) = delete;
+  ~StreamCharSource() = default;
 
   operator bool() const;
   char operator[](std::size_t i) const { return m_stream.CharAt(m_offset + i); }
@@ -27,8 +31,6 @@ class StreamCharSource {
  private:
   std::size_t m_offset;
   const Stream& m_stream;
-
-  StreamCharSource& operator=(const StreamCharSource&);  // non-assignable
 };
 
 inline StreamCharSource::operator bool() const {
@@ -38,11 +40,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 += i;
+    source.m_offset += static_cast<std::size_t>(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,7 +6,8 @@
 #include "token.h"
 
 namespace YAML {
-Tag::Tag(const Token& token) : type(static_cast<TYPE>(token.data)) {
+Tag::Tag(const Token& token)
+    : type(static_cast<TYPE>(token.data)), handle{}, value{} {
   switch (type) {
     case VERBATIM:
       value = token.value;
@@ -28,7 +29,7 @@ Tag::Tag(const Token& token) : type(static_cast<TYPE>(token.data)) {
   }
 }
 
-const std::string Tag::Translate(const Directives& directives) {
+std::string Tag::Translate(const Directives& directives) {
   switch (type) {
     case VERBATIM:
       return value;
@@ -46,4 +47,4 @@ const 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);
-  const std::string Translate(const Directives& directives);
+  std::string Translate(const Directives& directives);
 
   TYPE type;
   std::string handle, value;

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

@@ -14,10 +14,11 @@
 
 namespace YAML {
 const std::string TokenNames[] = {
-    "DIRECTIVE", "DOC_START", "DOC_END", "BLOCK_SEQ_START", "BLOCK_MAP_START",
-    "BLOCK_SEQ_END", "BLOCK_MAP_END", "BLOCK_ENTRY", "FLOW_SEQ_START",
-    "FLOW_MAP_START", "FLOW_SEQ_END", "FLOW_MAP_END", "FLOW_MAP_COMPACT",
-    "FLOW_ENTRY", "KEY", "VALUE", "ANCHOR", "ALIAS", "TAG", "SCALAR"};
+    "DIRECTIVE",        "DOC_START",      "DOC_END",       "BLOCK_SEQ_START",
+    "BLOCK_MAP_START",  "BLOCK_SEQ_END",  "BLOCK_MAP_END", "BLOCK_ENTRY",
+    "FLOW_SEQ_START",   "FLOW_MAP_START", "FLOW_SEQ_END",  "FLOW_MAP_END",
+    "FLOW_MAP_COMPACT", "FLOW_ENTRY",     "KEY",           "VALUE",
+    "ANCHOR",           "ALIAS",          "TAG",           "SCALAR"};
 
 struct Token {
   // enums
@@ -48,12 +49,12 @@ struct Token {
 
   // data
   Token(TYPE type_, const Mark& mark_)
-      : status(VALID), type(type_), mark(mark_), data(0) {}
+      : status(VALID), type(type_), mark(mark_), value{}, params{}, data(0) {}
 
   friend std::ostream& operator<<(std::ostream& out, const Token& token) {
     out << TokenNames[token.type] << std::string(": ") << token.value;
-    for (std::size_t i = 0; i < token.params.size(); i++)
-      out << std::string(" ") << token.params[i];
+    for (const std::string& param : token.params)
+      out << std::string(" ") << param;
     return out;
   }
 
@@ -64,6 +65,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,7 +95,7 @@
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <InlineFunctionExpansion>Disabled</InlineFunctionExpansion>
       <AdditionalIncludeDirectories>$(SolutionDir)3rdparty\yaml-cpp\include\;$(SolutionDir)3rdparty\yaml-cpp\src\;</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;_WINDOWS;_DEBUG;_ITERATOR_DEBUG_LEVEL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>YAML_CPP_STATIC_DEFINE;WIN32;_WINDOWS;_DEBUG;_ITERATOR_DEBUG_LEVEL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
   </ItemDefinitionGroup>
@@ -107,7 +107,7 @@
       </SDLCheck>
       <AdditionalIncludeDirectories>$(SolutionDir)3rdparty\yaml-cpp\include\;$(SolutionDir)3rdparty\yaml-cpp\src\;</AdditionalIncludeDirectories>
       <InlineFunctionExpansion>Disabled</InlineFunctionExpansion>
-      <PreprocessorDefinitions>WIN32;_WINDOWS;_DEBUG;_ITERATOR_DEBUG_LEVEL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>YAML_CPP_STATIC_DEFINE;WIN32;_WINDOWS;_DEBUG;_ITERATOR_DEBUG_LEVEL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
   </ItemDefinitionGroup>
@@ -120,7 +120,7 @@
       <SDLCheck>
       </SDLCheck>
       <AdditionalIncludeDirectories>$(SolutionDir)3rdparty\yaml-cpp\include\;$(SolutionDir)3rdparty\yaml-cpp\src\;</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;_WINDOWS;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>YAML_CPP_STATIC_DEFINE;WIN32;_WINDOWS;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
     </ClCompile>
     <Link>
@@ -137,7 +137,7 @@
       <SDLCheck>
       </SDLCheck>
       <AdditionalIncludeDirectories>$(SolutionDir)3rdparty\yaml-cpp\include\;$(SolutionDir)3rdparty\yaml-cpp\src\;</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;_WINDOWS;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>YAML_CPP_STATIC_DEFINE;WIN32;_WINDOWS;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
     </ClCompile>
     <Link>
@@ -174,6 +174,7 @@
     <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,6 +89,9 @@
     <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 11) # C++11...
+set(CMAKE_CXX_STANDARD 17) # C++17...
 set(CMAKE_CXX_STANDARD_REQUIRED ON) #...is required...
 #set(CMAKE_CXX_EXTENSIONS OFF) #...without compiler extensions like gnu++11
 
@@ -309,6 +309,17 @@ 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)
 #

README.md

@@ -1,8 +1,8 @@
 <img src="doc/logo.png" align="right" height="90" />
 
 # rAthena
-[![Total alerts](https://img.shields.io/lgtm/alerts/g/rathena/rathena.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/rathena/rathena/alerts/) [![Language grade: C/C++](https://img.shields.io/lgtm/grade/cpp/g/rathena/rathena.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/rathena/rathena/context:cpp) ![GitHub](https://img.shields.io/github/license/rathena/rathena.svg) ![GitHub repo size](https://img.shields.io/github/repo-size/rathena/rathena.svg)
-> rAthena is a collaborative software development project revolving around the creation of a robust massively multiplayer online role playing game (MMORPG) server package. Written in C, the program is very versatile and provides NPCs, warps and modifications. The project is jointly managed by a group of volunteers located around the world as well as a tremendous community providing QA and support. rAthena is a continuation of the eAthena project.
+![clang](https://img.shields.io/github/actions/workflow/status/rathena/rathena/build_servers_clang.yml?label=clang%20build&logo=llvm) ![cmake](https://img.shields.io/github/actions/workflow/status/rathena/rathena/build_servers_cmake.yml?label=cmake%20build&logo=cmake) ![gcc](https://img.shields.io/github/actions/workflow/status/rathena/rathena/build_servers_gcc.yml?label=gcc%20build&logo=gnu) ![ms](https://img.shields.io/github/actions/workflow/status/rathena/rathena/build_servers_msbuild.yml?label=ms%20build&logo=visualstudio) ![GitHub](https://img.shields.io/github/license/rathena/rathena.svg) ![commit activity](https://img.shields.io/github/commit-activity/w/rathena/rathena) ![GitHub repo size](https://img.shields.io/github/repo-size/rathena/rathena.svg)
+> rAthena is a collaborative software development project revolving around the creation of a robust massively multiplayer online role playing game (MMORPG) server package. Written in C++, the program is very versatile and provides NPCs, warps and modifications. The project is jointly managed by a group of volunteers located around the world as well as a tremendous community providing QA and support. rAthena is a continuation of the eAthena project.
 
 [Forum](https://rathena.org/board)|[Discord](https://rathena.org/discord)|[Wiki](https://github.com/rathena/rathena/wiki)|[FluxCP](https://github.com/rathena/FluxCP)|[Crowdfunding](https://rathena.org/board/crowdfunding/)|[Fork and Pull Request Q&A](https://rathena.org/board/topic/86913-pull-request-qa/)
 --------|--------|--------|--------|--------|--------
@@ -29,8 +29,8 @@ Disk Space | 300 MB | 500 MB
 ### Operating System & Preferred Compiler
 Operating System | Compiler
 ------|------
-Linux  | [gcc-5 or newer](https://www.gnu.org/software/gcc/gcc-5/) / [Make](https://www.gnu.org/software/make/)
-Windows | [MS Visual Studio 2013, 2015, 2017](https://www.visualstudio.com/downloads/)
+Linux  | [gcc-6 or newer](https://www.gnu.org/software/gcc/gcc-6/) / [Make](https://www.gnu.org/software/make/)
+Windows | [MS Visual Studio 2017 or newer](https://www.visualstudio.com/downloads/)
 
 ### Required Applications
 Application | Name

conf/atcommands.yml

@@ -1019,6 +1019,9 @@ Body:
   - Command: roulette
     Help: |
       Opens the roulette UI.
+  - Command: setcard 
+    Help: |
+      Adds a card or enchant to the specific slot of the equipment.
 
 Footer:
   Imports:

conf/battle/feature.conf

@@ -33,6 +33,11 @@ feature.warp_suggestions: off
 // Requires: 2013-07-24aRagexe or later
 feature.banking: on
 
+// Should Banking strictly checks the UI state on zeny deposit and withdrawal? (Note 1)
+// Note: Disabled by default because existing official clients do not report the banking UI state to the server.
+// But this config could be useful in case of clients that actually report the UI state or custom clients.
+feature.banking_state_enforce: no
+
 // Autotrade persistency (Note 1)
 // Should vendors that used @autotrade be restored after a restart?
 feature.autotrade: on
@@ -141,12 +146,32 @@ feature.dynamicnpc_rangey: 2
 feature.dynamicnpc_direction: no
 
 // Itemlink System on informational related commands (Note 1)
-// Generates <ITEML> string for an item and can be used for npctalk, message,
+// Generates an itemlink string for an item and can be used for npctalk, message,
 // dispbottom, and broadcast commands. The result is clickable-item name just
 // like from SHIFT+Click from player's inventory/cart/equipment window.
-// Requires: 2010-00-00RagexeRE or later
+// Requires: 2015-11-04Ragexe or later
 feature.itemlink: on
 
+// Itemlink System on NPC messages (Note 1)
+// Generates an itemlink string for an item and can be used for NPC's mes command.
+// Requires: 2010-01-01 or later
+feature.mesitemlink: on
+
+// Force all mesitemlinks to be wrapped in brackets (Note 1)
+// Default: no
+feature.mesitemlink_brackets: no
+
+// Force all mesitemlinks to use the database name (Note 1)
+// Default: no
+feature.mesitemlink_dbname: no
+
 // Stylist UI (Note 1)
 // Requires: 2015-11-04 or later
 feature.stylist: on
+
+// Are players allowed to reconnect into instances? (Note 1)
+// This is enabled by default in Renewal mode and
+// disabled by default in Pre-Renewal mode.
+// If this is allowed the "nosave" mapflag is still being respected
+// and may prevent players from warping back into the instance.
+//feature.instance_allow_reconnect: yes

conf/battle/homunc.conf

@@ -50,7 +50,7 @@ homunculus_auto_vapor: 80
 homunculus_max_level: 99
 
 // Max level for Homunculus S
-homunculus_S_max_level: 175
+homunculus_S_max_level: 250
 
 // Growth level for Homunculus S
 // This is the level at which homunculus S can use their growth tables

conf/maps_athena.conf

@@ -1570,5 +1570,37 @@ map: herosria
 map: mjo_wst01
 map: ra_pol01
 
+// Episode 20
+map: 1@20cn1
+map: 1@20cn2
+map: 1@slug
+map: 1@twas
+map: 1@twbs
+map: 1@twig
+map: 1@twsd
+map: icas_in2
+map: jor_back4
+map: jor_back5
+map: jor_back6
+map: jor_maze
+map: jor_root1
+map: jor_root2
+map: jor_root3
+map: jor_safty1
+map: jor_safty2
+map: jor_sanct
+map: jor_twice
+map: jor_twig
+
+// Biosphere 1st floor
+map: bl_depth1
+
+// Garden of Time
+map: 1@ba_go
+map: 1@f_lake
+map: for_dun01
+map: for_dun02
+map: t_garden
+
 //------------------------- Clone Maps ---------------------------
 //------------------------- Extra Maps ---------------------------