From: Gianfranco Costamagna Date: Wed, 13 May 2020 17:26:42 +0000 (+0100) Subject: yaml-cpp (0.6.3-7) unstable; urgency=medium X-Git-Tag: archive/raspbian/0.6.3-7+rpi1^2~11 X-Git-Url: https://dgit.raspbian.org/?a=commitdiff_plain;h=61c17f76247eca69115b4fd2dd47c509f5bd2366;p=yaml-cpp.git 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) [dgit import unpatched yaml-cpp 0.6.3-7] --- 61c17f76247eca69115b4fd2dd47c509f5bd2366 diff --cc debian/changelog index 0000000,0000000..b14c18f new file mode 100644 --- /dev/null +++ b/debian/changelog @@@ -1,0 -1,0 +1,217 @@@ ++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 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 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 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 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 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 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 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 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 Wed, 29 Apr 2020 20:24:07 -0500 ++ ++yaml-cpp (0.6.2-4) unstable; urgency=medium ++ ++ * Upload to Sid. ++ ++ -- Simon Quigley Mon, 07 Jan 2019 16:00:33 -0600 ++ ++yaml-cpp (0.6.2-3) experimental; urgency=medium ++ ++ * Update symbols from build logs. ++ ++ -- Simon Quigley 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 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 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 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 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 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 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 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 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 Fri, 30 Aug 2013 18:29:05 +0800 ++ ++yaml-cpp (0.3.0-1) unstable; urgency=low ++ ++ * Initial release (Closes: #636985) ++ ++ -- Lifeng Sun Sun, 03 Jun 2012 23:48:30 +0800 diff --cc debian/control index 0000000,0000000..bcfcffc new file mode 100644 --- /dev/null +++ b/debian/control @@@ -1,0 -1,0 +1,32 @@@ ++Source: yaml-cpp ++Maintainer: Simon Quigley ++Uploaders: Gianfranco Costamagna ++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. diff --cc debian/copyright index 0000000,0000000..6a1f1e9 new file mode 100644 --- /dev/null +++ b/debian/copyright @@@ -1,0 -1,0 +1,43 @@@ ++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 ++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 ++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 ++ . ++ On Debian systems, the complete text of the GNU General ++ Public License version 2 can be found in "/usr/share/common-licenses/GPL-2". diff --cc debian/libyaml-cpp-dev.install index 0000000,0000000..4cef216 new file mode 100644 --- /dev/null +++ b/debian/libyaml-cpp-dev.install @@@ -1,0 -1,0 +1,5 @@@ ++usr/include/yaml-cpp/ ++usr/lib/*/*.a ++usr/lib/*/*.so ++usr/lib/*/cmake/ ++usr/lib/*/pkgconfig/ diff --cc debian/libyaml-cpp0.6.install index 0000000,0000000..7a0ab28 new file mode 100644 --- /dev/null +++ b/debian/libyaml-cpp0.6.install @@@ -1,0 -1,0 +1,1 @@@ ++usr/lib/*/libyaml-cpp.so.* diff --cc debian/libyaml-cpp0.6.symbols index 0000000,0000000..e5f99d1 new file mode 100644 --- /dev/null +++ b/debian/libyaml-cpp0.6.symbols @@@ -1,0 -1,0 +1,266 @@@ ++libyaml-cpp.so.0.6 libyaml-cpp0.6 #MINVER# ++#yaml-cpp does not deliberately define any weak symbols; ++# they are all inline functions that the compiler has chosen ++# to also emit a symbol for. ++(optional)#include "weak-symbols" ++# Actual symbols of the yaml-cpp ABI ++ _ZN4YAML11BadPushbackD0Ev@Base 0.6.2 ++ _ZN4YAML11BadPushbackD1Ev@Base 0.6.2 ++ _ZN4YAML11BadPushbackD2Ev@Base 0.6.2 ++ _ZN4YAML11InvalidNodeD0Ev@Base 0.6.2 ++ _ZN4YAML11InvalidNodeD1Ev@Base 0.6.2 ++ _ZN4YAML11InvalidNodeD2Ev@Base 0.6.2 ++ _ZN4YAML11KeyNotFoundD0Ev@Base 0.6.2 ++ _ZN4YAML11KeyNotFoundD1Ev@Base 0.6.2 ++ _ZN4YAML11KeyNotFoundD2Ev@Base 0.6.2 ++ _ZN4YAML12BadSubscriptD0Ev@Base 0.6.2 ++ _ZN4YAML12BadSubscriptD1Ev@Base 0.6.2 ++ _ZN4YAML12BadSubscriptD2Ev@Base 0.6.2 ++ _ZN4YAML12DecodeBase64ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2 ++ (arch-bits=64)_ZN4YAML12EncodeBase64B5cxx11EPKhm@Base 0.6.2 ++ (arch-bits=32)_ZN4YAML12EncodeBase64B5cxx11EPKhj@Base 0.6.2 ++ _ZN4YAML12IsNullStringERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2 ++ _ZN4YAML13BadConversionD0Ev@Base 0.6.2 ++ _ZN4YAML13BadConversionD1Ev@Base 0.6.2 ++ _ZN4YAML13BadConversionD2Ev@Base 0.6.2 ++ _ZN4YAML13InvalidScalarD0Ev@Base 0.6.2 ++ _ZN4YAML13InvalidScalarD1Ev@Base 0.6.2 ++ _ZN4YAML13InvalidScalarD2Ev@Base 0.6.2 ++ _ZN4YAML14BadDereferenceD0Ev@Base 0.6.2 ++ _ZN4YAML14BadDereferenceD1Ev@Base 0.6.2 ++ _ZN4YAML14BadDereferenceD2Ev@Base 0.6.2 ++ _ZN4YAML15LoadAllFromFileERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2 ++ _ZN4YAML15ostream_wrapper10update_posEc@Base 0.6.2 ++ (arch-bits=64)_ZN4YAML15ostream_wrapper5writeEPKcm@Base 0.6.2 ++ (arch-bits=32)_ZN4YAML15ostream_wrapper5writeEPKcj@Base 0.6.2 ++ _ZN4YAML15ostream_wrapper5writeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2 ++ _ZN4YAML15ostream_wrapperC1ERSo@Base 0.6.2 ++ _ZN4YAML15ostream_wrapperC1Ev@Base 0.6.2 ++ _ZN4YAML15ostream_wrapperC2ERSo@Base 0.6.2 ++ _ZN4YAML15ostream_wrapperC2Ev@Base 0.6.2 ++ _ZN4YAML15ostream_wrapperD1Ev@Base 0.6.2 ++ _ZN4YAML15ostream_wrapperD2Ev@Base 0.6.2 ++ _ZN4YAML15ParserExceptionD0Ev@Base 0.6.2 ++ _ZN4YAML15ParserExceptionD1Ev@Base 0.6.2 ++ _ZN4YAML15ParserExceptionD2Ev@Base 0.6.2 ++ _ZN4YAML16EmitterExceptionD0Ev@Base 0.6.2 ++ _ZN4YAML16EmitterExceptionD1Ev@Base 0.6.2 ++ _ZN4YAML16EmitterExceptionD2Ev@Base 0.6.2 ++ _ZN4YAML23RepresentationExceptionD0Ev@Base 0.6.2 ++ _ZN4YAML23RepresentationExceptionD1Ev@Base 0.6.2 ++ _ZN4YAML23RepresentationExceptionD2Ev@Base 0.6.2 ++ _ZN4YAML4DumpB5cxx11ERKNS_4NodeE@Base 0.6.2 ++ _ZN4YAML4LoadEPKc@Base 0.6.2 ++ _ZN4YAML4LoadERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2 ++ _ZN4YAML4LoadERSi@Base 0.6.2 ++ _ZN4YAML4NullE@Base 0.6.2 ++ _ZN4YAML5CloneERKNS_4NodeE@Base 0.6.2 ++ _ZN4YAML5RegExC1Ec@Base 0.6.2 ++ _ZN4YAML5RegExC1Ecc@Base 0.6.2 ++ _ZN4YAML5RegExC1ENS_8REGEX_OPE@Base 0.6.2 ++ _ZN4YAML5RegExC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_8REGEX_OPE@Base 0.6.2 ++ _ZN4YAML5RegExC1Ev@Base 0.6.2 ++ _ZN4YAML5RegExC2Ec@Base 0.6.2 ++ _ZN4YAML5RegExC2Ecc@Base 0.6.2 ++ _ZN4YAML5RegExC2ENS_8REGEX_OPE@Base 0.6.2 ++ _ZN4YAML5RegExC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_8REGEX_OPE@Base 0.6.2 ++ _ZN4YAML5RegExC2Ev@Base 0.6.2 ++ _ZN4YAML6detail13memory_holder5mergeERS1_@Base 0.6.2 ++ _ZN4YAML6detail6memory11create_nodeEv@Base 0.6.2 ++ _ZN4YAML6detail6memory5mergeERKS1_@Base 0.6.2 ++ _ZN4YAML6detail9node_data10set_scalarERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2 ++ _ZN4YAML6detail9node_data12empty_scalarB5cxx11E@Base 0.6.2 ++ _ZN4YAML6detail9node_data12mark_definedEv@Base 0.6.2 ++ _ZN4YAML6detail9node_data14convert_to_mapESt10shared_ptrINS0_13memory_holderEE@Base 0.6.2 ++ _ZN4YAML6detail9node_data14reset_sequenceEv@Base 0.6.2 ++ _ZN4YAML6detail9node_data15insert_map_pairERNS0_4nodeES3_@Base 0.6.2 ++ _ZN4YAML6detail9node_data23convert_sequence_to_mapESt10shared_ptrINS0_13memory_holderEE@Base 0.6.2 ++ _ZN4YAML6detail9node_data3endEv@Base 0.6.2 ++ _ZN4YAML6detail9node_data3getERNS0_4nodeESt10shared_ptrINS0_13memory_holderEE@Base 0.6.2 ++ _ZN4YAML6detail9node_data5beginEv@Base 0.6.2 ++ _ZN4YAML6detail9node_data6insertERNS0_4nodeES3_St10shared_ptrINS0_13memory_holderEE@Base 0.6.2 ++ _ZN4YAML6detail9node_data6removeERNS0_4nodeESt10shared_ptrINS0_13memory_holderEE@Base 0.6.2 ++ _ZN4YAML6detail9node_data7set_tagERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2 ++ _ZN4YAML6detail9node_data8set_markERKNS_4MarkE@Base 0.6.2 ++ _ZN4YAML6detail9node_data8set_nullEv@Base 0.6.2 ++ _ZN4YAML6detail9node_data8set_typeENS_8NodeType5valueE@Base 0.6.2 ++ _ZN4YAML6detail9node_data9push_backERNS0_4nodeESt10shared_ptrINS0_13memory_holderEE@Base 0.6.2 ++ _ZN4YAML6detail9node_data9reset_mapEv@Base 0.6.2 ++ _ZN4YAML6detail9node_data9set_styleENS_12EmitterStyle5valueE@Base 0.6.2 ++ _ZN4YAML6detail9node_dataC1Ev@Base 0.6.2 ++ _ZN4YAML6detail9node_dataC2Ev@Base 0.6.2 ++ _ZN4YAML6Parser11PrintTokensERSo@Base 0.6.2 ++ _ZN4YAML6Parser15HandleDirectiveERKNS_5TokenE@Base 0.6.2 ++ _ZN4YAML6Parser15ParseDirectivesEv@Base 0.6.2 ++ _ZN4YAML6Parser18HandleNextDocumentERNS_12EventHandlerE@Base 0.6.2 ++ _ZN4YAML6Parser18HandleTagDirectiveERKNS_5TokenE@Base 0.6.2 ++ _ZN4YAML6Parser19HandleYamlDirectiveERKNS_5TokenE@Base 0.6.2 ++ _ZN4YAML6Parser4LoadERSi@Base 0.6.2 ++ _ZN4YAML6ParserC1ERSi@Base 0.6.2 ++ _ZN4YAML6ParserC1Ev@Base 0.6.2 ++ _ZN4YAML6ParserC2ERSi@Base 0.6.2 ++ _ZN4YAML6ParserC2Ev@Base 0.6.2 ++ _ZN4YAML6ParserD1Ev@Base 0.6.2 ++ _ZN4YAML6ParserD2Ev@Base 0.6.2 ++ _ZN4YAML7BadFileD0Ev@Base 0.6.2 ++ _ZN4YAML7BadFileD1Ev@Base 0.6.2 ++ _ZN4YAML7BadFileD2Ev@Base 0.6.2 ++ _ZN4YAML7convertIbE6decodeERKNS_4NodeERb@Base 0.6.2 ++ _ZN4YAML7Emitter10EmitEndDocEv@Base 0.6.2 ++ _ZN4YAML7Emitter10EmitEndMapEv@Base 0.6.2 ++ _ZN4YAML7Emitter10EmitEndSeqEv@Base 0.6.2 ++ _ZN4YAML7Emitter10SetIntBaseENS_13EMITTER_MANIPE@Base 0.6.2 ++ _ZN4YAML7Emitter11EmitKindTagEv@Base 0.6.2 ++ _ZN4YAML7Emitter11EmitNewlineEv@Base 0.6.2 ++ _ZN4YAML7Emitter11PrepareNodeENS_15EmitterNodeType5valueE@Base 0.6.2 ++ _ZN4YAML7Emitter12EmitBeginDocEv@Base 0.6.2 ++ _ZN4YAML7Emitter12EmitBeginMapEv@Base 0.6.2 ++ _ZN4YAML7Emitter12EmitBeginSeqEv@Base 0.6.2 ++ _ZN4YAML7Emitter12SetMapFormatENS_13EMITTER_MANIPE@Base 0.6.2 ++ _ZN4YAML7Emitter12SetSeqFormatENS_13EMITTER_MANIPE@Base 0.6.2 ++ _ZN4YAML7Emitter13SetBoolFormatENS_13EMITTER_MANIPE@Base 0.6.2 ++ _ZN4YAML7Emitter13SetLocalValueENS_13EMITTER_MANIPE@Base 0.6.2 ++ _ZN4YAML7Emitter13StartedScalarEv@Base 0.6.2 ++ _ZN4YAML7Emitter14PrepareTopNodeENS_15EmitterNodeType5valueE@Base 0.6.2 ++ _ZN4YAML7Emitter14SetLocalIndentERKNS_7_IndentE@Base 0.6.2 ++ _ZN4YAML7Emitter15SetStringFormatENS_13EMITTER_MANIPE@Base 0.6.2 ++ (arch-bits=64)_ZN4YAML7Emitter15SpaceOrIndentToEbm@Base 0.6.2 ++ (arch-bits=32)_ZN4YAML7Emitter15SpaceOrIndentToEbj@Base 0.6.2 ++ _ZN4YAML7Emitter16SetOutputCharsetENS_13EMITTER_MANIPE@Base 0.6.2 ++ (arch-bits=64)_ZN4YAML7Emitter17SetFloatPrecisionEm@Base 0.6.2 ++ (arch-bits=32)_ZN4YAML7Emitter17SetFloatPrecisionEj@Base 0.6.2 ++ _ZN4YAML7Emitter17SetLocalPrecisionERKNS_10_PrecisionE@Base 0.6.2 ++ _ZN4YAML7Emitter18FlowMapPrepareNodeENS_15EmitterNodeType5valueE@Base 0.6.2 ++ _ZN4YAML7Emitter18FlowSeqPrepareNodeENS_15EmitterNodeType5valueE@Base 0.6.2 ++ (arch-bits=64)_ZN4YAML7Emitter18SetDoublePrecisionEm@Base 0.6.2 ++ (arch-bits=32)_ZN4YAML7Emitter18SetDoublePrecisionEj@Base 0.6.2 ++ _ZN4YAML7Emitter19BlockMapPrepareNodeENS_15EmitterNodeType5valueE@Base 0.6.2 ++ _ZN4YAML7Emitter19BlockSeqPrepareNodeENS_15EmitterNodeType5valueE@Base 0.6.2 ++ (arch-bits=64)_ZN4YAML7Emitter19SetPreCommentIndentEm@Base 0.6.2 ++ (arch-bits=32)_ZN4YAML7Emitter19SetPreCommentIndentEj@Base 0.6.2 ++ (arch-bits=64)_ZN4YAML7Emitter20SetPostCommentIndentEm@Base 0.6.2 ++ (arch-bits=32)_ZN4YAML7Emitter20SetPostCommentIndentEj@Base 0.6.2 ++ _ZN4YAML7Emitter21FlowMapPrepareLongKeyENS_15EmitterNodeType5valueE@Base 0.6.2 ++ _ZN4YAML7Emitter22BlockMapPrepareLongKeyENS_15EmitterNodeType5valueE@Base 0.6.2 ++ _ZN4YAML7Emitter23FlowMapPrepareSimpleKeyENS_15EmitterNodeType5valueE@Base 0.6.2 ++ _ZN4YAML7Emitter24BlockMapPrepareSimpleKeyENS_15EmitterNodeType5valueE@Base 0.6.2 ++ _ZN4YAML7Emitter26FlowMapPrepareLongKeyValueENS_15EmitterNodeType5valueE@Base 0.6.2 ++ _ZN4YAML7Emitter27BlockMapPrepareLongKeyValueENS_15EmitterNodeType5valueE@Base 0.6.2 ++ _ZN4YAML7Emitter28FlowMapPrepareSimpleKeyValueENS_15EmitterNodeType5valueE@Base 0.6.2 ++ _ZN4YAML7Emitter29BlockMapPrepareSimpleKeyValueENS_15EmitterNodeType5valueE@Base 0.6.2 ++ _ZN4YAML7Emitter5WriteEb@Base 0.6.2 ++ _ZN4YAML7Emitter5WriteEc@Base 0.6.2 ++ _ZN4YAML7Emitter5WriteERKNS_4_TagE@Base 0.6.2 ++ _ZN4YAML7Emitter5WriteERKNS_5_NullE@Base 0.6.2 ++ _ZN4YAML7Emitter5WriteERKNS_6_AliasE@Base 0.6.2 ++ _ZN4YAML7Emitter5WriteERKNS_6BinaryE@Base 0.6.2 ++ _ZN4YAML7Emitter5WriteERKNS_7_AnchorE@Base 0.6.2 ++ _ZN4YAML7Emitter5WriteERKNS_8_CommentE@Base 0.6.2 ++ _ZN4YAML7Emitter5WriteERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2 ++ (arch-bits=64)_ZN4YAML7Emitter9SetIndentEm@Base 0.6.2 ++ (arch-bits=32)_ZN4YAML7Emitter9SetIndentEj@Base 0.6.2 ++ _ZN4YAML7EmitterC1ERSo@Base 0.6.2 ++ _ZN4YAML7EmitterC1Ev@Base 0.6.2 ++ _ZN4YAML7EmitterC2ERSo@Base 0.6.2 ++ _ZN4YAML7EmitterC2Ev@Base 0.6.2 ++ _ZN4YAML7EmitterD1Ev@Base 0.6.2 ++ _ZN4YAML7EmitterD2Ev@Base 0.6.2 ++ _ZN4YAML7LoadAllEPKc@Base 0.6.2 ++ _ZN4YAML7LoadAllERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2 ++ _ZN4YAML7LoadAllERSi@Base 0.6.2 ++ _ZN4YAML8LoadFileERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@Base 0.6.2 ++ _ZN4YAML9BadInsertD0Ev@Base 0.6.2 ++ _ZN4YAML9BadInsertD1Ev@Base 0.6.2 ++ _ZN4YAML9BadInsertD2Ev@Base 0.6.2 ++ _ZN4YAML9ExceptionD0Ev@Base 0.6.2 ++ _ZN4YAML9ExceptionD1Ev@Base 0.6.2 ++ _ZN4YAML9ExceptionD2Ev@Base 0.6.2 ++ _ZN4YAMLaaERKNS_5RegExES2_@Base 0.6.2 ++ _ZN4YAMLlsERNS_7EmitterERKNS_4NodeE@Base 0.6.2 ++ _ZN4YAMLlsERSoRKNS_4NodeE@Base 0.6.2 ++ _ZN4YAMLntERKNS_5RegExE@Base 0.6.2 ++ _ZN4YAMLooERKNS_5RegExES2_@Base 0.6.2 ++ _ZN4YAMLplERKNS_5RegExES2_@Base 0.6.2 ++ _ZNK4YAML6detail9node_data16compute_map_sizeEv@Base 0.6.2 ++ _ZNK4YAML6detail9node_data16compute_seq_sizeEv@Base 0.6.2 ++ _ZNK4YAML6detail9node_data3endEv@Base 0.6.2 ++ _ZNK4YAML6detail9node_data3getERNS0_4nodeESt10shared_ptrINS0_13memory_holderEE@Base 0.6.2 ++ _ZNK4YAML6detail9node_data4sizeEv@Base 0.6.2 ++ _ZNK4YAML6detail9node_data5beginEv@Base 0.6.2 ++ _ZNK4YAML6ParsercvbEv@Base 0.6.2 ++ _ZNK4YAML7Emitter12GetLastErrorB5cxx11Ev@Base 0.6.2 ++ _ZNK4YAML7Emitter14CanEmitNewlineEv@Base 0.6.2 ++ _ZNK4YAML7Emitter17GetFloatPrecisionEv@Base 0.6.2 ++ _ZNK4YAML7Emitter18GetDoublePrecisionEv@Base 0.6.2 ++ _ZNK4YAML7Emitter19ComputeFullBoolNameEb@Base 0.6.2 ++ _ZNK4YAML7Emitter21PrepareIntegralStreamERNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE@Base 0.6.2 ++ _ZNK4YAML7Emitter4goodEv@Base 0.6.2 ++ _ZNK4YAML7Emitter4sizeEv@Base 0.6.2 ++ _ZNK4YAML7Emitter5c_strEv@Base 0.6.2 ++ _ZTIN4YAML11BadPushbackE@Base 0.6.2 ++ _ZTIN4YAML11InvalidNodeE@Base 0.6.2 ++ _ZTIN4YAML11KeyNotFoundE@Base 0.6.2 ++ _ZTIN4YAML12BadSubscriptE@Base 0.6.2 ++ _ZTIN4YAML13BadConversionE@Base 0.6.2 ++ _ZTIN4YAML13InvalidScalarE@Base 0.6.2 ++ _ZTIN4YAML14BadDereferenceE@Base 0.6.2 ++ _ZTIN4YAML15ParserExceptionE@Base 0.6.2 ++ _ZTIN4YAML16EmitterExceptionE@Base 0.6.2 ++ _ZTIN4YAML23RepresentationExceptionE@Base 0.6.2 ++ _ZTIN4YAML7BadFileE@Base 0.6.2 ++ _ZTIN4YAML9BadInsertE@Base 0.6.2 ++ _ZTIN4YAML9ExceptionE@Base 0.6.2 ++ (arch= armel riscv64)_ZTIN9__gnu_cxx7__mutexE@Base 0.6.2 ++ (arch= armel riscv64)_ZTISt11_Mutex_baseILN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2 ++ (arch= !armel !riscv64)_ZTISt11_Mutex_baseILN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 ++ (arch= armel riscv64)_ZTISt15_Sp_counted_ptrIPN4YAML6detail13memory_holderELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2 ++ (arch= !armel !riscv64)_ZTISt15_Sp_counted_ptrIPN4YAML6detail13memory_holderELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 ++ (arch= armel riscv64)_ZTISt15_Sp_counted_ptrIPN4YAML6detail6memoryELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2 ++ (arch= !armel !riscv64)_ZTISt15_Sp_counted_ptrIPN4YAML6detail6memoryELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 ++ (arch= armel riscv64)_ZTISt15_Sp_counted_ptrIPN4YAML6detail9node_dataELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2 ++ (arch= !armel !riscv64)_ZTISt15_Sp_counted_ptrIPN4YAML6detail9node_dataELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 ++ (arch= armel riscv64)_ZTISt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2 ++ (arch= !armel !riscv64)_ZTISt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 ++ _ZTSN4YAML11BadPushbackE@Base 0.6.2 ++ _ZTSN4YAML11InvalidNodeE@Base 0.6.2 ++ _ZTSN4YAML11KeyNotFoundE@Base 0.6.2 ++ _ZTSN4YAML12BadSubscriptE@Base 0.6.2 ++ _ZTSN4YAML13BadConversionE@Base 0.6.2 ++ _ZTSN4YAML13InvalidScalarE@Base 0.6.2 ++ _ZTSN4YAML14BadDereferenceE@Base 0.6.2 ++ _ZTSN4YAML15ParserExceptionE@Base 0.6.2 ++ _ZTSN4YAML16EmitterExceptionE@Base 0.6.2 ++ _ZTSN4YAML23RepresentationExceptionE@Base 0.6.2 ++ _ZTSN4YAML7BadFileE@Base 0.6.2 ++ _ZTSN4YAML9BadInsertE@Base 0.6.2 ++ _ZTSN4YAML9ExceptionE@Base 0.6.2 ++ (arch= armel riscv64)_ZTSN9__gnu_cxx7__mutexE@Base 0.6.2-2 ++ (arch= armel riscv64)_ZTSSt11_Mutex_baseILN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2 ++ (arch= !armel !riscv64)_ZTSSt11_Mutex_baseILN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 ++ (arch= armel riscv64)_ZTSSt15_Sp_counted_ptrIPN4YAML6detail13memory_holderELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2 ++ (arch= !armel !riscv64)_ZTSSt15_Sp_counted_ptrIPN4YAML6detail13memory_holderELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 ++ (arch= armel riscv64)_ZTSSt15_Sp_counted_ptrIPN4YAML6detail6memoryELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2 ++ (arch= !armel !riscv64)_ZTSSt15_Sp_counted_ptrIPN4YAML6detail6memoryELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 ++ (arch= armel riscv64)_ZTSSt15_Sp_counted_ptrIPN4YAML6detail9node_dataELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2 ++ (arch= !armel !riscv64)_ZTSSt15_Sp_counted_ptrIPN4YAML6detail9node_dataELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 ++ (arch= armel riscv64)_ZTSSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2 ++ (arch= !armel !riscv64)_ZTSSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 ++ _ZTVN4YAML11BadPushbackE@Base 0.6.2 ++ _ZTVN4YAML11InvalidNodeE@Base 0.6.2 ++ _ZTVN4YAML11KeyNotFoundE@Base 0.6.2 ++ _ZTVN4YAML12BadSubscriptE@Base 0.6.2 ++ _ZTVN4YAML13BadConversionE@Base 0.6.2 ++ _ZTVN4YAML13InvalidScalarE@Base 0.6.2 ++ _ZTVN4YAML14BadDereferenceE@Base 0.6.2 ++ _ZTVN4YAML15ParserExceptionE@Base 0.6.2 ++ _ZTVN4YAML16EmitterExceptionE@Base 0.6.2 ++ _ZTVN4YAML23RepresentationExceptionE@Base 0.6.2 ++ _ZTVN4YAML7BadFileE@Base 0.6.2 ++ _ZTVN4YAML9BadInsertE@Base 0.6.2 ++ _ZTVN4YAML9ExceptionE@Base 0.6.2 ++ (arch= armel riscv64)_ZTVSt15_Sp_counted_ptrIPN4YAML6detail13memory_holderELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2 ++ (arch= !armel !riscv64)_ZTVSt15_Sp_counted_ptrIPN4YAML6detail13memory_holderELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 ++ (arch= armel riscv64)_ZTVSt15_Sp_counted_ptrIPN4YAML6detail6memoryELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2 ++ (arch= !armel !riscv64)_ZTVSt15_Sp_counted_ptrIPN4YAML6detail6memoryELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 ++ (arch= armel riscv64)_ZTVSt15_Sp_counted_ptrIPN4YAML6detail9node_dataELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2 ++ (arch= !armel !riscv64)_ZTVSt15_Sp_counted_ptrIPN4YAML6detail9node_dataELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 diff --cc debian/patches/0001-Revert-Static-analysis-fix-replace-0-and-NULL-with-n.patch index 0000000,0000000..144ef1b new file mode 100644 --- /dev/null +++ b/debian/patches/0001-Revert-Static-analysis-fix-replace-0-and-NULL-with-n.patch @@@ -1,0 -1,0 +1,156 @@@ ++From dd072aab1264e1343dead7de0dc2c67c588fdd30 Mon Sep 17 00:00:00 2001 ++From: Adrian Bunk ++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 ++ inline const std::string BAD_SUBSCRIPT_WITH_KEY( ++- const T&, typename disable_if>::type* = nullptr) { +++ const T&, typename disable_if>::type* = 0) { ++ return BAD_SUBSCRIPT; ++ } ++ ++@@ -129,7 +129,7 @@ inline const std::string BAD_SUBSCRIPT_WITH_KEY(const std::string& key) { ++ ++ template ++ inline const std::string BAD_SUBSCRIPT_WITH_KEY( ++- const T& key, typename enable_if>::type* = nullptr) { +++ const T& key, typename enable_if>::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 ++ struct get_idx { ++ static node* get(const std::vector& /* sequence */, ++ const Key& /* key */, shared_memory_holder /* pMemory */) { ++- return nullptr; +++ return 0; ++ } ++ }; ++ ++@@ -27,7 +27,7 @@ struct get_idx::value>::type> { ++ static node* get(const std::vector& 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& sequence, const Key& key, ++@@ -46,13 +46,13 @@ struct get_idx::value>::type> { ++ shared_memory_holder pMemory) { ++ return key >= 0 ? get_idx::get( ++ sequence, static_cast(key), pMemory) ++- : nullptr; +++ : 0; ++ } ++ static node* get(std::vector& sequence, const Key& key, ++ shared_memory_holder pMemory) { ++ return key >= 0 ? get_idx::get( ++ sequence, static_cast(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::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 ++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 ++ struct node_iterator_value : public std::pair { ++ typedef std::pair 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 ++ diff --cc debian/patches/0002-Revert-Improve-error-messages-on-operator-or-as-656.patch index 0000000,0000000..20d816a new file mode 100644 --- /dev/null +++ b/debian/patches/0002-Revert-Improve-error-messages-on-operator-or-as-656.patch @@@ -1,0 -1,0 +1,595 @@@ ++From 66799954bb9b7007b31de0ecd20b07f926be3ca6 Mon Sep 17 00:00:00 2001 ++From: Adrian Bunk ++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 ++-inline const std::string BAD_SUBSCRIPT_WITH_KEY( ++- const T&, typename disable_if>::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 ++-inline const std::string BAD_SUBSCRIPT_WITH_KEY( ++- const T& key, typename enable_if>::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 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 ++- 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 ++ #include ++ ++ 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 ++ 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 { ++ template ++ inline T Node::as() const { ++ if (!m_isValid) ++- throw InvalidNode(m_invalidKey); +++ throw InvalidNode(); ++ return as_if(*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 ++ 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 ++ inline void Node::Assign(const T& rhs) { ++ if (!m_isValid) ++- throw InvalidNode(m_invalidKey); +++ throw InvalidNode(); ++ AssignData(convert::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 ++ 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::return_type to_value(const T& t) { ++ } ++ } // namespace detail ++ ++-template ++-std::string key_to_string(const Key& key) { ++- return streamable_to_string::value>().impl(key); ++-} ++- ++ // indexing ++ template ++ inline const Node Node::operator[](const Key& key) const { ++ if (!m_isValid) ++- throw InvalidNode(m_invalidKey); +++ throw InvalidNode(); ++ EnsureNodeExists(); ++ detail::node* value = static_cast(*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 ++ 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 ++ 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(*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 ++ 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 ++-#include ++ ++ #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 ++-#include ++-#include ++-#include ++- ++ namespace YAML { ++ template ++ struct is_numeric { ++@@ -105,31 +100,4 @@ template ++ struct disable_if : public disable_if_c {}; ++ } ++ ++-template ++-struct is_streamable { ++- template ++- static auto test(int) ++- -> decltype(std::declval() << std::declval(), std::true_type()); ++- ++- template ++- static auto test(...) -> std::false_type; ++- ++- static const bool value = decltype(test(0))::value; ++-}; ++- ++-template ++-struct streamable_to_string { ++- static std::string impl(const Key& key) { ++- std::stringstream ss; ++- ss << key; ++- return ss.str(); ++- } ++-}; ++- ++-template ++-struct streamable_to_string { ++- 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()], ++- "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(), ++- "invalid node; first invalid key: \"fourth\""); ++- ++- EXPECT_THROW_EXCEPTION(YAML::InvalidNode, doc["first"][37].as(), ++- "invalid node; first invalid key: \"37\""); ++- ++- // Non-printable key is not included in error message ++- EXPECT_THROW_EXCEPTION(YAML::InvalidNode, ++- doc["first"][std::vector()].as(), ++- "invalid node; this may result from using a map " ++- "iterator as a sequence iterator, or vice-versa"); ++-} ++-} ++-} ++-- ++2.20.1 ++ diff --cc debian/patches/0003-Revert-Disallow-moving-for-the-Parser.patch index 0000000,0000000..556cdff new file mode 100644 --- /dev/null +++ b/debian/patches/0003-Revert-Disallow-moving-for-the-Parser.patch @@@ -1,0 -1,0 +1,31 @@@ ++From c6ae5659621322e5ec8085d1e04a269e3fac6705 Mon Sep 17 00:00:00 2001 ++From: Adrian Bunk ++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 ++ diff --cc debian/patches/0004-Revert-Apply-formatting-style-tweaks-to-comply-with-.patch index 0000000,0000000..885a22a new file mode 100644 --- /dev/null +++ b/debian/patches/0004-Revert-Apply-formatting-style-tweaks-to-comply-with-.patch @@@ -1,0 -1,0 +1,1571 @@@ ++From 6452cb9b826df569c396e7c645d874fc068607d6 Mon Sep 17 00:00:00 2001 ++From: Adrian Bunk ++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 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 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 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 ++ ++ 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 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 ++ ++ 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 ++ inline typename to_value_t::return_type to_value(const T& t) { ++ return to_value_t(t)(); ++ } ++-} // namespace detail +++} ++ ++ // indexing ++ template ++@@ -374,8 +374,8 @@ inline const Node Node::operator[](const Key& key) const { ++ if (!m_isValid) ++ throw InvalidNode(); ++ EnsureNodeExists(); ++- detail::node* value = static_cast(*m_pNode).get( ++- detail::to_value(key), m_pMemory); +++ detail::node* value = static_cast(*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 ++ 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 ++ ++ #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 m_pScanner; ++ std::unique_ptr 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 ++ #include +++#include ++ ++ 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 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::max_digits10), ++- m_doublePrecision(std::numeric_limits::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::max_digits10); +++ m_doublePrecision.set(std::numeric_limits::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& 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 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 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 ++ #include ++ +++#include "yaml-cpp/noncopyable.h" +++ ++ namespace YAML { ++ ++ // TODO: This class is no longer needed ++ template ++-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> 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 ++ 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 ++-#include ++ #include +++#include "yaml-cpp/noncopyable.h" ++ ++ namespace YAML { ++ class SettingChangeBase; ++@@ -18,7 +18,6 @@ template ++ class Setting { ++ public: ++ Setting() : m_value() {} ++- Setting(const T& value) : m_value() { set(value); } ++ ++ const T get() const { return m_value; } ++ std::unique_ptr set(const T& value); ++@@ -37,14 +36,10 @@ class SettingChangeBase { ++ template ++ class SettingChange : public SettingChangeBase { ++ public: ++- SettingChange(Setting* 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* 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 Setting::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> 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 ++ ++ #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& 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 ++ #include ++@@ -16,15 +17,11 @@ ++ #include ++ ++ 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 ++ ++ 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(token.data)), handle{}, value{} { +++Tag::Tag(const Token& token) : type(static_cast(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 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 ++ diff --cc debian/patches/0005-Revert-fix-up-static-so-works-as-DLL-559.patch index 0000000,0000000..f3cf29b new file mode 100644 --- /dev/null +++ b/debian/patches/0005-Revert-fix-up-static-so-works-as-DLL-559.patch @@@ -1,0 -1,0 +1,64 @@@ ++From bde52684630ffb7c3464e406f02533e7de0ade38 Mon Sep 17 00:00:00 2001 ++From: Adrian Bunk ++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 ++ diff --cc debian/patches/fix-CVE-2017-11692.patch index 0000000,0000000..619d676 new file mode 100644 --- /dev/null +++ b/debian/patches/fix-CVE-2017-11692.patch @@@ -1,0 -1,0 +1,36 @@@ ++commit c9460110e072df84b7dee3eb651f2ec5df75fb18 ++Author: Jesse Beder ++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(), "foo"); ++ } ++ +++TEST(NodeTest, LoadTagWithNullScalar) { +++ Node node = Load("!2"); +++ EXPECT_TRUE(node.IsNull()); +++} +++ ++ } // namespace ++ } // namespace YAML diff --cc debian/patches/fix-unbounded-recursion-depth.patch index 0000000,0000000..526641c new file mode 100644 --- /dev/null +++ b/debian/patches/fix-unbounded-recursion-depth.patch @@@ -1,0 -1,0 +1,164 @@@ ++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?= ++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 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 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 +++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 diff --cc debian/patches/install-cmake-dev-files.patch index 0000000,0000000..a02c6f4 new file mode 100644 --- /dev/null +++ b/debian/patches/install-cmake-dev-files.patch @@@ -1,0 -1,0 +1,24 @@@ ++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 ++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 diff --cc debian/patches/reproducible-build.patch index 0000000,0000000..c80ecea new file mode 100644 --- /dev/null +++ b/debian/patches/reproducible-build.patch @@@ -1,0 -1,0 +1,15 @@@ ++Description: Make the build reproducible ++Author: Reiner Herrmann ++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}") diff --cc debian/patches/series index 0000000,0000000..25ad54d new file mode 100644 --- /dev/null +++ b/debian/patches/series @@@ -1,0 -1,0 +1,10 @@@ ++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 diff --cc debian/patches/symbol-visibility.patch index 0000000,0000000..a85c5c0 new file mode 100644 --- /dev/null +++ b/debian/patches/symbol-visibility.patch @@@ -1,0 -1,0 +1,46 @@@ ++commit df9206778fe9ff1bdd56d975c29c43dfe1e66de7 ++Author: Christopher James Halse Rogers ++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 diff --cc debian/rules index 0000000,0000000..2da237b new file mode 100755 --- /dev/null +++ b/debian/rules @@@ -1,0 -1,0 +1,77 @@@ ++#!/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 ++ ++DEB_HOST_MULTIARCH ?= $(shell dpkg-architecture -qDEB_HOST_MULTIARCH) ++ ++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 ++ ++ifeq (,$(filter $(DEB_BUILD_ARCH),kfreebsd-amd64 kfreebsd-i386 hurd-i386)) ++ DISABLE_PTHREADS=OFF ++else ++ DISABLE_PTHREADS=ON ++endif ++ ++override_dh_auto_configure: ++ dh_testdir ++ dh_auto_configure --builddirectory=build-static -- -DCMAKE_INSTALL_PREFIX=/usr \ ++ -DLIB_INSTALL_DIR=/usr/lib/$(DEB_HOST_MULTIARCH) \ ++ -DYAML_CPP_BUILD_TOOLS=ON \ ++ -Dgtest_disable_pthreads=$(DISABLE_PTHREADS) ++ dh_auto_configure --builddirectory=build-shared -- -DCMAKE_INSTALL_PREFIX=/usr \ ++ -DLIB_INSTALL_DIR=/usr/lib/$(DEB_HOST_MULTIARCH) \ ++ -DYAML_BUILD_SHARED_LIBS=ON \ ++ -DYAML_CPP_BUILD_TOOLS=ON \ ++ -Dgtest_disable_pthreads=$(DISABLE_PTHREADS) ++ ++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 diff --cc debian/source/format index 0000000,0000000..163aaf8 new file mode 100644 --- /dev/null +++ b/debian/source/format @@@ -1,0 -1,0 +1,1 @@@ ++3.0 (quilt) diff --cc debian/watch index 0000000,0000000..bc79ae0 new file mode 100644 --- /dev/null +++ b/debian/watch @@@ -1,0 -1,0 +1,3 @@@ ++version=4 ++ ++https://github.com/jbeder/yaml-cpp/releases .*/[relasymcp.-]*(\d\S*)\.tar\.gz