rapidjson 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 (53) hide show
  1. checksums.yaml +7 -0
  2. data/CODE_OF_CONDUCT.md +84 -0
  3. data/LICENSE.txt +21 -0
  4. data/README.md +110 -0
  5. data/Rakefile +20 -0
  6. data/ext/rapidjson/buffer.hh +66 -0
  7. data/ext/rapidjson/cext.cc +77 -0
  8. data/ext/rapidjson/cext.hh +20 -0
  9. data/ext/rapidjson/encoder.hh +150 -0
  10. data/ext/rapidjson/extconf.rb +19 -0
  11. data/ext/rapidjson/parser.hh +149 -0
  12. data/ext/rapidjson/rapidjson/include/rapidjson/allocators.h +692 -0
  13. data/ext/rapidjson/rapidjson/include/rapidjson/cursorstreamwrapper.h +78 -0
  14. data/ext/rapidjson/rapidjson/include/rapidjson/document.h +3027 -0
  15. data/ext/rapidjson/rapidjson/include/rapidjson/encodedstream.h +299 -0
  16. data/ext/rapidjson/rapidjson/include/rapidjson/encodings.h +716 -0
  17. data/ext/rapidjson/rapidjson/include/rapidjson/error/en.h +122 -0
  18. data/ext/rapidjson/rapidjson/include/rapidjson/error/error.h +216 -0
  19. data/ext/rapidjson/rapidjson/include/rapidjson/filereadstream.h +99 -0
  20. data/ext/rapidjson/rapidjson/include/rapidjson/filewritestream.h +104 -0
  21. data/ext/rapidjson/rapidjson/include/rapidjson/fwd.h +151 -0
  22. data/ext/rapidjson/rapidjson/include/rapidjson/internal/biginteger.h +297 -0
  23. data/ext/rapidjson/rapidjson/include/rapidjson/internal/clzll.h +71 -0
  24. data/ext/rapidjson/rapidjson/include/rapidjson/internal/diyfp.h +261 -0
  25. data/ext/rapidjson/rapidjson/include/rapidjson/internal/dtoa.h +249 -0
  26. data/ext/rapidjson/rapidjson/include/rapidjson/internal/ieee754.h +78 -0
  27. data/ext/rapidjson/rapidjson/include/rapidjson/internal/itoa.h +308 -0
  28. data/ext/rapidjson/rapidjson/include/rapidjson/internal/meta.h +186 -0
  29. data/ext/rapidjson/rapidjson/include/rapidjson/internal/pow10.h +55 -0
  30. data/ext/rapidjson/rapidjson/include/rapidjson/internal/regex.h +739 -0
  31. data/ext/rapidjson/rapidjson/include/rapidjson/internal/stack.h +232 -0
  32. data/ext/rapidjson/rapidjson/include/rapidjson/internal/strfunc.h +83 -0
  33. data/ext/rapidjson/rapidjson/include/rapidjson/internal/strtod.h +293 -0
  34. data/ext/rapidjson/rapidjson/include/rapidjson/internal/swap.h +46 -0
  35. data/ext/rapidjson/rapidjson/include/rapidjson/istreamwrapper.h +128 -0
  36. data/ext/rapidjson/rapidjson/include/rapidjson/memorybuffer.h +70 -0
  37. data/ext/rapidjson/rapidjson/include/rapidjson/memorystream.h +71 -0
  38. data/ext/rapidjson/rapidjson/include/rapidjson/msinttypes/inttypes.h +316 -0
  39. data/ext/rapidjson/rapidjson/include/rapidjson/msinttypes/stdint.h +300 -0
  40. data/ext/rapidjson/rapidjson/include/rapidjson/ostreamwrapper.h +81 -0
  41. data/ext/rapidjson/rapidjson/include/rapidjson/pointer.h +1482 -0
  42. data/ext/rapidjson/rapidjson/include/rapidjson/prettywriter.h +277 -0
  43. data/ext/rapidjson/rapidjson/include/rapidjson/rapidjson.h +741 -0
  44. data/ext/rapidjson/rapidjson/include/rapidjson/reader.h +2246 -0
  45. data/ext/rapidjson/rapidjson/include/rapidjson/schema.h +2795 -0
  46. data/ext/rapidjson/rapidjson/include/rapidjson/stream.h +223 -0
  47. data/ext/rapidjson/rapidjson/include/rapidjson/stringbuffer.h +121 -0
  48. data/ext/rapidjson/rapidjson/include/rapidjson/uri.h +481 -0
  49. data/ext/rapidjson/rapidjson/include/rapidjson/writer.h +710 -0
  50. data/lib/rapidjson/json_gem.rb +36 -0
  51. data/lib/rapidjson/version.rb +5 -0
  52. data/lib/rapidjson.rb +9 -0
  53. metadata +98 -0
