--- /dev/null
+yaml-cpp (0.6.3-8) unstable; urgency=medium
+
+ [ Debian Janitor ]
+ * Set upstream metadata fields: Bug-Database, Bug-Submit, Repository,
+ Repository-Browse.
+
+ [ Helmut Grohne ]
+ * Fix FTCBFS: Don't build tests for DEB_BUILD_OPTIONS=nocheck.
+ (Closes: #960167)
+
+ -- Gianfranco Costamagna <locutusofborg@debian.org> Thu, 14 May 2020 10:29:07 +0200
+
+yaml-cpp (0.6.3-7) unstable; urgency=medium
+
+ * Team upload
+ [ Adrian Bunk ]
+ * From Adrian Bunk, fix other c++ symbols that broke ABI
+ (Closes: #959201)
+
+ -- Gianfranco Costamagna <locutusofborg@debian.org> Wed, 13 May 2020 19:26:42 +0200
+
+yaml-cpp (0.6.3-6) unstable; urgency=medium
+
+ * Ack NMUs, thanks a bunch Gianfranco!
+ - Add him as a co-maintainer so he doesn't have to grandfather in team
+ uploads.
+
+ -- Simon Quigley <tsimonq2@debian.org> Sun, 10 May 2020 14:15:46 -0500
+
+yaml-cpp (0.6.3-5) unstable; urgency=medium
+
+ * Team upload.
+ [ Helmut Grohne ]
+ * Fix FTCBFS (Closes: #843918)
+ + Let dh_auto_configure pass cross flags
+ + Honour DEB_BUILD_OPTIONS=nocheck
+
+ -- Gianfranco Costamagna <locutusofborg@debian.org> Sat, 09 May 2020 17:34:48 +0200
+
+yaml-cpp (0.6.3-4) unstable; urgency=medium
+
+ * Team upload (salsa.d.o namespace)
+ * Use -g1 optimization level to fix FTBFS on mipsel
+
+ -- Gianfranco Costamagna <locutusofborg@debian.org> Fri, 08 May 2020 23:34:57 +0200
+
+yaml-cpp (0.6.3-3) unstable; urgency=medium
+
+ * Team upload (salsa.d.o namespace)
+ * Lower mipsel build to parallel=1
+
+ -- Gianfranco Costamagna <locutusofborg@debian.org> Fri, 08 May 2020 19:17:53 +0200
+
+yaml-cpp (0.6.3-2) unstable; urgency=medium
+
+ * Team upload (salsa.d.o namespace)
+ * Fix mipsel build by lowering to parallel=2 there (Closes: #959402)
+
+ -- Gianfranco Costamagna <locutusofborg@debian.org> Fri, 08 May 2020 15:42:46 +0200
+
+yaml-cpp (0.6.3-1.2) unstable; urgency=medium
+
+ * Non-maintainer upload.
+ * Update also symbols file
+
+ -- Gianfranco Costamagna <locutusofborg@debian.org> Fri, 08 May 2020 14:15:10 +0200
+
+yaml-cpp (0.6.3-1.1) unstable; urgency=medium
+
+ * Non-maintainer upload
+ * Revert ABI changes in new release (Closes: #959201)
+ - debian/patches/revert-774f25800e6f19f4b927023c85d1389af322da5e.patch:
+
+ -- Gianfranco Costamagna <locutusofborg@debian.org> Fri, 08 May 2020 13:15:00 +0200
+
+yaml-cpp (0.6.3-1) unstable; urgency=medium
+
+ * New upstream release (Closes: #958505).
+ - Refresh patches.
+ - BUILD_SHARED_LIBS -> YAML_BUILD_SHARED_LIBS cmake flag.
+ - Update symbols from amd64 build log.
+ * Add the following CVE patches:
+ - fix-CVE-2017-11692.patch
+ + Fixes CVE-2017-11692 (Closes: #870326).
+ - fix-unbounded-recursion-depth.patch
+ + Fixes CVE-2017-5950 (Closes: #859891).
+ + Fixes CVE-2018-20573 (Closes: #918147).
+ + Fixes CVE-2018-20574 (Closes: #918145).
+ + Fixes CVE-2019-6285 (Closes: #919432, 919430).
+ * Migrate to using the debhelper-compat dependency.
+ * Bump Standards-version to 4.5.0, no changes needed.
+ * Migrate to debhelper 13.
+
+ -- Simon Quigley <tsimonq2@debian.org> Wed, 29 Apr 2020 20:24:07 -0500
+
+yaml-cpp (0.6.2-4) unstable; urgency=medium
+
+ * Upload to Sid.
+
+ -- Simon Quigley <tsimonq2@debian.org> Mon, 07 Jan 2019 16:00:33 -0600
+
+yaml-cpp (0.6.2-3) experimental; urgency=medium
+
+ * Update symbols from build logs.
+
+ -- Simon Quigley <tsimonq2@debian.org> Sat, 05 Jan 2019 17:27:47 -0600
+
+yaml-cpp (0.6.2-2) experimental; urgency=medium
+
+ [ Christopher James Halse Rogers ]
+ * d/libyaml-cpp0.6.symbols:
+ - Add symbols file now that only public symbols are exported
+ * d/libyaml-cpp-dev.install:
+ - Don't install gtest/gmock headers (Closes: #915575)
+
+ [ Simon Quigley ]
+ * Change my email to tsimonq2@debian.org now that I am a Debian Developer.
+ * Bump Standards-version to 4.3.0, no changes needed.
+
+ -- Simon Quigley <tsimonq2@debian.org> Sun, 23 Dec 2018 22:25:40 -0600
+
+yaml-cpp (0.6.2-1) experimental; urgency=medium
+
+ [ Andreas Tille ]
+ * New upstream version
+ * debhelper 11
+ * Standards-Version: 4.2.0
+ * Point Vcs-fields to Salsa
+ * Fix watch file
+
+ [ Graham Inggs ]
+ * Drop patches no longer needed
+ * Drop dependencies on libboost-dev, no longer needed
+ * Rename binary package for libyaml-cpp0.6 transition
+
+ [ Ondřej Nový ]
+ * d/copyright: Use https protocol in Format field
+ * d/changelog: Remove trailing whitespaces
+
+ [ Christopher James Halse Rogers ]
+ * patches/symbol-visibility.patch: Hide non-public-API symbols.
+ - Cuts down the number of exported symbols by over half, and makes
+ it more feasible to use a .symbols file
+ * d/rules: Use VERBOSE make.
+ - Lets the hardening buildlog scanning check that the appropriate
+ flags have been passed, and makes it easier to debug build
+ failures.
+
+ [ Simon Quigley ]
+ * Take over maintainership of the package (Closes: #914853).
+ * Depend on debhelper 11.
+ * Run wrap-and-sort.
+ * Bump Standards-version to 4.2.1.
+
+ -- Simon Quigley <tsimonq2@ubuntu.com> Tue, 27 Nov 2018 18:23:07 -0600
+
+yaml-cpp (0.5.2-4) unstable; urgency=medium
+
+ * Make the build reproducible (Closes: #808714)
+ * Add libboost-dev dependency (Closes: #812851)
+ * Fix yaml-cpp 0.5.2 issue (Closes: #814499)
+ * Fix lintian warnings: spelling, standards-version, and Vcs-Git
+
+ -- Paul Novotny <paul@paulnovo.us> Wed, 12 Oct 2016 19:48:11 -0400
+
+yaml-cpp (0.5.2-3.1) unstable; urgency=medium
+
+ * Non-maintainer upload.
+ * Work around bug in googletest causing segfault with gcc-6.
+ (Closes: #812284)
+
+ -- Christian Hofstaedtler <zeha@debian.org> Sat, 02 Jul 2016 13:27:16 +0200
+
+yaml-cpp (0.5.2-3) unstable; urgency=medium
+
+ * Fix error in yaml-cpp-config.cmake
+ * Disable gtest's use of pthread on hurd and kfreebsd
+
+ -- Paul Novotny <paul@paulnovo.us> Mon, 30 Nov 2015 16:53:57 -0500
+
+yaml-cpp (0.5.2-2) unstable; urgency=medium
+
+ * Rename libyaml-cpp0.5 to libyaml-cpp0.5v5 for gcc5 transition
+ (Closes: #791317)
+
+ -- Paul Novotny <paul@paulnovo.us> Tue, 04 Aug 2015 18:03:35 -0400
+
+yaml-cpp (0.5.2-1) unstable; urgency=medium
+
+ * Update due to yaml-cpp from Google Code to GitHub
+ * Imported Upstream version 0.5.2
+ * Remove patches/fix-unit-test.patch, applied upstream
+ * Remove patches/remove-conflicting-google-libs.patch, applied upstream
+
+ -- Paul Novotny <paul@paulnovo.us> Thu, 23 Apr 2015 16:40:20 -0400
+
+yaml-cpp (0.5.1+hg20150210-1) experimental; urgency=medium
+
+ [ Andreas Tille ]
+ * Import latest upstream
+ * Fix failing unit tests
+ * Inject package into collab-maint to enable more people contributing
+ * cme fix dpkg-control
+ * debhelper 9
+
+ [ Paul Novotny ]
+ * Add myself as Uploader
+ * Import latest upstream VCS status
+ * Fix failing unit tests, update version number
+ * Install cmake development files
+
+ -- Andreas Tille <tille@debian.org> Mon, 09 Feb 2015 13:36:42 +0100
+
+yaml-cpp (0.5.1-1) unstable; urgency=low
+
+ * New upstream release. (Closes: #706708)
+ * Bump Standards-Version to 3.9.4.
+ * libyaml-cpp-dev: remove multiarch path in yaml-cpp.pc to make
+ lintian happy.
+ * debian/copyright: new Format URI.
+ * debian/control: remove Vcs-Svn field.
+
+ -- Lifeng Sun <lifongsun@gmail.com> Fri, 30 Aug 2013 18:29:05 +0800
+
+yaml-cpp (0.3.0-1) unstable; urgency=low
+
+ * Initial release (Closes: #636985)
+
+ -- Lifeng Sun <lifongsun@gmail.com> Sun, 03 Jun 2012 23:48:30 +0800
--- /dev/null
+Source: yaml-cpp
+Maintainer: Simon Quigley <tsimonq2@debian.org>
+Uploaders: Gianfranco Costamagna <locutusofborg@debian.org>
+Section: devel
+Priority: optional
+Build-Depends: cmake, debhelper-compat (= 13)
+Standards-Version: 4.5.0
+Vcs-Browser: https://salsa.debian.org/debian/yaml-cpp
+Vcs-Git: https://salsa.debian.org/debian/yaml-cpp.git
+Homepage: https://github.com/jbeder/yaml-cpp
+
+Package: libyaml-cpp0.6
+Architecture: any
+Multi-Arch: same
+Section: libs
+Depends: ${misc:Depends}, ${shlibs:Depends}
+Pre-Depends: ${misc:Pre-Depends}
+Description: YAML parser and emitter for C++
+ yaml-cpp is a C++ library for parsing and emitting data in YAML 1.2, a
+ human-readable data serialization format.
+ .
+ This package provides run-time library of yaml-cpp.
+
+Package: libyaml-cpp-dev
+Architecture: any
+Section: libdevel
+Depends: libyaml-cpp0.6 (= ${binary:Version}), ${misc:Depends}
+Description: YAML parser and emitter for C++ - development files
+ yaml-cpp is a C++ library for parsing and emitting data in YAML 1.2, a
+ human-readable data serialization format.
+ .
+ This package provides development files of yaml-cpp.
--- /dev/null
+Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: yaml-cpp
+Source: https://github.com/jbeder/yaml-cpp
+
+Files: *
+Copyright: 2008 Jesse Beder <jbeder@gmail.com>
+License: X11
+ Permission is hereby granted, free of charge, to any person obtaining a
+ copy of this software and associated documentation files (the "Software"),
+ to deal in the Software without restriction, including without limitation
+ the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ and/or sell copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following conditions:
+ .
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+ .
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+
+Files: debian/*
+Copyright: 2011-2013 Lifeng Sun <lifongsun@gmail.com>
+License: GPL-2.0+
+ This package is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+ .
+ This package is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ .
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>
+ .
+ On Debian systems, the complete text of the GNU General
+ Public License version 2 can be found in "/usr/share/common-licenses/GPL-2".
--- /dev/null
+usr/include/yaml-cpp/
+usr/lib/*/*.a
+usr/lib/*/*.so
+usr/lib/*/cmake/
+usr/lib/*/pkgconfig/
--- /dev/null
+usr/lib/*/libyaml-cpp.so.*
--- /dev/null
+libyaml-cpp.so.0.6 libyaml-cpp0.6 #MINVER#
+#yaml-cpp does not deliberately define any weak symbols;
+# they are all inline functions that the compiler has chosen
+# to also emit a symbol for.
+(optional)#include "weak-symbols"
+# Actual symbols of the yaml-cpp ABI
+ _ZN4YAML11BadPushbackD0Ev@Base 0.6.2
+ _ZN4YAML11BadPushbackD1Ev@Base 0.6.2
+ _ZN4YAML11BadPushbackD2Ev@Base 0.6.2
+ _ZN4YAML11InvalidNodeD0Ev@Base 0.6.2
+ _ZN4YAML11InvalidNodeD1Ev@Base 0.6.2
+ _ZN4YAML11InvalidNodeD2Ev@Base 0.6.2
+ _ZN4YAML11KeyNotFoundD0Ev@Base 0.6.2
+ _ZN4YAML11KeyNotFoundD1Ev@Base 0.6.2
+ _ZN4YAML11KeyNotFoundD2Ev@Base 0.6.2
+ _ZN4YAML12BadSubscriptD0Ev@Base 0.6.2
+ _ZN4YAML12BadSubscriptD1Ev@Base 0.6.2
+ _ZN4YAML12BadSubscriptD2Ev@Base 0.6.2
+ _ZN4YAML12DecodeBase64ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2
+ (arch-bits=64)_ZN4YAML12EncodeBase64B5cxx11EPKhm@Base 0.6.2
+ (arch-bits=32)_ZN4YAML12EncodeBase64B5cxx11EPKhj@Base 0.6.2
+ _ZN4YAML12IsNullStringERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2
+ _ZN4YAML13BadConversionD0Ev@Base 0.6.2
+ _ZN4YAML13BadConversionD1Ev@Base 0.6.2
+ _ZN4YAML13BadConversionD2Ev@Base 0.6.2
+ _ZN4YAML13InvalidScalarD0Ev@Base 0.6.2
+ _ZN4YAML13InvalidScalarD1Ev@Base 0.6.2
+ _ZN4YAML13InvalidScalarD2Ev@Base 0.6.2
+ _ZN4YAML14BadDereferenceD0Ev@Base 0.6.2
+ _ZN4YAML14BadDereferenceD1Ev@Base 0.6.2
+ _ZN4YAML14BadDereferenceD2Ev@Base 0.6.2
+ _ZN4YAML15LoadAllFromFileERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2
+ _ZN4YAML15ostream_wrapper10update_posEc@Base 0.6.2
+ (arch-bits=64)_ZN4YAML15ostream_wrapper5writeEPKcm@Base 0.6.2
+ (arch-bits=32)_ZN4YAML15ostream_wrapper5writeEPKcj@Base 0.6.2
+ _ZN4YAML15ostream_wrapper5writeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2
+ _ZN4YAML15ostream_wrapperC1ERSo@Base 0.6.2
+ _ZN4YAML15ostream_wrapperC1Ev@Base 0.6.2
+ _ZN4YAML15ostream_wrapperC2ERSo@Base 0.6.2
+ _ZN4YAML15ostream_wrapperC2Ev@Base 0.6.2
+ _ZN4YAML15ostream_wrapperD1Ev@Base 0.6.2
+ _ZN4YAML15ostream_wrapperD2Ev@Base 0.6.2
+ _ZN4YAML15ParserExceptionD0Ev@Base 0.6.2
+ _ZN4YAML15ParserExceptionD1Ev@Base 0.6.2
+ _ZN4YAML15ParserExceptionD2Ev@Base 0.6.2
+ _ZN4YAML16EmitterExceptionD0Ev@Base 0.6.2
+ _ZN4YAML16EmitterExceptionD1Ev@Base 0.6.2
+ _ZN4YAML16EmitterExceptionD2Ev@Base 0.6.2
+ _ZN4YAML23RepresentationExceptionD0Ev@Base 0.6.2
+ _ZN4YAML23RepresentationExceptionD1Ev@Base 0.6.2
+ _ZN4YAML23RepresentationExceptionD2Ev@Base 0.6.2
+ _ZN4YAML4DumpB5cxx11ERKNS_4NodeE@Base 0.6.2
+ _ZN4YAML4LoadEPKc@Base 0.6.2
+ _ZN4YAML4LoadERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2
+ _ZN4YAML4LoadERSi@Base 0.6.2
+ _ZN4YAML4NullE@Base 0.6.2
+ _ZN4YAML5CloneERKNS_4NodeE@Base 0.6.2
+ _ZN4YAML5RegExC1Ec@Base 0.6.2
+ _ZN4YAML5RegExC1Ecc@Base 0.6.2
+ _ZN4YAML5RegExC1ENS_8REGEX_OPE@Base 0.6.2
+ _ZN4YAML5RegExC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_8REGEX_OPE@Base 0.6.2
+ _ZN4YAML5RegExC1Ev@Base 0.6.2
+ _ZN4YAML5RegExC2Ec@Base 0.6.2
+ _ZN4YAML5RegExC2Ecc@Base 0.6.2
+ _ZN4YAML5RegExC2ENS_8REGEX_OPE@Base 0.6.2
+ _ZN4YAML5RegExC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_8REGEX_OPE@Base 0.6.2
+ _ZN4YAML5RegExC2Ev@Base 0.6.2
+ _ZN4YAML6detail13memory_holder5mergeERS1_@Base 0.6.2
+ _ZN4YAML6detail6memory11create_nodeEv@Base 0.6.2
+ _ZN4YAML6detail6memory5mergeERKS1_@Base 0.6.2
+ _ZN4YAML6detail9node_data10set_scalarERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2
+ _ZN4YAML6detail9node_data12empty_scalarB5cxx11E@Base 0.6.2
+ _ZN4YAML6detail9node_data12mark_definedEv@Base 0.6.2
+ _ZN4YAML6detail9node_data14convert_to_mapESt10shared_ptrINS0_13memory_holderEE@Base 0.6.2
+ _ZN4YAML6detail9node_data14reset_sequenceEv@Base 0.6.2
+ _ZN4YAML6detail9node_data15insert_map_pairERNS0_4nodeES3_@Base 0.6.2
+ _ZN4YAML6detail9node_data23convert_sequence_to_mapESt10shared_ptrINS0_13memory_holderEE@Base 0.6.2
+ _ZN4YAML6detail9node_data3endEv@Base 0.6.2
+ _ZN4YAML6detail9node_data3getERNS0_4nodeESt10shared_ptrINS0_13memory_holderEE@Base 0.6.2
+ _ZN4YAML6detail9node_data5beginEv@Base 0.6.2
+ _ZN4YAML6detail9node_data6insertERNS0_4nodeES3_St10shared_ptrINS0_13memory_holderEE@Base 0.6.2
+ _ZN4YAML6detail9node_data6removeERNS0_4nodeESt10shared_ptrINS0_13memory_holderEE@Base 0.6.2
+ _ZN4YAML6detail9node_data7set_tagERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2
+ _ZN4YAML6detail9node_data8set_markERKNS_4MarkE@Base 0.6.2
+ _ZN4YAML6detail9node_data8set_nullEv@Base 0.6.2
+ _ZN4YAML6detail9node_data8set_typeENS_8NodeType5valueE@Base 0.6.2
+ _ZN4YAML6detail9node_data9push_backERNS0_4nodeESt10shared_ptrINS0_13memory_holderEE@Base 0.6.2
+ _ZN4YAML6detail9node_data9reset_mapEv@Base 0.6.2
+ _ZN4YAML6detail9node_data9set_styleENS_12EmitterStyle5valueE@Base 0.6.2
+ _ZN4YAML6detail9node_dataC1Ev@Base 0.6.2
+ _ZN4YAML6detail9node_dataC2Ev@Base 0.6.2
+ _ZN4YAML6Parser11PrintTokensERSo@Base 0.6.2
+ _ZN4YAML6Parser15HandleDirectiveERKNS_5TokenE@Base 0.6.2
+ _ZN4YAML6Parser15ParseDirectivesEv@Base 0.6.2
+ _ZN4YAML6Parser18HandleNextDocumentERNS_12EventHandlerE@Base 0.6.2
+ _ZN4YAML6Parser18HandleTagDirectiveERKNS_5TokenE@Base 0.6.2
+ _ZN4YAML6Parser19HandleYamlDirectiveERKNS_5TokenE@Base 0.6.2
+ _ZN4YAML6Parser4LoadERSi@Base 0.6.2
+ _ZN4YAML6ParserC1ERSi@Base 0.6.2
+ _ZN4YAML6ParserC1Ev@Base 0.6.2
+ _ZN4YAML6ParserC2ERSi@Base 0.6.2
+ _ZN4YAML6ParserC2Ev@Base 0.6.2
+ _ZN4YAML6ParserD1Ev@Base 0.6.2
+ _ZN4YAML6ParserD2Ev@Base 0.6.2
+ _ZN4YAML7BadFileD0Ev@Base 0.6.2
+ _ZN4YAML7BadFileD1Ev@Base 0.6.2
+ _ZN4YAML7BadFileD2Ev@Base 0.6.2
+ _ZN4YAML7convertIbE6decodeERKNS_4NodeERb@Base 0.6.2
+ _ZN4YAML7Emitter10EmitEndDocEv@Base 0.6.2
+ _ZN4YAML7Emitter10EmitEndMapEv@Base 0.6.2
+ _ZN4YAML7Emitter10EmitEndSeqEv@Base 0.6.2
+ _ZN4YAML7Emitter10SetIntBaseENS_13EMITTER_MANIPE@Base 0.6.2
+ _ZN4YAML7Emitter11EmitKindTagEv@Base 0.6.2
+ _ZN4YAML7Emitter11EmitNewlineEv@Base 0.6.2
+ _ZN4YAML7Emitter11PrepareNodeENS_15EmitterNodeType5valueE@Base 0.6.2
+ _ZN4YAML7Emitter12EmitBeginDocEv@Base 0.6.2
+ _ZN4YAML7Emitter12EmitBeginMapEv@Base 0.6.2
+ _ZN4YAML7Emitter12EmitBeginSeqEv@Base 0.6.2
+ _ZN4YAML7Emitter12SetMapFormatENS_13EMITTER_MANIPE@Base 0.6.2
+ _ZN4YAML7Emitter12SetSeqFormatENS_13EMITTER_MANIPE@Base 0.6.2
+ _ZN4YAML7Emitter13SetBoolFormatENS_13EMITTER_MANIPE@Base 0.6.2
+ _ZN4YAML7Emitter13SetLocalValueENS_13EMITTER_MANIPE@Base 0.6.2
+ _ZN4YAML7Emitter13StartedScalarEv@Base 0.6.2
+ _ZN4YAML7Emitter14PrepareTopNodeENS_15EmitterNodeType5valueE@Base 0.6.2
+ _ZN4YAML7Emitter14SetLocalIndentERKNS_7_IndentE@Base 0.6.2
+ _ZN4YAML7Emitter15SetStringFormatENS_13EMITTER_MANIPE@Base 0.6.2
+ (arch-bits=64)_ZN4YAML7Emitter15SpaceOrIndentToEbm@Base 0.6.2
+ (arch-bits=32)_ZN4YAML7Emitter15SpaceOrIndentToEbj@Base 0.6.2
+ _ZN4YAML7Emitter16SetOutputCharsetENS_13EMITTER_MANIPE@Base 0.6.2
+ (arch-bits=64)_ZN4YAML7Emitter17SetFloatPrecisionEm@Base 0.6.2
+ (arch-bits=32)_ZN4YAML7Emitter17SetFloatPrecisionEj@Base 0.6.2
+ _ZN4YAML7Emitter17SetLocalPrecisionERKNS_10_PrecisionE@Base 0.6.2
+ _ZN4YAML7Emitter18FlowMapPrepareNodeENS_15EmitterNodeType5valueE@Base 0.6.2
+ _ZN4YAML7Emitter18FlowSeqPrepareNodeENS_15EmitterNodeType5valueE@Base 0.6.2
+ (arch-bits=64)_ZN4YAML7Emitter18SetDoublePrecisionEm@Base 0.6.2
+ (arch-bits=32)_ZN4YAML7Emitter18SetDoublePrecisionEj@Base 0.6.2
+ _ZN4YAML7Emitter19BlockMapPrepareNodeENS_15EmitterNodeType5valueE@Base 0.6.2
+ _ZN4YAML7Emitter19BlockSeqPrepareNodeENS_15EmitterNodeType5valueE@Base 0.6.2
+ (arch-bits=64)_ZN4YAML7Emitter19SetPreCommentIndentEm@Base 0.6.2
+ (arch-bits=32)_ZN4YAML7Emitter19SetPreCommentIndentEj@Base 0.6.2
+ (arch-bits=64)_ZN4YAML7Emitter20SetPostCommentIndentEm@Base 0.6.2
+ (arch-bits=32)_ZN4YAML7Emitter20SetPostCommentIndentEj@Base 0.6.2
+ _ZN4YAML7Emitter21FlowMapPrepareLongKeyENS_15EmitterNodeType5valueE@Base 0.6.2
+ _ZN4YAML7Emitter22BlockMapPrepareLongKeyENS_15EmitterNodeType5valueE@Base 0.6.2
+ _ZN4YAML7Emitter23FlowMapPrepareSimpleKeyENS_15EmitterNodeType5valueE@Base 0.6.2
+ _ZN4YAML7Emitter24BlockMapPrepareSimpleKeyENS_15EmitterNodeType5valueE@Base 0.6.2
+ _ZN4YAML7Emitter26FlowMapPrepareLongKeyValueENS_15EmitterNodeType5valueE@Base 0.6.2
+ _ZN4YAML7Emitter27BlockMapPrepareLongKeyValueENS_15EmitterNodeType5valueE@Base 0.6.2
+ _ZN4YAML7Emitter28FlowMapPrepareSimpleKeyValueENS_15EmitterNodeType5valueE@Base 0.6.2
+ _ZN4YAML7Emitter29BlockMapPrepareSimpleKeyValueENS_15EmitterNodeType5valueE@Base 0.6.2
+ _ZN4YAML7Emitter5WriteEb@Base 0.6.2
+ _ZN4YAML7Emitter5WriteEc@Base 0.6.2
+ _ZN4YAML7Emitter5WriteERKNS_4_TagE@Base 0.6.2
+ _ZN4YAML7Emitter5WriteERKNS_5_NullE@Base 0.6.2
+ _ZN4YAML7Emitter5WriteERKNS_6_AliasE@Base 0.6.2
+ _ZN4YAML7Emitter5WriteERKNS_6BinaryE@Base 0.6.2
+ _ZN4YAML7Emitter5WriteERKNS_7_AnchorE@Base 0.6.2
+ _ZN4YAML7Emitter5WriteERKNS_8_CommentE@Base 0.6.2
+ _ZN4YAML7Emitter5WriteERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2
+ (arch-bits=64)_ZN4YAML7Emitter9SetIndentEm@Base 0.6.2
+ (arch-bits=32)_ZN4YAML7Emitter9SetIndentEj@Base 0.6.2
+ _ZN4YAML7EmitterC1ERSo@Base 0.6.2
+ _ZN4YAML7EmitterC1Ev@Base 0.6.2
+ _ZN4YAML7EmitterC2ERSo@Base 0.6.2
+ _ZN4YAML7EmitterC2Ev@Base 0.6.2
+ _ZN4YAML7EmitterD1Ev@Base 0.6.2
+ _ZN4YAML7EmitterD2Ev@Base 0.6.2
+ _ZN4YAML7LoadAllEPKc@Base 0.6.2
+ _ZN4YAML7LoadAllERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2
+ _ZN4YAML7LoadAllERSi@Base 0.6.2
+ _ZN4YAML8LoadFileERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2
+ _ZN4YAML9BadInsertD0Ev@Base 0.6.2
+ _ZN4YAML9BadInsertD1Ev@Base 0.6.2
+ _ZN4YAML9BadInsertD2Ev@Base 0.6.2
+ _ZN4YAML9ExceptionD0Ev@Base 0.6.2
+ _ZN4YAML9ExceptionD1Ev@Base 0.6.2
+ _ZN4YAML9ExceptionD2Ev@Base 0.6.2
+ _ZN4YAMLaaERKNS_5RegExES2_@Base 0.6.2
+ _ZN4YAMLlsERNS_7EmitterERKNS_4NodeE@Base 0.6.2
+ _ZN4YAMLlsERSoRKNS_4NodeE@Base 0.6.2
+ _ZN4YAMLntERKNS_5RegExE@Base 0.6.2
+ _ZN4YAMLooERKNS_5RegExES2_@Base 0.6.2
+ _ZN4YAMLplERKNS_5RegExES2_@Base 0.6.2
+ _ZNK4YAML6detail9node_data16compute_map_sizeEv@Base 0.6.2
+ _ZNK4YAML6detail9node_data16compute_seq_sizeEv@Base 0.6.2
+ _ZNK4YAML6detail9node_data3endEv@Base 0.6.2
+ _ZNK4YAML6detail9node_data3getERNS0_4nodeESt10shared_ptrINS0_13memory_holderEE@Base 0.6.2
+ _ZNK4YAML6detail9node_data4sizeEv@Base 0.6.2
+ _ZNK4YAML6detail9node_data5beginEv@Base 0.6.2
+ _ZNK4YAML6ParsercvbEv@Base 0.6.2
+ _ZNK4YAML7Emitter12GetLastErrorB5cxx11Ev@Base 0.6.2
+ _ZNK4YAML7Emitter14CanEmitNewlineEv@Base 0.6.2
+ _ZNK4YAML7Emitter17GetFloatPrecisionEv@Base 0.6.2
+ _ZNK4YAML7Emitter18GetDoublePrecisionEv@Base 0.6.2
+ _ZNK4YAML7Emitter19ComputeFullBoolNameEb@Base 0.6.2
+ _ZNK4YAML7Emitter21PrepareIntegralStreamERNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE@Base 0.6.2
+ _ZNK4YAML7Emitter4goodEv@Base 0.6.2
+ _ZNK4YAML7Emitter4sizeEv@Base 0.6.2
+ _ZNK4YAML7Emitter5c_strEv@Base 0.6.2
+ _ZTIN4YAML11BadPushbackE@Base 0.6.2
+ _ZTIN4YAML11InvalidNodeE@Base 0.6.2
+ _ZTIN4YAML11KeyNotFoundE@Base 0.6.2
+ _ZTIN4YAML12BadSubscriptE@Base 0.6.2
+ _ZTIN4YAML13BadConversionE@Base 0.6.2
+ _ZTIN4YAML13InvalidScalarE@Base 0.6.2
+ _ZTIN4YAML14BadDereferenceE@Base 0.6.2
+ _ZTIN4YAML15ParserExceptionE@Base 0.6.2
+ _ZTIN4YAML16EmitterExceptionE@Base 0.6.2
+ _ZTIN4YAML23RepresentationExceptionE@Base 0.6.2
+ _ZTIN4YAML7BadFileE@Base 0.6.2
+ _ZTIN4YAML9BadInsertE@Base 0.6.2
+ _ZTIN4YAML9ExceptionE@Base 0.6.2
+ (arch= armel riscv64)_ZTIN9__gnu_cxx7__mutexE@Base 0.6.2
+ (arch= armel riscv64)_ZTISt11_Mutex_baseILN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2
+ (arch= !armel !riscv64)_ZTISt11_Mutex_baseILN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2
+ (arch= armel riscv64)_ZTISt15_Sp_counted_ptrIPN4YAML6detail13memory_holderELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2
+ (arch= !armel !riscv64)_ZTISt15_Sp_counted_ptrIPN4YAML6detail13memory_holderELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2
+ (arch= armel riscv64)_ZTISt15_Sp_counted_ptrIPN4YAML6detail6memoryELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2
+ (arch= !armel !riscv64)_ZTISt15_Sp_counted_ptrIPN4YAML6detail6memoryELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2
+ (arch= armel riscv64)_ZTISt15_Sp_counted_ptrIPN4YAML6detail9node_dataELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2
+ (arch= !armel !riscv64)_ZTISt15_Sp_counted_ptrIPN4YAML6detail9node_dataELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2
+ (arch= armel riscv64)_ZTISt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2
+ (arch= !armel !riscv64)_ZTISt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2
+ _ZTSN4YAML11BadPushbackE@Base 0.6.2
+ _ZTSN4YAML11InvalidNodeE@Base 0.6.2
+ _ZTSN4YAML11KeyNotFoundE@Base 0.6.2
+ _ZTSN4YAML12BadSubscriptE@Base 0.6.2
+ _ZTSN4YAML13BadConversionE@Base 0.6.2
+ _ZTSN4YAML13InvalidScalarE@Base 0.6.2
+ _ZTSN4YAML14BadDereferenceE@Base 0.6.2
+ _ZTSN4YAML15ParserExceptionE@Base 0.6.2
+ _ZTSN4YAML16EmitterExceptionE@Base 0.6.2
+ _ZTSN4YAML23RepresentationExceptionE@Base 0.6.2
+ _ZTSN4YAML7BadFileE@Base 0.6.2
+ _ZTSN4YAML9BadInsertE@Base 0.6.2
+ _ZTSN4YAML9ExceptionE@Base 0.6.2
+ (arch= armel riscv64)_ZTSN9__gnu_cxx7__mutexE@Base 0.6.2-2
+ (arch= armel riscv64)_ZTSSt11_Mutex_baseILN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2
+ (arch= !armel !riscv64)_ZTSSt11_Mutex_baseILN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2
+ (arch= armel riscv64)_ZTSSt15_Sp_counted_ptrIPN4YAML6detail13memory_holderELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2
+ (arch= !armel !riscv64)_ZTSSt15_Sp_counted_ptrIPN4YAML6detail13memory_holderELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2
+ (arch= armel riscv64)_ZTSSt15_Sp_counted_ptrIPN4YAML6detail6memoryELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2
+ (arch= !armel !riscv64)_ZTSSt15_Sp_counted_ptrIPN4YAML6detail6memoryELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2
+ (arch= armel riscv64)_ZTSSt15_Sp_counted_ptrIPN4YAML6detail9node_dataELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2
+ (arch= !armel !riscv64)_ZTSSt15_Sp_counted_ptrIPN4YAML6detail9node_dataELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2
+ (arch= armel riscv64)_ZTSSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2
+ (arch= !armel !riscv64)_ZTSSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2
+ _ZTVN4YAML11BadPushbackE@Base 0.6.2
+ _ZTVN4YAML11InvalidNodeE@Base 0.6.2
+ _ZTVN4YAML11KeyNotFoundE@Base 0.6.2
+ _ZTVN4YAML12BadSubscriptE@Base 0.6.2
+ _ZTVN4YAML13BadConversionE@Base 0.6.2
+ _ZTVN4YAML13InvalidScalarE@Base 0.6.2
+ _ZTVN4YAML14BadDereferenceE@Base 0.6.2
+ _ZTVN4YAML15ParserExceptionE@Base 0.6.2
+ _ZTVN4YAML16EmitterExceptionE@Base 0.6.2
+ _ZTVN4YAML23RepresentationExceptionE@Base 0.6.2
+ _ZTVN4YAML7BadFileE@Base 0.6.2
+ _ZTVN4YAML9BadInsertE@Base 0.6.2
+ _ZTVN4YAML9ExceptionE@Base 0.6.2
+ (arch= armel riscv64)_ZTVSt15_Sp_counted_ptrIPN4YAML6detail13memory_holderELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2
+ (arch= !armel !riscv64)_ZTVSt15_Sp_counted_ptrIPN4YAML6detail13memory_holderELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2
+ (arch= armel riscv64)_ZTVSt15_Sp_counted_ptrIPN4YAML6detail6memoryELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2
+ (arch= !armel !riscv64)_ZTVSt15_Sp_counted_ptrIPN4YAML6detail6memoryELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2
+ (arch= armel riscv64)_ZTVSt15_Sp_counted_ptrIPN4YAML6detail9node_dataELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2
+ (arch= !armel !riscv64)_ZTVSt15_Sp_counted_ptrIPN4YAML6detail9node_dataELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2
--- /dev/null
+From dd072aab1264e1343dead7de0dc2c67c588fdd30 Mon Sep 17 00:00:00 2001
+From: Adrian Bunk <bunk@debian.org>
+Date: Sun, 10 May 2020 11:39:29 +0300
+Subject: Revert "Static analysis fix: replace 0 and NULL with nullptr (#738)"
+
+This reverts commit db0bda7087a6fac811e78957787fc5037465ac4e.
+---
+ include/yaml-cpp/binary.h | 2 +-
+ include/yaml-cpp/exceptions.h | 4 ++--
+ include/yaml-cpp/node/detail/impl.h | 14 +++++++-------
+ include/yaml-cpp/node/detail/node_iterator.h | 4 ++--
+ include/yaml-cpp/node/impl.h | 2 +-
+ include/yaml-cpp/ostream_wrapper.h | 2 +-
+ 6 files changed, 14 insertions(+), 14 deletions(-)
+
+diff --git a/include/yaml-cpp/binary.h b/include/yaml-cpp/binary.h
+index 1050dae..0267a3a 100644
+--- a/include/yaml-cpp/binary.h
++++ b/include/yaml-cpp/binary.h
+@@ -39,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 = nullptr;
++ m_unownedData = 0;
+ m_unownedSize = 0;
+ } else {
+ m_data.swap(rhs);
+diff --git a/include/yaml-cpp/exceptions.h b/include/yaml-cpp/exceptions.h
+index eef2283..3b1b01a 100644
+--- a/include/yaml-cpp/exceptions.h
++++ b/include/yaml-cpp/exceptions.h
+@@ -117,7 +117,7 @@ inline const std::string KEY_NOT_FOUND_WITH_KEY(
+
+ template <typename T>
+ inline const std::string BAD_SUBSCRIPT_WITH_KEY(
+- const T&, typename disable_if<is_numeric<T>>::type* = nullptr) {
++ const T&, typename disable_if<is_numeric<T>>::type* = 0) {
+ return BAD_SUBSCRIPT;
+ }
+
+@@ -129,7 +129,7 @@ inline const std::string BAD_SUBSCRIPT_WITH_KEY(const std::string& key) {
+
+ template <typename T>
+ inline const std::string BAD_SUBSCRIPT_WITH_KEY(
+- const T& key, typename enable_if<is_numeric<T>>::type* = nullptr) {
++ const T& key, typename enable_if<is_numeric<T>>::type* = 0) {
+ std::stringstream stream;
+ stream << BAD_SUBSCRIPT << " (key: \"" << key << "\")";
+ return stream.str();
+diff --git a/include/yaml-cpp/node/detail/impl.h b/include/yaml-cpp/node/detail/impl.h
+index 4123b85..46615a9 100644
+--- a/include/yaml-cpp/node/detail/impl.h
++++ b/include/yaml-cpp/node/detail/impl.h
+@@ -17,7 +17,7 @@ template <typename Key, typename Enable = void>
+ struct get_idx {
+ static node* get(const std::vector<node*>& /* sequence */,
+ const Key& /* key */, shared_memory_holder /* pMemory */) {
+- return nullptr;
++ return 0;
+ }
+ };
+
+@@ -27,7 +27,7 @@ struct get_idx<Key,
+ !std::is_same<Key, bool>::value>::type> {
+ static node* get(const std::vector<node*>& sequence, const Key& key,
+ shared_memory_holder /* pMemory */) {
+- return key < sequence.size() ? sequence[key] : nullptr;
++ return key < sequence.size() ? sequence[key] : 0;
+ }
+
+ static node* get(std::vector<node*>& sequence, const Key& key,
+@@ -46,13 +46,13 @@ struct get_idx<Key, typename std::enable_if<std::is_signed<Key>::value>::type> {
+ shared_memory_holder pMemory) {
+ return key >= 0 ? get_idx<std::size_t>::get(
+ sequence, static_cast<std::size_t>(key), pMemory)
+- : nullptr;
++ : 0;
+ }
+ static node* get(std::vector<node*>& sequence, const Key& key,
+ shared_memory_holder pMemory) {
+ return key >= 0 ? get_idx<std::size_t>::get(
+ sequence, static_cast<std::size_t>(key), pMemory)
+- : nullptr;
++ : 0;
+ }
+ };
+
+@@ -109,11 +109,11 @@ inline node* node_data::get(const Key& key,
+ break;
+ case NodeType::Undefined:
+ case NodeType::Null:
+- return nullptr;
++ return NULL;
+ case NodeType::Sequence:
+ if (node* pNode = get_idx<Key>::get(m_sequence, key, pMemory))
+ return pNode;
+- return nullptr;
++ return NULL;
+ case NodeType::Scalar:
+ throw BadSubscript(key);
+ }
+@@ -124,7 +124,7 @@ inline node* node_data::get(const Key& key,
+ }
+ }
+
+- return nullptr;
++ return NULL;
+ }
+
+ template <typename Key>
+diff --git a/include/yaml-cpp/node/detail/node_iterator.h b/include/yaml-cpp/node/detail/node_iterator.h
+index ab6916f..088090f 100644
+--- a/include/yaml-cpp/node/detail/node_iterator.h
++++ b/include/yaml-cpp/node/detail/node_iterator.h
+@@ -26,9 +26,9 @@ template <typename V>
+ struct node_iterator_value : public std::pair<V*, V*> {
+ typedef std::pair<V*, V*> kv;
+
+- node_iterator_value() : kv(), pNode(nullptr) {}
++ node_iterator_value() : kv(), pNode(0) {}
+ explicit node_iterator_value(V& rhs) : kv(), pNode(&rhs) {}
+- explicit node_iterator_value(V& key, V& value) : kv(&key, &value), pNode(nullptr) {}
++ explicit node_iterator_value(V& key, V& value) : kv(&key, &value), pNode(0) {}
+
+ V& operator*() const { return *pNode; }
+ V& operator->() const { return *pNode; }
+diff --git a/include/yaml-cpp/node/impl.h b/include/yaml-cpp/node/impl.h
+index 7a3deac..0b0e296 100644
+--- a/include/yaml-cpp/node/impl.h
++++ b/include/yaml-cpp/node/impl.h
+@@ -52,7 +52,7 @@ 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) {}
++ : m_isValid(false), m_invalidKey(key), m_pMemory{}, m_pNode(NULL) {}
+
+ inline Node::Node(detail::node& node, detail::shared_memory_holder pMemory)
+ : m_isValid(true), m_invalidKey{}, m_pMemory(pMemory), m_pNode(&node) {}
+diff --git a/include/yaml-cpp/ostream_wrapper.h b/include/yaml-cpp/ostream_wrapper.h
+index cf89741..259801b 100644
+--- a/include/yaml-cpp/ostream_wrapper.h
++++ b/include/yaml-cpp/ostream_wrapper.h
+@@ -30,7 +30,7 @@ class YAML_CPP_API ostream_wrapper {
+
+ const char* str() const {
+ if (m_pStream) {
+- return nullptr;
++ return 0;
+ } else {
+ m_buffer[m_pos] = '\0';
+ return &m_buffer[0];
+--
+2.20.1
+
--- /dev/null
+From 66799954bb9b7007b31de0ecd20b07f926be3ca6 Mon Sep 17 00:00:00 2001
+From: Adrian Bunk <bunk@debian.org>
+Date: Sun, 10 May 2020 11:39:29 +0300
+Subject: Revert "Improve error messages on operator[] or as<> (#656)"
+
+This reverts commit 012269756149ae99745b6dafefd415843d7420bb.
+---
+ include/yaml-cpp/exceptions.h | 40 ++----------
+ include/yaml-cpp/node/detail/impl.h | 4 +-
+ include/yaml-cpp/node/impl.h | 83 ++++++++++--------------
+ include/yaml-cpp/node/node.h | 4 --
+ include/yaml-cpp/traits.h | 32 ---------
+ src/node_data.cpp | 4 +-
+ test/integration/error_messages_test.cpp | 61 -----------------
+ 7 files changed, 42 insertions(+), 186 deletions(-)
+ delete mode 100644 test/integration/error_messages_test.cpp
+
+diff --git a/include/yaml-cpp/exceptions.h b/include/yaml-cpp/exceptions.h
+index 3b1b01a..4ee7b15 100644
+--- a/include/yaml-cpp/exceptions.h
++++ b/include/yaml-cpp/exceptions.h
+@@ -114,35 +114,6 @@ 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* = 0) {
+- 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();
+-}
+-
+-template <typename T>
+-inline const std::string BAD_SUBSCRIPT_WITH_KEY(
+- const T& key, typename enable_if<is_numeric<T>>::type* = 0) {
+- 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();
+-}
+ }
+
+ class YAML_CPP_API Exception : public std::runtime_error {
+@@ -223,9 +194,8 @@ inline TypedKeyNotFound<T> MakeTypedKeyNotFound(const Mark& mark,
+
+ class YAML_CPP_API InvalidNode : public RepresentationException {
+ public:
+- InvalidNode(std::string key)
+- : RepresentationException(Mark::null_mark(),
+- ErrorMsg::INVALID_NODE_WITH_KEY(key)) {}
++ InvalidNode()
++ : RepresentationException(Mark::null_mark(), ErrorMsg::INVALID_NODE) {}
+ InvalidNode(const InvalidNode&) = default;
+ virtual ~InvalidNode() YAML_CPP_NOEXCEPT;
+ };
+@@ -254,10 +224,8 @@ class YAML_CPP_API BadDereference : public RepresentationException {
+
+ class YAML_CPP_API BadSubscript : public RepresentationException {
+ public:
+- template <typename Key>
+- BadSubscript(const Key& key)
+- : RepresentationException(Mark::null_mark(),
+- ErrorMsg::BAD_SUBSCRIPT_WITH_KEY(key)) {}
++ BadSubscript()
++ : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_SUBSCRIPT) {}
+ BadSubscript(const BadSubscript&) = default;
+ virtual ~BadSubscript() YAML_CPP_NOEXCEPT;
+ };
+diff --git a/include/yaml-cpp/node/detail/impl.h b/include/yaml-cpp/node/detail/impl.h
+index 46615a9..c8853cf 100644
+--- a/include/yaml-cpp/node/detail/impl.h
++++ b/include/yaml-cpp/node/detail/impl.h
+@@ -115,7 +115,7 @@ inline node* node_data::get(const Key& key,
+ return pNode;
+ return NULL;
+ case NodeType::Scalar:
+- throw BadSubscript(key);
++ throw BadSubscript();
+ }
+
+ for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
+@@ -143,7 +143,7 @@ inline node& node_data::get(const Key& key, shared_memory_holder pMemory) {
+ convert_to_map(pMemory);
+ break;
+ case NodeType::Scalar:
+- throw BadSubscript(key);
++ throw BadSubscript();
+ }
+
+ for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
+diff --git a/include/yaml-cpp/node/impl.h b/include/yaml-cpp/node/impl.h
+index 0b0e296..8346f40 100644
+--- a/include/yaml-cpp/node/impl.h
++++ b/include/yaml-cpp/node/impl.h
+@@ -12,16 +12,13 @@
+ #include "yaml-cpp/node/detail/node.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_invalidKey{}, m_pMemory(nullptr), m_pNode(nullptr) {}
++inline Node::Node() : m_isValid(true), m_pMemory(nullptr), m_pNode(nullptr) {}
+
+ inline Node::Node(NodeType::value type)
+ : m_isValid(true),
+- m_invalidKey{},
+ m_pMemory(new detail::memory_holder),
+ m_pNode(&m_pMemory->create_node()) {
+ m_pNode->set_type(type);
+@@ -30,7 +27,6 @@ inline Node::Node(NodeType::value type)
+ template <typename T>
+ inline Node::Node(const T& rhs)
+ : m_isValid(true),
+- m_invalidKey{},
+ m_pMemory(new detail::memory_holder),
+ m_pNode(&m_pMemory->create_node()) {
+ Assign(rhs);
+@@ -38,30 +34,24 @@ inline Node::Node(const T& rhs)
+
+ inline Node::Node(const detail::iterator_value& rhs)
+ : m_isValid(rhs.m_isValid),
+- m_invalidKey(rhs.m_invalidKey),
+ m_pMemory(rhs.m_pMemory),
+ m_pNode(rhs.m_pNode) {}
+
+ inline Node::Node(const Node& rhs)
+ : m_isValid(rhs.m_isValid),
+- m_invalidKey(rhs.m_invalidKey),
+ m_pMemory(rhs.m_pMemory),
+ m_pNode(rhs.m_pNode) {}
+
+-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(NULL) {}
++inline Node::Node(Zombie) : m_isValid(false), m_pMemory{}, m_pNode(nullptr) {}
+
+ inline Node::Node(detail::node& node, detail::shared_memory_holder pMemory)
+- : m_isValid(true), m_invalidKey{}, m_pMemory(pMemory), m_pNode(&node) {}
++ : m_isValid(true), m_pMemory(pMemory), m_pNode(&node) {}
+
+ inline Node::~Node() {}
+
+ inline void Node::EnsureNodeExists() const {
+ if (!m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ if (!m_pNode) {
+ m_pMemory.reset(new detail::memory_holder);
+ m_pNode = &m_pMemory->create_node();
+@@ -78,14 +68,14 @@ inline bool Node::IsDefined() const {
+
+ inline Mark Node::Mark() const {
+ if (!m_isValid) {
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ }
+ return m_pNode ? m_pNode->mark() : Mark::null_mark();
+ }
+
+ inline NodeType::value Node::Type() const {
+ if (!m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ return m_pNode ? m_pNode->type() : NodeType::Null;
+ }
+
+@@ -152,7 +142,7 @@ struct as_if<std::string, void> {
+ template <typename T>
+ inline T Node::as() const {
+ if (!m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ return as_if<T, void>(*this)();
+ }
+
+@@ -165,32 +155,32 @@ inline T Node::as(const S& fallback) const {
+
+ inline const std::string& Node::Scalar() const {
+ if (!m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ return m_pNode ? m_pNode->scalar() : detail::node_data::empty_scalar();
+ }
+
+ inline const std::string& Node::Tag() const {
+ if (!m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ return m_pNode ? m_pNode->tag() : detail::node_data::empty_scalar();
+ }
+
+ inline void Node::SetTag(const std::string& tag) {
+ if (!m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ EnsureNodeExists();
+ m_pNode->set_tag(tag);
+ }
+
+ inline EmitterStyle::value Node::Style() const {
+ if (!m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ return m_pNode ? m_pNode->style() : EmitterStyle::Default;
+ }
+
+ inline void Node::SetStyle(EmitterStyle::value style) {
+ if (!m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ EnsureNodeExists();
+ m_pNode->set_style(style);
+ }
+@@ -198,7 +188,7 @@ inline void Node::SetStyle(EmitterStyle::value style) {
+ // assignment
+ inline bool Node::is(const Node& rhs) const {
+ if (!m_isValid || !rhs.m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ if (!m_pNode || !rhs.m_pNode)
+ return false;
+ return m_pNode->is(*rhs.m_pNode);
+@@ -207,14 +197,14 @@ inline bool Node::is(const Node& rhs) const {
+ template <typename T>
+ inline Node& Node::operator=(const T& rhs) {
+ if (!m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ Assign(rhs);
+ return *this;
+ }
+
+ inline Node& Node::operator=(const Node& rhs) {
+ if (!m_isValid || !rhs.m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ if (is(rhs))
+ return *this;
+ AssignNode(rhs);
+@@ -223,7 +213,7 @@ inline Node& Node::operator=(const Node& rhs) {
+
+ inline void Node::reset(const YAML::Node& rhs) {
+ if (!m_isValid || !rhs.m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ m_pMemory = rhs.m_pMemory;
+ m_pNode = rhs.m_pNode;
+ }
+@@ -231,35 +221,35 @@ inline void Node::reset(const YAML::Node& rhs) {
+ template <typename T>
+ inline void Node::Assign(const T& rhs) {
+ if (!m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ AssignData(convert<T>::encode(rhs));
+ }
+
+ template <>
+ inline void Node::Assign(const std::string& rhs) {
+ if (!m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ EnsureNodeExists();
+ m_pNode->set_scalar(rhs);
+ }
+
+ inline void Node::Assign(const char* rhs) {
+ if (!m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ EnsureNodeExists();
+ m_pNode->set_scalar(rhs);
+ }
+
+ inline void Node::Assign(char* rhs) {
+ if (!m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ EnsureNodeExists();
+ m_pNode->set_scalar(rhs);
+ }
+
+ inline void Node::AssignData(const Node& rhs) {
+ if (!m_isValid || !rhs.m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ EnsureNodeExists();
+ rhs.EnsureNodeExists();
+
+@@ -269,7 +259,7 @@ inline void Node::AssignData(const Node& rhs) {
+
+ inline void Node::AssignNode(const Node& rhs) {
+ if (!m_isValid || !rhs.m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ rhs.EnsureNodeExists();
+
+ if (!m_pNode) {
+@@ -286,7 +276,7 @@ inline void Node::AssignNode(const Node& rhs) {
+ // size/iterator
+ inline std::size_t Node::size() const {
+ if (!m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ return m_pNode ? m_pNode->size() : 0;
+ }
+
+@@ -319,13 +309,13 @@ inline iterator Node::end() {
+ template <typename T>
+ inline void Node::push_back(const T& rhs) {
+ if (!m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ push_back(Node(rhs));
+ }
+
+ inline void Node::push_back(const Node& rhs) {
+ if (!m_isValid || !rhs.m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ EnsureNodeExists();
+ rhs.EnsureNodeExists();
+
+@@ -378,21 +368,16 @@ inline typename to_value_t<T>::return_type to_value(const T& t) {
+ }
+ } // namespace detail
+
+-template<typename Key>
+-std::string key_to_string(const Key& key) {
+- return streamable_to_string<Key, is_streamable<std::stringstream, Key>::value>().impl(key);
+-}
+-
+ // indexing
+ template <typename Key>
+ inline const Node Node::operator[](const Key& key) const {
+ if (!m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ EnsureNodeExists();
+ detail::node* value = static_cast<const detail::node&>(*m_pNode).get(
+ detail::to_value(key), m_pMemory);
+ if (!value) {
+- return Node(ZombieNode, key_to_string(key));
++ return Node(ZombieNode);
+ }
+ return Node(*value, m_pMemory);
+ }
+@@ -400,7 +385,7 @@ inline const Node Node::operator[](const Key& key) const {
+ template <typename Key>
+ inline Node Node::operator[](const Key& key) {
+ if (!m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ EnsureNodeExists();
+ detail::node& value = m_pNode->get(detail::to_value(key), m_pMemory);
+ return Node(value, m_pMemory);
+@@ -409,28 +394,28 @@ inline Node Node::operator[](const Key& key) {
+ template <typename Key>
+ inline bool Node::remove(const Key& key) {
+ if (!m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ EnsureNodeExists();
+ return m_pNode->remove(detail::to_value(key), m_pMemory);
+ }
+
+ inline const Node Node::operator[](const Node& key) const {
+ if (!m_isValid || !key.m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ EnsureNodeExists();
+ key.EnsureNodeExists();
+ m_pMemory->merge(*key.m_pMemory);
+ detail::node* value =
+ static_cast<const detail::node&>(*m_pNode).get(*key.m_pNode, m_pMemory);
+ if (!value) {
+- return Node(ZombieNode, key_to_string(key));
++ return Node(ZombieNode);
+ }
+ return Node(*value, m_pMemory);
+ }
+
+ inline Node Node::operator[](const Node& key) {
+ if (!m_isValid || !key.m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ EnsureNodeExists();
+ key.EnsureNodeExists();
+ m_pMemory->merge(*key.m_pMemory);
+@@ -440,7 +425,7 @@ inline Node Node::operator[](const Node& key) {
+
+ inline bool Node::remove(const Node& key) {
+ if (!m_isValid || !key.m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ EnsureNodeExists();
+ key.EnsureNodeExists();
+ return m_pNode->remove(*key.m_pNode, m_pMemory);
+@@ -450,7 +435,7 @@ inline bool Node::remove(const Node& key) {
+ template <typename Key, typename Value>
+ inline void Node::force_insert(const Key& key, const Value& value) {
+ if (!m_isValid)
+- throw InvalidNode(m_invalidKey);
++ throw InvalidNode();
+ EnsureNodeExists();
+ m_pNode->force_insert(detail::to_value(key), detail::to_value(value),
+ m_pMemory);
+diff --git a/include/yaml-cpp/node/node.h b/include/yaml-cpp/node/node.h
+index 49af58e..1ded7d2 100644
+--- a/include/yaml-cpp/node/node.h
++++ b/include/yaml-cpp/node/node.h
+@@ -8,7 +8,6 @@
+ #endif
+
+ #include <stdexcept>
+-#include <string>
+
+ #include "yaml-cpp/dll.h"
+ #include "yaml-cpp/emitterstyle.h"
+@@ -117,7 +116,6 @@ class YAML_CPP_API Node {
+ private:
+ enum Zombie { ZombieNode };
+ explicit Node(Zombie);
+- explicit Node(Zombie, const std::string&);
+ explicit Node(detail::node& node, detail::shared_memory_holder pMemory);
+
+ void EnsureNodeExists() const;
+@@ -132,8 +130,6 @@ class YAML_CPP_API Node {
+
+ private:
+ bool m_isValid;
+- // String representation of invalid key, if the node is invalid.
+- std::string m_invalidKey;
+ mutable detail::shared_memory_holder m_pMemory;
+ mutable detail::node* m_pNode;
+ };
+diff --git a/include/yaml-cpp/traits.h b/include/yaml-cpp/traits.h
+index 36d406b..f33d0e1 100644
+--- a/include/yaml-cpp/traits.h
++++ b/include/yaml-cpp/traits.h
+@@ -7,11 +7,6 @@
+ #pragma once
+ #endif
+
+-#include <type_traits>
+-#include <utility>
+-#include <string>
+-#include <sstream>
+-
+ namespace YAML {
+ template <typename>
+ struct is_numeric {
+@@ -105,31 +100,4 @@ template <class Cond, class T = void>
+ struct disable_if : public disable_if_c<Cond::value, T> {};
+ }
+
+-template <typename S, typename T>
+-struct is_streamable {
+- template <typename SS, typename TT>
+- static auto test(int)
+- -> decltype(std::declval<SS&>() << std::declval<TT>(), 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
+diff --git a/src/node_data.cpp b/src/node_data.cpp
+index 6cfedfc..c65accb 100644
+--- a/src/node_data.cpp
++++ b/src/node_data.cpp
+@@ -196,7 +196,7 @@ void node_data::insert(node& key, node& value, shared_memory_holder pMemory) {
+ convert_to_map(pMemory);
+ break;
+ case NodeType::Scalar:
+- throw BadSubscript(key);
++ throw BadSubscript();
+ }
+
+ insert_map_pair(key, value);
+@@ -226,7 +226,7 @@ node& node_data::get(node& key, shared_memory_holder pMemory) {
+ convert_to_map(pMemory);
+ break;
+ case NodeType::Scalar:
+- throw BadSubscript(key);
++ throw BadSubscript();
+ }
+
+ for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
+diff --git a/test/integration/error_messages_test.cpp b/test/integration/error_messages_test.cpp
+deleted file mode 100644
+index 64ab6b9..0000000
+--- a/test/integration/error_messages_test.cpp
++++ /dev/null
+@@ -1,61 +0,0 @@
+-#include "yaml-cpp/yaml.h" // IWYU pragma: keep
+-
+-#include "gtest/gtest.h"
+-
+-#define EXPECT_THROW_EXCEPTION(exception_type, statement, message) \
+- ASSERT_THROW(statement, exception_type); \
+- try { \
+- statement; \
+- } catch (const exception_type& e) { \
+- EXPECT_EQ(e.msg, message); \
+- }
+-
+-namespace YAML {
+-namespace {
+-
+-TEST(ErrorMessageTest, BadSubscriptErrorMessage) {
+- const char *example_yaml = "first:\n"
+- " second: 1\n"
+- " third: 2\n";
+-
+- Node doc = Load(example_yaml);
+-
+- // Test that printable key is part of error message
+- EXPECT_THROW_EXCEPTION(YAML::BadSubscript, doc["first"]["second"]["fourth"],
+- "operator[] call on a scalar (key: \"fourth\")");
+-
+- EXPECT_THROW_EXCEPTION(YAML::BadSubscript, doc["first"]["second"][37],
+- "operator[] call on a scalar (key: \"37\")");
+-
+-
+- // Non-printable key is not included in error message
+- EXPECT_THROW_EXCEPTION(YAML::BadSubscript,
+- doc["first"]["second"][std::vector<int>()],
+- "operator[] call on a scalar");
+-
+- EXPECT_THROW_EXCEPTION(YAML::BadSubscript, doc["first"]["second"][Node()],
+- "operator[] call on a scalar");
+-}
+-
+-TEST(ErrorMessageTest, Ex9_1_InvalidNodeErrorMessage) {
+- const char *example_yaml = "first:\n"
+- " second: 1\n"
+- " third: 2\n";
+-
+- const Node doc = Load(example_yaml);
+-
+- // Test that printable key is part of error message
+- EXPECT_THROW_EXCEPTION(YAML::InvalidNode, doc["first"]["fourth"].as<int>(),
+- "invalid node; first invalid key: \"fourth\"");
+-
+- EXPECT_THROW_EXCEPTION(YAML::InvalidNode, doc["first"][37].as<int>(),
+- "invalid node; first invalid key: \"37\"");
+-
+- // Non-printable key is not included in error message
+- EXPECT_THROW_EXCEPTION(YAML::InvalidNode,
+- doc["first"][std::vector<int>()].as<int>(),
+- "invalid node; this may result from using a map "
+- "iterator as a sequence iterator, or vice-versa");
+-}
+-}
+-}
+--
+2.20.1
+
--- /dev/null
+From c6ae5659621322e5ec8085d1e04a269e3fac6705 Mon Sep 17 00:00:00 2001
+From: Adrian Bunk <bunk@debian.org>
+Date: Sun, 10 May 2020 11:39:29 +0300
+Subject: Revert "Disallow moving for the Parser."
+
+This reverts commit bd7f8c60c82614bb0bd1c526db2cbc39dac02fec.
+---
+ include/yaml-cpp/parser.h | 5 +++--
+ 1 file changed, 3 insertions(+), 2 deletions(-)
+
+diff --git a/include/yaml-cpp/parser.h b/include/yaml-cpp/parser.h
+index 2f403c3..e9fba0c 100644
+--- a/include/yaml-cpp/parser.h
++++ b/include/yaml-cpp/parser.h
+@@ -28,10 +28,11 @@ class YAML_CPP_API Parser {
+ /** Constructs an empty parser (with no input. */
+ Parser();
+
++ /** non copyable but movable */
+ Parser(const Parser&) = delete;
+- Parser(Parser&&) = delete;
++ Parser(Parser&&) = default;
+ Parser& operator=(const Parser&) = delete;
+- Parser& operator=(Parser&&) = delete;
++ Parser& operator=(Parser&&) = default;
+
+ /**
+ * Constructs a parser from the given input stream. The input stream must
+--
+2.20.1
+
--- /dev/null
+From 6452cb9b826df569c396e7c645d874fc068607d6 Mon Sep 17 00:00:00 2001
+From: Adrian Bunk <bunk@debian.org>
+Date: Sun, 10 May 2020 11:39:29 +0300
+Subject: Revert "Apply formatting/style tweaks to comply with compile time
+ diagnostics for g++ and clang++ (#686)"
+
+This reverts commit 0d5c57150cebb430fcc216d8066dbb28aeaafe8e.
+---
+ CMakeLists.txt | 2 +-
+ include/yaml-cpp/binary.h | 10 ++---
+ include/yaml-cpp/contrib/anchordict.h | 3 +-
+ include/yaml-cpp/emitter.h | 7 ++--
+ include/yaml-cpp/node/detail/memory.h | 5 +--
+ include/yaml-cpp/node/detail/node.h | 12 +++---
+ include/yaml-cpp/node/impl.h | 36 ++++++++--------
+ include/yaml-cpp/noncopyable.h | 25 +++++++++++
+ include/yaml-cpp/ostream_wrapper.h | 8 +---
+ include/yaml-cpp/parser.h | 11 ++---
+ src/collectionstack.h | 5 +--
+ src/contrib/graphbuilderadapter.h | 16 ++-----
+ src/directives.cpp | 9 +++-
+ src/emitfromevents.cpp | 7 ++--
+ src/emitter.cpp | 4 +-
+ src/emitterstate.cpp | 40 ++++++++----------
+ src/emitterstate.h | 9 +---
+ src/emitterutils.cpp | 20 ++++-----
+ src/exp.h | 60 +++++++++++++--------------
+ src/node_data.cpp | 19 ++++-----
+ src/nodebuilder.cpp | 9 +---
+ src/nodebuilder.h | 6 +--
+ src/nodeevents.cpp | 4 +-
+ src/nodeevents.h | 8 +---
+ src/ostream_wrapper.cpp | 9 +---
+ src/parser.cpp | 6 +--
+ src/ptr_vector.h | 12 +++---
+ src/regex_yaml.cpp | 20 +++++----
+ src/regex_yaml.h | 8 ++--
+ src/scanner.cpp | 7 +---
+ src/scantoken.cpp | 4 +-
+ src/setting.h | 24 ++++-------
+ src/singledocparser.cpp | 9 ++--
+ src/singledocparser.h | 7 +---
+ src/stream.cpp | 32 ++++++++------
+ src/stream.h | 9 ++--
+ src/streamcharsource.h | 8 ++--
+ src/tag.cpp | 5 +--
+ src/token.h | 13 +++---
+ test/regex_test.cpp | 18 ++++----
+ 40 files changed, 241 insertions(+), 285 deletions(-)
+ create mode 100644 include/yaml-cpp/noncopyable.h
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 4732a45..85de975 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -159,7 +159,7 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR
+ set(GCC_EXTRA_OPTIONS "${GCC_EXTRA_OPTIONS} -fPIC")
+ endif()
+ #
+- set(FLAG_TESTED "-Wextra -Wshadow -Weffc++ -pedantic -pedantic-errors")
++ set(FLAG_TESTED "-Wextra")
+ check_cxx_compiler_flag(${FLAG_TESTED} FLAG_WEXTRA)
+ if(FLAG_WEXTRA)
+ set(GCC_EXTRA_OPTIONS "${GCC_EXTRA_OPTIONS} ${FLAG_TESTED}")
+diff --git a/include/yaml-cpp/binary.h b/include/yaml-cpp/binary.h
+index 0267a3a..29d5dbd 100644
+--- a/include/yaml-cpp/binary.h
++++ b/include/yaml-cpp/binary.h
+@@ -19,13 +19,9 @@ YAML_CPP_API std::vector<unsigned char> DecodeBase64(const std::string &input);
+
+ class YAML_CPP_API Binary {
+ public:
++ Binary() : m_unownedData(0), m_unownedSize(0) {}
+ Binary(const unsigned char *data_, std::size_t size_)
+- : m_data{}, m_unownedData(data_), m_unownedSize(size_) {}
+- Binary() : Binary(nullptr, 0) {}
+- Binary(const Binary &) = default;
+- Binary(Binary &&) = default;
+- Binary &operator=(const Binary &) = default;
+- Binary &operator=(Binary &&) = default;
++ : m_unownedData(data_), m_unownedSize(size_) {}
+
+ bool owned() const { return !m_unownedData; }
+ std::size_t size() const { return owned() ? m_data.size() : m_unownedSize; }
+@@ -66,6 +62,6 @@ class YAML_CPP_API Binary {
+ const unsigned char *m_unownedData;
+ std::size_t m_unownedSize;
+ };
+-} // namespace YAML
++}
+
+ #endif // BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+diff --git a/include/yaml-cpp/contrib/anchordict.h b/include/yaml-cpp/contrib/anchordict.h
+index 1b7809b..78db9ec 100644
+--- a/include/yaml-cpp/contrib/anchordict.h
++++ b/include/yaml-cpp/contrib/anchordict.h
+@@ -22,7 +22,6 @@ namespace YAML {
+ template <class T>
+ class AnchorDict {
+ public:
+- AnchorDict() : m_data{} {}
+ void Register(anchor_t anchor, T value) {
+ if (anchor > m_data.size()) {
+ m_data.resize(anchor);
+@@ -35,6 +34,6 @@ class AnchorDict {
+ private:
+ std::vector<T> m_data;
+ };
+-} // namespace YAML
++}
+
+ #endif // ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+diff --git a/include/yaml-cpp/emitter.h b/include/yaml-cpp/emitter.h
+index 6f142b0..bf723ab 100644
+--- a/include/yaml-cpp/emitter.h
++++ b/include/yaml-cpp/emitter.h
+@@ -19,6 +19,7 @@
+ #include "yaml-cpp/dll.h"
+ #include "yaml-cpp/emitterdef.h"
+ #include "yaml-cpp/emittermanip.h"
++#include "yaml-cpp/noncopyable.h"
+ #include "yaml-cpp/null.h"
+ #include "yaml-cpp/ostream_wrapper.h"
+
+@@ -30,12 +31,10 @@ struct _Null;
+ namespace YAML {
+ class EmitterState;
+
+-class YAML_CPP_API Emitter {
++class YAML_CPP_API Emitter : private noncopyable {
+ public:
+ Emitter();
+ explicit Emitter(std::ostream& stream);
+- Emitter(const Emitter&) = delete;
+- Emitter& operator=(const Emitter&) = delete;
+ ~Emitter();
+
+ // output
+@@ -274,6 +273,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
+diff --git a/include/yaml-cpp/node/detail/memory.h b/include/yaml-cpp/node/detail/memory.h
+index a4df0f7..8f2bc26 100644
+--- a/include/yaml-cpp/node/detail/memory.h
++++ b/include/yaml-cpp/node/detail/memory.h
+@@ -22,7 +22,6 @@ namespace YAML {
+ namespace detail {
+ class YAML_CPP_API memory {
+ public:
+- memory() : m_nodes{} {}
+ node& create_node();
+ void merge(const memory& rhs);
+
+@@ -41,7 +40,7 @@ class YAML_CPP_API memory_holder {
+ private:
+ shared_memory m_pMemory;
+ };
+-} // namespace detail
+-} // namespace YAML
++}
++}
+
+ #endif // VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+diff --git a/include/yaml-cpp/node/detail/node.h b/include/yaml-cpp/node/detail/node.h
+index a2cc52b..8a776f6 100644
+--- a/include/yaml-cpp/node/detail/node.h
++++ b/include/yaml-cpp/node/detail/node.h
+@@ -7,18 +7,18 @@
+ #pragma once
+ #endif
+
+-#include "yaml-cpp/dll.h"
+ #include "yaml-cpp/emitterstyle.h"
+-#include "yaml-cpp/node/detail/node_ref.h"
+-#include "yaml-cpp/node/ptr.h"
++#include "yaml-cpp/dll.h"
+ #include "yaml-cpp/node/type.h"
++#include "yaml-cpp/node/ptr.h"
++#include "yaml-cpp/node/detail/node_ref.h"
+ #include <set>
+
+ namespace YAML {
+ namespace detail {
+ class node {
+ public:
+- node() : m_pRef(new node_ref), m_dependencies{} {}
++ node() : m_pRef(new node_ref) {}
+ node(const node&) = delete;
+ node& operator=(const node&) = delete;
+
+@@ -163,7 +163,7 @@ class node {
+ typedef std::set<node*> nodes;
+ nodes m_dependencies;
+ };
+-} // namespace detail
+-} // namespace YAML
++}
++}
+
+ #endif // NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+diff --git a/include/yaml-cpp/node/impl.h b/include/yaml-cpp/node/impl.h
+index 8346f40..de2bf44 100644
+--- a/include/yaml-cpp/node/impl.h
++++ b/include/yaml-cpp/node/impl.h
+@@ -7,15 +7,15 @@
+ #pragma once
+ #endif
+
+-#include "yaml-cpp/exceptions.h"
++#include "yaml-cpp/node/node.h"
++#include "yaml-cpp/node/iterator.h"
+ #include "yaml-cpp/node/detail/memory.h"
+ #include "yaml-cpp/node/detail/node.h"
+-#include "yaml-cpp/node/iterator.h"
+-#include "yaml-cpp/node/node.h"
++#include "yaml-cpp/exceptions.h"
+ #include <string>
+
+ namespace YAML {
+-inline Node::Node() : m_isValid(true), m_pMemory(nullptr), m_pNode(nullptr) {}
++inline Node::Node() : m_isValid(true), m_pNode(NULL) {}
+
+ inline Node::Node(NodeType::value type)
+ : m_isValid(true),
+@@ -42,7 +42,7 @@ inline Node::Node(const Node& rhs)
+ m_pMemory(rhs.m_pMemory),
+ m_pNode(rhs.m_pNode) {}
+
+-inline Node::Node(Zombie) : m_isValid(false), m_pMemory{}, m_pNode(nullptr) {}
++inline Node::Node(Zombie) : m_isValid(false), m_pNode(NULL) {}
+
+ inline Node::Node(detail::node& node, detail::shared_memory_holder pMemory)
+ : m_isValid(true), m_pMemory(pMemory), m_pNode(&node) {}
+@@ -202,15 +202,6 @@ inline Node& Node::operator=(const T& rhs) {
+ return *this;
+ }
+
+-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::reset(const YAML::Node& rhs) {
+ if (!m_isValid || !rhs.m_isValid)
+ throw InvalidNode();
+@@ -247,6 +238,15 @@ inline void Node::Assign(char* rhs) {
+ 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();
+@@ -366,7 +366,7 @@ template <typename T>
+ inline typename to_value_t<T>::return_type to_value(const T& t) {
+ return to_value_t<T>(t)();
+ }
+-} // namespace detail
++}
+
+ // indexing
+ template <typename Key>
+@@ -374,8 +374,8 @@ 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(detail::to_value(key), m_pMemory);
+ if (!value) {
+ return Node(ZombieNode);
+ }
+@@ -443,6 +443,6 @@ inline void Node::force_insert(const Key& key, const Value& value) {
+
+ // 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
+diff --git a/include/yaml-cpp/noncopyable.h b/include/yaml-cpp/noncopyable.h
+new file mode 100644
+index 0000000..a261040
+--- /dev/null
++++ b/include/yaml-cpp/noncopyable.h
+@@ -0,0 +1,25 @@
++#ifndef NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
++#define NONCOPYABLE_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
++#endif
++
++#include "yaml-cpp/dll.h"
++
++namespace YAML {
++// this is basically boost::noncopyable
++class YAML_CPP_API noncopyable {
++ protected:
++ noncopyable() {}
++ ~noncopyable() {}
++
++ private:
++ noncopyable(const noncopyable&);
++ const noncopyable& operator=(const noncopyable&);
++};
++}
++
++#endif // NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+diff --git a/include/yaml-cpp/ostream_wrapper.h b/include/yaml-cpp/ostream_wrapper.h
+index 259801b..09d45f3 100644
+--- a/include/yaml-cpp/ostream_wrapper.h
++++ b/include/yaml-cpp/ostream_wrapper.h
+@@ -17,10 +17,6 @@ class YAML_CPP_API ostream_wrapper {
+ public:
+ ostream_wrapper();
+ explicit ostream_wrapper(std::ostream& stream);
+- ostream_wrapper(const ostream_wrapper&) = delete;
+- ostream_wrapper(ostream_wrapper&&) = delete;
+- ostream_wrapper& operator=(const ostream_wrapper&) = delete;
+- ostream_wrapper& operator=(ostream_wrapper&&) = delete;
+ ~ostream_wrapper();
+
+ void write(const std::string& str);
+@@ -56,7 +52,7 @@ class YAML_CPP_API ostream_wrapper {
+
+ template <std::size_t N>
+ inline ostream_wrapper& operator<<(ostream_wrapper& stream,
+- const char (&str)[N]) {
++ const char(&str)[N]) {
+ stream.write(str, N - 1);
+ return stream;
+ }
+@@ -71,6 +67,6 @@ inline ostream_wrapper& operator<<(ostream_wrapper& stream, char ch) {
+ stream.write(&ch, 1);
+ return stream;
+ }
+-} // namespace YAML
++}
+
+ #endif // OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+diff --git a/include/yaml-cpp/parser.h b/include/yaml-cpp/parser.h
+index e9fba0c..ceac22d 100644
+--- a/include/yaml-cpp/parser.h
++++ b/include/yaml-cpp/parser.h
+@@ -11,6 +11,7 @@
+ #include <memory>
+
+ #include "yaml-cpp/dll.h"
++#include "yaml-cpp/noncopyable.h"
+
+ namespace YAML {
+ class EventHandler;
+@@ -23,17 +24,11 @@ struct Token;
+ * A parser turns a stream of bytes into one stream of "events" per YAML
+ * document in the input stream.
+ */
+-class YAML_CPP_API Parser {
++class YAML_CPP_API Parser : private noncopyable {
+ public:
+ /** Constructs an empty parser (with no input. */
+ Parser();
+
+- /** non copyable but movable */
+- Parser(const Parser&) = delete;
+- Parser(Parser&&) = default;
+- Parser& operator=(const Parser&) = delete;
+- Parser& operator=(Parser&&) = default;
+-
+ /**
+ * Constructs a parser from the given input stream. The input stream must
+ * live as long as the parser.
+@@ -86,6 +81,6 @@ class YAML_CPP_API Parser {
+ std::unique_ptr<Scanner> m_pScanner;
+ std::unique_ptr<Directives> m_pDirectives;
+ };
+-} // namespace YAML
++}
+
+ #endif // PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+diff --git a/src/collectionstack.h b/src/collectionstack.h
+index 9feba96..ebdc587 100644
+--- a/src/collectionstack.h
++++ b/src/collectionstack.h
+@@ -7,8 +7,8 @@
+ #pragma once
+ #endif
+
+-#include <cassert>
+ #include <stack>
++#include <cassert>
+
+ namespace YAML {
+ struct CollectionType {
+@@ -17,7 +17,6 @@ struct CollectionType {
+
+ class CollectionStack {
+ public:
+- CollectionStack() : collectionStack{} {}
+ CollectionType::value GetCurCollectionType() const {
+ if (collectionStack.empty())
+ return CollectionType::NoCollection;
+@@ -36,6 +35,6 @@ class CollectionStack {
+ private:
+ std::stack<CollectionType::value> collectionStack;
+ };
+-} // namespace YAML
++}
+
+ #endif // COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+diff --git a/src/contrib/graphbuilderadapter.h b/src/contrib/graphbuilderadapter.h
+index 9078cdf..62b40a1 100644
+--- a/src/contrib/graphbuilderadapter.h
++++ b/src/contrib/graphbuilderadapter.h
+@@ -26,15 +26,7 @@ namespace YAML {
+ class GraphBuilderAdapter : public EventHandler {
+ public:
+ GraphBuilderAdapter(GraphBuilderInterface& builder)
+- : 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;
++ : m_builder(builder), m_pRootNode(nullptr), m_pKeyNode(nullptr) {}
+
+ virtual void OnDocumentStart(const Mark& mark) { (void)mark; }
+ virtual void OnDocumentEnd() {}
+@@ -58,8 +50,8 @@ class GraphBuilderAdapter : public EventHandler {
+ struct ContainerFrame {
+ ContainerFrame(void* pSequence)
+ : pContainer(pSequence), pPrevKeyNode(&sequenceMarker) {}
+- ContainerFrame(void* pMap, void* pPreviousKeyNode)
+- : pContainer(pMap), pPrevKeyNode(pPreviousKeyNode) {}
++ ContainerFrame(void* pMap, void* pPrevKeyNode)
++ : pContainer(pMap), pPrevKeyNode(pPrevKeyNode) {}
+
+ void* pContainer;
+ void* pPrevKeyNode;
+@@ -82,6 +74,6 @@ class GraphBuilderAdapter : public EventHandler {
+ void RegisterAnchor(anchor_t anchor, void* pNode);
+ void DispositionNode(void* pNode);
+ };
+-} // namespace YAML
++}
+
+ #endif // GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+diff --git a/src/directives.cpp b/src/directives.cpp
+index 0c85d0f..963bd2c 100644
+--- a/src/directives.cpp
++++ b/src/directives.cpp
+@@ -1,7 +1,12 @@
+ #include "directives.h"
+
+ namespace YAML {
+-Directives::Directives() : version{true, 1, 2}, tags{} {}
++Directives::Directives() {
++ // version
++ version.isDefault = true;
++ version.major = 1;
++ version.minor = 2;
++}
+
+ const std::string Directives::TranslateTagHandle(
+ const std::string& handle) const {
+@@ -14,4 +19,4 @@ const std::string Directives::TranslateTagHandle(
+
+ return it->second;
+ }
+-} // namespace YAML
++}
+diff --git a/src/emitfromevents.cpp b/src/emitfromevents.cpp
+index 5a51bb4..4832649 100644
+--- a/src/emitfromevents.cpp
++++ b/src/emitfromevents.cpp
+@@ -16,11 +16,10 @@ std::string ToString(YAML::anchor_t anchor) {
+ stream << anchor;
+ return stream.str();
+ }
+-} // namespace
++}
+
+ namespace YAML {
+-EmitFromEvents::EmitFromEvents(Emitter& emitter)
+- : m_emitter(emitter), m_stateStack{} {}
++EmitFromEvents::EmitFromEvents(Emitter& emitter) : m_emitter(emitter) {}
+
+ void EmitFromEvents::OnDocumentStart(const Mark&) {}
+
+@@ -117,4 +116,4 @@ void EmitFromEvents::EmitProps(const std::string& tag, anchor_t anchor) {
+ if (anchor)
+ m_emitter << Anchor(ToString(anchor));
+ }
+-} // namespace YAML
++}
+diff --git a/src/emitter.cpp b/src/emitter.cpp
+index 016beb1..6872252 100644
+--- a/src/emitter.cpp
++++ b/src/emitter.cpp
+@@ -11,7 +11,7 @@ namespace YAML {
+ class Binary;
+ struct _Null;
+
+-Emitter::Emitter() : m_pState(new EmitterState), m_stream{} {}
++Emitter::Emitter() : m_pState(new EmitterState) {}
+
+ Emitter::Emitter(std::ostream& stream)
+ : m_pState(new EmitterState), m_stream(stream) {}
+@@ -906,4 +906,4 @@ Emitter& Emitter::Write(const Binary& binary) {
+
+ return *this;
+ }
+-} // namespace YAML
++}
+diff --git a/src/emitterstate.cpp b/src/emitterstate.cpp
+index 890b4f0..d5f39e7 100644
+--- a/src/emitterstate.cpp
++++ b/src/emitterstate.cpp
+@@ -6,31 +6,27 @@
+ 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_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_hasTag(false),
+ m_hasNonContent(false),
+- m_docCount(0) {}
++ m_docCount(0) {
++ // set default global manipulators
++ m_charset.set(EmitNonAscii);
++ m_strFmt.set(Auto);
++ m_boolFmt.set(TrueFalseBool);
++ m_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>::max_digits10);
++ m_doublePrecision.set(std::numeric_limits<double>::max_digits10);
++}
+
+ EmitterState::~EmitterState() {}
+
+@@ -366,4 +362,4 @@ bool EmitterState::SetDoublePrecision(std::size_t value,
+ _Set(m_doublePrecision, value, scope);
+ return true;
+ }
+-} // namespace YAML
++}
+diff --git a/src/emitterstate.h b/src/emitterstate.h
+index 75e2166..0937f00 100644
+--- a/src/emitterstate.h
++++ b/src/emitterstate.h
+@@ -145,12 +145,7 @@ class EmitterState {
+
+ struct Group {
+ explicit Group(GroupType::value type_)
+- : type(type_),
+- flowType{},
+- indent(0),
+- childCount(0),
+- longKey(false),
+- modifiedSettings{} {}
++ : type(type_), indent(0), childCount(0), longKey(false) {}
+
+ GroupType::value type;
+ FlowType::value flowType;
+@@ -203,6 +198,6 @@ void EmitterState::_Set(Setting<T>& fmt, T value, FmtScope::value scope) {
+ assert(false);
+ }
+ }
+-} // namespace YAML
++}
+
+ #endif // EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+diff --git a/src/emitterutils.cpp b/src/emitterutils.cpp
+index e348599..e02931f 100644
+--- a/src/emitterutils.cpp
++++ b/src/emitterutils.cpp
+@@ -8,8 +8,8 @@
+ #include "regeximpl.h"
+ #include "stringsource.h"
+ #include "yaml-cpp/binary.h" // IWYU pragma: keep
+-#include "yaml-cpp/null.h"
+ #include "yaml-cpp/ostream_wrapper.h"
++#include "yaml-cpp/null.h"
+
+ namespace YAML {
+ namespace Utils {
+@@ -173,12 +173,12 @@ 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::EndScalarInFlow() || (Exp::BlankOrBreak() + Exp::Comment()) ||
++ Exp::NotPrintable() || Exp::Utf8_ByteOrderMark() || Exp::Break() ||
+ Exp::Tab();
+ static const RegEx& disallowed_block =
+- Exp::EndScalar() | (Exp::BlankOrBreak() + Exp::Comment()) |
+- Exp::NotPrintable() | Exp::Utf8_ByteOrderMark() | Exp::Break() |
++ Exp::EndScalar() || (Exp::BlankOrBreak() + Exp::Comment()) ||
++ Exp::NotPrintable() || Exp::Utf8_ByteOrderMark() || Exp::Break() ||
+ Exp::Tab();
+ const RegEx& disallowed =
+ flowType == FlowType::Flow ? disallowed_flow : disallowed_block;
+@@ -258,7 +258,7 @@ bool WriteAliasName(ostream_wrapper& out, const std::string& str) {
+ }
+ return true;
+ }
+-} // namespace
++}
+
+ StringFormat::value ComputeStringFormat(const std::string& str,
+ EMITTER_MANIP strFormat,
+@@ -401,8 +401,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);
+@@ -479,5 +479,5 @@ bool WriteBinary(ostream_wrapper& out, const Binary& binary) {
+ false);
+ return true;
+ }
+-} // namespace Utils
+-} // namespace YAML
++}
++}
+diff --git a/src/exp.h b/src/exp.h
+index fe36535..7c02cf6 100644
+--- a/src/exp.h
++++ b/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");
+ 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,11 +106,11 @@ 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() {
+@@ -122,20 +122,20 @@ inline const RegEx Comment() {
+ 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 +148,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) |
++ !(BlankOrBreak() || RegEx("?,[]{}#&*!|>\'\"%@`", REGEX_OR) ||
+ (RegEx("-:", REGEX_OR) + Blank()));
+ return e;
+ }
+ inline const RegEx& EndScalar() {
+- static const RegEx e = RegEx(':') + (BlankOrBreak() | RegEx());
++ static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx());
+ return e;
+ }
+ inline const RegEx& EndScalarInFlow() {
+ static const RegEx e =
+- (RegEx(':') + (BlankOrBreak() | RegEx() | RegEx(",]}", REGEX_OR))) |
++ (RegEx(':') + (BlankOrBreak() || RegEx() || RegEx(",]}", REGEX_OR))) ||
+ RegEx(",?[]{}", REGEX_OR);
+ return e;
+ }
+
+ inline const RegEx& ScanScalarEndInFlow() {
+- static const RegEx e = (EndScalarInFlow() | (BlankOrBreak() + Comment()));
++ static const RegEx e = (EndScalarInFlow() || (BlankOrBreak() + Comment()));
+ return e;
+ }
+
+ inline const RegEx& ScanScalarEnd() {
+- static const RegEx e = EndScalar() | (BlankOrBreak() + Comment());
++ static const RegEx e = EndScalar() || (BlankOrBreak() + Comment());
+ return e;
+ }
+ inline const RegEx& EscSingleQuote() {
+@@ -192,8 +192,8 @@ 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;
+ }
+diff --git a/src/node_data.cpp b/src/node_data.cpp
+index c65accb..04104b7 100644
+--- a/src/node_data.cpp
++++ b/src/node_data.cpp
+@@ -14,21 +14,16 @@ namespace YAML {
+ namespace detail {
+
+ const std::string& node_data::empty_scalar() {
+- static const std::string svalue;
+- return svalue;
++ static const std::string svalue;
++ return svalue;
+ }
+
+ node_data::node_data()
+ : m_isDefined(false),
+ m_mark(Mark::null_mark()),
+ m_type(NodeType::Null),
+- m_tag{},
+ m_style(EmitterStyle::Default),
+- m_scalar{},
+- m_sequence{},
+- m_seqSize(0),
+- m_map{},
+- m_undefinedPairs{} {}
++ m_seqSize(0) {}
+
+ void node_data::mark_defined() {
+ if (m_type == NodeType::Undefined)
+@@ -243,8 +238,8 @@ bool node_data::remove(node& 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 it = m_undefinedPairs.begin();
++ while (it != m_undefinedPairs.end()) {
+ kv_pairs::iterator jt = std::next(it);
+ if (it->first->is(key))
+ m_undefinedPairs.erase(it);
+@@ -312,5 +307,5 @@ void node_data::convert_sequence_to_map(shared_memory_holder pMemory) {
+ reset_sequence();
+ m_type = NodeType::Map;
+ }
+-} // namespace detail
+-} // namespace YAML
++}
++}
+diff --git a/src/nodebuilder.cpp b/src/nodebuilder.cpp
+index c90a66c..e79ac50 100644
+--- a/src/nodebuilder.cpp
++++ b/src/nodebuilder.cpp
+@@ -11,12 +11,7 @@ namespace YAML {
+ struct Mark;
+
+ NodeBuilder::NodeBuilder()
+- : m_pMemory(new detail::memory_holder),
+- m_pRoot(nullptr),
+- m_stack{},
+- m_anchors{},
+- m_keys{},
+- m_mapDepth(0) {
++ : m_pMemory(new detail::memory_holder), m_pRoot(nullptr), m_mapDepth(0) {
+ m_anchors.push_back(nullptr); // since the anchors start at 1
+ }
+
+@@ -132,4 +127,4 @@ void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node) {
+ m_anchors.push_back(&node);
+ }
+ }
+-} // namespace YAML
++}
+diff --git a/src/nodebuilder.h b/src/nodebuilder.h
+index 642da36..a6a47f0 100644
+--- a/src/nodebuilder.h
++++ b/src/nodebuilder.h
+@@ -27,10 +27,6 @@ class Node;
+ class NodeBuilder : public EventHandler {
+ public:
+ NodeBuilder();
+- NodeBuilder(const NodeBuilder&) = delete;
+- NodeBuilder(NodeBuilder&&) = delete;
+- NodeBuilder& operator=(const NodeBuilder&) = delete;
+- NodeBuilder& operator=(NodeBuilder&&) = delete;
+ virtual ~NodeBuilder();
+
+ Node Root();
+@@ -69,6 +65,6 @@ class NodeBuilder : public EventHandler {
+ std::vector<PushedKey> m_keys;
+ std::size_t m_mapDepth;
+ };
+-} // namespace YAML
++}
+
+ #endif // NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+diff --git a/src/nodeevents.cpp b/src/nodeevents.cpp
+index b7222e0..82261fe 100644
+--- a/src/nodeevents.cpp
++++ b/src/nodeevents.cpp
+@@ -20,7 +20,7 @@ anchor_t NodeEvents::AliasManager::LookupAnchor(
+ }
+
+ NodeEvents::NodeEvents(const Node& node)
+- : m_pMemory(node.m_pMemory), m_root(node.m_pNode), m_refCount{} {
++ : m_pMemory(node.m_pMemory), m_root(node.m_pNode) {
+ if (m_root)
+ Setup(*m_root);
+ }
+@@ -98,4 +98,4 @@ bool NodeEvents::IsAliased(const detail::node& node) const {
+ RefCount::const_iterator it = m_refCount.find(node.ref());
+ return it != m_refCount.end() && it->second > 1;
+ }
+-} // namespace YAML
++}
+diff --git a/src/nodeevents.h b/src/nodeevents.h
+index dbed5d2..49c18eb 100644
+--- a/src/nodeevents.h
++++ b/src/nodeevents.h
+@@ -26,17 +26,13 @@ class Node;
+ class NodeEvents {
+ public:
+ explicit NodeEvents(const Node& node);
+- NodeEvents(const NodeEvents&) = delete;
+- NodeEvents(NodeEvents&&) = delete;
+- NodeEvents& operator=(const NodeEvents&) = delete;
+- NodeEvents& operator=(NodeEvents&&) = delete;
+
+ void Emit(EventHandler& handler);
+
+ private:
+ class AliasManager {
+ public:
+- AliasManager() : m_anchorByIdentity{}, m_curAnchor(0) {}
++ AliasManager() : m_curAnchor(0) {}
+
+ void RegisterReference(const detail::node& node);
+ anchor_t LookupAnchor(const detail::node& node) const;
+@@ -63,6 +59,6 @@ class NodeEvents {
+ typedef std::map<const detail::node_ref*, int> RefCount;
+ RefCount m_refCount;
+ };
+-} // namespace YAML
++}
+
+ #endif // NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+diff --git a/src/ostream_wrapper.cpp b/src/ostream_wrapper.cpp
+index 5fa5858..a3c7597 100644
+--- a/src/ostream_wrapper.cpp
++++ b/src/ostream_wrapper.cpp
+@@ -14,12 +14,7 @@ ostream_wrapper::ostream_wrapper()
+ m_comment(false) {}
+
+ ostream_wrapper::ostream_wrapper(std::ostream& stream)
+- : m_buffer{},
+- m_pStream(&stream),
+- m_pos(0),
+- m_row(0),
+- m_col(0),
+- m_comment(false) {}
++ : m_pStream(&stream), m_pos(0), m_row(0), m_col(0), m_comment(false) {}
+
+ ostream_wrapper::~ostream_wrapper() {}
+
+@@ -59,4 +54,4 @@ void ostream_wrapper::update_pos(char ch) {
+ m_comment = false;
+ }
+ }
+-} // namespace YAML
++}
+diff --git a/src/parser.cpp b/src/parser.cpp
+index 7bc0c78..cd69f39 100644
+--- a/src/parser.cpp
++++ b/src/parser.cpp
+@@ -11,9 +11,9 @@
+ namespace YAML {
+ class EventHandler;
+
+-Parser::Parser() : m_pScanner{}, m_pDirectives{} {}
++Parser::Parser() {}
+
+-Parser::Parser(std::istream& in) : Parser() { Load(in); }
++Parser::Parser(std::istream& in) { Load(in); }
+
+ Parser::~Parser() {}
+
+@@ -126,4 +126,4 @@ void Parser::PrintTokens(std::ostream& out) {
+ m_pScanner->pop();
+ }
+ }
+-} // namespace YAML
++}
+diff --git a/src/ptr_vector.h b/src/ptr_vector.h
+index d58de04..955aebd 100644
+--- a/src/ptr_vector.h
++++ b/src/ptr_vector.h
+@@ -12,17 +12,15 @@
+ #include <memory>
+ #include <vector>
+
++#include "yaml-cpp/noncopyable.h"
++
+ namespace YAML {
+
+ // TODO: This class is no longer needed
+ template <typename T>
+-class ptr_vector {
++class ptr_vector : private YAML::noncopyable {
+ public:
+- ptr_vector() : m_data{} {}
+- ptr_vector(const ptr_vector&) = delete;
+- ptr_vector(ptr_vector&&) = default;
+- ptr_vector& operator=(const ptr_vector&) = delete;
+- ptr_vector& operator=(ptr_vector&&) = default;
++ ptr_vector() {}
+
+ void clear() { m_data.clear(); }
+
+@@ -40,6 +38,6 @@ class ptr_vector {
+ private:
+ std::vector<std::unique_ptr<T>> m_data;
+ };
+-} // namespace YAML
++}
+
+ #endif // PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+diff --git a/src/regex_yaml.cpp b/src/regex_yaml.cpp
+index bf1784b..20b7720 100644
+--- a/src/regex_yaml.cpp
++++ b/src/regex_yaml.cpp
+@@ -2,16 +2,18 @@
+
+ namespace YAML {
+ // constructors
++RegEx::RegEx() : m_op(REGEX_EMPTY) {}
+
+-RegEx::RegEx(REGEX_OP op) : m_op(op), m_a(0), m_z(0), m_params{} {}
+-RegEx::RegEx() : RegEx(REGEX_EMPTY) {}
++RegEx::RegEx(REGEX_OP op) : m_op(op) {}
+
+-RegEx::RegEx(char ch) : m_op(REGEX_MATCH), m_a(ch), m_z(0), m_params{} {}
++RegEx::RegEx(char ch) : m_op(REGEX_MATCH), m_a(ch) {}
+
+-RegEx::RegEx(char a, char z) : m_op(REGEX_RANGE), m_a(a), m_z(z), m_params{} {}
++RegEx::RegEx(char a, char z) : m_op(REGEX_RANGE), m_a(a), m_z(z) {}
+
+-RegEx::RegEx(const std::string& str, REGEX_OP op)
+- : m_op(op), m_a(0), m_z(0), m_params(str.begin(), str.end()) {}
++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]));
++}
+
+ // combination constructors
+ RegEx operator!(const RegEx& ex) {
+@@ -20,14 +22,14 @@ RegEx operator!(const RegEx& ex) {
+ return ret;
+ }
+
+-RegEx operator|(const RegEx& ex1, const RegEx& ex2) {
++RegEx operator||(const RegEx& ex1, const RegEx& ex2) {
+ RegEx ret(REGEX_OR);
+ ret.m_params.push_back(ex1);
+ ret.m_params.push_back(ex2);
+ return ret;
+ }
+
+-RegEx operator&(const RegEx& ex1, const RegEx& ex2) {
++RegEx operator&&(const RegEx& ex1, const RegEx& ex2) {
+ RegEx ret(REGEX_AND);
+ ret.m_params.push_back(ex1);
+ ret.m_params.push_back(ex2);
+@@ -40,4 +42,4 @@ RegEx operator+(const RegEx& ex1, const RegEx& ex2) {
+ ret.m_params.push_back(ex2);
+ return ret;
+ }
+-} // namespace YAML
++}
+diff --git a/src/regex_yaml.h b/src/regex_yaml.h
+index 3a347bb..1611cb2 100644
+--- a/src/regex_yaml.h
++++ b/src/regex_yaml.h
+@@ -31,14 +31,14 @@ enum REGEX_OP {
+ class YAML_CPP_API RegEx {
+ public:
+ RegEx();
+- explicit RegEx(char ch);
++ RegEx(char ch);
+ RegEx(char a, char z);
+ RegEx(const std::string& str, REGEX_OP op = REGEX_SEQ);
+ ~RegEx() {}
+
+ friend YAML_CPP_API RegEx operator!(const RegEx& ex);
+- friend YAML_CPP_API RegEx operator|(const RegEx& ex1, const RegEx& ex2);
+- friend YAML_CPP_API RegEx operator&(const RegEx& ex1, const RegEx& ex2);
++ friend YAML_CPP_API RegEx operator||(const RegEx& ex1, const RegEx& ex2);
++ friend YAML_CPP_API RegEx operator&&(const RegEx& ex1, const RegEx& ex2);
+ friend YAML_CPP_API RegEx operator+(const RegEx& ex1, const RegEx& ex2);
+
+ bool Matches(char ch) const;
+@@ -53,7 +53,7 @@ class YAML_CPP_API RegEx {
+ int Match(const Source& source) const;
+
+ private:
+- explicit RegEx(REGEX_OP op);
++ RegEx(REGEX_OP op);
+
+ template <typename Source>
+ bool IsValidSource(const Source& source) const;
+diff --git a/src/scanner.cpp b/src/scanner.cpp
+index ac84892..546a2f0 100644
+--- a/src/scanner.cpp
++++ b/src/scanner.cpp
+@@ -9,15 +9,10 @@
+ namespace YAML {
+ Scanner::Scanner(std::istream& in)
+ : INPUT(in),
+- m_tokens{},
+ m_startedStream(false),
+ m_endedStream(false),
+ m_simpleKeyAllowed(false),
+- m_canBeJSONFlow(false),
+- m_simpleKeys{},
+- m_indents{},
+- m_indentRefs{},
+- m_flows{} {}
++ m_canBeJSONFlow(false) {}
+
+ Scanner::~Scanner() {}
+
+diff --git a/src/scantoken.cpp b/src/scantoken.cpp
+index 325de57..fd8758d 100644
+--- a/src/scantoken.cpp
++++ b/src/scantoken.cpp
+@@ -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
++}
+diff --git a/src/setting.h b/src/setting.h
+index 280d1e7..b78d40e 100644
+--- a/src/setting.h
++++ b/src/setting.h
+@@ -8,8 +8,8 @@
+ #endif
+
+ #include <memory>
+-#include <utility>
+ #include <vector>
++#include "yaml-cpp/noncopyable.h"
+
+ namespace YAML {
+ class SettingChangeBase;
+@@ -18,7 +18,6 @@ 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);
+@@ -37,14 +36,10 @@ class SettingChangeBase {
+ template <typename T>
+ class SettingChange : public SettingChangeBase {
+ public:
+- 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;
++ SettingChange(Setting<T>* pSetting) : m_pCurSetting(pSetting) {
++ // copy old setting to save its state
++ m_oldSetting = *pSetting;
++ }
+
+ virtual void pop() { m_pCurSetting->restore(m_oldSetting); }
+
+@@ -60,12 +55,9 @@ inline std::unique_ptr<SettingChangeBase> Setting<T>::set(const T& value) {
+ return pChange;
+ }
+
+-class SettingChanges {
++class SettingChanges : private noncopyable {
+ public:
+- SettingChanges() : m_settingChanges{} {}
+- SettingChanges(const SettingChanges&) = delete;
+- SettingChanges(SettingChanges&&) = default;
+- SettingChanges& operator=(const SettingChanges&) = delete;
++ SettingChanges() {}
+ ~SettingChanges() { clear(); }
+
+ void clear() {
+@@ -98,6 +90,6 @@ class SettingChanges {
+ typedef std::vector<std::unique_ptr<SettingChangeBase>> setting_changes;
+ setting_changes m_settingChanges;
+ };
+-} // namespace YAML
++}
+
+ #endif // SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+diff --git a/src/singledocparser.cpp b/src/singledocparser.cpp
+index be82741..e267797 100644
+--- a/src/singledocparser.cpp
++++ b/src/singledocparser.cpp
+@@ -18,7 +18,6 @@ SingleDocParser::SingleDocParser(Scanner& scanner, const Directives& directives)
+ : m_scanner(scanner),
+ m_directives(directives),
+ m_pCollectionStack(new CollectionStack),
+- m_anchors{},
+ m_curAnchor(0) {}
+
+ SingleDocParser::~SingleDocParser() {}
+@@ -171,10 +170,10 @@ void SingleDocParser::HandleBlockSequence(EventHandler& eventHandler) {
+
+ // check for null
+ if (!m_scanner.empty()) {
+- const Token& nextToken = m_scanner.peek();
+- if (nextToken.type == Token::BLOCK_ENTRY ||
+- nextToken.type == Token::BLOCK_SEQ_END) {
+- eventHandler.OnNull(nextToken.mark, NullAnchor);
++ const Token& token = m_scanner.peek();
++ if (token.type == Token::BLOCK_ENTRY ||
++ token.type == Token::BLOCK_SEQ_END) {
++ eventHandler.OnNull(token.mark, NullAnchor);
+ continue;
+ }
+ }
+diff --git a/src/singledocparser.h b/src/singledocparser.h
+index 392453e..a78301e 100644
+--- a/src/singledocparser.h
++++ b/src/singledocparser.h
+@@ -12,6 +12,7 @@
+ #include <string>
+
+ #include "yaml-cpp/anchor.h"
++#include "yaml-cpp/noncopyable.h"
+
+ namespace YAML {
+ class CollectionStack;
+@@ -22,13 +23,9 @@ struct Directives;
+ struct Mark;
+ struct Token;
+
+-class SingleDocParser {
++class SingleDocParser : private noncopyable {
+ public:
+ SingleDocParser(Scanner& scanner, const Directives& directives);
+- SingleDocParser(const SingleDocParser&) = delete;
+- SingleDocParser(SingleDocParser&&) = delete;
+- SingleDocParser& operator=(const SingleDocParser&) = delete;
+- SingleDocParser& operator=(SingleDocParser&&) = delete;
+ ~SingleDocParser();
+
+ void HandleDocument(EventHandler& eventHandler);
+diff --git a/src/stream.cpp b/src/stream.cpp
+index 592802d..3b013cf 100644
+--- a/src/stream.cpp
++++ b/src/stream.cpp
+@@ -111,15 +111,24 @@ static UtfIntroState s_introTransitions[][uictMax] = {
+
+ static char s_introUngetCount[][uictMax] = {
+ // uict00, uictBB, uictBF, uictEF, uictFE, uictFF, uictAscii, uictOther
+- {0, 1, 1, 0, 0, 0, 0, 1}, {0, 2, 2, 2, 2, 2, 2, 2},
+- {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) {
+@@ -183,9 +192,6 @@ 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) {
+@@ -439,4 +445,4 @@ void Stream::StreamInUtf32() const {
+
+ QueueUnicodeCodepoint(m_readahead, ch);
+ }
+-} // namespace YAML
++}
+diff --git a/src/stream.h b/src/stream.h
+index ff5149e..42d542d 100644
+--- a/src/stream.h
++++ b/src/stream.h
+@@ -7,6 +7,7 @@
+ #pragma once
+ #endif
+
++#include "yaml-cpp/noncopyable.h"
+ #include "yaml-cpp/mark.h"
+ #include <cstddef>
+ #include <deque>
+@@ -16,15 +17,11 @@
+ #include <string>
+
+ namespace YAML {
+-class Stream {
++class Stream : private noncopyable {
+ 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;
+@@ -74,6 +71,6 @@ inline bool Stream::ReadAheadTo(size_t i) const {
+ return true;
+ return _ReadAheadTo(i);
+ }
+-} // namespace YAML
++}
+
+ #endif // STREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+diff --git a/src/streamcharsource.h b/src/streamcharsource.h
+index 4b6a143..624599e 100644
+--- a/src/streamcharsource.h
++++ b/src/streamcharsource.h
+@@ -7,6 +7,7 @@
+ #pragma once
+ #endif
+
++#include "yaml-cpp/noncopyable.h"
+ #include <cstddef>
+
+ namespace YAML {
+@@ -15,9 +16,6 @@ class StreamCharSource {
+ 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&&) = default;
+- StreamCharSource& operator=(const StreamCharSource&) = delete;
+- StreamCharSource& operator=(StreamCharSource&&) = delete;
+ ~StreamCharSource() {}
+
+ operator bool() const;
+@@ -29,6 +27,8 @@ class StreamCharSource {
+ private:
+ std::size_t m_offset;
+ const Stream& m_stream;
++
++ StreamCharSource& operator=(const StreamCharSource&); // non-assignable
+ };
+
+ inline StreamCharSource::operator bool() const {
+@@ -43,6 +43,6 @@ inline const StreamCharSource StreamCharSource::operator+(int i) const {
+ source.m_offset = 0;
+ return source;
+ }
+-} // namespace YAML
++}
+
+ #endif // STREAMCHARSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+diff --git a/src/tag.cpp b/src/tag.cpp
+index df8a2cf..5143552 100644
+--- a/src/tag.cpp
++++ b/src/tag.cpp
+@@ -6,8 +6,7 @@
+ #include "token.h"
+
+ namespace YAML {
+-Tag::Tag(const Token& token)
+- : type(static_cast<TYPE>(token.data)), handle{}, value{} {
++Tag::Tag(const Token& token) : type(static_cast<TYPE>(token.data)) {
+ switch (type) {
+ case VERBATIM:
+ value = token.value;
+@@ -47,4 +46,4 @@ const std::string Tag::Translate(const Directives& directives) {
+ }
+ throw std::runtime_error("yaml-cpp: internal error, bad tag type");
+ }
+-} // namespace YAML
++}
+diff --git a/src/token.h b/src/token.h
+index 9a27f3d..ad0b7d0 100644
+--- a/src/token.h
++++ b/src/token.h
+@@ -14,11 +14,10 @@
+
+ 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
+@@ -49,7 +48,7 @@ struct Token {
+
+ // data
+ Token(TYPE type_, const Mark& mark_)
+- : status(VALID), type(type_), mark(mark_), value{}, params{}, data(0) {}
++ : status(VALID), type(type_), mark(mark_), data(0) {}
+
+ friend std::ostream& operator<<(std::ostream& out, const Token& token) {
+ out << TokenNames[token.type] << std::string(": ") << token.value;
+@@ -65,6 +64,6 @@ struct Token {
+ std::vector<std::string> params;
+ int data;
+ };
+-} // namespace YAML
++}
+
+ #endif // TOKEN_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+diff --git a/test/regex_test.cpp b/test/regex_test.cpp
+index 658db9e..7589d2e 100644
+--- a/test/regex_test.cpp
++++ b/test/regex_test.cpp
+@@ -1,6 +1,6 @@
++#include "gtest/gtest.h"
+ #include "regex_yaml.h"
+ #include "stream.h"
+-#include "gtest/gtest.h"
+
+ using YAML::RegEx;
+ using YAML::Stream;
+@@ -106,8 +106,8 @@ TEST(RegExTest, OperatorOr) {
+ for (int j = i + 1; j < 128; ++j) {
+ auto iStr = std::string(1, char(i));
+ auto jStr = std::string(1, char(j));
+- RegEx ex1 = RegEx(iStr) | RegEx(jStr);
+- RegEx ex2 = RegEx(jStr) | RegEx(iStr);
++ RegEx ex1 = RegEx(iStr) || RegEx(jStr);
++ RegEx ex2 = RegEx(jStr) || RegEx(iStr);
+
+ for (int k = MIN_CHAR; k < 128; ++k) {
+ auto str = std::string(1, char(k));
+@@ -128,8 +128,8 @@ TEST(RegExTest, OperatorOr) {
+ }
+
+ TEST(RegExTest, OperatorOrShortCircuits) {
+- RegEx ex1 = RegEx(std::string("aaaa")) | RegEx(std::string("aa"));
+- RegEx ex2 = RegEx(std::string("aa")) | RegEx(std::string("aaaa"));
++ RegEx ex1 = RegEx(std::string("aaaa")) || RegEx(std::string("aa"));
++ RegEx ex2 = RegEx(std::string("aa")) || RegEx(std::string("aaaa"));
+
+ EXPECT_TRUE(ex1.Matches(std::string("aaaaa")));
+ EXPECT_EQ(4, ex1.Match(std::string("aaaaa")));
+@@ -139,13 +139,13 @@ TEST(RegExTest, OperatorOrShortCircuits) {
+ }
+
+ TEST(RegExTest, OperatorAnd) {
+- RegEx emptySet = RegEx('a') & RegEx();
++ RegEx emptySet = RegEx('a') && RegEx();
+ EXPECT_FALSE(emptySet.Matches(std::string("a")));
+ }
+
+ TEST(RegExTest, OperatorAndShortCircuits) {
+- RegEx ex1 = RegEx(std::string("aaaa")) & RegEx(std::string("aa"));
+- RegEx ex2 = RegEx(std::string("aa")) & RegEx(std::string("aaaa"));
++ RegEx ex1 = RegEx(std::string("aaaa")) && RegEx(std::string("aa"));
++ RegEx ex2 = RegEx(std::string("aa")) && RegEx(std::string("aaaa"));
+
+ EXPECT_TRUE(ex1.Matches(std::string("aaaaa")));
+ EXPECT_EQ(4, ex1.Match(std::string("aaaaa")));
+@@ -174,4 +174,4 @@ TEST(RegExTest, StringOr) {
+
+ EXPECT_EQ(1, ex.Match(str));
+ }
+-} // namespace
++}
+--
+2.20.1
+
--- /dev/null
+From bde52684630ffb7c3464e406f02533e7de0ade38 Mon Sep 17 00:00:00 2001
+From: Adrian Bunk <bunk@debian.org>
+Date: Sun, 10 May 2020 11:39:29 +0300
+Subject: Revert "fix up static, so works as DLL (#559)"
+
+This reverts commit 774f25800e6f19f4b927023c85d1389af322da5e.
+---
+ include/yaml-cpp/node/detail/node_data.h | 2 +-
+ include/yaml-cpp/node/impl.h | 4 ++--
+ src/node_data.cpp | 5 +----
+ 3 files changed, 4 insertions(+), 7 deletions(-)
+
+diff --git a/include/yaml-cpp/node/detail/node_data.h b/include/yaml-cpp/node/detail/node_data.h
+index 82fb79a..50bcd74 100644
+--- a/include/yaml-cpp/node/detail/node_data.h
++++ b/include/yaml-cpp/node/detail/node_data.h
+@@ -81,7 +81,7 @@ class YAML_CPP_API node_data {
+ shared_memory_holder pMemory);
+
+ public:
+- static const std::string& empty_scalar();
++ static std::string empty_scalar;
+
+ private:
+ void compute_seq_size() const;
+diff --git a/include/yaml-cpp/node/impl.h b/include/yaml-cpp/node/impl.h
+index de2bf44..20c487a 100644
+--- a/include/yaml-cpp/node/impl.h
++++ b/include/yaml-cpp/node/impl.h
+@@ -156,13 +156,13 @@ 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();
++ 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();
++ return m_pNode ? m_pNode->tag() : detail::node_data::empty_scalar;
+ }
+
+ inline void Node::SetTag(const std::string& tag) {
+diff --git a/src/node_data.cpp b/src/node_data.cpp
+index 04104b7..34d81f7 100644
+--- a/src/node_data.cpp
++++ b/src/node_data.cpp
+@@ -13,10 +13,7 @@
+ namespace YAML {
+ namespace detail {
+
+-const std::string& node_data::empty_scalar() {
+- static const std::string svalue;
+- return svalue;
+-}
++std::string node_data::empty_scalar;
+
+ node_data::node_data()
+ : m_isDefined(false),
+--
+2.20.1
+
--- /dev/null
+commit c9460110e072df84b7dee3eb651f2ec5df75fb18
+Author: Jesse Beder <jbeder@gmail.com>
+Date: Mon Jan 20 18:05:15 2020 -0600
+
+ Fix reading empty token stack with a node with properties but no scalar.
+
+ E.g. `!2`.
+
+--- a/src/singledocparser.cpp
++++ b/src/singledocparser.cpp
+@@ -79,6 +79,12 @@
+ if (!anchor_name.empty())
+ eventHandler.OnAnchor(mark, anchor_name);
+
++ // after parsing properties, an empty node is again a possibility
++ if (m_scanner.empty()) {
++ eventHandler.OnNull(mark, anchor);
++ return;
++ }
++
+ const Token& token = m_scanner.peek();
+
+ if (token.type == Token::PLAIN_SCALAR && IsNullString(token.value)) {
+--- a/test/integration/load_node_test.cpp
++++ b/test/integration/load_node_test.cpp
+@@ -257,5 +257,10 @@
+ EXPECT_EQ(node.as<std::string>(), "foo");
+ }
+
++TEST(NodeTest, LoadTagWithNullScalar) {
++ Node node = Load("!2");
++ EXPECT_TRUE(node.IsNull());
++}
++
+ } // namespace
+ } // namespace YAML
--- /dev/null
+Description: Fix unbounded recursion CVEs
+Origin: https://github.com/jbeder/yaml-cpp/pull/807
+Forwarded: yes
+Bug: https://github.com/jbeder/yaml-cpp/issues/459
+Bug: https://github.com/jbeder/yaml-cpp/issues/655
+Bug: https://github.com/jbeder/yaml-cpp/issues/654
+Bug: https://github.com/jbeder/yaml-cpp/issues/660
+
+This cherry-picks the (so-far-unmerged) upstream pull request.
+The final 5 commits of that PR are not included; they only add tests
+to a file not present in the 0.6.2 (or 0.6.3) release.
+
+From d540476e31b080aa1f903ad20ec0426dd3838be7 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Antoine=20Beaupr=C3=A9?= <anarcat@debian.org>
+Date: Tue, 25 Apr 2017 20:10:20 -0400
+Subject: [PATCH 1/9] fix stack overflow in HandleNode() (CVE-2017-5950)
+
+simply set a hardcoded recursion limit to 2000 (inspired by Python's)
+to avoid infinitely recursing into arbitrary data structures
+
+assert() the depth. unsure if this is the right approach, but given
+that HandleNode() is "void", I am not sure how else to return an
+error. the problem with this approach of course is that it will still
+crash the caller, unless they have proper exception handling in place.
+
+Closes: #459
+---
+ src/singledocparser.cpp | 2 ++
+ src/singledocparser.h | 2 ++
+ 2 files changed, 4 insertions(+)
+
+--- a/src/singledocparser.cpp
++++ b/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
+@@ -47,6 +48,8 @@
+ }
+
+ void SingleDocParser::HandleNode(EventHandler& eventHandler) {
++ DepthGuard depthguard(depth, m_scanner.mark(), ErrorMsg::BAD_FILE);
++
+ // an empty node *is* a possibility
+ if (m_scanner.empty()) {
+ eventHandler.OnNull(m_scanner.mark(), NullAnchor);
+--- a/src/singledocparser.h
++++ b/src/singledocparser.h
+@@ -15,6 +15,8 @@
+
+ namespace YAML {
+ class CollectionStack;
++template <int> class DepthGuard; // depthguard.h
++class DeepRecursion; // an exception which may be thrown from excessive call stack recursion, see depthguard.h
+ class EventHandler;
+ class Node;
+ class Scanner;
+@@ -55,6 +57,8 @@
+ anchor_t LookupAnchor(const Mark& mark, const std::string& name) const;
+
+ private:
++ using DepthGuard = YAML::DepthGuard<2000>;
++ int depth = 0;
+ Scanner& m_scanner;
+ const Directives& m_directives;
+ std::unique_ptr<CollectionStack> m_pCollectionStack;
+--- /dev/null
++++ b/include/yaml-cpp/depthguard.h
+@@ -0,0 +1,74 @@
++#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 {
++ int m_atDepth = 0;
++public:
++ // no custom dtor needed, but virtual dtor necessary to prevent slicing
++ virtual ~DeepRecursion() = default;
++
++ // construct an exception explaining how deep you were
++ DeepRecursion(int at_depth, const Mark& mark_, const std::string& msg_);
++
++ // query how deep you were when the exception was thrown
++ int AtDepth() const;
++};
++
++/**
++ * @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 /* final because non-virtual dtor */ {
++ int & m_depth;
++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 is neither copyable nor moveable.
++ 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;
++ }
++};
++
++} // namespace YAML
++
++#endif // DEPTH_GUARD_H_00000000000000000000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/depthguard.cpp
+@@ -0,0 +1,14 @@
++#include "yaml-cpp/depthguard.h"
++
++namespace YAML {
++
++DeepRecursion::DeepRecursion(int at_depth, const Mark& mark_, const std::string& msg_)
++ : ParserException(mark_, msg_),
++ m_atDepth(at_depth) {
++}
++
++int DeepRecursion::AtDepth() const {
++ return m_atDepth;
++}
++
++} // namespace YAML
--- /dev/null
+Description: Install libs and cmake files to the Debian location
+ Instead of moving the libs to the DEB_HOST_MULTIARCH lib directory during
+ packaging, have cmake install the libs directly. This is needed so the CMake
+ development files point to the correct location for the libs. Also, install
+ yaml-cpp-config.cmake, yaml-cpp-config-version.cmake, and
+ yaml-cpp-targets.cmake.
+Author: Paul Novotny <paul@paulnovo.us>
+Forwarded: not-needed
+Last-Update: 2015-11-29
+
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -240,7 +240,10 @@
+ set(INCLUDE_INSTALL_ROOT_DIR include)
+
+ set(INCLUDE_INSTALL_DIR ${INCLUDE_INSTALL_ROOT_DIR}/yaml-cpp)
+-set(LIB_INSTALL_DIR "lib${LIB_SUFFIX}")
++SET(LIB_INSTALL_DIR "${_library_dir}${LIB_SUFFIX}" CACHE
++ "Directory relative to CMAKE_INSTALL_PREFIX in which to install libraries"
++ STRING)
++MARK_AS_ADVANCED(LIB_INSTALL_DIR)
+
+ set(_INSTALL_DESTINATIONS
+ RUNTIME DESTINATION bin
--- /dev/null
+Description: Make the build reproducible
+Author: Reiner Herrmann <reiner@reiner-h.de>
+Bug-Debian: https://bugs.debian.org/808714
+Last-Update: 2016-10-11
+
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -88,6 +88,7 @@
+ ${contrib_private_headers}
+ )
+ add_sources(${library_sources})
++list(SORT library_sources)
+
+ if(VERBOSE)
+ message(STATUS "sources: ${sources}")
--- /dev/null
+install-cmake-dev-files.patch
+reproducible-build.patch
+symbol-visibility.patch
+fix-CVE-2017-11692.patch
+fix-unbounded-recursion-depth.patch
+0001-Revert-Static-analysis-fix-replace-0-and-NULL-with-n.patch
+0002-Revert-Improve-error-messages-on-operator-or-as-656.patch
+0003-Revert-Disallow-moving-for-the-Parser.patch
+0004-Revert-Apply-formatting-style-tweaks-to-comply-with-.patch
+0005-Revert-fix-up-static-so-works-as-DLL-559.patch
--- /dev/null
+commit df9206778fe9ff1bdd56d975c29c43dfe1e66de7
+Author: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
+Date: Fri Nov 23 15:26:53 2018 +1100
+
+ Export only YAML_CPP_API-tagged symbols on Linux.
+
+ This marks classes tagged with YAML_CPP_API with visibility("default"), to
+ explicitly export them, and then makes the default visibility "hidden" via
+ -fvisibility=hidden.
+
+ This reduces the number of exported symbols by more than 50%, which has
+ a small application start-up time and memory useage benefit. It also
+ makes it more feasible to audit the set of exported symbols in automated
+ ABI compatibility systems.
+
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -137,6 +137,14 @@
+ endif()
+ endif()
+
++if(CMAKE_SYSTEM_NAME MATCHES "Linux")
++ set(CMAKE_CXX_VISIBILITY_PRESET hidden)
++ if (POLICY CMP0063)
++ cmake_policy(SET CMP0063 NEW)
++ endif()
++ add_definitions(-DYAML_CPP_USE_VISIBILITY)
++endif()
++
+ # GCC or Clang or Intel Compiler specialities
+ if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR
+ (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND NOT "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC") OR
+--- a/include/yaml-cpp/dll.h
++++ b/include/yaml-cpp/dll.h
+@@ -27,7 +27,11 @@
+ #define YAML_CPP_API __declspec(dllimport)
+ #endif // yaml_cpp_EXPORTS
+ #else // YAML_CPP_DLL
++#ifdef YAML_CPP_USE_VISIBILITY
++#define YAML_CPP_API __attribute__ ((visibility("default")))
++#else
+ #define YAML_CPP_API
++#endif // YAML_CPP_USE_VISIBILITY
+ #endif // YAML_CPP_DLL
+
+ #endif // DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#!/usr/bin/make -f
+
+# Uncomment this to turn on verbose mode.
+#export DH_VERBOSE=1
+
+# This has to be exported to make some magic below work.
+export DH_OPTIONS
+
+include /usr/share/dpkg/architecture.mk
+
+CPPFLAGS :=$(shell dpkg-buildflags --get CPPFLAGS)
+ifneq (,$(filter $(DEB_BUILD_ARCH),mipsel))
+ CFLAGS :=$(shell dpkg-buildflags --get CFLAGS) -g1
+ CXXFLAGS :=$(shell dpkg-buildflags --get CXXFLAGS) -g1
+else
+ CFLAGS :=$(shell dpkg-buildflags --get CFLAGS)
+ CXXFLAGS :=$(shell dpkg-buildflags --get CXXFLAGS)
+endif
+LDFLAGS :=$(shell dpkg-buildflags --get LDFLAGS)
+
+export DEB_HOST_MULTIARCH CPPFLAGS CFLAGS CXXFLAGS LDFLAGS
+
+COMMON_CMAKE_FLAGS = \
+ -DCMAKE_INSTALL_PREFIX=/usr \
+ -DLIB_INSTALL_DIR=/usr/lib/$(DEB_HOST_MULTIARCH) \
+ -DYAML_CPP_BUILD_TOOLS=ON \
+ -DYAML_CPP_BUILD_TESTS=$(if $(filter nocheck,$(DEB_BUILD_OPTIONS)),OFF,ON) \
+ -Dgtest_disable_pthreads=$(if $(filter $(DEB_HOST_ARCH_OS),kfreebsd hurd),ON,OFF)
+
+override_dh_auto_configure:
+ dh_testdir
+ dh_auto_configure --builddirectory=build-static -- $(COMMON_CMAKE_FLAGS)
+ dh_auto_configure --builddirectory=build-shared -- $(COMMON_CMAKE_FLAGS) \
+ -DYAML_BUILD_SHARED_LIBS=ON
+
+override_dh_auto_build:
+ dh_testdir
+ $(MAKE) -C build-static VERBOSE=1
+ $(MAKE) -C build-shared VERBOSE=1
+ # It might make sense to also provide the utils in a separate package
+ # $(MAKE) -C build-shared util
+
+override_dh_auto_install:
+ dh_testdir
+ dh_prep
+ $(MAKE) -C build-static install DESTDIR=$(CURDIR)/debian/tmp
+ $(MAKE) -C build-shared install DESTDIR=$(CURDIR)/debian/tmp
+
+ifeq ($(filter nocheck,$(DEB_BUILD_OPTIONS)),)
+override_dh_auto_test:
+ $(MAKE) -C build-static test
+ $(MAKE) -C build-shared test
+endif
+
+debian/weak-symbols: override_dh_auto_build
+ # All the weak symbols are either template instantiations of the STL
+ # or are optional symbols for inline functions.
+ nm --dynamic --defined-only build-shared/libyaml-cpp.so | awk '$$2 ~ /W/ { print " " $$3 "@Base 0.6.2" } ' > $@
+
+override_dh_makeshlibs: debian/weak-symbols
+ dh_makeshlibs -VNone
+
+clean:
+ dh_testdir
+ dh_auto_clean
+ dh_clean
+ rm -rf build-static build-shared
+
+%:
+ dh $@
+
+.PHONY: clean
--- /dev/null
+3.0 (quilt)
--- /dev/null
+Bug-Database: https://github.com/jbeder/yaml-cpp/issues
+Bug-Submit: https://github.com/jbeder/yaml-cpp/issues/new
+Repository: https://github.com/jbeder/yaml-cpp.git
+Repository-Browse: https://github.com/jbeder/yaml-cpp
--- /dev/null
+version=4
+
+https://github.com/jbeder/yaml-cpp/releases .*/[relasymcp.-]*(\d\S*)\.tar\.gz
projects / yaml-cpp.git / commitdiff