From 0f86957bffbc732c2a4bb6112366ae8885ec1e38 Mon Sep 17 00:00:00 2001 From: Raspbian forward porter Date: Thu, 26 Aug 2021 23:24:06 +0100 Subject: [PATCH] Import yaml-cpp_0.6.3-10+rpi1.debian.tar.xz [dgit import tarball yaml-cpp 0.6.3-10+rpi1 yaml-cpp_0.6.3-10+rpi1.debian.tar.xz] --- changelog | 248 +++ control | 32 + copyright | 43 + libyaml-cpp-dev.install | 5 + libyaml-cpp0.6.install | 1 + libyaml-cpp0.6.symbols | 266 +++ ...alysis-fix-replace-0-and-NULL-with-n.patch | 156 ++ ...error-messages-on-operator-or-as-656.patch | 595 +++++++ ...evert-Disallow-moving-for-the-Parser.patch | 31 + ...matting-style-tweaks-to-comply-with-.patch | 1571 +++++++++++++++++ ...rt-fix-up-static-so-works-as-DLL-559.patch | 64 + patches/fix-CVE-2017-11692.patch | 36 + patches/fix-pkg-config.patch | 39 + patches/fix-unbounded-recursion-depth.patch | 164 ++ patches/install-cmake-dev-files.patch | 24 + patches/reproducible-build.patch | 15 + patches/series | 11 + patches/symbol-visibility.patch | 46 + rules | 72 + source/format | 1 + upstream/metadata | 4 + watch | 3 + 22 files changed, 3427 insertions(+) create mode 100644 changelog create mode 100644 control create mode 100644 copyright create mode 100644 libyaml-cpp-dev.install create mode 100644 libyaml-cpp0.6.install create mode 100644 libyaml-cpp0.6.symbols create mode 100644 patches/0001-Revert-Static-analysis-fix-replace-0-and-NULL-with-n.patch create mode 100644 patches/0002-Revert-Improve-error-messages-on-operator-or-as-656.patch create mode 100644 patches/0003-Revert-Disallow-moving-for-the-Parser.patch create mode 100644 patches/0004-Revert-Apply-formatting-style-tweaks-to-comply-with-.patch create mode 100644 patches/0005-Revert-fix-up-static-so-works-as-DLL-559.patch create mode 100644 patches/fix-CVE-2017-11692.patch create mode 100644 patches/fix-pkg-config.patch create mode 100644 patches/fix-unbounded-recursion-depth.patch create mode 100644 patches/install-cmake-dev-files.patch create mode 100644 patches/reproducible-build.patch create mode 100644 patches/series create mode 100644 patches/symbol-visibility.patch create mode 100755 rules create mode 100644 source/format create mode 100644 upstream/metadata create mode 100644 watch diff --git a/changelog b/changelog new file mode 100644 index 0000000..9646176 --- /dev/null +++ b/changelog @@ -0,0 +1,248 @@ +yaml-cpp (0.6.3-10+rpi1) bookworm-staging; urgency=medium + + [changes brought forward from 0.6.2-4+rpi1 by Peter Michael Green at Fri, 18 Jan 2019 20:49:45 +0000] + * Update symbols file for raspbian. + + -- Raspbian forward porter Thu, 26 Aug 2021 22:24:06 +0000 + +yaml-cpp (0.6.3-10) unstable; urgency=medium + + * Mark symbols as optional not seen when building with lto. + + -- Matthias Klose Mon, 22 Mar 2021 22:04:27 +0100 + +yaml-cpp (0.6.3-9) unstable; urgency=medium + + * Fix pkg-config and cmake wrong files and paths. LP: #1880419 + + -- Gianfranco Costamagna Tue, 26 May 2020 17:56:33 +0200 + +yaml-cpp (0.6.3-8) unstable; urgency=medium + + [ Debian Janitor ] + * Set upstream metadata fields: Bug-Database, Bug-Submit, Repository, + Repository-Browse. + + [ Helmut Grohne ] + * Fix FTCBFS: Don't build tests for DEB_BUILD_OPTIONS=nocheck. + (Closes: #960167) + + -- Gianfranco Costamagna Thu, 14 May 2020 10:29:07 +0200 + +yaml-cpp (0.6.3-7) unstable; urgency=medium + + * Team upload + [ Adrian Bunk ] + * From Adrian Bunk, fix other c++ symbols that broke ABI + (Closes: #959201) + + -- Gianfranco Costamagna 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 --git a/control b/control new file mode 100644 index 0000000..bcfcffc --- /dev/null +++ b/control @@ -0,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 --git a/copyright b/copyright new file mode 100644 index 0000000..6a1f1e9 --- /dev/null +++ b/copyright @@ -0,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 --git a/libyaml-cpp-dev.install b/libyaml-cpp-dev.install new file mode 100644 index 0000000..4cef216 --- /dev/null +++ b/libyaml-cpp-dev.install @@ -0,0 +1,5 @@ +usr/include/yaml-cpp/ +usr/lib/*/*.a +usr/lib/*/*.so +usr/lib/*/cmake/ +usr/lib/*/pkgconfig/ diff --git a/libyaml-cpp0.6.install b/libyaml-cpp0.6.install new file mode 100644 index 0000000..7a0ab28 --- /dev/null +++ b/libyaml-cpp0.6.install @@ -0,0 +1 @@ +usr/lib/*/libyaml-cpp.so.* diff --git a/libyaml-cpp0.6.symbols b/libyaml-cpp0.6.symbols new file mode 100644 index 0000000..92ab3c4 --- /dev/null +++ b/libyaml-cpp0.6.symbols @@ -0,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 + (optional=notarmelandprobabllynotraspbian)_ZTISt11_Mutex_baseILN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 + (arch= armel riscv64)_ZTISt15_Sp_counted_ptrIPN4YAML6detail13memory_holderELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2 + (optional=notarmelandprobabllynotraspbian)_ZTISt15_Sp_counted_ptrIPN4YAML6detail13memory_holderELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 + (arch= armel riscv64)_ZTISt15_Sp_counted_ptrIPN4YAML6detail6memoryELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2 + (optional=notarmelandprobabllynotraspbian)_ZTISt15_Sp_counted_ptrIPN4YAML6detail6memoryELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 + (arch= armel riscv64)_ZTISt15_Sp_counted_ptrIPN4YAML6detail9node_dataELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2 + (optional=notarmelandprobabllynotraspbian)_ZTISt15_Sp_counted_ptrIPN4YAML6detail9node_dataELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 + (arch= armel riscv64)_ZTISt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2 + (optional=notarmelandprobabllynotraspbian)_ZTISt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 + _ZTSN4YAML11BadPushbackE@Base 0.6.2 + _ZTSN4YAML11InvalidNodeE@Base 0.6.2 + _ZTSN4YAML11KeyNotFoundE@Base 0.6.2 + _ZTSN4YAML12BadSubscriptE@Base 0.6.2 + _ZTSN4YAML13BadConversionE@Base 0.6.2 + _ZTSN4YAML13InvalidScalarE@Base 0.6.2 + _ZTSN4YAML14BadDereferenceE@Base 0.6.2 + _ZTSN4YAML15ParserExceptionE@Base 0.6.2 + _ZTSN4YAML16EmitterExceptionE@Base 0.6.2 + _ZTSN4YAML23RepresentationExceptionE@Base 0.6.2 + _ZTSN4YAML7BadFileE@Base 0.6.2 + _ZTSN4YAML9BadInsertE@Base 0.6.2 + _ZTSN4YAML9ExceptionE@Base 0.6.2 + (arch= armel riscv64)_ZTSN9__gnu_cxx7__mutexE@Base 0.6.2-2 + (arch= armel riscv64)_ZTSSt11_Mutex_baseILN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2 + (optional=notarmelandprobabllynotraspbian)_ZTSSt11_Mutex_baseILN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 + (arch= armel riscv64)_ZTSSt15_Sp_counted_ptrIPN4YAML6detail13memory_holderELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2 + (optional=notarmelandprobabllynotraspbian)_ZTSSt15_Sp_counted_ptrIPN4YAML6detail13memory_holderELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 + (arch= armel riscv64)_ZTSSt15_Sp_counted_ptrIPN4YAML6detail6memoryELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2 + (optional=notarmelandprobabllynotraspbian)_ZTSSt15_Sp_counted_ptrIPN4YAML6detail6memoryELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 + (arch= armel riscv64)_ZTSSt15_Sp_counted_ptrIPN4YAML6detail9node_dataELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2 + (optional=notarmelandprobabllynotraspbian)_ZTSSt15_Sp_counted_ptrIPN4YAML6detail9node_dataELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 + (arch= armel riscv64)_ZTSSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2 + (optional=notarmelandprobabllynotraspbian)_ZTSSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 + _ZTVN4YAML11BadPushbackE@Base 0.6.2 + _ZTVN4YAML11InvalidNodeE@Base 0.6.2 + _ZTVN4YAML11KeyNotFoundE@Base 0.6.2 + _ZTVN4YAML12BadSubscriptE@Base 0.6.2 + _ZTVN4YAML13BadConversionE@Base 0.6.2 + _ZTVN4YAML13InvalidScalarE@Base 0.6.2 + _ZTVN4YAML14BadDereferenceE@Base 0.6.2 + _ZTVN4YAML15ParserExceptionE@Base 0.6.2 + _ZTVN4YAML16EmitterExceptionE@Base 0.6.2 + _ZTVN4YAML23RepresentationExceptionE@Base 0.6.2 + _ZTVN4YAML7BadFileE@Base 0.6.2 + _ZTVN4YAML9BadInsertE@Base 0.6.2 + _ZTVN4YAML9ExceptionE@Base 0.6.2 + (arch= armel riscv64)_ZTVSt15_Sp_counted_ptrIPN4YAML6detail13memory_holderELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2 + (optional=notarmelandprobabllynotraspbian)_ZTVSt15_Sp_counted_ptrIPN4YAML6detail13memory_holderELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 + (arch= armel riscv64)_ZTVSt15_Sp_counted_ptrIPN4YAML6detail6memoryELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2 + (optional=notarmelandprobabllynotraspbian)_ZTVSt15_Sp_counted_ptrIPN4YAML6detail6memoryELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 + (arch= armel riscv64)_ZTVSt15_Sp_counted_ptrIPN4YAML6detail9node_dataELN9__gnu_cxx12_Lock_policyE1EE@Base 0.6.2-2 + (optional=notarmelandprobabllynotraspbian)_ZTVSt15_Sp_counted_ptrIPN4YAML6detail9node_dataELN9__gnu_cxx12_Lock_policyE2EE@Base 0.6.2 diff --git a/patches/0001-Revert-Static-analysis-fix-replace-0-and-NULL-with-n.patch b/patches/0001-Revert-Static-analysis-fix-replace-0-and-NULL-with-n.patch new file mode 100644 index 0000000..144ef1b --- /dev/null +++ b/patches/0001-Revert-Static-analysis-fix-replace-0-and-NULL-with-n.patch @@ -0,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 --git a/patches/0002-Revert-Improve-error-messages-on-operator-or-as-656.patch b/patches/0002-Revert-Improve-error-messages-on-operator-or-as-656.patch new file mode 100644 index 0000000..20d816a --- /dev/null +++ b/patches/0002-Revert-Improve-error-messages-on-operator-or-as-656.patch @@ -0,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 --git a/patches/0003-Revert-Disallow-moving-for-the-Parser.patch b/patches/0003-Revert-Disallow-moving-for-the-Parser.patch new file mode 100644 index 0000000..556cdff --- /dev/null +++ b/patches/0003-Revert-Disallow-moving-for-the-Parser.patch @@ -0,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 --git a/patches/0004-Revert-Apply-formatting-style-tweaks-to-comply-with-.patch b/patches/0004-Revert-Apply-formatting-style-tweaks-to-comply-with-.patch new file mode 100644 index 0000000..885a22a --- /dev/null +++ b/patches/0004-Revert-Apply-formatting-style-tweaks-to-comply-with-.patch @@ -0,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 --git a/patches/0005-Revert-fix-up-static-so-works-as-DLL-559.patch b/patches/0005-Revert-fix-up-static-so-works-as-DLL-559.patch new file mode 100644 index 0000000..f3cf29b --- /dev/null +++ b/patches/0005-Revert-fix-up-static-so-works-as-DLL-559.patch @@ -0,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 --git a/patches/fix-CVE-2017-11692.patch b/patches/fix-CVE-2017-11692.patch new file mode 100644 index 0000000..619d676 --- /dev/null +++ b/patches/fix-CVE-2017-11692.patch @@ -0,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 --git a/patches/fix-pkg-config.patch b/patches/fix-pkg-config.patch new file mode 100644 index 0000000..393f554 --- /dev/null +++ b/patches/fix-pkg-config.patch @@ -0,0 +1,39 @@ +Description: fix pkg-config file and cmake one +Author: Gianfranco Costamagna +Forwarded: not needed, upstream reworked the cmake handling +Bug-Ubuntu: https://bugs.launchpad.net/ubuntu/+source/yaml-cpp/+bug/1880419 +Last-Update: 2020-05-26 + +--- yaml-cpp-0.6.3.orig/CMakeLists.txt ++++ yaml-cpp-0.6.3/CMakeLists.txt +@@ -325,7 +325,7 @@ export( + export(PACKAGE yaml-cpp) + set(EXPORT_TARGETS yaml-cpp CACHE INTERNAL "export targets") + +-set(CONFIG_INCLUDE_DIRS "${YAML_CPP_SOURCE_DIR}/include") ++set(CONFIG_INCLUDE_DIRS include) + configure_file(${CMAKE_CURRENT_SOURCE_DIR}/yaml-cpp-config.cmake.in + "${PROJECT_BINARY_DIR}/yaml-cpp-config.cmake" @ONLY) + +--- yaml-cpp-0.6.3.orig/yaml-cpp-config.cmake.in ++++ yaml-cpp-0.6.3/yaml-cpp-config.cmake.in +@@ -5,7 +5,7 @@ + + # Compute paths + get_filename_component(YAML_CPP_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH) +-set(YAML_CPP_INCLUDE_DIR "@CONFIG_INCLUDE_DIRS@") ++set(YAML_CPP_INCLUDE_DIR "@INCLUDE_INSTALL_ROOT_DIR@") + + # Our library dependencies (contains definitions for IMPORTED targets) + include("${YAML_CPP_CMAKE_DIR}/yaml-cpp-targets.cmake") +--- yaml-cpp-0.6.3.orig/yaml-cpp.pc.cmake ++++ yaml-cpp-0.6.3/yaml-cpp.pc.cmake +@@ -1,7 +1,7 @@ + prefix=@CMAKE_INSTALL_PREFIX@ + exec_prefix=${prefix} + includedir=${prefix}/@INCLUDE_INSTALL_ROOT_DIR@ +-libdir=${exec_prefix}/@LIB_INSTALL_DIR@ ++libdir=@LIB_INSTALL_DIR@ + + Name: Yaml-cpp + Description: A YAML parser and emitter for C++ diff --git a/patches/fix-unbounded-recursion-depth.patch b/patches/fix-unbounded-recursion-depth.patch new file mode 100644 index 0000000..526641c --- /dev/null +++ b/patches/fix-unbounded-recursion-depth.patch @@ -0,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 --git a/patches/install-cmake-dev-files.patch b/patches/install-cmake-dev-files.patch new file mode 100644 index 0000000..a02c6f4 --- /dev/null +++ b/patches/install-cmake-dev-files.patch @@ -0,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 --git a/patches/reproducible-build.patch b/patches/reproducible-build.patch new file mode 100644 index 0000000..c80ecea --- /dev/null +++ b/patches/reproducible-build.patch @@ -0,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 --git a/patches/series b/patches/series new file mode 100644 index 0000000..4554fe6 --- /dev/null +++ b/patches/series @@ -0,0 +1,11 @@ +install-cmake-dev-files.patch +reproducible-build.patch +symbol-visibility.patch +fix-CVE-2017-11692.patch +fix-unbounded-recursion-depth.patch +0001-Revert-Static-analysis-fix-replace-0-and-NULL-with-n.patch +0002-Revert-Improve-error-messages-on-operator-or-as-656.patch +0003-Revert-Disallow-moving-for-the-Parser.patch +0004-Revert-Apply-formatting-style-tweaks-to-comply-with-.patch +0005-Revert-fix-up-static-so-works-as-DLL-559.patch +fix-pkg-config.patch diff --git a/patches/symbol-visibility.patch b/patches/symbol-visibility.patch new file mode 100644 index 0000000..a85c5c0 --- /dev/null +++ b/patches/symbol-visibility.patch @@ -0,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 --git a/rules b/rules new file mode 100755 index 0000000..4ddc232 --- /dev/null +++ b/rules @@ -0,0 +1,72 @@ +#!/usr/bin/make -f + +# Uncomment this to turn on verbose mode. +#export DH_VERBOSE=1 + +# This has to be exported to make some magic below work. +export DH_OPTIONS + +include /usr/share/dpkg/architecture.mk + +CPPFLAGS :=$(shell dpkg-buildflags --get CPPFLAGS) +ifneq (,$(filter $(DEB_BUILD_ARCH),mipsel)) + CFLAGS :=$(shell dpkg-buildflags --get CFLAGS) -g1 + CXXFLAGS :=$(shell dpkg-buildflags --get CXXFLAGS) -g1 +else + CFLAGS :=$(shell dpkg-buildflags --get CFLAGS) + CXXFLAGS :=$(shell dpkg-buildflags --get CXXFLAGS) +endif +LDFLAGS :=$(shell dpkg-buildflags --get LDFLAGS) + +export DEB_HOST_MULTIARCH CPPFLAGS CFLAGS CXXFLAGS LDFLAGS + +COMMON_CMAKE_FLAGS = \ + -DCMAKE_INSTALL_PREFIX=/usr \ + -DLIB_INSTALL_DIR=/usr/lib/$(DEB_HOST_MULTIARCH) \ + -DYAML_CPP_BUILD_TOOLS=ON \ + -DYAML_CPP_BUILD_TESTS=$(if $(filter nocheck,$(DEB_BUILD_OPTIONS)),OFF,ON) \ + -Dgtest_disable_pthreads=$(if $(filter $(DEB_HOST_ARCH_OS),kfreebsd hurd),ON,OFF) + +override_dh_auto_configure: + dh_testdir + dh_auto_configure --builddirectory=build-static -- $(COMMON_CMAKE_FLAGS) + dh_auto_configure --builddirectory=build-shared -- $(COMMON_CMAKE_FLAGS) \ + -DYAML_BUILD_SHARED_LIBS=ON + +override_dh_auto_build: + dh_testdir + $(MAKE) -C build-static VERBOSE=1 + $(MAKE) -C build-shared VERBOSE=1 + # It might make sense to also provide the utils in a separate package + # $(MAKE) -C build-shared util + +override_dh_auto_install: + dh_testdir + dh_prep + $(MAKE) -C build-static install DESTDIR=$(CURDIR)/debian/tmp + $(MAKE) -C build-shared install DESTDIR=$(CURDIR)/debian/tmp + +ifeq ($(filter nocheck,$(DEB_BUILD_OPTIONS)),) +override_dh_auto_test: + $(MAKE) -C build-static test + $(MAKE) -C build-shared test +endif + +debian/weak-symbols: override_dh_auto_build + # All the weak symbols are either template instantiations of the STL + # or are optional symbols for inline functions. + nm --dynamic --defined-only build-shared/libyaml-cpp.so | awk '$$2 ~ /W/ { print " " $$3 "@Base 0.6.2" } ' > $@ + +override_dh_makeshlibs: debian/weak-symbols + dh_makeshlibs -VNone + +clean: + dh_testdir + dh_auto_clean + dh_clean + rm -rf build-static build-shared + +%: + dh $@ + +.PHONY: clean diff --git a/source/format b/source/format new file mode 100644 index 0000000..163aaf8 --- /dev/null +++ b/source/format @@ -0,0 +1 @@ +3.0 (quilt) diff --git a/upstream/metadata b/upstream/metadata new file mode 100644 index 0000000..9b82caf --- /dev/null +++ b/upstream/metadata @@ -0,0 +1,4 @@ +Bug-Database: https://github.com/jbeder/yaml-cpp/issues +Bug-Submit: https://github.com/jbeder/yaml-cpp/issues/new +Repository: https://github.com/jbeder/yaml-cpp.git +Repository-Browse: https://github.com/jbeder/yaml-cpp diff --git a/watch b/watch new file mode 100644 index 0000000..bc79ae0 --- /dev/null +++ b/watch @@ -0,0 +1,3 @@ +version=4 + +https://github.com/jbeder/yaml-cpp/releases .*/[relasymcp.-]*(\d\S*)\.tar\.gz -- 2.30.2