@@ -0,0 +1,232 @@
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.
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
+ #include <cstddef>
21
+
22
+ #if defined(__clang__)
23
+ RAPIDJSON_DIAG_PUSH
24
+ RAPIDJSON_DIAG_OFF(c++98-compat)
25
+ #endif
26
+
27
+ RAPIDJSON_NAMESPACE_BEGIN
28
+ namespace internal {
29
+
30
+ ///////////////////////////////////////////////////////////////////////////////
31
+ // Stack
32
+
33
+ //! A type-unsafe stack for storing different types of data.
34
+ /*! \tparam Allocator Allocator for allocating stack memory.
35
+ */
36
+ template <typename Allocator>
37
+ class Stack {
38
+ public:
39
+ // Optimization note: Do not allocate memory for stack_ in constructor.
40
+ // Do it lazily when first Push() -> Expand() -> Resize().
41
+ Stack(Allocator* allocator, size_t stackCapacity) : allocator_(allocator), ownAllocator_(0), stack_(0), stackTop_(0), stackEnd_(0), initialCapacity_(stackCapacity) {
42
+ }
43
+
44
+ #if RAPIDJSON_HAS_CXX11_RVALUE_REFS
45
+ Stack(Stack&& rhs)
46
+ : allocator_(rhs.allocator_),
47
+ ownAllocator_(rhs.ownAllocator_),
48
+ stack_(rhs.stack_),
49
+ stackTop_(rhs.stackTop_),
50
+ stackEnd_(rhs.stackEnd_),
51
+ initialCapacity_(rhs.initialCapacity_)
52
+ {
53
+ rhs.allocator_ = 0;
54
+ rhs.ownAllocator_ = 0;
55
+ rhs.stack_ = 0;
56
+ rhs.stackTop_ = 0;
57
+ rhs.stackEnd_ = 0;
58
+ rhs.initialCapacity_ = 0;
59
+ }
60
+ #endif
61
+
62
+ ~Stack() {
63
+ Destroy();
64
+ }
65
+
66
+ #if RAPIDJSON_HAS_CXX11_RVALUE_REFS
67
+ Stack& operator=(Stack&& rhs) {
68
+ if (&rhs != this)
69
+ {
70
+ Destroy();
71
+
72
+ allocator_ = rhs.allocator_;
73
+ ownAllocator_ = rhs.ownAllocator_;
74
+ stack_ = rhs.stack_;
75
+ stackTop_ = rhs.stackTop_;
76
+ stackEnd_ = rhs.stackEnd_;
77
+ initialCapacity_ = rhs.initialCapacity_;
78
+
79
+ rhs.allocator_ = 0;
80
+ rhs.ownAllocator_ = 0;
81
+ rhs.stack_ = 0;
82
+ rhs.stackTop_ = 0;
83
+ rhs.stackEnd_ = 0;
84
+ rhs.initialCapacity_ = 0;
85
+ }
86
+ return *this;
87
+ }
88
+ #endif
89
+
90
+ void Swap(Stack& rhs) RAPIDJSON_NOEXCEPT {
91
+ internal::Swap(allocator_, rhs.allocator_);
92
+ internal::Swap(ownAllocator_, rhs.ownAllocator_);
93
+ internal::Swap(stack_, rhs.stack_);
94
+ internal::Swap(stackTop_, rhs.stackTop_);
95
+ internal::Swap(stackEnd_, rhs.stackEnd_);
96
+ internal::Swap(initialCapacity_, rhs.initialCapacity_);
97
+ }
98
+
99
+ void Clear() { stackTop_ = stack_; }
100
+
101
+ void ShrinkToFit() {
102
+ if (Empty()) {
103
+ // If the stack is empty, completely deallocate the memory.
104
+ Allocator::Free(stack_); // NOLINT (+clang-analyzer-unix.Malloc)
105
+ stack_ = 0;
106
+ stackTop_ = 0;
107
+ stackEnd_ = 0;
108
+ }
109
+ else
110
+ Resize(GetSize());
111
+ }
112
+
113
+ // Optimization note: try to minimize the size of this function for force inline.
114
+ // Expansion is run very infrequently, so it is moved to another (probably non-inline) function.
115
+ template<typename T>
116
+ RAPIDJSON_FORCEINLINE void Reserve(size_t count = 1) {
117
+ // Expand the stack if needed
118
+ if (RAPIDJSON_UNLIKELY(static_cast<std::ptrdiff_t>(sizeof(T) * count) > (stackEnd_ - stackTop_)))
119
+ Expand<T>(count);
120
+ }
121
+
122
+ template<typename T>
123
+ RAPIDJSON_FORCEINLINE T* Push(size_t count = 1) {
124
+ Reserve<T>(count);
125
+ return PushUnsafe<T>(count);
126
+ }
127
+
128
+ template<typename T>
129
+ RAPIDJSON_FORCEINLINE T* PushUnsafe(size_t count = 1) {
130
+ RAPIDJSON_ASSERT(stackTop_);
131
+ RAPIDJSON_ASSERT(static_cast<std::ptrdiff_t>(sizeof(T) * count) <= (stackEnd_ - stackTop_));
132
+ T* ret = reinterpret_cast<T*>(stackTop_);
133
+ stackTop_ += sizeof(T) * count;
134
+ return ret;
135
+ }
136
+
137
+ template<typename T>
138
+ T* Pop(size_t count) {
139
+ RAPIDJSON_ASSERT(GetSize() >= count * sizeof(T));
140
+ stackTop_ -= count * sizeof(T);
141
+ return reinterpret_cast<T*>(stackTop_);
142
+ }
143
+
144
+ template<typename T>
145
+ T* Top() {
146
+ RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
147
+ return reinterpret_cast<T*>(stackTop_ - sizeof(T));
148
+ }
149
+
150
+ template<typename T>
151
+ const T* Top() const {
152
+ RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
153
+ return reinterpret_cast<T*>(stackTop_ - sizeof(T));
154
+ }
155
+
156
+ template<typename T>
157
+ T* End() { return reinterpret_cast<T*>(stackTop_); }
158
+
159
+ template<typename T>
160
+ const T* End() const { return reinterpret_cast<T*>(stackTop_); }
161
+
162
+ template<typename T>
163
+ T* Bottom() { return reinterpret_cast<T*>(stack_); }
164
+
165
+ template<typename T>
166
+ const T* Bottom() const { return reinterpret_cast<T*>(stack_); }
167
+
168
+ bool HasAllocator() const {
169
+ return allocator_ != 0;
170
+ }
171
+
172
+ Allocator& GetAllocator() {
173
+ RAPIDJSON_ASSERT(allocator_);
174
+ return *allocator_;
175
+ }
176
+
177
+ bool Empty() const { return stackTop_ == stack_; }
178
+ size_t GetSize() const { return static_cast<size_t>(stackTop_ - stack_); }
179
+ size_t GetCapacity() const { return static_cast<size_t>(stackEnd_ - stack_); }
180
+
181
+ private:
182
+ template<typename T>
183
+ void Expand(size_t count) {
184
+ // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity.
185
+ size_t newCapacity;
186
+ if (stack_ == 0) {
187
+ if (!allocator_)
188
+ ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
189
+ newCapacity = initialCapacity_;
190
+ } else {
191
+ newCapacity = GetCapacity();
192
+ newCapacity += (newCapacity + 1) / 2;
193
+ }
194
+ size_t newSize = GetSize() + sizeof(T) * count;
195
+ if (newCapacity < newSize)
196
+ newCapacity = newSize;
197
+
198
+ Resize(newCapacity);
199
+ }
200
+
201
+ void Resize(size_t newCapacity) {
202
+ const size_t size = GetSize(); // Backup the current size
203
+ stack_ = static_cast<char*>(allocator_->Realloc(stack_, GetCapacity(), newCapacity));
204
+ stackTop_ = stack_ + size;
205
+ stackEnd_ = stack_ + newCapacity;
206
+ }
207
+
208
+ void Destroy() {
209
+ Allocator::Free(stack_);
210
+ RAPIDJSON_DELETE(ownAllocator_); // Only delete if it is owned by the stack
211
+ }
212
+
213
+ // Prohibit copy constructor & assignment operator.
214
+ Stack(const Stack&);
215
+ Stack& operator=(const Stack&);
216
+
217
+ Allocator* allocator_;
218
+ Allocator* ownAllocator_;
219
+ char *stack_;
220
+ char *stackTop_;
221
+ char *stackEnd_;
222
+ size_t initialCapacity_;
223
+ };
224
+
225
+ } // namespace internal
226
+ RAPIDJSON_NAMESPACE_END
227
+
228
+ #if defined(__clang__)
229
+ RAPIDJSON_DIAG_POP
230
+ #endif
231
+
232
+ #endif // RAPIDJSON_STACK_H_
@@ -0,0 +1,83 @@
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.
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
+ #include <cwchar>
20
+
21
+ RAPIDJSON_NAMESPACE_BEGIN
22
+ namespace internal {
23
+
24
+ //! Custom strlen() which works on different character types.
25
+ /*! \tparam Ch Character type (e.g. char, wchar_t, short)
26
+ \param s Null-terminated input string.
27
+ \return Number of characters in the string.
28
+ \note This has the same semantics as strlen(), the return value is not number of Unicode codepoints.
29
+ */
30
+ template <typename Ch>
31
+ inline SizeType StrLen(const Ch* s) {
32
+ RAPIDJSON_ASSERT(s != 0);
33
+ const Ch* p = s;
34
+ while (*p) ++p;
35
+ return SizeType(p - s);
36
+ }
37
+
38
+ template <>
39
+ inline SizeType StrLen(const char* s) {
40
+ return SizeType(std::strlen(s));
41
+ }
42
+
43
+ template <>
44
+ inline SizeType StrLen(const wchar_t* s) {
45
+ return SizeType(std::wcslen(s));
46
+ }
47
+
48
+ //! Custom strcmpn() which works on different character types.
49
+ /*! \tparam Ch Character type (e.g. char, wchar_t, short)
50
+ \param s1 Null-terminated input string.
51
+ \param s2 Null-terminated input string.
52
+ \return 0 if equal
53
+ */
54
+ template<typename Ch>
55
+ inline int StrCmp(const Ch* s1, const Ch* s2) {
56
+ RAPIDJSON_ASSERT(s1 != 0);
57
+ RAPIDJSON_ASSERT(s2 != 0);
58
+ while(*s1 && (*s1 == *s2)) { s1++; s2++; }
59
+ return static_cast<unsigned>(*s1) < static_cast<unsigned>(*s2) ? -1 : static_cast<unsigned>(*s1) > static_cast<unsigned>(*s2);
60
+ }
61
+
62
+ //! Returns number of code points in a encoded string.
63
+ template<typename Encoding>
64
+ bool CountStringCodePoint(const typename Encoding::Ch* s, SizeType length, SizeType* outCount) {
65
+ RAPIDJSON_ASSERT(s != 0);
66
+ RAPIDJSON_ASSERT(outCount != 0);
67
+ GenericStringStream<Encoding> is(s);
68
+ const typename Encoding::Ch* end = s + length;
69
+ SizeType count = 0;
70
+ while (is.src_ < end) {
71
+ unsigned codepoint;
72
+ if (!Encoding::Decode(is, &codepoint))
73
+ return false;
74
+ count++;
75
+ }
76
+ *outCount = count;
77
+ return true;
78
+ }
79
+
80
+ } // namespace internal
81
+ RAPIDJSON_NAMESPACE_END
82
+
83
+ #endif // RAPIDJSON_INTERNAL_STRFUNC_H_
@@ -0,0 +1,293 @@
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.
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
+ #include <climits>
23
+ #include <limits>
24
+
25
+ RAPIDJSON_NAMESPACE_BEGIN
26
+ namespace internal {
27
+
28
+ inline double FastPath(double significand, int exp) {
29
+ if (exp < -308)
30
+ return 0.0;
31
+ else if (exp >= 0)
32
+ return significand * internal::Pow10(exp);
33
+ else
34
+ return significand / internal::Pow10(-exp);
35
+ }
36
+
37
+ inline double StrtodNormalPrecision(double d, int p) {
38
+ if (p < -308) {
39
+ // Prevent expSum < -308, making Pow10(p) = 0
40
+ d = FastPath(d, -308);
41
+ d = FastPath(d, p + 308);
42
+ }
43
+ else
44
+ d = FastPath(d, p);
45
+ return d;
46
+ }
47
+
48
+ template <typename T>
49
+ inline T Min3(T a, T b, T c) {
50
+ T m = a;
51
+ if (m > b) m = b;
52
+ if (m > c) m = c;
53
+ return m;
54
+ }
55
+
56
+ inline int CheckWithinHalfULP(double b, const BigInteger& d, int dExp) {
57
+ const Double db(b);
58
+ const uint64_t bInt = db.IntegerSignificand();
59
+ const int bExp = db.IntegerExponent();
60
+ const int hExp = bExp - 1;
61
+
62
+ int dS_Exp2 = 0, dS_Exp5 = 0, bS_Exp2 = 0, bS_Exp5 = 0, hS_Exp2 = 0, hS_Exp5 = 0;
63
+
64
+ // Adjust for decimal exponent
65
+ if (dExp >= 0) {
66
+ dS_Exp2 += dExp;
67
+ dS_Exp5 += dExp;
68
+ }
69
+ else {
70
+ bS_Exp2 -= dExp;
71
+ bS_Exp5 -= dExp;
72
+ hS_Exp2 -= dExp;
73
+ hS_Exp5 -= dExp;
74
+ }
75
+
76
+ // Adjust for binary exponent
77
+ if (bExp >= 0)
78
+ bS_Exp2 += bExp;
79
+ else {
80
+ dS_Exp2 -= bExp;
81
+ hS_Exp2 -= bExp;
82
+ }
83
+
84
+ // Adjust for half ulp exponent
85
+ if (hExp >= 0)
86
+ hS_Exp2 += hExp;
87
+ else {
88
+ dS_Exp2 -= hExp;
89
+ bS_Exp2 -= hExp;
90
+ }
91
+
92
+ // Remove common power of two factor from all three scaled values
93
+ int common_Exp2 = Min3(dS_Exp2, bS_Exp2, hS_Exp2);
94
+ dS_Exp2 -= common_Exp2;
95
+ bS_Exp2 -= common_Exp2;
96
+ hS_Exp2 -= common_Exp2;
97
+
98
+ BigInteger dS = d;
99
+ dS.MultiplyPow5(static_cast<unsigned>(dS_Exp5)) <<= static_cast<unsigned>(dS_Exp2);
100
+
101
+ BigInteger bS(bInt);
102
+ bS.MultiplyPow5(static_cast<unsigned>(bS_Exp5)) <<= static_cast<unsigned>(bS_Exp2);
103
+
104
+ BigInteger hS(1);
105
+ hS.MultiplyPow5(static_cast<unsigned>(hS_Exp5)) <<= static_cast<unsigned>(hS_Exp2);
106
+
107
+ BigInteger delta(0);
108
+ dS.Difference(bS, &delta);
109
+
110
+ return delta.Compare(hS);
111
+ }
112
+
113
+ inline bool StrtodFast(double d, int p, double* result) {
114
+ // Use fast path for string-to-double conversion if possible
115
+ // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion/
116
+ if (p > 22 && p < 22 + 16) {
117
+ // Fast Path Cases In Disguise
118
+ d *= internal::Pow10(p - 22);
119
+ p = 22;
120
+ }
121
+
122
+ if (p >= -22 && p <= 22 && d <= 9007199254740991.0) { // 2^53 - 1
123
+ *result = FastPath(d, p);
124
+ return true;
125
+ }
126
+ else
127
+ return false;
128
+ }
129
+
130
+ // Compute an approximation and see if it is within 1/2 ULP
131
+ template<typename Ch>
132
+ inline bool StrtodDiyFp(const Ch* decimals, int dLen, int dExp, double* result) {
133
+ uint64_t significand = 0;
134
+ int i = 0; // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999
135
+ for (; i < dLen; i++) {
136
+ if (significand > RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) ||
137
+ (significand == RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) && decimals[i] > Ch('5')))
138
+ break;
139
+ significand = significand * 10u + static_cast<unsigned>(decimals[i] - Ch('0'));
140
+ }
141
+
142
+ if (i < dLen && decimals[i] >= Ch('5')) // Rounding
143
+ significand++;
144
+
145
+ int remaining = dLen - i;
146
+ const int kUlpShift = 3;
147
+ const int kUlp = 1 << kUlpShift;
148
+ int64_t error = (remaining == 0) ? 0 : kUlp / 2;
149
+
150
+ DiyFp v(significand, 0);
151
+ v = v.Normalize();
152
+ error <<= -v.e;
153
+
154
+ dExp += remaining;
155
+
156
+ int actualExp;
157
+ DiyFp cachedPower = GetCachedPower10(dExp, &actualExp);
158
+ if (actualExp != dExp) {
159
+ static const DiyFp kPow10[] = {
160
+ DiyFp(RAPIDJSON_UINT64_C2(0xa0000000, 0x00000000), -60), // 10^1
161
+ DiyFp(RAPIDJSON_UINT64_C2(0xc8000000, 0x00000000), -57), // 10^2
162
+ DiyFp(RAPIDJSON_UINT64_C2(0xfa000000, 0x00000000), -54), // 10^3
163
+ DiyFp(RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), -50), // 10^4
164
+ DiyFp(RAPIDJSON_UINT64_C2(0xc3500000, 0x00000000), -47), // 10^5
165
+ DiyFp(RAPIDJSON_UINT64_C2(0xf4240000, 0x00000000), -44), // 10^6
166
+ DiyFp(RAPIDJSON_UINT64_C2(0x98968000, 0x00000000), -40) // 10^7
167
+ };
168
+ int adjustment = dExp - actualExp;
169
+ RAPIDJSON_ASSERT(adjustment >= 1 && adjustment < 8);
170
+ v = v * kPow10[adjustment - 1];
171
+ if (dLen + adjustment > 19) // has more digits than decimal digits in 64-bit
172
+ error += kUlp / 2;
173
+ }
174
+
175
+ v = v * cachedPower;
176
+
177
+ error += kUlp + (error == 0 ? 0 : 1);
178
+
179
+ const int oldExp = v.e;
180
+ v = v.Normalize();
181
+ error <<= oldExp - v.e;
182
+
183
+ const int effectiveSignificandSize = Double::EffectiveSignificandSize(64 + v.e);
184
+ int precisionSize = 64 - effectiveSignificandSize;
185
+ if (precisionSize + kUlpShift >= 64) {
186
+ int scaleExp = (precisionSize + kUlpShift) - 63;
187
+ v.f >>= scaleExp;
188
+ v.e += scaleExp;
189
+ error = (error >> scaleExp) + 1 + kUlp;
190
+ precisionSize -= scaleExp;
191
+ }
192
+
193
+ DiyFp rounded(v.f >> precisionSize, v.e + precisionSize);
194
+ const uint64_t precisionBits = (v.f & ((uint64_t(1) << precisionSize) - 1)) * kUlp;
195
+ const uint64_t halfWay = (uint64_t(1) << (precisionSize - 1)) * kUlp;
196
+ if (precisionBits >= halfWay + static_cast<unsigned>(error)) {
197
+ rounded.f++;
198
+ if (rounded.f & (DiyFp::kDpHiddenBit << 1)) { // rounding overflows mantissa (issue #340)
199
+ rounded.f >>= 1;
200
+ rounded.e++;
201
+ }
202
+ }
203
+
204
+ *result = rounded.ToDouble();
205
+
206
+ return halfWay - static_cast<unsigned>(error) >= precisionBits || precisionBits >= halfWay + static_cast<unsigned>(error);
207
+ }
208
+
209
+ template<typename Ch>
210
+ inline double StrtodBigInteger(double approx, const Ch* decimals, int dLen, int dExp) {
211
+ RAPIDJSON_ASSERT(dLen >= 0);
212
+ const BigInteger dInt(decimals, static_cast<unsigned>(dLen));
213
+ Double a(approx);
214
+ int cmp = CheckWithinHalfULP(a.Value(), dInt, dExp);
215
+ if (cmp < 0)
216
+ return a.Value(); // within half ULP
217
+ else if (cmp == 0) {
218
+ // Round towards even
219
+ if (a.Significand() & 1)
220
+ return a.NextPositiveDouble();
221
+ else
222
+ return a.Value();
223
+ }
224
+ else // adjustment
225
+ return a.NextPositiveDouble();
226
+ }
227
+
228
+ template<typename Ch>
229
+ inline double StrtodFullPrecision(double d, int p, const Ch* decimals, size_t length, size_t decimalPosition, int exp) {
230
+ RAPIDJSON_ASSERT(d >= 0.0);
231
+ RAPIDJSON_ASSERT(length >= 1);
232
+
233
+ double result = 0.0;
234
+ if (StrtodFast(d, p, &result))
235
+ return result;
236
+
237
+ RAPIDJSON_ASSERT(length <= INT_MAX);
238
+ int dLen = static_cast<int>(length);
239
+
240
+ RAPIDJSON_ASSERT(length >= decimalPosition);
241
+ RAPIDJSON_ASSERT(length - decimalPosition <= INT_MAX);
242
+ int dExpAdjust = static_cast<int>(length - decimalPosition);
243
+
244
+ RAPIDJSON_ASSERT(exp >= INT_MIN + dExpAdjust);
245
+ int dExp = exp - dExpAdjust;
246
+
247
+ // Make sure length+dExp does not overflow
248
+ RAPIDJSON_ASSERT(dExp <= INT_MAX - dLen);
249
+
250
+ // Trim leading zeros
251
+ while (dLen > 0 && *decimals == '0') {
252
+ dLen--;
253
+ decimals++;
254
+ }
255
+
256
+ // Trim trailing zeros
257
+ while (dLen > 0 && decimals[dLen - 1] == '0') {
258
+ dLen--;
259
+ dExp++;
260
+ }
261
+
262
+ if (dLen == 0) { // Buffer only contains zeros.
263
+ return 0.0;
264
+ }
265
+
266
+ // Trim right-most digits
267
+ const int kMaxDecimalDigit = 767 + 1;
268
+ if (dLen > kMaxDecimalDigit) {
269
+ dExp += dLen - kMaxDecimalDigit;
270
+ dLen = kMaxDecimalDigit;
271
+ }
272
+
273
+ // If too small, underflow to zero.
274
+ // Any x <= 10^-324 is interpreted as zero.
275
+ if (dLen + dExp <= -324)
276
+ return 0.0;
277
+
278
+ // If too large, overflow to infinity.
279
+ // Any x >= 10^309 is interpreted as +infinity.
280
+ if (dLen + dExp > 309)
281
+ return std::numeric_limits<double>::infinity();
282
+
283
+ if (StrtodDiyFp(decimals, dLen, dExp, &result))
284
+ return result;
285
+
286
+ // Use approximation from StrtodDiyFp and make adjustment with BigInteger comparison
287
+ return StrtodBigInteger(result, decimals, dLen, dExp);
288
+ }
289
+
290
+ } // namespace internal
291
+ RAPIDJSON_NAMESPACE_END
292
+
293
+ #endif // RAPIDJSON_STRTOD_
@@ -0,0 +1,46 @@
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.
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_SWAP_H_
16
+ #define RAPIDJSON_INTERNAL_SWAP_H_
17
+
18
+ #include "../rapidjson.h"
19
+
20
+ #if defined(__clang__)
21
+ RAPIDJSON_DIAG_PUSH
22
+ RAPIDJSON_DIAG_OFF(c++98-compat)
23
+ #endif
24
+
25
+ RAPIDJSON_NAMESPACE_BEGIN
26
+ namespace internal {
27
+
28
+ //! Custom swap() to avoid dependency on C++ <algorithm> header
29
+ /*! \tparam T Type of the arguments to swap, should be instantiated with primitive C++ types only.
30
+ \note This has the same semantics as std::swap().
31
+ */
32
+ template <typename T>
33
+ inline void Swap(T& a, T& b) RAPIDJSON_NOEXCEPT {
34
+ T tmp = a;
35
+ a = b;
36
+ b = tmp;
37
+ }
38
+
39
+ } // namespace internal
40
+ RAPIDJSON_NAMESPACE_END
41
+
42
+ #if defined(__clang__)
43
+ RAPIDJSON_DIAG_POP
44
+ #endif
45
+
46
+ #endif // RAPIDJSON_INTERNAL_SWAP_H_