jsoncpp切openEuler7.0

Signed-off-by: @ran-zhao-yu <ranzhaoyu1@huawei.com>

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 <tero.kinnunen@gmail.com>
+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 <tero.kinnunen@vaisala.com>
+
+Co-authored-by: Tero Kinnunen <tero.kinnunen@vaisala.com>
+---
+ 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 <algorithm>
+ #include <cassert>
++#include <cmath>
+ #include <cstring>
+ #include <iostream>
+ #include <istream>
+@@ -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<double>::max())
++      value = std::numeric_limits<double>::infinity();
++    else if (value == std::numeric_limits<double>::lowest())
++      value = -std::numeric_limits<double>::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<double>::max())
++      value = std::numeric_limits<double>::infinity();
++    else if (value == std::numeric_limits<double>::lowest())
++      value = -std::numeric_limits<double>::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
+

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 <jrtc27@jrtc27.com>
+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 <cstring>
+ #include <memory>
+ 
+-#pragma pack(push, 8)
++#pragma pack(push)
++#pragma pack()
+ 
+ namespace Json {
+ template <typename T> 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
+

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."
     }
 ]

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)

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 <liubo1@xfusion.com> - 1.9.5-5
+- Use default rather than hard-coded 8 for maximum aggregate member alignment
+
+* Wed Oct 18 2023 liubo <liubo1@xfusion.com> - 1.9.5-4
+- Parse large floats as infinity
+
 * Mon Jan 10 2022 shixuantong <shixuantong@huawei.com> - 1.9.5-3
 - Delete so files of lower versions