sq_detailed_metrics 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (69) hide show
  1. checksums.yaml +7 -0
  2. data/extconf.rb +26 -0
  3. data/include/half.hpp +4575 -0
  4. data/include/msgpack.h +24 -0
  5. data/include/msgpack/fbuffer.h +42 -0
  6. data/include/msgpack/gcc_atomic.h +25 -0
  7. data/include/msgpack/object.h +118 -0
  8. data/include/msgpack/pack.h +174 -0
  9. data/include/msgpack/pack_define.h +18 -0
  10. data/include/msgpack/pack_template.h +952 -0
  11. data/include/msgpack/sbuffer.h +115 -0
  12. data/include/msgpack/sysdep.h +221 -0
  13. data/include/msgpack/timestamp.h +58 -0
  14. data/include/msgpack/unpack.h +281 -0
  15. data/include/msgpack/unpack_define.h +89 -0
  16. data/include/msgpack/unpack_template.h +471 -0
  17. data/include/msgpack/util.h +15 -0
  18. data/include/msgpack/version.h +38 -0
  19. data/include/msgpack/version_master.h +3 -0
  20. data/include/msgpack/vrefbuffer.h +144 -0
  21. data/include/msgpack/zbuffer.h +205 -0
  22. data/include/msgpack/zone.h +163 -0
  23. data/include/rapidjson/allocators.h +271 -0
  24. data/include/rapidjson/document.h +2575 -0
  25. data/include/rapidjson/encodedstream.h +299 -0
  26. data/include/rapidjson/encodings.h +716 -0
  27. data/include/rapidjson/error/en.h +74 -0
  28. data/include/rapidjson/error/error.h +155 -0
  29. data/include/rapidjson/filereadstream.h +99 -0
  30. data/include/rapidjson/filewritestream.h +104 -0
  31. data/include/rapidjson/fwd.h +151 -0
  32. data/include/rapidjson/internal/biginteger.h +290 -0
  33. data/include/rapidjson/internal/diyfp.h +258 -0
  34. data/include/rapidjson/internal/dtoa.h +245 -0
  35. data/include/rapidjson/internal/ieee754.h +78 -0
  36. data/include/rapidjson/internal/itoa.h +304 -0
  37. data/include/rapidjson/internal/meta.h +181 -0
  38. data/include/rapidjson/internal/pow10.h +55 -0
  39. data/include/rapidjson/internal/regex.h +701 -0
  40. data/include/rapidjson/internal/stack.h +230 -0
  41. data/include/rapidjson/internal/strfunc.h +55 -0
  42. data/include/rapidjson/internal/strtod.h +269 -0
  43. data/include/rapidjson/internal/swap.h +46 -0
  44. data/include/rapidjson/istreamwrapper.h +115 -0
  45. data/include/rapidjson/memorybuffer.h +70 -0
  46. data/include/rapidjson/memorystream.h +71 -0
  47. data/include/rapidjson/msinttypes/inttypes.h +316 -0
  48. data/include/rapidjson/msinttypes/stdint.h +300 -0
  49. data/include/rapidjson/ostreamwrapper.h +81 -0
  50. data/include/rapidjson/pointer.h +1358 -0
  51. data/include/rapidjson/prettywriter.h +255 -0
  52. data/include/rapidjson/rapidjson.h +615 -0
  53. data/include/rapidjson/reader.h +1879 -0
  54. data/include/rapidjson/schema.h +2006 -0
  55. data/include/rapidjson/stream.h +179 -0
  56. data/include/rapidjson/stringbuffer.h +117 -0
  57. data/include/rapidjson/writer.h +610 -0
  58. data/include/xxhash.h +328 -0
  59. data/json_conv.cpp +284 -0
  60. data/json_conv.hpp +17 -0
  61. data/metrics.cpp +239 -0
  62. data/metrics.hpp +84 -0
  63. data/msgpack/objectc.c +482 -0
  64. data/msgpack/unpack.c +703 -0
  65. data/msgpack/version.c +22 -0
  66. data/msgpack/vrefbuffer.c +250 -0
  67. data/msgpack/zone.c +222 -0
  68. data/sq_detailed_metrics.cpp +248 -0
  69. metadata +199 -0
