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.
- checksums.yaml +7 -0
- data/CODE_OF_CONDUCT.md +84 -0
- data/LICENSE.txt +21 -0
- data/README.md +110 -0
- data/Rakefile +20 -0
- data/ext/rapidjson/buffer.hh +66 -0
- data/ext/rapidjson/cext.cc +77 -0
- data/ext/rapidjson/cext.hh +20 -0
- data/ext/rapidjson/encoder.hh +150 -0
- data/ext/rapidjson/extconf.rb +19 -0
- data/ext/rapidjson/parser.hh +149 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/allocators.h +692 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/cursorstreamwrapper.h +78 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/document.h +3027 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/encodedstream.h +299 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/encodings.h +716 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/error/en.h +122 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/error/error.h +216 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/filereadstream.h +99 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/filewritestream.h +104 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/fwd.h +151 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/internal/biginteger.h +297 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/internal/clzll.h +71 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/internal/diyfp.h +261 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/internal/dtoa.h +249 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/internal/ieee754.h +78 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/internal/itoa.h +308 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/internal/meta.h +186 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/internal/pow10.h +55 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/internal/regex.h +739 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/internal/stack.h +232 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/internal/strfunc.h +83 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/internal/strtod.h +293 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/internal/swap.h +46 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/istreamwrapper.h +128 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/memorybuffer.h +70 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/memorystream.h +71 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/msinttypes/inttypes.h +316 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/msinttypes/stdint.h +300 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/ostreamwrapper.h +81 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/pointer.h +1482 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/prettywriter.h +277 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/rapidjson.h +741 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/reader.h +2246 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/schema.h +2795 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/stream.h +223 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/stringbuffer.h +121 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/uri.h +481 -0
- data/ext/rapidjson/rapidjson/include/rapidjson/writer.h +710 -0
- data/lib/rapidjson/json_gem.rb +36 -0
- data/lib/rapidjson/version.rb +5 -0
- data/lib/rapidjson.rb +9 -0
- 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_
|