From 619d98613734a8cdd7c47d685ddfb15de42f9b91 Mon Sep 17 00:00:00 2001 From: "@ran-zhao-yu" Date: Thu, 25 Apr 2024 19:18:55 +0800 Subject: [PATCH] =?UTF-8?q?jsoncpp=E5=88=87openEuler7.0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: @ran-zhao-yu --- ...e-large-floats-as-infinity-1349-1353.patch | 102 ++++++++++++++ ...er-than-hard-coded-8-for-maximum-agg.patch | 126 ++++++++++++++++++ README.OpenSource | 4 +- install.py | 6 +- jsoncpp.spec | 11 +- 5 files changed, 245 insertions(+), 4 deletions(-) create mode 100644 0001-Parse-large-floats-as-infinity-1349-1353.patch create mode 100644 0001-Use-default-rather-than-hard-coded-8-for-maximum-agg.patch diff --git a/0001-Parse-large-floats-as-infinity-1349-1353.patch b/0001-Parse-large-floats-as-infinity-1349-1353.patch new file mode 100644 index 0000000..2890925 --- /dev/null +++ b/0001-Parse-large-floats-as-infinity-1349-1353.patch @@ -0,0 +1,102 @@ +From 2d55c7445ffedf30db62231f223137ef02e611a9 Mon Sep 17 00:00:00 2001 +From: Tero Kinnunen +Date: Wed, 15 Dec 2021 04:00:28 +0200 +Subject: [PATCH] Parse large floats as infinity (#1349) (#1353) + +Return 1.9.1 functionality where values too large to fit in +double are converted to positive or negative infinity. + +Commit 645cd04 changed functionality so that large floats cause +parse error, while version 1.9.1 accepted them as infinite. +This is problematic because writer outputs infinity values +as `1e+9999`, which could no longer be parsed back. + +Fixed also legacy Reader even though it did not parse large values +even before breaking change, due to problematic output/parse asymmetry. + +`>>` operator sets value to numeric_limits::max/lowest value if +representation is too large to fit to double. [1][2] In macos +value appears to be parsed to infinity. + +> | value in *val* | description | +> |--------------------------|-------------| +> | numeric_limits::max() | The sequence represents a value too large for the type of val | +> | numeric_limits::lowest() | The sequence represents a value too large negative for the type of val | + +[1] https://www.cplusplus.com/reference/istream/istream/operator%3E%3E/ +[2] https://www.cplusplus.com/reference/locale/num_get/get/ + +Signed-off-by: Tero Kinnunen + +Co-authored-by: Tero Kinnunen +--- + src/lib_json/json_reader.cpp | 18 +++++++++++++++--- + test/data/legacy_test_real_13.expected | 3 +++ + test/data/legacy_test_real_13.json | 1 + + 3 files changed, 19 insertions(+), 3 deletions(-) + create mode 100644 test/data/legacy_test_real_13.expected + create mode 100644 test/data/legacy_test_real_13.json + +diff --git a/src/lib_json/json_reader.cpp b/src/lib_json/json_reader.cpp +index a6a3f4e..896bf1b 100644 +--- a/src/lib_json/json_reader.cpp ++++ b/src/lib_json/json_reader.cpp +@@ -12,6 +12,7 @@ + #endif // if !defined(JSON_IS_AMALGAMATION) + #include + #include ++#include + #include + #include + #include +@@ -600,9 +601,15 @@ bool Reader::decodeDouble(Token& token, Value& decoded) { + double value = 0; + String buffer(token.start_, token.end_); + IStringStream is(buffer); +- if (!(is >> value)) +- return addError( ++ if (!(is >> value)) { ++ if (value == std::numeric_limits::max()) ++ value = std::numeric_limits::infinity(); ++ else if (value == std::numeric_limits::lowest()) ++ value = -std::numeric_limits::infinity(); ++ else if (!std::isinf(value)) ++ return addError( + "'" + String(token.start_, token.end_) + "' is not a number.", token); ++ } + decoded = value; + return true; + } +@@ -1647,7 +1654,12 @@ bool OurReader::decodeDouble(Token& token, Value& decoded) { + const String buffer(token.start_, token.end_); + IStringStream is(buffer); + if (!(is >> value)) { +- return addError( ++ if (value == std::numeric_limits::max()) ++ value = std::numeric_limits::infinity(); ++ else if (value == std::numeric_limits::lowest()) ++ value = -std::numeric_limits::infinity(); ++ else if (!std::isinf(value)) ++ return addError( + "'" + String(token.start_, token.end_) + "' is not a number.", token); + } + decoded = value; +diff --git a/test/data/legacy_test_real_13.expected b/test/data/legacy_test_real_13.expected +new file mode 100644 +index 0000000..8d3f03f +--- /dev/null ++++ b/test/data/legacy_test_real_13.expected +@@ -0,0 +1,3 @@ ++.=[] ++.[0]=-inf ++.[1]=inf +diff --git a/test/data/legacy_test_real_13.json b/test/data/legacy_test_real_13.json +new file mode 100644 +index 0000000..287258a +--- /dev/null ++++ b/test/data/legacy_test_real_13.json +@@ -0,0 +1 @@ ++[-1e+9999, 1e+9999] +-- +2.42.0.windows.2 + diff --git a/0001-Use-default-rather-than-hard-coded-8-for-maximum-agg.patch b/0001-Use-default-rather-than-hard-coded-8-for-maximum-agg.patch new file mode 100644 index 0000000..d72236a --- /dev/null +++ b/0001-Use-default-rather-than-hard-coded-8-for-maximum-agg.patch @@ -0,0 +1,126 @@ +From 42e892d96e47b1f6e29844cc705e148ec4856448 Mon Sep 17 00:00:00 2001 +From: Jessica Clarke +Date: Wed, 12 Jan 2022 21:27:16 +0000 +Subject: [PATCH] Use default rather than hard-coded 8 for maximum aggregate + member alignment (#1378) + +On CHERI, and thus Arm's Morello prototype, pointers are represented as +hardware capabilities. These capabilities are comprised of not just an +integer address, as is the representation for traditional pointers, but +also bounds, permissions and other metadata, plus a tag bit used as the +validity bit, which provides fine-grained spatial and referential safety +for C and C++ in hardware. This tag bit is not part of the data itself +and is instead kept on the side, flowing with the capability between +registers and the memory subsystem, and any attempt to amplify the +privilege of or corrupt a capability clears this tag (or, in some cases, +traps), rendering them impossible to forge; you can only create +capabilities that are (possibly trivial) subsets of existing ones. + +When the capability is stored in memory, this tag bit needs to be +preserved, which is done through the use of tagged memory. Every +capability-sized word gains an additional non-addressable (from the +CPU's perspective; depending on the implementation the tag bits may be +stored in a small block of memory carved out of normal DRAM that the CPU +is blocked from accessing) bit. This means that capabilities can only be +stored to aligned locations; attempting to store them to unaligned +locations will trap with an alignment fault or, if you end up using a +memcpy call, will copy the raw bytes of the capability's representation +but lose the tag, so when it is eventually loaded back as a capability +and dereferenced it will fault. + +Since, on 64-bit architectures, our capabilities, used to implement C +language pointers, are 128-bit quantities, this means they need 16-byte +alignment. Currently the various #pragma pack directives, used to work +around (extremely broken and bogus) code that includes jsoncpp in a +context where the maximum alignment has been overridden, hard-code 8 as +the maximum alignment to use, and so do not sufficiently align CHERI / +Morello capabilities on 64-bit architectures. On Windows x64, the +default is also not 8 but 16 (ARM64 is supposedly 8), so this is +slightly dodgy to do there too, but in practice likely not an issue so +long as you don't use any 128-bit types there. + +Instead of hard-coding a width, use a directive that resets the packing +back to the default. Unfortunately, whilst GCC and Clang both accept +using #pragma pack(push, 0) as shorthand like for any non-zero value, +MSVC does not, so this needs to be two directives. +--- + include/json/allocator.h | 3 ++- + include/json/json_features.h | 3 ++- + include/json/reader.h | 3 ++- + include/json/value.h | 3 ++- + include/json/writer.h | 3 ++- + 5 files changed, 10 insertions(+), 5 deletions(-) + +diff --git a/include/json/allocator.h b/include/json/allocator.h +index 95ef8a5..7540642 100644 +--- a/include/json/allocator.h ++++ b/include/json/allocator.h +@@ -9,7 +9,8 @@ + #include + #include + +-#pragma pack(push, 8) ++#pragma pack(push) ++#pragma pack() + + namespace Json { + template class SecureAllocator { +diff --git a/include/json/json_features.h b/include/json/json_features.h +index 7c7e9f5..e4a61d6 100644 +--- a/include/json/json_features.h ++++ b/include/json/json_features.h +@@ -10,7 +10,8 @@ + #include "forwards.h" + #endif // if !defined(JSON_IS_AMALGAMATION) + +-#pragma pack(push, 8) ++#pragma pack(push) ++#pragma pack() + + namespace Json { + +diff --git a/include/json/reader.h b/include/json/reader.h +index be0d767..46975d8 100644 +--- a/include/json/reader.h ++++ b/include/json/reader.h +@@ -23,7 +23,8 @@ + #pragma warning(disable : 4251) + #endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) + +-#pragma pack(push, 8) ++#pragma pack(push) ++#pragma pack() + + namespace Json { + +diff --git a/include/json/value.h b/include/json/value.h +index 0edeb05..57ecb13 100644 +--- a/include/json/value.h ++++ b/include/json/value.h +@@ -53,7 +53,8 @@ + #pragma warning(disable : 4251 4275) + #endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) + +-#pragma pack(push, 8) ++#pragma pack(push) ++#pragma pack() + + /** \brief JSON (JavaScript Object Notation). + */ +diff --git a/include/json/writer.h b/include/json/writer.h +index 03f9906..7d8cf4d 100644 +--- a/include/json/writer.h ++++ b/include/json/writer.h +@@ -20,7 +20,8 @@ + #pragma warning(disable : 4251) + #endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) + +-#pragma pack(push, 8) ++#pragma pack(push) ++#pragma pack() + + namespace Json { + +-- +2.42.0.windows.2 + diff --git a/README.OpenSource b/README.OpenSource index ca99b28..9110558 100644 --- a/README.OpenSource +++ b/README.OpenSource @@ -3,9 +3,9 @@ "Name": "jsonCpp", "License": "MIT License", "License File": "Copyright", - "Version Number": "jsoncpp-1.9.5.oe2203sp1", + "Version Number": "jsoncpp-1.9.5.oe2203sp3", "Owner": "jameslee@huawei.com", - "Upstream URL": "https://repo.openeuler.org/openEuler-22.03-LTS-SP1/source/Packages/jsoncpp-1.9.5.oe2203sp1.src.rpm", + "Upstream URL": "https://repo.openeuler.org/openEuler-22.03-LTS-SP3/source/Packages/jsoncpp-1.9.5-5.oe2203sp3.src.rpm", "Description": "JsonCpp is a C++ library that allows manipulating JSON values, including serialization and deserialization to and from strings. It can also preserve existing comment in unserialization/serialization steps, making it a convenient format to store user input files." } ] diff --git a/install.py b/install.py index 30b47cc..129700f 100755 --- a/install.py +++ b/install.py @@ -47,7 +47,11 @@ def apply_patch(patch_file, target_dir): def do_patch(args, target_dir): - patch_file = [ "Fix error whenparses the value of 5E-324 with libc++.patch" ] + patch_file = [ + "Fix error whenparses the value of 5E-324 with libc++.patch", + "0001-Parse-large-floats-as-infinity-1349-1353.patch", + "0001-Use-default-rather-than-hard-coded-8-for-maximum-agg.patch" + ] for patch in patch_file: file_path = os.path.join(args.source_file, patch) diff --git a/jsoncpp.spec b/jsoncpp.spec index d432321..0f81952 100644 --- a/jsoncpp.spec +++ b/jsoncpp.spec @@ -1,12 +1,15 @@ Name: jsoncpp Version: 1.9.5 -Release: 3 +Release: 5 Summary: JSON C++ library License: Public Domain or MIT URL: https://github.com/open-source-parsers/jsoncpp Source0: https://github.com/open-source-parsers/jsoncpp/archive/%{version}/%{name}-%{version}.tar.gz BuildRequires: gcc-c++ cmake >= 3.1 python3-devel +Patch0001: 0001-Parse-large-floats-as-infinity-1349-1353.patch +Patch0002: 0001-Use-default-rather-than-hard-coded-8-for-maximum-agg.patch + %description JsonCpp is a C++ library that allows manipulating JSON values, including serialization and deserialization to and from strings. @@ -91,6 +94,12 @@ hardlink -cfv %{buildroot}%{_docdir}/%{name} %changelog +* Thu Nov 16 2023 liubo - 1.9.5-5 +- Use default rather than hard-coded 8 for maximum aggregate member alignment + +* Wed Oct 18 2023 liubo - 1.9.5-4 +- Parse large floats as infinity + * Mon Jan 10 2022 shixuantong - 1.9.5-3 - Delete so files of lower versions