@@ -0,0 +1,230 @@
1
+ // Tencent is pleased to support the open source community by making RapidJSON available.
2
+ //
3
+ // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
4
+ //
5
+ // Licensed under the MIT License (the "License"); you may not use this file except
6
+ // in compliance with the License. You may obtain a copy of the License at
7
+ //
8
+ // http://opensource.org/licenses/MIT
9
+ //
10
+ // Unless required by applicable law or agreed to in writing, software distributed
11
+ // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
12
+ // CONDITIONS OF ANY KIND, either express or implied. See the License for the
13
+ // specific language governing permissions and limitations under the License.
14
+
15
+ #ifndef RAPIDJSON_INTERNAL_STACK_H_
16
+ #define RAPIDJSON_INTERNAL_STACK_H_
17
+
18
+ #include "../allocators.h"
19
+ #include "swap.h"
20
+
21
+ #if defined(__clang__)
22
+ RAPIDJSON_DIAG_PUSH
23
+ RAPIDJSON_DIAG_OFF(c++98-compat)
24
+ #endif
25
+
26
+ RAPIDJSON_NAMESPACE_BEGIN
27
+ namespace internal {
28
+
29
+ ///////////////////////////////////////////////////////////////////////////////
30
+ // Stack
31
+
32
+ //! A type-unsafe stack for storing different types of data.
33
+ /*! \tparam Allocator Allocator for allocating stack memory.
34
+ */
35
+ template <typename Allocator>
36
+ class Stack {
37
+ public:
38
+ // Optimization note: Do not allocate memory for stack_ in constructor.
39
+ // Do it lazily when first Push() -> Expand() -> Resize().
40
+ Stack(Allocator* allocator, size_t stackCapacity) : allocator_(allocator), ownAllocator_(0), stack_(0), stackTop_(0), stackEnd_(0), initialCapacity_(stackCapacity) {
41
+ }
42
+
43
+ #if RAPIDJSON_HAS_CXX11_RVALUE_REFS
44
+ Stack(Stack&& rhs)
45
+ : allocator_(rhs.allocator_),
46
+ ownAllocator_(rhs.ownAllocator_),
47
+ stack_(rhs.stack_),
48
+ stackTop_(rhs.stackTop_),
49
+ stackEnd_(rhs.stackEnd_),
50
+ initialCapacity_(rhs.initialCapacity_)
51
+ {
52
+ rhs.allocator_ = 0;
53
+ rhs.ownAllocator_ = 0;
54
+ rhs.stack_ = 0;
55
+ rhs.stackTop_ = 0;
56
+ rhs.stackEnd_ = 0;
57
+ rhs.initialCapacity_ = 0;
58
+ }
59
+ #endif
60
+
61
+ ~Stack() {
62
+ Destroy();
63
+ }
64
+
65
+ #if RAPIDJSON_HAS_CXX11_RVALUE_REFS
66
+ Stack& operator=(Stack&& rhs) {
67
+ if (&rhs != this)
68
+ {
69
+ Destroy();
70
+
71
+ allocator_ = rhs.allocator_;
72
+ ownAllocator_ = rhs.ownAllocator_;
73
+ stack_ = rhs.stack_;
74
+ stackTop_ = rhs.stackTop_;
75
+ stackEnd_ = rhs.stackEnd_;
76
+ initialCapacity_ = rhs.initialCapacity_;
77
+
78
+ rhs.allocator_ = 0;
79
+ rhs.ownAllocator_ = 0;
80
+ rhs.stack_ = 0;
81
+ rhs.stackTop_ = 0;
82
+ rhs.stackEnd_ = 0;
83
+ rhs.initialCapacity_ = 0;
84
+ }
85
+ return *this;
86
+ }
87
+ #endif
88
+
89
+ void Swap(Stack& rhs) RAPIDJSON_NOEXCEPT {
90
+ internal::Swap(allocator_, rhs.allocator_);
91
+ internal::Swap(ownAllocator_, rhs.ownAllocator_);
92
+ internal::Swap(stack_, rhs.stack_);
93
+ internal::Swap(stackTop_, rhs.stackTop_);
94
+ internal::Swap(stackEnd_, rhs.stackEnd_);
95
+ internal::Swap(initialCapacity_, rhs.initialCapacity_);
96
+ }
97
+
98
+ void Clear() { stackTop_ = stack_; }
99
+
100
+ void ShrinkToFit() {
101
+ if (Empty()) {
102
+ // If the stack is empty, completely deallocate the memory.
103
+ Allocator::Free(stack_);
104
+ stack_ = 0;
105
+ stackTop_ = 0;
106
+ stackEnd_ = 0;
107
+ }
108
+ else
109
+ Resize(GetSize());
110
+ }
111
+
112
+ // Optimization note: try to minimize the size of this function for force inline.
113
+ // Expansion is run very infrequently, so it is moved to another (probably non-inline) function.
114
+ template<typename T>
115
+ RAPIDJSON_FORCEINLINE void Reserve(size_t count = 1) {
116
+ // Expand the stack if needed
117
+ if (RAPIDJSON_UNLIKELY(stackTop_ + sizeof(T) * count > stackEnd_))
118
+ Expand<T>(count);
119
+ }
120
+
121
+ template<typename T>
122
+ RAPIDJSON_FORCEINLINE T* Push(size_t count = 1) {
123
+ Reserve<T>(count);
124
+ return PushUnsafe<T>(count);
125
+ }
126
+
127
+ template<typename T>
128
+ RAPIDJSON_FORCEINLINE T* PushUnsafe(size_t count = 1) {
129
+ RAPIDJSON_ASSERT(stackTop_ + sizeof(T) * count <= stackEnd_);
130
+ T* ret = reinterpret_cast<T*>(stackTop_);
131
+ stackTop_ += sizeof(T) * count;
132
+ return ret;
133
+ }
134
+
135
+ template<typename T>
136
+ T* Pop(size_t count) {
137
+ RAPIDJSON_ASSERT(GetSize() >= count * sizeof(T));
138
+ stackTop_ -= count * sizeof(T);
139
+ return reinterpret_cast<T*>(stackTop_);
140
+ }
141
+
142
+ template<typename T>
143
+ T* Top() {
144
+ RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
145
+ return reinterpret_cast<T*>(stackTop_ - sizeof(T));
146
+ }
147
+
148
+ template<typename T>
149
+ const T* Top() const {
150
+ RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
151
+ return reinterpret_cast<T*>(stackTop_ - sizeof(T));
152
+ }
153
+
154
+ template<typename T>
155
+ T* End() { return reinterpret_cast<T*>(stackTop_); }
156
+
157
+ template<typename T>
158
+ const T* End() const { return reinterpret_cast<T*>(stackTop_); }
159
+
160
+ template<typename T>
161
+ T* Bottom() { return reinterpret_cast<T*>(stack_); }
162
+
163
+ template<typename T>
164
+ const T* Bottom() const { return reinterpret_cast<T*>(stack_); }
165
+
166
+ bool HasAllocator() const {
167
+ return allocator_ != 0;
168
+ }
169
+
170
+ Allocator& GetAllocator() {
171
+ RAPIDJSON_ASSERT(allocator_);
172
+ return *allocator_;
173
+ }
174
+
175
+ bool Empty() const { return stackTop_ == stack_; }
176
+ size_t GetSize() const { return static_cast<size_t>(stackTop_ - stack_); }
177
+ size_t GetCapacity() const { return static_cast<size_t>(stackEnd_ - stack_); }
178
+
179
+ private:
180
+ template<typename T>
181
+ void Expand(size_t count) {
182
+ // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity.
183
+ size_t newCapacity;
184
+ if (stack_ == 0) {
185
+ if (!allocator_)
186
+ ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator());
187
+ newCapacity = initialCapacity_;
188
+ } else {
189
+ newCapacity = GetCapacity();
190
+ newCapacity += (newCapacity + 1) / 2;
191
+ }
192
+ size_t newSize = GetSize() + sizeof(T) * count;
193
+ if (newCapacity < newSize)
194
+ newCapacity = newSize;
195
+
196
+ Resize(newCapacity);
197
+ }
198
+
199
+ void Resize(size_t newCapacity) {
200
+ const size_t size = GetSize(); // Backup the current size
201
+ stack_ = static_cast<char*>(allocator_->Realloc(stack_, GetCapacity(), newCapacity));
202
+ stackTop_ = stack_ + size;
203
+ stackEnd_ = stack_ + newCapacity;
204
+ }
205
+
206
+ void Destroy() {
207
+ Allocator::Free(stack_);
208
+ RAPIDJSON_DELETE(ownAllocator_); // Only delete if it is owned by the stack
209
+ }
210
+
211
+ // Prohibit copy constructor & assignment operator.
212
+ Stack(const Stack&);
213
+ Stack& operator=(const Stack&);
214
+
215
+ Allocator* allocator_;
216
+ Allocator* ownAllocator_;
217
+ char *stack_;
218
+ char *stackTop_;
219
+ char *stackEnd_;
220
+ size_t initialCapacity_;
221
+ };
222
+
223
+ } // namespace internal
224
+ RAPIDJSON_NAMESPACE_END
225
+
226
+ #if defined(__clang__)
227
+ RAPIDJSON_DIAG_POP
228
+ #endif
229
+
230
+ #endif // RAPIDJSON_STACK_H_
@@ -0,0 +1,55 @@
1
+ // Tencent is pleased to support the open source community by making RapidJSON available.
2
+ //
3
+ // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
4
+ //
5
+ // Licensed under the MIT License (the "License"); you may not use this file except
6
+ // in compliance with the License. You may obtain a copy of the License at
7
+ //
8
+ // http://opensource.org/licenses/MIT
9
+ //
10
+ // Unless required by applicable law or agreed to in writing, software distributed
11
+ // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
12
+ // CONDITIONS OF ANY KIND, either express or implied. See the License for the
13
+ // specific language governing permissions and limitations under the License.
14
+
15
+ #ifndef RAPIDJSON_INTERNAL_STRFUNC_H_
16
+ #define RAPIDJSON_INTERNAL_STRFUNC_H_
17
+
18
+ #include "../stream.h"
19
+
20
+ RAPIDJSON_NAMESPACE_BEGIN
21
+ namespace internal {
22
+
23
+ //! Custom strlen() which works on different character types.
24
+ /*! \tparam Ch Character type (e.g. char, wchar_t, short)
25
+ \param s Null-terminated input string.
26
+ \return Number of characters in the string.
27
+ \note This has the same semantics as strlen(), the return value is not number of Unicode codepoints.
28
+ */
29
+ template <typename Ch>
30
+ inline SizeType StrLen(const Ch* s) {
31
+ const Ch* p = s;
32
+ while (*p) ++p;
33
+ return SizeType(p - s);
34
+ }
35
+
36
+ //! Returns number of code points in a encoded string.
37
+ template<typename Encoding>
38
+ bool CountStringCodePoint(const typename Encoding::Ch* s, SizeType length, SizeType* outCount) {
39
+ GenericStringStream<Encoding> is(s);
40
+ const typename Encoding::Ch* end = s + length;
41
+ SizeType count = 0;
42
+ while (is.src_ < end) {
43
+ unsigned codepoint;
44
+ if (!Encoding::Decode(is, &codepoint))
45
+ return false;
46
+ count++;
47
+ }
48
+ *outCount = count;
49
+ return true;
50
+ }
51
+
52
+ } // namespace internal
53
+ RAPIDJSON_NAMESPACE_END
54
+
55
+ #endif // RAPIDJSON_INTERNAL_STRFUNC_H_
@@ -0,0 +1,269 @@
1
+ // Tencent is pleased to support the open source community by making RapidJSON available.
2
+ //
3
+ // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
4
+ //
5
+ // Licensed under the MIT License (the "License"); you may not use this file except
6
+ // in compliance with the License. You may obtain a copy of the License at
7
+ //
8
+ // http://opensource.org/licenses/MIT
9
+ //
10
+ // Unless required by applicable law or agreed to in writing, software distributed
11
+ // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
12
+ // CONDITIONS OF ANY KIND, either express or implied. See the License for the
13
+ // specific language governing permissions and limitations under the License.
14
+
15
+ #ifndef RAPIDJSON_STRTOD_
16
+ #define RAPIDJSON_STRTOD_
17
+
18
+ #include "ieee754.h"
19
+ #include "biginteger.h"
20
+ #include "diyfp.h"
21
+ #include "pow10.h"
22
+
23
+ RAPIDJSON_NAMESPACE_BEGIN
24
+ namespace internal {
25
+
26
+ inline double FastPath(double significand, int exp) {
27
+ if (exp < -308)
28
+ return 0.0;
29
+ else if (exp >= 0)
30
+ return significand * internal::Pow10(exp);
31
+ else
32
+ return significand / internal::Pow10(-exp);
33
+ }
34
+
35
+ inline double StrtodNormalPrecision(double d, int p) {
36
+ if (p < -308) {
37
+ // Prevent expSum < -308, making Pow10(p) = 0
38
+ d = FastPath(d, -308);
39
+ d = FastPath(d, p + 308);
40
+ }
41
+ else
42
+ d = FastPath(d, p);
43
+ return d;
44
+ }
45
+
46
+ template <typename T>
47
+ inline T Min3(T a, T b, T c) {
48
+ T m = a;
49
+ if (m > b) m = b;
50
+ if (m > c) m = c;
51
+ return m;
52
+ }
53
+
54
+ inline int CheckWithinHalfULP(double b, const BigInteger& d, int dExp) {
55
+ const Double db(b);
56
+ const uint64_t bInt = db.IntegerSignificand();
57
+ const int bExp = db.IntegerExponent();
58
+ const int hExp = bExp - 1;
59
+
60
+ int dS_Exp2 = 0, dS_Exp5 = 0, bS_Exp2 = 0, bS_Exp5 = 0, hS_Exp2 = 0, hS_Exp5 = 0;
61
+
62
+ // Adjust for decimal exponent
63
+ if (dExp >= 0) {
64
+ dS_Exp2 += dExp;
65
+ dS_Exp5 += dExp;
66
+ }
67
+ else {
68
+ bS_Exp2 -= dExp;
69
+ bS_Exp5 -= dExp;
70
+ hS_Exp2 -= dExp;
71
+ hS_Exp5 -= dExp;
72
+ }
73
+
74
+ // Adjust for binary exponent
75
+ if (bExp >= 0)
76
+ bS_Exp2 += bExp;
77
+ else {
78
+ dS_Exp2 -= bExp;
79
+ hS_Exp2 -= bExp;
80
+ }
81
+
82
+ // Adjust for half ulp exponent
83
+ if (hExp >= 0)
84
+ hS_Exp2 += hExp;
85
+ else {
86
+ dS_Exp2 -= hExp;
87
+ bS_Exp2 -= hExp;
88
+ }
89
+
90
+ // Remove common power of two factor from all three scaled values
91
+ int common_Exp2 = Min3(dS_Exp2, bS_Exp2, hS_Exp2);
92
+ dS_Exp2 -= common_Exp2;
93
+ bS_Exp2 -= common_Exp2;
94
+ hS_Exp2 -= common_Exp2;
95
+
96
+ BigInteger dS = d;
97
+ dS.MultiplyPow5(static_cast<unsigned>(dS_Exp5)) <<= static_cast<unsigned>(dS_Exp2);
98
+
99
+ BigInteger bS(bInt);
100
+ bS.MultiplyPow5(static_cast<unsigned>(bS_Exp5)) <<= static_cast<unsigned>(bS_Exp2);
101
+
102
+ BigInteger hS(1);
103
+ hS.MultiplyPow5(static_cast<unsigned>(hS_Exp5)) <<= static_cast<unsigned>(hS_Exp2);
104
+
105
+ BigInteger delta(0);
106
+ dS.Difference(bS, &delta);
107
+
108
+ return delta.Compare(hS);
109
+ }
110
+
111
+ inline bool StrtodFast(double d, int p, double* result) {
112
+ // Use fast path for string-to-double conversion if possible
113
+ // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion/
114
+ if (p > 22 && p < 22 + 16) {
115
+ // Fast Path Cases In Disguise
116
+ d *= internal::Pow10(p - 22);
117
+ p = 22;
118
+ }
119
+
120
+ if (p >= -22 && p <= 22 && d <= 9007199254740991.0) { // 2^53 - 1
121
+ *result = FastPath(d, p);
122
+ return true;
123
+ }
124
+ else
125
+ return false;
126
+ }
127
+
128
+ // Compute an approximation and see if it is within 1/2 ULP
129
+ inline bool StrtodDiyFp(const char* decimals, size_t length, size_t decimalPosition, int exp, double* result) {
130
+ uint64_t significand = 0;
131
+ size_t i = 0; // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999
132
+ for (; i < length; i++) {
133
+ if (significand > RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) ||
134
+ (significand == RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) && decimals[i] > '5'))
135
+ break;
136
+ significand = significand * 10u + static_cast<unsigned>(decimals[i] - '0');
137
+ }
138
+
139
+ if (i < length && decimals[i] >= '5') // Rounding
140
+ significand++;
141
+
142
+ size_t remaining = length - i;
143
+ const unsigned kUlpShift = 3;
144
+ const unsigned kUlp = 1 << kUlpShift;
145
+ int64_t error = (remaining == 0) ? 0 : kUlp / 2;
146
+
147
+ DiyFp v(significand, 0);
148
+ v = v.Normalize();
149
+ error <<= -v.e;
150
+
151
+ const int dExp = static_cast<int>(decimalPosition) - static_cast<int>(i) + exp;
152
+
153
+ int actualExp;
154
+ DiyFp cachedPower = GetCachedPower10(dExp, &actualExp);
155
+ if (actualExp != dExp) {
156
+ static const DiyFp kPow10[] = {
157
+ DiyFp(RAPIDJSON_UINT64_C2(0xa0000000, 00000000), -60), // 10^1
158
+ DiyFp(RAPIDJSON_UINT64_C2(0xc8000000, 00000000), -57), // 10^2
159
+ DiyFp(RAPIDJSON_UINT64_C2(0xfa000000, 00000000), -54), // 10^3
160
+ DiyFp(RAPIDJSON_UINT64_C2(0x9c400000, 00000000), -50), // 10^4
161
+ DiyFp(RAPIDJSON_UINT64_C2(0xc3500000, 00000000), -47), // 10^5
162
+ DiyFp(RAPIDJSON_UINT64_C2(0xf4240000, 00000000), -44), // 10^6
163
+ DiyFp(RAPIDJSON_UINT64_C2(0x98968000, 00000000), -40) // 10^7
164
+ };
165
+ int adjustment = dExp - actualExp - 1;
166
+ RAPIDJSON_ASSERT(adjustment >= 0 && adjustment < 7);
167
+ v = v * kPow10[adjustment];
168
+ if (length + static_cast<unsigned>(adjustment)> 19u) // has more digits than decimal digits in 64-bit
169
+ error += kUlp / 2;
170
+ }
171
+
172
+ v = v * cachedPower;
173
+
174
+ error += kUlp + (error == 0 ? 0 : 1);
175
+
176
+ const int oldExp = v.e;
177
+ v = v.Normalize();
178
+ error <<= oldExp - v.e;
179
+
180
+ const unsigned effectiveSignificandSize = Double::EffectiveSignificandSize(64 + v.e);
181
+ unsigned precisionSize = 64 - effectiveSignificandSize;
182
+ if (precisionSize + kUlpShift >= 64) {
183
+ unsigned scaleExp = (precisionSize + kUlpShift) - 63;
184
+ v.f >>= scaleExp;
185
+ v.e += scaleExp;
186
+ error = (error >> scaleExp) + 1 + static_cast<int>(kUlp);
187
+ precisionSize -= scaleExp;
188
+ }
189
+
190
+ DiyFp rounded(v.f >> precisionSize, v.e + static_cast<int>(precisionSize));
191
+ const uint64_t precisionBits = (v.f & ((uint64_t(1) << precisionSize) - 1)) * kUlp;
192
+ const uint64_t halfWay = (uint64_t(1) << (precisionSize - 1)) * kUlp;
193
+ if (precisionBits >= halfWay + static_cast<unsigned>(error)) {
194
+ rounded.f++;
195
+ if (rounded.f & (DiyFp::kDpHiddenBit << 1)) { // rounding overflows mantissa (issue #340)
196
+ rounded.f >>= 1;
197
+ rounded.e++;
198
+ }
199
+ }
200
+
201
+ *result = rounded.ToDouble();
202
+
203
+ return halfWay - static_cast<unsigned>(error) >= precisionBits || precisionBits >= halfWay + static_cast<unsigned>(error);
204
+ }
205
+
206
+ inline double StrtodBigInteger(double approx, const char* decimals, size_t length, size_t decimalPosition, int exp) {
207
+ const BigInteger dInt(decimals, length);
208
+ const int dExp = static_cast<int>(decimalPosition) - static_cast<int>(length) + exp;
209
+ Double a(approx);
210
+ int cmp = CheckWithinHalfULP(a.Value(), dInt, dExp);
211
+ if (cmp < 0)
212
+ return a.Value(); // within half ULP
213
+ else if (cmp == 0) {
214
+ // Round towards even
215
+ if (a.Significand() & 1)
216
+ return a.NextPositiveDouble();
217
+ else
218
+ return a.Value();
219
+ }
220
+ else // adjustment
221
+ return a.NextPositiveDouble();
222
+ }
223
+
224
+ inline double StrtodFullPrecision(double d, int p, const char* decimals, size_t length, size_t decimalPosition, int exp) {
225
+ RAPIDJSON_ASSERT(d >= 0.0);
226
+ RAPIDJSON_ASSERT(length >= 1);
227
+
228
+ double result;
229
+ if (StrtodFast(d, p, &result))
230
+ return result;
231
+
232
+ // Trim leading zeros
233
+ while (*decimals == '0' && length > 1) {
234
+ length--;
235
+ decimals++;
236
+ decimalPosition--;
237
+ }
238
+
239
+ // Trim trailing zeros
240
+ while (decimals[length - 1] == '0' && length > 1) {
241
+ length--;
242
+ decimalPosition--;
243
+ exp++;
244
+ }
245
+
246
+ // Trim right-most digits
247
+ const int kMaxDecimalDigit = 780;
248
+ if (static_cast<int>(length) > kMaxDecimalDigit) {
249
+ int delta = (static_cast<int>(length) - kMaxDecimalDigit);
250
+ exp += delta;
251
+ decimalPosition -= static_cast<unsigned>(delta);
252
+ length = kMaxDecimalDigit;
253
+ }
254
+
255
+ // If too small, underflow to zero
256
+ if (int(length) + exp < -324)
257
+ return 0.0;
258
+
259
+ if (StrtodDiyFp(decimals, length, decimalPosition, exp, &result))
260
+ return result;
261
+
262
+ // Use approximation from StrtodDiyFp and make adjustment with BigInteger comparison
263
+ return StrtodBigInteger(result, decimals, length, decimalPosition, exp);
264
+ }
265
+
266
+ } // namespace internal
267
+ RAPIDJSON_NAMESPACE_END
268
+
269
+ #endif // RAPIDJSON_STRTOD_