[changes brought forward from 0.6.2-4+rpi1 by Peter Michael Green <plugwash@raspbian.org> at Fri, 18 Jan 2019 20:49:45 +0000]
* Update symbols file for raspbian.
[dgit import unpatched yaml-cpp 0.6.3-10+rpi1]
--- /dev/null
--- /dev/null
++yaml-cpp (0.6.3-10+rpi1) bookworm-staging; urgency=medium
++
++ [changes brought forward from 0.6.2-4+rpi1 by Peter Michael Green <plugwash@raspbian.org> at Fri, 18 Jan 2019 20:49:45 +0000]
++ * Update symbols file for raspbian.
++
++ -- Raspbian forward porter <root@raspbian.org> Thu, 26 Aug 2021 22:24:06 +0000
++
++yaml-cpp (0.6.3-10) unstable; urgency=medium
++
++ * Mark symbols as optional not seen when building with lto.
++
++ -- Matthias Klose <doko@ubuntu.com> Mon, 22 Mar 2021 22:04:27 +0100
++
++yaml-cpp (0.6.3-9) unstable; urgency=medium
++
++ * Fix pkg-config and cmake wrong files and paths. LP: #1880419
++
++ -- Gianfranco Costamagna <locutusofborg@debian.org> Tue, 26 May 2020 17:56:33 +0200
++
++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
--- /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
--- /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
--- /dev/null
++usr/include/yaml-cpp/
++usr/lib/*/*.a
++usr/lib/*/*.so
++usr/lib/*/cmake/
++usr/lib/*/pkgconfig/
--- /dev/null
--- /dev/null
++usr/lib/*/libyaml-cpp.so.*
--- /dev/null
--- /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
++ (optional=notarmelandprobabllynotraspbian)_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
++ (optional=notarmelandprobabllynotraspbian)_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
++ (optional=notarmelandprobabllynotraspbian)_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
++ (optional=notarmelandprobabllynotraspbian)_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
++ (optional=notarmelandprobabllynotraspbian)_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
++ (optional=notarmelandprobabllynotraspbian)_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
++ (optional=notarmelandprobabllynotraspbian)_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
++ (optional=notarmelandprobabllynotraspbian)_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
++ (optional=notarmelandprobabllynotraspbian)_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
++ (optional=notarmelandprobabllynotraspbian)_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
++ (optional=notarmelandprobabllynotraspbian)_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
++ (optional=notarmelandprobabllynotraspbian)_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
++ (optional=notarmelandprobabllynotraspbian)_ZTVSt15_Sp_counted_ptrIPN4YAML6detail9node_dataELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2
--- /dev/null
--- /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
--- /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
--- /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
--- /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
--- /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
--- /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
--- /dev/null
++Description: fix pkg-config file and cmake one
++Author: Gianfranco Costamagna <locutusofborg@debian.org>
++Forwarded: not needed, upstream reworked the cmake handling
++Bug-Ubuntu: https://bugs.launchpad.net/ubuntu/+source/yaml-cpp/+bug/1880419
++Last-Update: 2020-05-26
++
++--- yaml-cpp-0.6.3.orig/CMakeLists.txt
+++++ yaml-cpp-0.6.3/CMakeLists.txt
++@@ -325,7 +325,7 @@ export(
++ export(PACKAGE yaml-cpp)
++ set(EXPORT_TARGETS yaml-cpp CACHE INTERNAL "export targets")
++
++-set(CONFIG_INCLUDE_DIRS "${YAML_CPP_SOURCE_DIR}/include")
+++set(CONFIG_INCLUDE_DIRS include)
++ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/yaml-cpp-config.cmake.in
++ "${PROJECT_BINARY_DIR}/yaml-cpp-config.cmake" @ONLY)
++
++--- yaml-cpp-0.6.3.orig/yaml-cpp-config.cmake.in
+++++ yaml-cpp-0.6.3/yaml-cpp-config.cmake.in
++@@ -5,7 +5,7 @@
++
++ # Compute paths
++ get_filename_component(YAML_CPP_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
++-set(YAML_CPP_INCLUDE_DIR "@CONFIG_INCLUDE_DIRS@")
+++set(YAML_CPP_INCLUDE_DIR "@INCLUDE_INSTALL_ROOT_DIR@")
++
++ # Our library dependencies (contains definitions for IMPORTED targets)
++ include("${YAML_CPP_CMAKE_DIR}/yaml-cpp-targets.cmake")
++--- yaml-cpp-0.6.3.orig/yaml-cpp.pc.cmake
+++++ yaml-cpp-0.6.3/yaml-cpp.pc.cmake
++@@ -1,7 +1,7 @@
++ prefix=@CMAKE_INSTALL_PREFIX@
++ exec_prefix=${prefix}
++ includedir=${prefix}/@INCLUDE_INSTALL_ROOT_DIR@
++-libdir=${exec_prefix}/@LIB_INSTALL_DIR@
+++libdir=@LIB_INSTALL_DIR@
++
++ Name: Yaml-cpp
++ Description: A YAML parser and emitter for C++
--- /dev/null
--- /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
--- /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
--- /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
--- /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
++fix-pkg-config.patch
--- /dev/null
--- /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
--- /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
--- /dev/null
++3.0 (quilt)
--- /dev/null
--- /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
--- /dev/null
++version=4
++
++https://github.com/jbeder/yaml-cpp/releases .*/[relasymcp.-]*(\d\S*)\.tar\.gz
projects / yaml-cpp.git / commitdiff