RapidJSON: include/rapidjson/reader.h 源文件

reader.h
浏览该文件的文档.
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_READER_H_
16 #define RAPIDJSON_READER_H_
17
18 /*! \file reader.h */
19
20 #include "allocators.h"
21 #include "stream.h"
22 #include "encodedstream.h"
23 #include "internal/clzll.h"
24 #include "internal/meta.h"
25 #include "internal/stack.h"
26 #include "internal/strtod.h"
27 #include <limits>
28
29 #if defined(RAPIDJSON_SIMD) && defined(_MSC_VER)
30 #include <intrin.h>
31 #pragma intrinsic(_BitScanForward)
32 #endif
33 #ifdef RAPIDJSON_SSE42
34 #include <nmmintrin.h>
35 #elif defined(RAPIDJSON_SSE2)
36 #include <emmintrin.h>
37 #elif defined(RAPIDJSON_NEON)
38 #include <arm_neon.h>
39 #endif
40
41 #ifdef __clang__
42 RAPIDJSON_DIAG_PUSH
43 RAPIDJSON_DIAG_OFF(old-style-cast)
44 RAPIDJSON_DIAG_OFF(padded)
45 RAPIDJSON_DIAG_OFF(switch-enum)
46 #elif defined(_MSC_VER)
47 RAPIDJSON_DIAG_PUSH
48 RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
49 RAPIDJSON_DIAG_OFF(4702) // unreachable code
50 #endif
51
52 #ifdef __GNUC__
53 RAPIDJSON_DIAG_PUSH
54 RAPIDJSON_DIAG_OFF(effc++)
55 #endif
56
57 //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
58 #define RAPIDJSON_NOTHING /* deliberately empty */
59 #ifndef RAPIDJSON_PARSE_ERROR_EARLY_RETURN
60 #define RAPIDJSON_PARSE_ERROR_EARLY_RETURN(value) \
61 RAPIDJSON_MULTILINEMACRO_BEGIN \
62 if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
63 RAPIDJSON_MULTILINEMACRO_END
64 #endif
65 #define RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID \
66 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
67 //!@endcond
68
69 /*! \def RAPIDJSON_PARSE_ERROR_NORETURN
70 \ingroup RAPIDJSON_ERRORS
71 \brief Macro to indicate a parse error.
72 \param parseErrorCode \ref rapidjson::ParseErrorCode of the error
73 \param offset position of the error in JSON input (\c size_t)
74
75 This macros can be used as a customization point for the internal
76 error handling mechanism of RapidJSON.
77
78 A common usage model is to throw an exception instead of requiring the
79 caller to explicitly check the \ref rapidjson::GenericReader::Parse's
80 return value:
81
82 \code
83 #define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode,offset) \
84 throw ParseException(parseErrorCode, #parseErrorCode, offset)
85
86 #include <stdexcept> // std::runtime_error
87 #include "rapidjson/error/error.h" // rapidjson::ParseResult
88
89 struct ParseException : std::runtime_error, rapidjson::ParseResult {
90 ParseException(rapidjson::ParseErrorCode code, const char* msg, size_t offset)
91 : std::runtime_error(msg), ParseResult(code, offset) {}
92 };
93
94 #include "rapidjson/reader.h"
95 \endcode
96
97 \see RAPIDJSON_PARSE_ERROR, rapidjson::GenericReader::Parse
98 */
99 #ifndef RAPIDJSON_PARSE_ERROR_NORETURN
100 #define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset) \
101 RAPIDJSON_MULTILINEMACRO_BEGIN \
102 RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
103 SetParseError(parseErrorCode, offset); \
104 RAPIDJSON_MULTILINEMACRO_END
105 #endif
106
107 /*! \def RAPIDJSON_PARSE_ERROR
108 \ingroup RAPIDJSON_ERRORS
109 \brief (Internal) macro to indicate and handle a parse error.
110 \param parseErrorCode \ref rapidjson::ParseErrorCode of the error
111 \param offset position of the error in JSON input (\c size_t)
112
113 Invokes RAPIDJSON_PARSE_ERROR_NORETURN and stops the parsing.
114
115 \see RAPIDJSON_PARSE_ERROR_NORETURN
116 \hideinitializer
117 */
118 #ifndef RAPIDJSON_PARSE_ERROR
119 #define RAPIDJSON_PARSE_ERROR(parseErrorCode, offset) \
120 RAPIDJSON_MULTILINEMACRO_BEGIN \
121 RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
122 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
123 RAPIDJSON_MULTILINEMACRO_END
124 #endif
125
126 #include "error/error.h" // ParseErrorCode, ParseResult
127
128 RAPIDJSON_NAMESPACE_BEGIN
129
130 ///////////////////////////////////////////////////////////////////////////////
131 // ParseFlag
132
133 /*! \def RAPIDJSON_PARSE_DEFAULT_FLAGS
134 \ingroup RAPIDJSON_CONFIG
135 \brief User-defined kParseDefaultFlags definition.
136
137 User can define this as any \c ParseFlag combinations.
138 */
139 #ifndef RAPIDJSON_PARSE_DEFAULT_FLAGS
140 #define RAPIDJSON_PARSE_DEFAULT_FLAGS kParseNoFlags
141 #endif
142
143 //! Combination of parseFlags
144 /*! \see Reader::Parse, Document::Parse, Document::ParseInsitu, Document::ParseStream
145 */
146 enum ParseFlag {
147 kParseNoFlags = 0, //!< No flags are set.
148 kParseInsituFlag = 1, //!< In-situ(destructive) parsing.
149 kParseValidateEncodingFlag = 2, //!< Validate encoding of JSON strings.
150 kParseIterativeFlag = 4, //!< Iterative(constant complexity in terms of function call stack size) parsing.
151 kParseStopWhenDoneFlag = 8, //!< After parsing a complete JSON root from stream, stop further processing the rest of stream. When this flag is used, parser will not generate kParseErrorDocumentRootNotSingular error.
152 kParseFullPrecisionFlag = 16, //!< Parse number in full precision (but slower).
153 kParseCommentsFlag = 32, //!< Allow one-line (//) and multi-line (/**/) comments.
154 kParseNumbersAsStringsFlag = 64, //!< Parse all numbers (ints/doubles) as strings.
155 kParseTrailingCommasFlag = 128, //!< Allow trailing commas at the end of objects and arrays.
156 kParseNanAndInfFlag = 256, //!< Allow parsing NaN, Inf, Infinity, -Inf and -Infinity as doubles.
157 kParseEscapedApostropheFlag = 512, //!< Allow escaped apostrophe in strings.
158 kParseDefaultFlags = RAPIDJSON_PARSE_DEFAULT_FLAGS //!< Default parse flags. Can be customized by defining RAPIDJSON_PARSE_DEFAULT_FLAGS
159 };
160
161 ///////////////////////////////////////////////////////////////////////////////
162 // Handler
163
164 /*! \class rapidjson::Handler
165 \brief Concept for receiving events from GenericReader upon parsing.
166 The functions return true if no error occurs. If they return false,
167 the event publisher should terminate the process.
168 \code
169 concept Handler {
170 typename Ch;
171
172 bool Null();
173 bool Bool(bool b);
174 bool Int(int i);
175 bool Uint(unsigned i);
176 bool Int64(int64_t i);
177 bool Uint64(uint64_t i);
178 bool Double(double d);
179 /// enabled via kParseNumbersAsStringsFlag, string is not null-terminated (use length)
180 bool RawNumber(const Ch* str, SizeType length, bool copy);
181 bool String(const Ch* str, SizeType length, bool copy);
182 bool StartObject();
183 bool Key(const Ch* str, SizeType length, bool copy);
184 bool EndObject(SizeType memberCount);
185 bool StartArray();
186 bool EndArray(SizeType elementCount);
187 };
188 \endcode
189 */
190 ///////////////////////////////////////////////////////////////////////////////
191 // BaseReaderHandler
192
193 //! Default implementation of Handler.
194 /*! This can be used as base class of any reader handler.
195 \note implements Handler concept
196 */
197 template<typename Encoding = UTF8<>, typename Derived = void>
198 struct BaseReaderHandler {
199 typedef typename Encoding::Ch Ch;
200
201 typedef typename internal::SelectIf<internal::IsSame<Derived, void>, BaseReaderHandler, Derived>::Type Override;
202
203 bool Default() { return true; }
204 bool Null() { return static_cast<Override&>(*this).Default(); }
205 bool Bool(bool) { return static_cast<Override&>(*this).Default(); }
206 bool Int(int) { return static_cast<Override&>(*this).Default(); }
207 bool Uint(unsigned) { return static_cast<Override&>(*this).Default(); }
208 bool Int64(int64_t) { return static_cast<Override&>(*this).Default(); }
209 bool Uint64(uint64_t) { return static_cast<Override&>(*this).Default(); }
210 bool Double(double) { return static_cast<Override&>(*this).Default(); }
211 /// enabled via kParseNumbersAsStringsFlag, string is not null-terminated (use length)
212 bool RawNumber(const Ch* str, SizeType len, bool copy) { return static_cast<Override&>(*this).String(str, len, copy); }
213 bool String(const Ch*, SizeType, bool) { return static_cast<Override&>(*this).Default(); }
214 bool StartObject() { return static_cast<Override&>(*this).Default(); }
215 bool Key(const Ch* str, SizeType len, bool copy) { return static_cast<Override&>(*this).String(str, len, copy); }
216 bool EndObject(SizeType) { return static_cast<Override&>(*this).Default(); }
217 bool StartArray() { return static_cast<Override&>(*this).Default(); }
218 bool EndArray(SizeType) { return static_cast<Override&>(*this).Default(); }
219 };
220
221 ///////////////////////////////////////////////////////////////////////////////
222 // StreamLocalCopy
223
224 namespace internal {
225
226 template<typename Stream, int = StreamTraits<Stream>::copyOptimization>
227 class StreamLocalCopy;
228
229 //! Do copy optimization.
230 template<typename Stream>
231 class StreamLocalCopy<Stream, 1> {
232 public:
233 StreamLocalCopy(Stream& original) : s(original), original_(original) {}
234 ~StreamLocalCopy() { original_ = s; }
235
236 Stream s;
237
238 private:
239 StreamLocalCopy& operator=(const StreamLocalCopy&) /* = delete */;
240
241 Stream& original_;
242 };
243
244 //! Keep reference.
245 template<typename Stream>
246 class StreamLocalCopy<Stream, 0> {
247 public:
248 StreamLocalCopy(Stream& original) : s(original) {}
249
250 Stream& s;
251
252 private:
253 StreamLocalCopy& operator=(const StreamLocalCopy&) /* = delete */;
254 };
255
256 } // namespace internal
257
258 ///////////////////////////////////////////////////////////////////////////////
259 // SkipWhitespace
260
261 //! Skip the JSON white spaces in a stream.
262 /*! \param is A input stream for skipping white spaces.
263 \note This function has SSE2/SSE4.2 specialization.
264 */
265 template<typename InputStream>
266 void SkipWhitespace(InputStream& is) {
267 internal::StreamLocalCopy<InputStream> copy(is);
268 InputStream& s(copy.s);
269
270 typename InputStream::Ch c;
271 while ((c = s.Peek()) == ' ' || c == '\n' || c == '\r' || c == '\t')
272 s.Take();
273 }
274
275 inline const char* SkipWhitespace(const char* p, const char* end) {
276 while (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
277 ++p;
278 return p;
279 }
280
281 #ifdef RAPIDJSON_SSE42
282 //! Skip whitespace with SSE 4.2 pcmpistrm instruction, testing 16 8-byte characters at once.
283 inline const char *SkipWhitespace_SIMD(const char* p) {
284 // Fast return for single non-whitespace
285 if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
286 ++p;
287 else
288 return p;
289
290 // 16-byte align to the next boundary
291 const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
292 while (p != nextAligned)
293 if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
294 ++p;
295 else
296 return p;
297
298 // The rest of string using SIMD
299 static const char whitespace[16] = " \n\r\t";
300 const __m128i w = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespace[0]));
301
302 for (;; p += 16) {
303 const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
304 const int r = _mm_cmpistri(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT | _SIDD_NEGATIVE_POLARITY);
305 if (r != 16) // some of characters is non-whitespace
306 return p + r;
307 }
308 }
309
310 inline const char *SkipWhitespace_SIMD(const char* p, const char* end) {
311 // Fast return for single non-whitespace
312 if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
313 ++p;
314 else
315 return p;
316
317 // The middle of string using SIMD
318 static const char whitespace[16] = " \n\r\t";
319 const __m128i w = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespace[0]));
320
321 for (; p <= end - 16; p += 16) {
322 const __m128i s = _mm_loadu_si128(reinterpret_cast<const __m128i *>(p));
323 const int r = _mm_cmpistri(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT | _SIDD_NEGATIVE_POLARITY);
324 if (r != 16) // some of characters is non-whitespace
325 return p + r;
326 }
327
328 return SkipWhitespace(p, end);
329 }
330
331 #elif defined(RAPIDJSON_SSE2)
332
333 //! Skip whitespace with SSE2 instructions, testing 16 8-byte characters at once.
334 inline const char *SkipWhitespace_SIMD(const char* p) {
335 // Fast return for single non-whitespace
336 if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
337 ++p;
338 else
339 return p;
340
341 // 16-byte align to the next boundary
342 const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
343 while (p != nextAligned)
344 if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
345 ++p;
346 else
347 return p;
348
349 // The rest of string
350 #define C16(c) { c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c }
351 static const char whitespaces[4][16] = { C16(' '), C16('\n'), C16('\r'), C16('\t') };
352 #undef C16
353
354 const __m128i w0 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[0][0]));
355 const __m128i w1 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[1][0]));
356 const __m128i w2 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[2][0]));
357 const __m128i w3 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[3][0]));
358
359 for (;; p += 16) {
360 const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
361 __m128i x = _mm_cmpeq_epi8(s, w0);
362 x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1));
363 x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2));
364 x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3));
365 unsigned short r = static_cast<unsigned short>(~_mm_movemask_epi8(x));
366 if (r != 0) { // some of characters may be non-whitespace
367 #ifdef _MSC_VER // Find the index of first non-whitespace
368 unsigned long offset;
369 _BitScanForward(&offset, r);
370 return p + offset;
371 #else
372 return p + __builtin_ffs(r) - 1;
373 #endif
374 }
375 }
376 }
377
378 inline const char *SkipWhitespace_SIMD(const char* p, const char* end) {
379 // Fast return for single non-whitespace
380 if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
381 ++p;
382 else
383 return p;
384
385 // The rest of string
386 #define C16(c) { c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c }
387 static const char whitespaces[4][16] = { C16(' '), C16('\n'), C16('\r'), C16('\t') };
388 #undef C16
389
390 const __m128i w0 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[0][0]));
391 const __m128i w1 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[1][0]));
392 const __m128i w2 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[2][0]));
393 const __m128i w3 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[3][0]));
394
395 for (; p <= end - 16; p += 16) {
396 const __m128i s = _mm_loadu_si128(reinterpret_cast<const __m128i *>(p));
397 __m128i x = _mm_cmpeq_epi8(s, w0);
398 x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1));
399 x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2));
400 x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3));
401 unsigned short r = static_cast<unsigned short>(~_mm_movemask_epi8(x));
402 if (r != 0) { // some of characters may be non-whitespace
403 #ifdef _MSC_VER // Find the index of first non-whitespace
404 unsigned long offset;
405 _BitScanForward(&offset, r);
406 return p + offset;
407 #else
408 return p + __builtin_ffs(r) - 1;
409 #endif
410 }
411 }
412
413 return SkipWhitespace(p, end);
414 }
415
416 #elif defined(RAPIDJSON_NEON)
417
418 //! Skip whitespace with ARM Neon instructions, testing 16 8-byte characters at once.
419 inline const char *SkipWhitespace_SIMD(const char* p) {
420 // Fast return for single non-whitespace
421 if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
422 ++p;
423 else
424 return p;
425
426 // 16-byte align to the next boundary
427 const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
428 while (p != nextAligned)
429 if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
430 ++p;
431 else
432 return p;
433
434 const uint8x16_t w0 = vmovq_n_u8(' ');
435 const uint8x16_t w1 = vmovq_n_u8('\n');
436 const uint8x16_t w2 = vmovq_n_u8('\r');
437 const uint8x16_t w3 = vmovq_n_u8('\t');
438
439 for (;; p += 16) {
440 const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
441 uint8x16_t x = vceqq_u8(s, w0);
442 x = vorrq_u8(x, vceqq_u8(s, w1));
443 x = vorrq_u8(x, vceqq_u8(s, w2));
444 x = vorrq_u8(x, vceqq_u8(s, w3));
445
446 x = vmvnq_u8(x); // Negate
447 x = vrev64q_u8(x); // Rev in 64
448 uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0); // extract
449 uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1); // extract
450
451 if (low == 0) {
452 if (high != 0) {
453 uint32_t lz = internal::clzll(high);
454 return p + 8 + (lz >> 3);
455 }
456 } else {
457 uint32_t lz = internal::clzll(low);
458 return p + (lz >> 3);
459 }
460 }
461 }
462
463 inline const char *SkipWhitespace_SIMD(const char* p, const char* end) {
464 // Fast return for single non-whitespace
465 if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
466 ++p;
467 else
468 return p;
469
470 const uint8x16_t w0 = vmovq_n_u8(' ');
471 const uint8x16_t w1 = vmovq_n_u8('\n');
472 const uint8x16_t w2 = vmovq_n_u8('\r');
473 const uint8x16_t w3 = vmovq_n_u8('\t');
474
475 for (; p <= end - 16; p += 16) {
476 const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
477 uint8x16_t x = vceqq_u8(s, w0);
478 x = vorrq_u8(x, vceqq_u8(s, w1));
479 x = vorrq_u8(x, vceqq_u8(s, w2));
480 x = vorrq_u8(x, vceqq_u8(s, w3));
481
482 x = vmvnq_u8(x); // Negate
483 x = vrev64q_u8(x); // Rev in 64
484 uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0); // extract
485 uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1); // extract
486
487 if (low == 0) {
488 if (high != 0) {
489 uint32_t lz = internal::clzll(high);
490 return p + 8 + (lz >> 3);
491 }
492 } else {
493 uint32_t lz = internal::clzll(low);
494 return p + (lz >> 3);
495 }
496 }
497
498 return SkipWhitespace(p, end);
499 }
500
501 #endif // RAPIDJSON_NEON
502
503 #ifdef RAPIDJSON_SIMD
504 //! Template function specialization for InsituStringStream
505 template<> inline void SkipWhitespace(InsituStringStream& is) {
506 is.src_ = const_cast<char*>(SkipWhitespace_SIMD(is.src_));
507 }
508
509 //! Template function specialization for StringStream
510 template<> inline void SkipWhitespace(StringStream& is) {
511 is.src_ = SkipWhitespace_SIMD(is.src_);
512 }
513
514 template<> inline void SkipWhitespace(EncodedInputStream<UTF8<>, MemoryStream>& is) {
515 is.is_.src_ = SkipWhitespace_SIMD(is.is_.src_, is.is_.end_);
516 }
517 #endif // RAPIDJSON_SIMD
518
519 ///////////////////////////////////////////////////////////////////////////////
520 // GenericReader
521
522 //! SAX-style JSON parser. Use \ref Reader for UTF8 encoding and default allocator.
523 /*! GenericReader parses JSON text from a stream, and send events synchronously to an
524 object implementing Handler concept.
525
526 It needs to allocate a stack for storing a single decoded string during
527 non-destructive parsing.
528
529 For in-situ parsing, the decoded string is directly written to the source
530 text string, no temporary buffer is required.
531
532 A GenericReader object can be reused for parsing multiple JSON text.
533
534 \tparam SourceEncoding Encoding of the input stream.
535 \tparam TargetEncoding Encoding of the parse output.
536 \tparam StackAllocator Allocator type for stack.
537 */
538 template <typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>
539 class GenericReader {
540 public:
541 typedef typename SourceEncoding::Ch Ch; //!< SourceEncoding character type
542
543 //! Constructor.
544 /*! \param stackAllocator Optional allocator for allocating stack memory. (Only use for non-destructive parsing)
545 \param stackCapacity stack capacity in bytes for storing a single decoded string. (Only use for non-destructive parsing)
546 */
547 GenericReader(StackAllocator* stackAllocator = 0, size_t stackCapacity = kDefaultStackCapacity) :
548 stack_(stackAllocator, stackCapacity), parseResult_(), state_(IterativeParsingStartState) {}
549
550 //! Parse JSON text.
551 /*! \tparam parseFlags Combination of \ref ParseFlag.
552 \tparam InputStream Type of input stream, implementing Stream concept.
553 \tparam Handler Type of handler, implementing Handler concept.
554 \param is Input stream to be parsed.
555 \param handler The handler to receive events.
556 \return Whether the parsing is successful.
557 */
558 template <unsigned parseFlags, typename InputStream, typename Handler>
559 ParseResult Parse(InputStream& is, Handler& handler) {
560 if (parseFlags & kParseIterativeFlag)
561 return IterativeParse<parseFlags>(is, handler);
562
563 parseResult_.Clear();
564
565 ClearStackOnExit scope(*this);
566
567 SkipWhitespaceAndComments<parseFlags>(is);
568 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
569
570 if (RAPIDJSON_UNLIKELY(is.Peek() == '\0')) {
571 RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentEmpty, is.Tell());
572 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
573 }
574 else {
575 ParseValue<parseFlags>(is, handler);
576 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
577
578 if (!(parseFlags & kParseStopWhenDoneFlag)) {
579 SkipWhitespaceAndComments<parseFlags>(is);
580 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
581
582 if (RAPIDJSON_UNLIKELY(is.Peek() != '\0')) {
583 RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentRootNotSingular, is.Tell());
584 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
585 }
586 }
587 }
588
589 return parseResult_;
590 }
591
592 //! Parse JSON text (with \ref kParseDefaultFlags)
593 /*! \tparam InputStream Type of input stream, implementing Stream concept
594 \tparam Handler Type of handler, implementing Handler concept.
595 \param is Input stream to be parsed.
596 \param handler The handler to receive events.
597 \return Whether the parsing is successful.
598 */
599 template <typename InputStream, typename Handler>
600 ParseResult Parse(InputStream& is, Handler& handler) {
601 return Parse<kParseDefaultFlags>(is, handler);
602 }
603
604 //! Initialize JSON text token-by-token parsing
605 /*!
606 */
607 void IterativeParseInit() {
608 parseResult_.Clear();
609 state_ = IterativeParsingStartState;
610 }
611
612 //! Parse one token from JSON text
613 /*! \tparam InputStream Type of input stream, implementing Stream concept
614 \tparam Handler Type of handler, implementing Handler concept.
615 \param is Input stream to be parsed.
616 \param handler The handler to receive events.
617 \return Whether the parsing is successful.
618 */
619 template <unsigned parseFlags, typename InputStream, typename Handler>
620 bool IterativeParseNext(InputStream& is, Handler& handler) {
621 while (RAPIDJSON_LIKELY(is.Peek() != '\0')) {
622 SkipWhitespaceAndComments<parseFlags>(is);
623
624 Token t = Tokenize(is.Peek());
625 IterativeParsingState n = Predict(state_, t);
626 IterativeParsingState d = Transit<parseFlags>(state_, t, n, is, handler);
627
628 // If we've finished or hit an error...
629 if (RAPIDJSON_UNLIKELY(IsIterativeParsingCompleteState(d))) {
630 // Report errors.
631 if (d == IterativeParsingErrorState) {
632 HandleError(state_, is);
633 return false;
634 }
635
636 // Transition to the finish state.
637 RAPIDJSON_ASSERT(d == IterativeParsingFinishState);
638 state_ = d;
639
640 // If StopWhenDone is not set...
641 if (!(parseFlags & kParseStopWhenDoneFlag)) {
642 // ... and extra non-whitespace data is found...
643 SkipWhitespaceAndComments<parseFlags>(is);
644 if (is.Peek() != '\0') {
645 // ... this is considered an error.
646 HandleError(state_, is);
647 return false;
648 }
649 }
650
651 // Success! We are done!
652 return true;
653 }
654
655 // Transition to the new state.
656 state_ = d;
657
658 // If we parsed anything other than a delimiter, we invoked the handler, so we can return true now.
659 if (!IsIterativeParsingDelimiterState(n))
660 return true;
661 }
662
663 // We reached the end of file.
664 stack_.Clear();
665
666 if (state_ != IterativeParsingFinishState) {
667 HandleError(state_, is);
668 return false;
669 }
670
671 return true;
672 }
673
674 //! Check if token-by-token parsing JSON text is complete
675 /*! \return Whether the JSON has been fully decoded.
676 */
677 RAPIDJSON_FORCEINLINE bool IterativeParseComplete() const {
678 return IsIterativeParsingCompleteState(state_);
679 }
680
681 //! Whether a parse error has occurred in the last parsing.
682 bool HasParseError() const { return parseResult_.IsError(); }
683
684 //! Get the \ref ParseErrorCode of last parsing.
685 ParseErrorCode GetParseErrorCode() const { return parseResult_.Code(); }
686
687 //! Get the position of last parsing error in input, 0 otherwise.
688 size_t GetErrorOffset() const { return parseResult_.Offset(); }
689
690 protected:
691 void SetParseError(ParseErrorCode code, size_t offset) { parseResult_.Set(code, offset); }
692
693 private:
694 // Prohibit copy constructor & assignment operator.
695 GenericReader(const GenericReader&);
696 GenericReader& operator=(const GenericReader&);
697
698 void ClearStack() { stack_.Clear(); }
699
700 // clear stack on any exit from ParseStream, e.g. due to exception
701 struct ClearStackOnExit {
702 explicit ClearStackOnExit(GenericReader& r) : r_(r) {}
703 ~ClearStackOnExit() { r_.ClearStack(); }
704 private:
705 GenericReader& r_;
706 ClearStackOnExit(const ClearStackOnExit&);
707 ClearStackOnExit& operator=(const ClearStackOnExit&);
708 };
709
710 template<unsigned parseFlags, typename InputStream>
711 void SkipWhitespaceAndComments(InputStream& is) {
712 SkipWhitespace(is);
713
714 if (parseFlags & kParseCommentsFlag) {
715 while (RAPIDJSON_UNLIKELY(Consume(is, '/'))) {
716 if (Consume(is, '*')) {
717 while (true) {
718 if (RAPIDJSON_UNLIKELY(is.Peek() == '\0'))
719 RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
720 else if (Consume(is, '*')) {
721 if (Consume(is, '/'))
722 break;
723 }
724 else
725 is.Take();
726 }
727 }
728 else if (RAPIDJSON_LIKELY(Consume(is, '/')))
729 while (is.Peek() != '\0' && is.Take() != '\n') {}
730 else
731 RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
732
733 SkipWhitespace(is);
734 }
735 }
736 }
737
738 // Parse object: { string : value, ... }
739 template<unsigned parseFlags, typename InputStream, typename Handler>
740 void ParseObject(InputStream& is, Handler& handler) {
741 RAPIDJSON_ASSERT(is.Peek() == '{');
742 is.Take(); // Skip '{'
743
744 if (RAPIDJSON_UNLIKELY(!handler.StartObject()))
745 RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
746
747 SkipWhitespaceAndComments<parseFlags>(is);
748 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
749
750 if (Consume(is, '}')) {
751 if (RAPIDJSON_UNLIKELY(!handler.EndObject(0))) // empty object
752 RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
753 return;
754 }
755
756 for (SizeType memberCount = 0;;) {
757 if (RAPIDJSON_UNLIKELY(is.Peek() != '"'))
758 RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell());
759
760 ParseString<parseFlags>(is, handler, true);
761 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
762
763 SkipWhitespaceAndComments<parseFlags>(is);
764 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
765
766 if (RAPIDJSON_UNLIKELY(!Consume(is, ':')))
767 RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell());
768
769 SkipWhitespaceAndComments<parseFlags>(is);
770 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
771
772 ParseValue<parseFlags>(is, handler);
773 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
774
775 SkipWhitespaceAndComments<parseFlags>(is);
776 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
777
778 ++memberCount;
779
780 switch (is.Peek()) {
781 case ',':
782 is.Take();
783 SkipWhitespaceAndComments<parseFlags>(is);
784 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
785 break;
786 case '}':
787 is.Take();
788 if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
789 RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
790 return;
791 default:
792 RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell()); break; // This useless break is only for making warning and coverage happy
793 }
794
795 if (parseFlags & kParseTrailingCommasFlag) {
796 if (is.Peek() == '}') {
797 if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
798 RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
799 is.Take();
800 return;
801 }
802 }
803 }
804 }
805
806 // Parse array: [ value, ... ]
807 template<unsigned parseFlags, typename InputStream, typename Handler>
808 void ParseArray(InputStream& is, Handler& handler) {
809 RAPIDJSON_ASSERT(is.Peek() == '[');
810 is.Take(); // Skip '['
811
812 if (RAPIDJSON_UNLIKELY(!handler.StartArray()))
813 RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
814
815 SkipWhitespaceAndComments<parseFlags>(is);
816 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
817
818 if (Consume(is, ']')) {
819 if (RAPIDJSON_UNLIKELY(!handler.EndArray(0))) // empty array
820 RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
821 return;
822 }
823
824 for (SizeType elementCount = 0;;) {
825 ParseValue<parseFlags>(is, handler);
826 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
827
828 ++elementCount;
829 SkipWhitespaceAndComments<parseFlags>(is);
830 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
831
832 if (Consume(is, ',')) {
833 SkipWhitespaceAndComments<parseFlags>(is);
834 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
835 }
836 else if (Consume(is, ']')) {
837 if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
838 RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
839 return;
840 }
841 else
842 RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());
843
844 if (parseFlags & kParseTrailingCommasFlag) {
845 if (is.Peek() == ']') {
846 if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
847 RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
848 is.Take();
849 return;
850 }
851 }
852 }
853 }
854
855 template<unsigned parseFlags, typename InputStream, typename Handler>
856 void ParseNull(InputStream& is, Handler& handler) {
857 RAPIDJSON_ASSERT(is.Peek() == 'n');
858 is.Take();
859
860 if (RAPIDJSON_LIKELY(Consume(is, 'u') && Consume(is, 'l') && Consume(is, 'l'))) {
861 if (RAPIDJSON_UNLIKELY(!handler.Null()))
862 RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
863 }
864 else
865 RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
866 }
867
868 template<unsigned parseFlags, typename InputStream, typename Handler>
869 void ParseTrue(InputStream& is, Handler& handler) {
870 RAPIDJSON_ASSERT(is.Peek() == 't');
871 is.Take();
872
873 if (RAPIDJSON_LIKELY(Consume(is, 'r') && Consume(is, 'u') && Consume(is, 'e'))) {
874 if (RAPIDJSON_UNLIKELY(!handler.Bool(true)))
875 RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
876 }
877 else
878 RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
879 }
880
881 template<unsigned parseFlags, typename InputStream, typename Handler>
882 void ParseFalse(InputStream& is, Handler& handler) {
883 RAPIDJSON_ASSERT(is.Peek() == 'f');
884 is.Take();
885
886 if (RAPIDJSON_LIKELY(Consume(is, 'a') && Consume(is, 'l') && Consume(is, 's') && Consume(is, 'e'))) {
887 if (RAPIDJSON_UNLIKELY(!handler.Bool(false)))
888 RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
889 }
890 else
891 RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
892 }
893
894 template<typename InputStream>
895 RAPIDJSON_FORCEINLINE static bool Consume(InputStream& is, typename InputStream::Ch expect) {
896 if (RAPIDJSON_LIKELY(is.Peek() == expect)) {
897 is.Take();
898 return true;
899 }
900 else
901 return false;
902 }
903
904 // Helper function to parse four hexadecimal digits in \uXXXX in ParseString().
905 template<typename InputStream>
906 unsigned ParseHex4(InputStream& is, size_t escapeOffset) {
907 unsigned codepoint = 0;
908 for (int i = 0; i < 4; i++) {
909 Ch c = is.Peek();
910 codepoint <<= 4;
911 codepoint += static_cast<unsigned>(c);
912 if (c >= '0' && c <= '9')
913 codepoint -= '0';
914 else if (c >= 'A' && c <= 'F')
915 codepoint -= 'A' - 10;
916 else if (c >= 'a' && c <= 'f')
917 codepoint -= 'a' - 10;
918 else {
919 RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorStringUnicodeEscapeInvalidHex, escapeOffset);
920 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(0);
921 }
922 is.Take();
923 }
924 return codepoint;
925 }
926
927 template <typename CharType>
928 class StackStream {
929 public:
930 typedef CharType Ch;
931
932 StackStream(internal::Stack<StackAllocator>& stack) : stack_(stack), length_(0) {}
933 RAPIDJSON_FORCEINLINE void Put(Ch c) {
934 *stack_.template Push<Ch>() = c;
935 ++length_;
936 }
937
938 RAPIDJSON_FORCEINLINE void* Push(SizeType count) {
939 length_ += count;
940 return stack_.template Push<Ch>(count);
941 }
942
943 size_t Length() const { return length_; }
944
945 Ch* Pop() {
946 return stack_.template Pop<Ch>(length_);
947 }
948
949 private:
950 StackStream(const StackStream&);
951 StackStream& operator=(const StackStream&);
952
953 internal::Stack<StackAllocator>& stack_;
954 SizeType length_;
955 };
956
957 // Parse string and generate String event. Different code paths for kParseInsituFlag.
958 template<unsigned parseFlags, typename InputStream, typename Handler>
959 void ParseString(InputStream& is, Handler& handler, bool isKey = false) {
960 internal::StreamLocalCopy<InputStream> copy(is);
961 InputStream& s(copy.s);
962
963 RAPIDJSON_ASSERT(s.Peek() == '\"');
964 s.Take(); // Skip '\"'
965
966 bool success = false;
967 if (parseFlags & kParseInsituFlag) {
968 typename InputStream::Ch *head = s.PutBegin();
969 ParseStringToStream<parseFlags, SourceEncoding, SourceEncoding>(s, s);
970 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
971 size_t length = s.PutEnd(head) - 1;
972 RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
973 const typename TargetEncoding::Ch* const str = reinterpret_cast<typename TargetEncoding::Ch*>(head);
974 success = (isKey ? handler.Key(str, SizeType(length), false) : handler.String(str, SizeType(length), false));
975 }
976 else {
977 StackStream<typename TargetEncoding::Ch> stackStream(stack_);
978 ParseStringToStream<parseFlags, SourceEncoding, TargetEncoding>(s, stackStream);
979 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
980 SizeType length = static_cast<SizeType>(stackStream.Length()) - 1;
981 const typename TargetEncoding::Ch* const str = stackStream.Pop();
982 success = (isKey ? handler.Key(str, length, true) : handler.String(str, length, true));
983 }
984 if (RAPIDJSON_UNLIKELY(!success))
985 RAPIDJSON_PARSE_ERROR(kParseErrorTermination, s.Tell());
986 }
987
988 // Parse string to an output is
989 // This function handles the prefix/suffix double quotes, escaping, and optional encoding validation.
990 template<unsigned parseFlags, typename SEncoding, typename TEncoding, typename InputStream, typename OutputStream>
991 RAPIDJSON_FORCEINLINE void ParseStringToStream(InputStream& is, OutputStream& os) {
992 //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
993 #define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
994 static const char escape[256] = {
995 Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '/',
996 Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0,
997 0, 0,'\b', 0, 0, 0,'\f', 0, 0, 0, 0, 0, 0, 0,'\n', 0,
998 0, 0,'\r', 0,'\t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
999 Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
1000 };
1001 #undef Z16
1002 //!@endcond
1003
1004 for (;;) {
1005 // Scan and copy string before "\\\"" or < 0x20. This is an optional optimzation.
1006 if (!(parseFlags & kParseValidateEncodingFlag))
1007 ScanCopyUnescapedString(is, os);
1008
1009 Ch c = is.Peek();
1010 if (RAPIDJSON_UNLIKELY(c == '\\')) { // Escape
1011 size_t escapeOffset = is.Tell(); // For invalid escaping, report the initial '\\' as error offset
1012 is.Take();
1013 Ch e = is.Peek();
1014 if ((sizeof(Ch) == 1 || unsigned(e) < 256) && RAPIDJSON_LIKELY(escape[static_cast<unsigned char>(e)])) {
1015 is.Take();
1016 os.Put(static_cast<typename TEncoding::Ch>(escape[static_cast<unsigned char>(e)]));
1017 }
1018 else if ((parseFlags & kParseEscapedApostropheFlag) && RAPIDJSON_LIKELY(e == '\'')) { // Allow escaped apostrophe
1019 is.Take();
1020 os.Put('\'');
1021 }
1022 else if (RAPIDJSON_LIKELY(e == 'u')) { // Unicode
1023 is.Take();
1024 unsigned codepoint = ParseHex4(is, escapeOffset);
1025 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
1026 if (RAPIDJSON_UNLIKELY(codepoint >= 0xD800 && codepoint <= 0xDFFF)) {
1027 // high surrogate, check if followed by valid low surrogate
1028 if (RAPIDJSON_LIKELY(codepoint <= 0xDBFF)) {
1029 // Handle UTF-16 surrogate pair
1030 if (RAPIDJSON_UNLIKELY(!Consume(is, '\\') || !Consume(is, 'u')))
1031 RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
1032 unsigned codepoint2 = ParseHex4(is, escapeOffset);
1033 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
1034 if (RAPIDJSON_UNLIKELY(codepoint2 < 0xDC00 || codepoint2 > 0xDFFF))
1035 RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
1036 codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000;
1037 }
1038 // single low surrogate
1039 else
1040 {
1041 RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
1042 }
1043 }
1044 TEncoding::Encode(os, codepoint);
1045 }
1046 else
1047 RAPIDJSON_PARSE_ERROR(kParseErrorStringEscapeInvalid, escapeOffset);
1048 }
1049 else if (RAPIDJSON_UNLIKELY(c == '"')) { // Closing double quote
1050 is.Take();
1051 os.Put('\0'); // null-terminate the string
1052 return;
1053 }
1054 else if (RAPIDJSON_UNLIKELY(static_cast<unsigned>(c) < 0x20)) { // RFC 4627: unescaped = %x20-21 / %x23-5B / %x5D-10FFFF
1055 if (c == '\0')
1056 RAPIDJSON_PARSE_ERROR(kParseErrorStringMissQuotationMark, is.Tell());
1057 else
1058 RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, is.Tell());
1059 }
1060 else {
1061 size_t offset = is.Tell();
1062 if (RAPIDJSON_UNLIKELY((parseFlags & kParseValidateEncodingFlag ?
1063 !Transcoder<SEncoding, TEncoding>::Validate(is, os) :
1064 !Transcoder<SEncoding, TEncoding>::Transcode(is, os))))
1065 RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, offset);
1066 }
1067 }
1068 }
1069
1070 template<typename InputStream, typename OutputStream>
1071 static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InputStream&, OutputStream&) {
1072 // Do nothing for generic version
1073 }
1074
1075 #if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42)
1076 // StringStream -> StackStream<char>
1077 static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(StringStream& is, StackStream<char>& os) {
1078 const char* p = is.src_;
1079
1080 // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
1081 const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
1082 while (p != nextAligned)
1083 if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
1084 is.src_ = p;
1085 return;
1086 }
1087 else
1088 os.Put(*p++);
1089
1090 // The rest of string using SIMD
1091 static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
1092 static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
1093 static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
1094 const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
1095 const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
1096 const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
1097
1098 for (;; p += 16) {
1099 const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
1100 const __m128i t1 = _mm_cmpeq_epi8(s, dq);
1101 const __m128i t2 = _mm_cmpeq_epi8(s, bs);
1102 const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
1103 const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
1104 unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
1105 if (RAPIDJSON_UNLIKELY(r != 0)) { // some of characters is escaped
1106 SizeType length;
1107 #ifdef _MSC_VER // Find the index of first escaped
1108 unsigned long offset;
1109 _BitScanForward(&offset, r);
1110 length = offset;
1111 #else
1112 length = static_cast<SizeType>(__builtin_ffs(r) - 1);
1113 #endif
1114 if (length != 0) {
1115 char* q = reinterpret_cast<char*>(os.Push(length));
1116 for (size_t i = 0; i < length; i++)
1117 q[i] = p[i];
1118
1119 p += length;
1120 }
1121 break;
1122 }
1123 _mm_storeu_si128(reinterpret_cast<__m128i *>(os.Push(16)), s);
1124 }
1125
1126 is.src_ = p;
1127 }
1128
1129 // InsituStringStream -> InsituStringStream
1130 static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InsituStringStream& is, InsituStringStream& os) {
1131 RAPIDJSON_ASSERT(&is == &os);
1132 (void)os;
1133
1134 if (is.src_ == is.dst_) {
1135 SkipUnescapedString(is);
1136 return;
1137 }
1138
1139 char* p = is.src_;
1140 char *q = is.dst_;
1141
1142 // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
1143 const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
1144 while (p != nextAligned)
1145 if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
1146 is.src_ = p;
1147 is.dst_ = q;
1148 return;
1149 }
1150 else
1151 *q++ = *p++;
1152
1153 // The rest of string using SIMD
1154 static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
1155 static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
1156 static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
1157 const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
1158 const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
1159 const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
1160
1161 for (;; p += 16, q += 16) {
1162 const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
1163 const __m128i t1 = _mm_cmpeq_epi8(s, dq);
1164 const __m128i t2 = _mm_cmpeq_epi8(s, bs);
1165 const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
1166 const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
1167 unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
1168 if (RAPIDJSON_UNLIKELY(r != 0)) { // some of characters is escaped
1169 size_t length;
1170 #ifdef _MSC_VER // Find the index of first escaped
1171 unsigned long offset;
1172 _BitScanForward(&offset, r);
1173 length = offset;
1174 #else
1175 length = static_cast<size_t>(__builtin_ffs(r) - 1);
1176 #endif
1177 for (const char* pend = p + length; p != pend; )
1178 *q++ = *p++;
1179 break;
1180 }
1181 _mm_storeu_si128(reinterpret_cast<__m128i *>(q), s);
1182 }
1183
1184 is.src_ = p;
1185 is.dst_ = q;
1186 }
1187
1188 // When read/write pointers are the same for insitu stream, just skip unescaped characters
1189 static RAPIDJSON_FORCEINLINE void SkipUnescapedString(InsituStringStream& is) {
1190 RAPIDJSON_ASSERT(is.src_ == is.dst_);
1191 char* p = is.src_;
1192
1193 // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
1194 const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
1195 for (; p != nextAligned; p++)
1196 if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
1197 is.src_ = is.dst_ = p;
1198 return;
1199 }
1200
1201 // The rest of string using SIMD
1202 static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
1203 static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
1204 static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
1205 const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
1206 const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
1207 const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
1208
1209 for (;; p += 16) {
1210 const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
1211 const __m128i t1 = _mm_cmpeq_epi8(s, dq);
1212 const __m128i t2 = _mm_cmpeq_epi8(s, bs);
1213 const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
1214 const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
1215 unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
1216 if (RAPIDJSON_UNLIKELY(r != 0)) { // some of characters is escaped
1217 size_t length;
1218 #ifdef _MSC_VER // Find the index of first escaped
1219 unsigned long offset;
1220 _BitScanForward(&offset, r);
1221 length = offset;
1222 #else
1223 length = static_cast<size_t>(__builtin_ffs(r) - 1);
1224 #endif
1225 p += length;
1226 break;
1227 }
1228 }
1229
1230 is.src_ = is.dst_ = p;
1231 }
1232 #elif defined(RAPIDJSON_NEON)
1233 // StringStream -> StackStream<char>
1234 static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(StringStream& is, StackStream<char>& os) {
1235 const char* p = is.src_;
1236
1237 // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
1238 const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
1239 while (p != nextAligned)
1240 if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
1241 is.src_ = p;
1242 return;
1243 }
1244 else
1245 os.Put(*p++);
1246
1247 // The rest of string using SIMD
1248 const uint8x16_t s0 = vmovq_n_u8('"');
1249 const uint8x16_t s1 = vmovq_n_u8('\\');
1250 const uint8x16_t s2 = vmovq_n_u8('\b');
1251 const uint8x16_t s3 = vmovq_n_u8(32);
1252
1253 for (;; p += 16) {
1254 const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
1255 uint8x16_t x = vceqq_u8(s, s0);
1256 x = vorrq_u8(x, vceqq_u8(s, s1));
1257 x = vorrq_u8(x, vceqq_u8(s, s2));
1258 x = vorrq_u8(x, vcltq_u8(s, s3));
1259
1260 x = vrev64q_u8(x); // Rev in 64
1261 uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0); // extract
1262 uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1); // extract
1263
1264 SizeType length = 0;
1265 bool escaped = false;
1266 if (low == 0) {
1267 if (high != 0) {
1268 uint32_t lz = internal::clzll(high);
1269 length = 8 + (lz >> 3);
1270 escaped = true;
1271 }
1272 } else {
1273 uint32_t lz = internal::clzll(low);
1274 length = lz >> 3;
1275 escaped = true;
1276 }
1277 if (RAPIDJSON_UNLIKELY(escaped)) { // some of characters is escaped
1278 if (length != 0) {
1279 char* q = reinterpret_cast<char*>(os.Push(length));
1280 for (size_t i = 0; i < length; i++)
1281 q[i] = p[i];
1282
1283 p += length;
1284 }
1285 break;
1286 }
1287 vst1q_u8(reinterpret_cast<uint8_t *>(os.Push(16)), s);
1288 }
1289
1290 is.src_ = p;
1291 }
1292
1293 // InsituStringStream -> InsituStringStream
1294 static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InsituStringStream& is, InsituStringStream& os) {
1295 RAPIDJSON_ASSERT(&is == &os);
1296 (void)os;
1297
1298 if (is.src_ == is.dst_) {
1299 SkipUnescapedString(is);
1300 return;
1301 }
1302
1303 char* p = is.src_;
1304 char *q = is.dst_;
1305
1306 // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
1307 const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
1308 while (p != nextAligned)
1309 if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
1310 is.src_ = p;
1311 is.dst_ = q;
1312 return;
1313 }
1314 else
1315 *q++ = *p++;
1316
1317 // The rest of string using SIMD
1318 const uint8x16_t s0 = vmovq_n_u8('"');
1319 const uint8x16_t s1 = vmovq_n_u8('\\');
1320 const uint8x16_t s2 = vmovq_n_u8('\b');
1321 const uint8x16_t s3 = vmovq_n_u8(32);
1322
1323 for (;; p += 16, q += 16) {
1324 const uint8x16_t s = vld1q_u8(reinterpret_cast<uint8_t *>(p));
1325 uint8x16_t x = vceqq_u8(s, s0);
1326 x = vorrq_u8(x, vceqq_u8(s, s1));
1327 x = vorrq_u8(x, vceqq_u8(s, s2));
1328 x = vorrq_u8(x, vcltq_u8(s, s3));
1329
1330 x = vrev64q_u8(x); // Rev in 64
1331 uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0); // extract
1332 uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1); // extract
1333
1334 SizeType length = 0;
1335 bool escaped = false;
1336 if (low == 0) {
1337 if (high != 0) {
1338 uint32_t lz = internal::clzll(high);
1339 length = 8 + (lz >> 3);
1340 escaped = true;
1341 }
1342 } else {
1343 uint32_t lz = internal::clzll(low);
1344 length = lz >> 3;
1345 escaped = true;
1346 }
1347 if (RAPIDJSON_UNLIKELY(escaped)) { // some of characters is escaped
1348 for (const char* pend = p + length; p != pend; ) {
1349 *q++ = *p++;
1350 }
1351 break;
1352 }
1353 vst1q_u8(reinterpret_cast<uint8_t *>(q), s);
1354 }
1355
1356 is.src_ = p;
1357 is.dst_ = q;
1358 }
1359
1360 // When read/write pointers are the same for insitu stream, just skip unescaped characters
1361 static RAPIDJSON_FORCEINLINE void SkipUnescapedString(InsituStringStream& is) {
1362 RAPIDJSON_ASSERT(is.src_ == is.dst_);
1363 char* p = is.src_;
1364
1365 // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
1366 const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
1367 for (; p != nextAligned; p++)
1368 if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
1369 is.src_ = is.dst_ = p;
1370 return;
1371 }
1372
1373 // The rest of string using SIMD
1374 const uint8x16_t s0 = vmovq_n_u8('"');
1375 const uint8x16_t s1 = vmovq_n_u8('\\');
1376 const uint8x16_t s2 = vmovq_n_u8('\b');
1377 const uint8x16_t s3 = vmovq_n_u8(32);
1378
1379 for (;; p += 16) {
1380 const uint8x16_t s = vld1q_u8(reinterpret_cast<uint8_t *>(p));
1381 uint8x16_t x = vceqq_u8(s, s0);
1382 x = vorrq_u8(x, vceqq_u8(s, s1));
1383 x = vorrq_u8(x, vceqq_u8(s, s2));
1384 x = vorrq_u8(x, vcltq_u8(s, s3));
1385
1386 x = vrev64q_u8(x); // Rev in 64
1387 uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0); // extract
1388 uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1); // extract
1389
1390 if (low == 0) {
1391 if (high != 0) {
1392 uint32_t lz = internal::clzll(high);
1393 p += 8 + (lz >> 3);
1394 break;
1395 }
1396 } else {
1397 uint32_t lz = internal::clzll(low);
1398 p += lz >> 3;
1399 break;
1400 }
1401 }
1402
1403 is.src_ = is.dst_ = p;
1404 }
1405 #endif // RAPIDJSON_NEON
1406
1407 template<typename InputStream, bool backup, bool pushOnTake>
1408 class NumberStream;
1409
1410 template<typename InputStream>
1411 class NumberStream<InputStream, false, false> {
1412 public:
1413 typedef typename InputStream::Ch Ch;
1414
1415 NumberStream(GenericReader& reader, InputStream& s) : is(s) { (void)reader; }
1416
1417 RAPIDJSON_FORCEINLINE Ch Peek() const { return is.Peek(); }
1418 RAPIDJSON_FORCEINLINE Ch TakePush() { return is.Take(); }
1419 RAPIDJSON_FORCEINLINE Ch Take() { return is.Take(); }
1420 RAPIDJSON_FORCEINLINE void Push(char) {}
1421
1422 size_t Tell() { return is.Tell(); }
1423 size_t Length() { return 0; }
1424 const char* Pop() { return 0; }
1425
1426 protected:
1427 NumberStream& operator=(const NumberStream&);
1428
1429 InputStream& is;
1430 };
1431
1432 template<typename InputStream>
1433 class NumberStream<InputStream, true, false> : public NumberStream<InputStream, false, false> {
1434 typedef NumberStream<InputStream, false, false> Base;
1435 public:
1436 NumberStream(GenericReader& reader, InputStream& is) : Base(reader, is), stackStream(reader.stack_) {}
1437
1438 RAPIDJSON_FORCEINLINE Ch TakePush() {
1439 stackStream.Put(static_cast<char>(Base::is.Peek()));
1440 return Base::is.Take();
1441 }
1442
1443 RAPIDJSON_FORCEINLINE void Push(char c) {
1444 stackStream.Put(c);
1445 }
1446
1447 size_t Length() { return stackStream.Length(); }
1448
1449 const char* Pop() {
1450 stackStream.Put('\0');
1451 return stackStream.Pop();
1452 }
1453
1454 private:
1455 StackStream<char> stackStream;
1456 };
1457
1458 template<typename InputStream>
1459 class NumberStream<InputStream, true, true> : public NumberStream<InputStream, true, false> {
1460 typedef NumberStream<InputStream, true, false> Base;
1461 public:
1462 NumberStream(GenericReader& reader, InputStream& is) : Base(reader, is) {}
1463
1464 RAPIDJSON_FORCEINLINE Ch Take() { return Base::TakePush(); }
1465 };
1466
1467 template<unsigned parseFlags, typename InputStream, typename Handler>
1468 void ParseNumber(InputStream& is, Handler& handler) {
1469 internal::StreamLocalCopy<InputStream> copy(is);
1470 NumberStream<InputStream,
1471 ((parseFlags & kParseNumbersAsStringsFlag) != 0) ?
1472 ((parseFlags & kParseInsituFlag) == 0) :
1473 ((parseFlags & kParseFullPrecisionFlag) != 0),
1474 (parseFlags & kParseNumbersAsStringsFlag) != 0 &&
1475 (parseFlags & kParseInsituFlag) == 0> s(*this, copy.s);
1476
1477 size_t startOffset = s.Tell();
1478 double d = 0.0;
1479 bool useNanOrInf = false;
1480
1481 // Parse minus
1482 bool minus = Consume(s, '-');
1483
1484 // Parse int: zero / ( digit1-9 *DIGIT )
1485 unsigned i = 0;
1486 uint64_t i64 = 0;
1487 bool use64bit = false;
1488 int significandDigit = 0;
1489 if (RAPIDJSON_UNLIKELY(s.Peek() == '0')) {
1490 i = 0;
1491 s.TakePush();
1492 }
1493 else if (RAPIDJSON_LIKELY(s.Peek() >= '1' && s.Peek() <= '9')) {
1494 i = static_cast<unsigned>(s.TakePush() - '0');
1495
1496 if (minus)
1497 while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
1498 if (RAPIDJSON_UNLIKELY(i >= 214748364)) { // 2^31 = 2147483648
1499 if (RAPIDJSON_LIKELY(i != 214748364 || s.Peek() > '8')) {
1500 i64 = i;
1501 use64bit = true;
1502 break;
1503 }
1504 }
1505 i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
1506 significandDigit++;
1507 }
1508 else
1509 while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
1510 if (RAPIDJSON_UNLIKELY(i >= 429496729)) { // 2^32 - 1 = 4294967295
1511 if (RAPIDJSON_LIKELY(i != 429496729 || s.Peek() > '5')) {
1512 i64 = i;
1513 use64bit = true;
1514 break;
1515 }
1516 }
1517 i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
1518 significandDigit++;
1519 }
1520 }
1521 // Parse NaN or Infinity here
1522 else if ((parseFlags & kParseNanAndInfFlag) && RAPIDJSON_LIKELY((s.Peek() == 'I' || s.Peek() == 'N'))) {
1523 if (Consume(s, 'N')) {
1524 if (Consume(s, 'a') && Consume(s, 'N')) {
1525 d = std::numeric_limits<double>::quiet_NaN();
1526 useNanOrInf = true;
1527 }
1528 }
1529 else if (RAPIDJSON_LIKELY(Consume(s, 'I'))) {
1530 if (Consume(s, 'n') && Consume(s, 'f')) {
1531 d = (minus ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity());
1532 useNanOrInf = true;
1533
1534 if (RAPIDJSON_UNLIKELY(s.Peek() == 'i' && !(Consume(s, 'i') && Consume(s, 'n')
1535 && Consume(s, 'i') && Consume(s, 't') && Consume(s, 'y')))) {
1536 RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
1537 }
1538 }
1539 }
1540
1541 if (RAPIDJSON_UNLIKELY(!useNanOrInf)) {
1542 RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
1543 }
1544 }
1545 else
1546 RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
1547
1548 // Parse 64bit int
1549 bool useDouble = false;
1550 if (use64bit) {
1551 if (minus)
1552 while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
1553 if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC))) // 2^63 = 9223372036854775808
1554 if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC) || s.Peek() > '8')) {
1555 d = static_cast<double>(i64);
1556 useDouble = true;
1557 break;
1558 }
1559 i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
1560 significandDigit++;
1561 }
1562 else
1563 while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
1564 if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x19999999, 0x99999999))) // 2^64 - 1 = 18446744073709551615
1565 if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) || s.Peek() > '5')) {
1566 d = static_cast<double>(i64);
1567 useDouble = true;
1568 break;
1569 }
1570 i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
1571 significandDigit++;
1572 }
1573 }
1574
1575 // Force double for big integer
1576 if (useDouble) {
1577 while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
1578 d = d * 10 + (s.TakePush() - '0');
1579 }
1580 }
1581
1582 // Parse frac = decimal-point 1*DIGIT
1583 int expFrac = 0;
1584 size_t decimalPosition;
1585 if (Consume(s, '.')) {
1586 decimalPosition = s.Length();
1587
1588 if (RAPIDJSON_UNLIKELY(!(s.Peek() >= '0' && s.Peek() <= '9')))
1589 RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissFraction, s.Tell());
1590
1591 if (!useDouble) {
1592 #if RAPIDJSON_64BIT
1593 // Use i64 to store significand in 64-bit architecture
1594 if (!use64bit)
1595 i64 = i;
1596
1597 while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
1598 if (i64 > RAPIDJSON_UINT64_C2(0x1FFFFF, 0xFFFFFFFF)) // 2^53 - 1 for fast path
1599 break;
1600 else {
1601 i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
1602 --expFrac;
1603 if (i64 != 0)
1604 significandDigit++;
1605 }
1606 }
1607
1608 d = static_cast<double>(i64);
1609 #else
1610 // Use double to store significand in 32-bit architecture
1611 d = static_cast<double>(use64bit ? i64 : i);
1612 #endif
1613 useDouble = true;
1614 }
1615
1616 while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
1617 if (significandDigit < 17) {
1618 d = d * 10.0 + (s.TakePush() - '0');
1619 --expFrac;
1620 if (RAPIDJSON_LIKELY(d > 0.0))
1621 significandDigit++;
1622 }
1623 else
1624 s.TakePush();
1625 }
1626 }
1627 else
1628 decimalPosition = s.Length(); // decimal position at the end of integer.
1629
1630 // Parse exp = e [ minus / plus ] 1*DIGIT
1631 int exp = 0;
1632 if (Consume(s, 'e') || Consume(s, 'E')) {
1633 if (!useDouble) {
1634 d = static_cast<double>(use64bit ? i64 : i);
1635 useDouble = true;
1636 }
1637
1638 bool expMinus = false;
1639 if (Consume(s, '+'))
1640 ;
1641 else if (Consume(s, '-'))
1642 expMinus = true;
1643
1644 if (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
1645 exp = static_cast<int>(s.Take() - '0');
1646 if (expMinus) {
1647 // (exp + expFrac) must not underflow int => we're detecting when -exp gets
1648 // dangerously close to INT_MIN (a pessimistic next digit 9 would push it into
1649 // underflow territory):
1650 //
1651 // -(exp * 10 + 9) + expFrac >= INT_MIN
1652 // <=> exp <= (expFrac - INT_MIN - 9) / 10
1653 RAPIDJSON_ASSERT(expFrac <= 0);
1654 int maxExp = (expFrac + 2147483639) / 10;
1655
1656 while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
1657 exp = exp * 10 + static_cast<int>(s.Take() - '0');
1658 if (RAPIDJSON_UNLIKELY(exp > maxExp)) {
1659 while (RAPIDJSON_UNLIKELY(s.Peek() >= '0' && s.Peek() <= '9')) // Consume the rest of exponent
1660 s.Take();
1661 }
1662 }
1663 }
1664 else { // positive exp
1665 int maxExp = 308 - expFrac;
1666 while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
1667 exp = exp * 10 + static_cast<int>(s.Take() - '0');
1668 if (RAPIDJSON_UNLIKELY(exp > maxExp))
1669 RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
1670 }
1671 }
1672 }
1673 else
1674 RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissExponent, s.Tell());
1675
1676 if (expMinus)
1677 exp = -exp;
1678 }
1679
1680 // Finish parsing, call event according to the type of number.
1681 bool cont = true;
1682
1683 if (parseFlags & kParseNumbersAsStringsFlag) {
1684 if (parseFlags & kParseInsituFlag) {
1685 s.Pop(); // Pop stack no matter if it will be used or not.
1686 typename InputStream::Ch* head = is.PutBegin();
1687 const size_t length = s.Tell() - startOffset;
1688 RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
1689 // unable to insert the \0 character here, it will erase the comma after this number
1690 const typename TargetEncoding::Ch* const str = reinterpret_cast<typename TargetEncoding::Ch*>(head);
1691 cont = handler.RawNumber(str, SizeType(length), false);
1692 }
1693 else {
1694 SizeType numCharsToCopy = static_cast<SizeType>(s.Length());
1695 StringStream srcStream(s.Pop());
1696 StackStream<typename TargetEncoding::Ch> dstStream(stack_);
1697 while (numCharsToCopy--) {
1698 Transcoder<UTF8<>, TargetEncoding>::Transcode(srcStream, dstStream);
1699 }
1700 dstStream.Put('\0');
1701 const typename TargetEncoding::Ch* str = dstStream.Pop();
1702 const SizeType length = static_cast<SizeType>(dstStream.Length()) - 1;
1703 cont = handler.RawNumber(str, SizeType(length), true);
1704 }
1705 }
1706 else {
1707 size_t length = s.Length();
1708 const char* decimal = s.Pop(); // Pop stack no matter if it will be used or not.
1709
1710 if (useDouble) {
1711 int p = exp + expFrac;
1712 if (parseFlags & kParseFullPrecisionFlag)
1713 d = internal::StrtodFullPrecision(d, p, decimal, length, decimalPosition, exp);
1714 else
1715 d = internal::StrtodNormalPrecision(d, p);
1716
1717 // Use > max, instead of == inf, to fix bogus warning -Wfloat-equal
1718 if (d > (std::numeric_limits<double>::max)()) {
1719 // Overflow
1720 // TODO: internal::StrtodX should report overflow (or underflow)
1721 RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
1722 }
1723
1724 cont = handler.Double(minus ? -d : d);
1725 }
1726 else if (useNanOrInf) {
1727 cont = handler.Double(d);
1728 }
1729 else {
1730 if (use64bit) {
1731 if (minus)
1732 cont = handler.Int64(static_cast<int64_t>(~i64 + 1));
1733 else
1734 cont = handler.Uint64(i64);
1735 }
1736 else {
1737 if (minus)
1738 cont = handler.Int(static_cast<int32_t>(~i + 1));
1739 else
1740 cont = handler.Uint(i);
1741 }
1742 }
1743 }
1744 if (RAPIDJSON_UNLIKELY(!cont))
1745 RAPIDJSON_PARSE_ERROR(kParseErrorTermination, startOffset);
1746 }
1747
1748 // Parse any JSON value
1749 template<unsigned parseFlags, typename InputStream, typename Handler>
1750 void ParseValue(InputStream& is, Handler& handler) {
1751 switch (is.Peek()) {
1752 case 'n': ParseNull <parseFlags>(is, handler); break;
1753 case 't': ParseTrue <parseFlags>(is, handler); break;
1754 case 'f': ParseFalse <parseFlags>(is, handler); break;
1755 case '"': ParseString<parseFlags>(is, handler); break;
1756 case '{': ParseObject<parseFlags>(is, handler); break;
1757 case '[': ParseArray <parseFlags>(is, handler); break;
1758 default :
1759 ParseNumber<parseFlags>(is, handler);
1760 break;
1761
1762 }
1763 }
1764
1765 // Iterative Parsing
1766
1767 // States
1768 enum IterativeParsingState {
1769 IterativeParsingFinishState = 0, // sink states at top
1770 IterativeParsingErrorState, // sink states at top
1771 IterativeParsingStartState,
1772
1773 // Object states
1774 IterativeParsingObjectInitialState,
1775 IterativeParsingMemberKeyState,
1776 IterativeParsingMemberValueState,
1777 IterativeParsingObjectFinishState,
1778
1779 // Array states
1780 IterativeParsingArrayInitialState,
1781 IterativeParsingElementState,
1782 IterativeParsingArrayFinishState,
1783
1784 // Single value state
1785 IterativeParsingValueState,
1786
1787 // Delimiter states (at bottom)
1788 IterativeParsingElementDelimiterState,
1789 IterativeParsingMemberDelimiterState,
1790 IterativeParsingKeyValueDelimiterState,
1791
1792 cIterativeParsingStateCount
1793 };
1794
1795 // Tokens
1796 enum Token {
1797 LeftBracketToken = 0,
1798 RightBracketToken,
1799
1800 LeftCurlyBracketToken,
1801 RightCurlyBracketToken,
1802
1803 CommaToken,
1804 ColonToken,
1805
1806 StringToken,
1807 FalseToken,
1808 TrueToken,
1809 NullToken,
1810 NumberToken,
1811
1812 kTokenCount
1813 };
1814
1815 RAPIDJSON_FORCEINLINE Token Tokenize(Ch c) const {
1816
1817 //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
1818 #define N NumberToken
1819 #define N16 N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N
1820 // Maps from ASCII to Token
1821 static const unsigned char tokenMap[256] = {
1822 N16, // 00~0F
1823 N16, // 10~1F
1824 N, N, StringToken, N, N, N, N, N, N, N, N, N, CommaToken, N, N, N, // 20~2F
1825 N, N, N, N, N, N, N, N, N, N, ColonToken, N, N, N, N, N, // 30~3F
1826 N16, // 40~4F
1827 N, N, N, N, N, N, N, N, N, N, N, LeftBracketToken, N, RightBracketToken, N, N, // 50~5F
1828 N, N, N, N, N, N, FalseToken, N, N, N, N, N, N, N, NullToken, N, // 60~6F
1829 N, N, N, N, TrueToken, N, N, N, N, N, N, LeftCurlyBracketToken, N, RightCurlyBracketToken, N, N, // 70~7F
1830 N16, N16, N16, N16, N16, N16, N16, N16 // 80~FF
1831 };
1832 #undef N
1833 #undef N16
1834 //!@endcond
1835
1836 if (sizeof(Ch) == 1 || static_cast<unsigned>(c) < 256)
1837 return static_cast<Token>(tokenMap[static_cast<unsigned char>(c)]);
1838 else
1839 return NumberToken;
1840 }
1841
1842 RAPIDJSON_FORCEINLINE IterativeParsingState Predict(IterativeParsingState state, Token token) const {
1843 // current state x one lookahead token -> new state
1844 static const char G[cIterativeParsingStateCount][kTokenCount] = {
1845 // Finish(sink state)
1846 {
1847 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1848 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1849 IterativeParsingErrorState
1850 },
1851 // Error(sink state)
1852 {
1853 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1854 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1855 IterativeParsingErrorState
1856 },
1857 // Start
1858 {
1859 IterativeParsingArrayInitialState, // Left bracket
1860 IterativeParsingErrorState, // Right bracket
1861 IterativeParsingObjectInitialState, // Left curly bracket
1862 IterativeParsingErrorState, // Right curly bracket
1863 IterativeParsingErrorState, // Comma
1864 IterativeParsingErrorState, // Colon
1865 IterativeParsingValueState, // String
1866 IterativeParsingValueState, // False
1867 IterativeParsingValueState, // True
1868 IterativeParsingValueState, // Null
1869 IterativeParsingValueState // Number
1870 },
1871 // ObjectInitial
1872 {
1873 IterativeParsingErrorState, // Left bracket
1874 IterativeParsingErrorState, // Right bracket
1875 IterativeParsingErrorState, // Left curly bracket
1876 IterativeParsingObjectFinishState, // Right curly bracket
1877 IterativeParsingErrorState, // Comma
1878 IterativeParsingErrorState, // Colon
1879 IterativeParsingMemberKeyState, // String
1880 IterativeParsingErrorState, // False
1881 IterativeParsingErrorState, // True
1882 IterativeParsingErrorState, // Null
1883 IterativeParsingErrorState // Number
1884 },
1885 // MemberKey
1886 {
1887 IterativeParsingErrorState, // Left bracket
1888 IterativeParsingErrorState, // Right bracket
1889 IterativeParsingErrorState, // Left curly bracket
1890 IterativeParsingErrorState, // Right curly bracket
1891 IterativeParsingErrorState, // Comma
1892 IterativeParsingKeyValueDelimiterState, // Colon
1893 IterativeParsingErrorState, // String
1894 IterativeParsingErrorState, // False
1895 IterativeParsingErrorState, // True
1896 IterativeParsingErrorState, // Null
1897 IterativeParsingErrorState // Number
1898 },
1899 // MemberValue
1900 {
1901 IterativeParsingErrorState, // Left bracket
1902 IterativeParsingErrorState, // Right bracket
1903 IterativeParsingErrorState, // Left curly bracket
1904 IterativeParsingObjectFinishState, // Right curly bracket
1905 IterativeParsingMemberDelimiterState, // Comma
1906 IterativeParsingErrorState, // Colon
1907 IterativeParsingErrorState, // String
1908 IterativeParsingErrorState, // False
1909 IterativeParsingErrorState, // True
1910 IterativeParsingErrorState, // Null
1911 IterativeParsingErrorState // Number
1912 },
1913 // ObjectFinish(sink state)
1914 {
1915 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1916 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1917 IterativeParsingErrorState
1918 },
1919 // ArrayInitial
1920 {
1921 IterativeParsingArrayInitialState, // Left bracket(push Element state)
1922 IterativeParsingArrayFinishState, // Right bracket
1923 IterativeParsingObjectInitialState, // Left curly bracket(push Element state)
1924 IterativeParsingErrorState, // Right curly bracket
1925 IterativeParsingErrorState, // Comma
1926 IterativeParsingErrorState, // Colon
1927 IterativeParsingElementState, // String
1928 IterativeParsingElementState, // False
1929 IterativeParsingElementState, // True
1930 IterativeParsingElementState, // Null
1931 IterativeParsingElementState // Number
1932 },
1933 // Element
1934 {
1935 IterativeParsingErrorState, // Left bracket
1936 IterativeParsingArrayFinishState, // Right bracket
1937 IterativeParsingErrorState, // Left curly bracket
1938 IterativeParsingErrorState, // Right curly bracket
1939 IterativeParsingElementDelimiterState, // Comma
1940 IterativeParsingErrorState, // Colon
1941 IterativeParsingErrorState, // String
1942 IterativeParsingErrorState, // False
1943 IterativeParsingErrorState, // True
1944 IterativeParsingErrorState, // Null
1945 IterativeParsingErrorState // Number
1946 },
1947 // ArrayFinish(sink state)
1948 {
1949 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1950 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1951 IterativeParsingErrorState
1952 },
1953 // Single Value (sink state)
1954 {
1955 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1956 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1957 IterativeParsingErrorState
1958 },
1959 // ElementDelimiter
1960 {
1961 IterativeParsingArrayInitialState, // Left bracket(push Element state)
1962 IterativeParsingArrayFinishState, // Right bracket
1963 IterativeParsingObjectInitialState, // Left curly bracket(push Element state)
1964 IterativeParsingErrorState, // Right curly bracket
1965 IterativeParsingErrorState, // Comma
1966 IterativeParsingErrorState, // Colon
1967 IterativeParsingElementState, // String
1968 IterativeParsingElementState, // False
1969 IterativeParsingElementState, // True
1970 IterativeParsingElementState, // Null
1971 IterativeParsingElementState // Number
1972 },
1973 // MemberDelimiter
1974 {
1975 IterativeParsingErrorState, // Left bracket
1976 IterativeParsingErrorState, // Right bracket
1977 IterativeParsingErrorState, // Left curly bracket
1978 IterativeParsingObjectFinishState, // Right curly bracket
1979 IterativeParsingErrorState, // Comma
1980 IterativeParsingErrorState, // Colon
1981 IterativeParsingMemberKeyState, // String
1982 IterativeParsingErrorState, // False
1983 IterativeParsingErrorState, // True
1984 IterativeParsingErrorState, // Null
1985 IterativeParsingErrorState // Number
1986 },
1987 // KeyValueDelimiter
1988 {
1989 IterativeParsingArrayInitialState, // Left bracket(push MemberValue state)
1990 IterativeParsingErrorState, // Right bracket
1991 IterativeParsingObjectInitialState, // Left curly bracket(push MemberValue state)
1992 IterativeParsingErrorState, // Right curly bracket
1993 IterativeParsingErrorState, // Comma
1994 IterativeParsingErrorState, // Colon
1995 IterativeParsingMemberValueState, // String
1996 IterativeParsingMemberValueState, // False
1997 IterativeParsingMemberValueState, // True
1998 IterativeParsingMemberValueState, // Null
1999 IterativeParsingMemberValueState // Number
2000 },
2001 }; // End of G
2002
2003 return static_cast<IterativeParsingState>(G[state][token]);
2004 }
2005
2006 // Make an advance in the token stream and state based on the candidate destination state which was returned by Transit().
2007 // May return a new state on state pop.
2008 template <unsigned parseFlags, typename InputStream, typename Handler>
2009 RAPIDJSON_FORCEINLINE IterativeParsingState Transit(IterativeParsingState src, Token token, IterativeParsingState dst, InputStream& is, Handler& handler) {
2010 (void)token;
2011
2012 switch (dst) {
2013 case IterativeParsingErrorState:
2014 return dst;
2015
2016 case IterativeParsingObjectInitialState:
2017 case IterativeParsingArrayInitialState:
2018 {
2019 // Push the state(Element or MemeberValue) if we are nested in another array or value of member.
2020 // In this way we can get the correct state on ObjectFinish or ArrayFinish by frame pop.
2021 IterativeParsingState n = src;
2022 if (src == IterativeParsingArrayInitialState || src == IterativeParsingElementDelimiterState)
2023 n = IterativeParsingElementState;
2024 else if (src == IterativeParsingKeyValueDelimiterState)
2025 n = IterativeParsingMemberValueState;
2026 // Push current state.
2027 *stack_.template Push<SizeType>(1) = n;
2028 // Initialize and push the member/element count.
2029 *stack_.template Push<SizeType>(1) = 0;
2030 // Call handler
2031 bool hr = (dst == IterativeParsingObjectInitialState) ? handler.StartObject() : handler.StartArray();
2032 // On handler short circuits the parsing.
2033 if (!hr) {
2034 RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
2035 return IterativeParsingErrorState;
2036 }
2037 else {
2038 is.Take();
2039 return dst;
2040 }
2041 }
2042
2043 case IterativeParsingMemberKeyState:
2044 ParseString<parseFlags>(is, handler, true);
2045 if (HasParseError())
2046 return IterativeParsingErrorState;
2047 else
2048 return dst;
2049
2050 case IterativeParsingKeyValueDelimiterState:
2051 RAPIDJSON_ASSERT(token == ColonToken);
2052 is.Take();
2053 return dst;
2054
2055 case IterativeParsingMemberValueState:
2056 // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
2057 ParseValue<parseFlags>(is, handler);
2058 if (HasParseError()) {
2059 return IterativeParsingErrorState;
2060 }
2061 return dst;
2062
2063 case IterativeParsingElementState:
2064 // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
2065 ParseValue<parseFlags>(is, handler);
2066 if (HasParseError()) {
2067 return IterativeParsingErrorState;
2068 }
2069 return dst;
2070
2071 case IterativeParsingMemberDelimiterState:
2072 case IterativeParsingElementDelimiterState:
2073 is.Take();
2074 // Update member/element count.
2075 *stack_.template Top<SizeType>() = *stack_.template Top<SizeType>() + 1;
2076 return dst;
2077
2078 case IterativeParsingObjectFinishState:
2079 {
2080 // Transit from delimiter is only allowed when trailing commas are enabled
2081 if (!(parseFlags & kParseTrailingCommasFlag) && src == IterativeParsingMemberDelimiterState) {
2082 RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorObjectMissName, is.Tell());
2083 return IterativeParsingErrorState;
2084 }
2085 // Get member count.
2086 SizeType c = *stack_.template Pop<SizeType>(1);
2087 // If the object is not empty, count the last member.
2088 if (src == IterativeParsingMemberValueState)
2089 ++c;
2090 // Restore the state.
2091 IterativeParsingState n = static_cast<IterativeParsingState>(*stack_.template Pop<SizeType>(1));
2092 // Transit to Finish state if this is the topmost scope.
2093 if (n == IterativeParsingStartState)
2094 n = IterativeParsingFinishState;
2095 // Call handler
2096 bool hr = handler.EndObject(c);
2097 // On handler short circuits the parsing.
2098 if (!hr) {
2099 RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
2100 return IterativeParsingErrorState;
2101 }
2102 else {
2103 is.Take();
2104 return n;
2105 }
2106 }
2107
2108 case IterativeParsingArrayFinishState:
2109 {
2110 // Transit from delimiter is only allowed when trailing commas are enabled
2111 if (!(parseFlags & kParseTrailingCommasFlag) && src == IterativeParsingElementDelimiterState) {
2112 RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorValueInvalid, is.Tell());
2113 return IterativeParsingErrorState;
2114 }
2115 // Get element count.
2116 SizeType c = *stack_.template Pop<SizeType>(1);
2117 // If the array is not empty, count the last element.
2118 if (src == IterativeParsingElementState)
2119 ++c;
2120 // Restore the state.
2121 IterativeParsingState n = static_cast<IterativeParsingState>(*stack_.template Pop<SizeType>(1));
2122 // Transit to Finish state if this is the topmost scope.
2123 if (n == IterativeParsingStartState)
2124 n = IterativeParsingFinishState;
2125 // Call handler
2126 bool hr = handler.EndArray(c);
2127 // On handler short circuits the parsing.
2128 if (!hr) {
2129 RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
2130 return IterativeParsingErrorState;
2131 }
2132 else {
2133 is.Take();
2134 return n;
2135 }
2136 }
2137
2138 default:
2139 // This branch is for IterativeParsingValueState actually.
2140 // Use `default:` rather than
2141 // `case IterativeParsingValueState:` is for code coverage.
2142
2143 // The IterativeParsingStartState is not enumerated in this switch-case.
2144 // It is impossible for that case. And it can be caught by following assertion.
2145
2146 // The IterativeParsingFinishState is not enumerated in this switch-case either.
2147 // It is a "derivative" state which cannot triggered from Predict() directly.
2148 // Therefore it cannot happen here. And it can be caught by following assertion.
2149 RAPIDJSON_ASSERT(dst == IterativeParsingValueState);
2150
2151 // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
2152 ParseValue<parseFlags>(is, handler);
2153 if (HasParseError()) {
2154 return IterativeParsingErrorState;
2155 }
2156 return IterativeParsingFinishState;
2157 }
2158 }
2159
2160 template <typename InputStream>
2161 void HandleError(IterativeParsingState src, InputStream& is) {
2162 if (HasParseError()) {
2163 // Error flag has been set.
2164 return;
2165 }
2166
2167 switch (src) {
2168 case IterativeParsingStartState: RAPIDJSON_PARSE_ERROR(kParseErrorDocumentEmpty, is.Tell()); return;
2169 case IterativeParsingFinishState: RAPIDJSON_PARSE_ERROR(kParseErrorDocumentRootNotSingular, is.Tell()); return;
2170 case IterativeParsingObjectInitialState:
2171 case IterativeParsingMemberDelimiterState: RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell()); return;
2172 case IterativeParsingMemberKeyState: RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell()); return;
2173 case IterativeParsingMemberValueState: RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell()); return;
2174 case IterativeParsingKeyValueDelimiterState:
2175 case IterativeParsingArrayInitialState:
2176 case IterativeParsingElementDelimiterState: RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell()); return;
2177 default: RAPIDJSON_ASSERT(src == IterativeParsingElementState); RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell()); return;
2178 }
2179 }
2180
2181 RAPIDJSON_FORCEINLINE bool IsIterativeParsingDelimiterState(IterativeParsingState s) const {
2182 return s >= IterativeParsingElementDelimiterState;
2183 }
2184
2185 RAPIDJSON_FORCEINLINE bool IsIterativeParsingCompleteState(IterativeParsingState s) const {
2186 return s <= IterativeParsingErrorState;
2187 }
2188
2189 template <unsigned parseFlags, typename InputStream, typename Handler>
2190 ParseResult IterativeParse(InputStream& is, Handler& handler) {
2191 parseResult_.Clear();
2192 ClearStackOnExit scope(*this);
2193 IterativeParsingState state = IterativeParsingStartState;
2194
2195 SkipWhitespaceAndComments<parseFlags>(is);
2196 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
2197 while (is.Peek() != '\0') {
2198 Token t = Tokenize(is.Peek());
2199 IterativeParsingState n = Predict(state, t);
2200 IterativeParsingState d = Transit<parseFlags>(state, t, n, is, handler);
2201
2202 if (d == IterativeParsingErrorState) {
2203 HandleError(state, is);
2204 break;
2205 }
2206
2207 state = d;
2208
2209 // Do not further consume streams if a root JSON has been parsed.
2210 if ((parseFlags & kParseStopWhenDoneFlag) && state == IterativeParsingFinishState)
2211 break;
2212
2213 SkipWhitespaceAndComments<parseFlags>(is);
2214 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
2215 }
2216
2217 // Handle the end of file.
2218 if (state != IterativeParsingFinishState)
2219 HandleError(state, is);
2220
2221 return parseResult_;
2222 }
2223
2224 static const size_t kDefaultStackCapacity = 256; //!< Default stack capacity in bytes for storing a single decoded string.
2225 internal::Stack<StackAllocator> stack_; //!< A stack for storing decoded string temporarily during non-destructive parsing.
2226 ParseResult parseResult_;
2227 IterativeParsingState state_;
2228 }; // class GenericReader
2229
2230 //! Reader with UTF8 encoding and default allocator.
2231 typedef GenericReader<UTF8<>, UTF8<> > Reader;
2232
2233 RAPIDJSON_NAMESPACE_END
2234
2235 #if defined(__clang__) || defined(_MSC_VER)
2236 RAPIDJSON_DIAG_POP
2237 #endif
2238
2239
2240 #ifdef __GNUC__
2241 RAPIDJSON_DIAG_POP
2242 #endif
2243
2244 #endif // RAPIDJSON_READER_H_
rapidjson::ParseResult
Result of parsing (wraps ParseErrorCode)
Definition: error.h:106
rapidjson::ParseFlag
ParseFlag
Combination of parseFlags
Definition: reader.h:146
rapidjson::StringStream
GenericStringStream< UTF8< char > > StringStream
String stream with UTF8 encoding.
Definition: fwd.h:47
rapidjson::kParseErrorUnspecificSyntaxError
@ kParseErrorUnspecificSyntaxError
Unspecific syntax error.
Definition: error.h:89
Stream
Concept for reading and writing characters.
rapidjson::kParseErrorDocumentRootNotSingular
@ kParseErrorDocumentRootNotSingular
The document root must not follow by other values.
Definition: error.h:68
rapidjson::BaseReaderHandler::RawNumber
bool RawNumber(const Ch *str, SizeType len, bool copy)
enabled via kParseNumbersAsStringsFlag, string is not null-terminated (use length)
Definition: reader.h:212
rapidjson::GenericInsituStringStream
A read-write string stream.
Definition: stream.h:188
rapidjson::Type
Type
Type of JSON value
Definition: rapidjson.h:680
rapidjson::kParseNoFlags
@ kParseNoFlags
No flags are set.
Definition: reader.h:147
rapidjson::kParseNanAndInfFlag
@ kParseNanAndInfFlag
Allow parsing NaN, Inf, Infinity, -Inf and -Infinity as doubles.
Definition: reader.h:156
rapidjson::kParseErrorObjectMissCommaOrCurlyBracket
@ kParseErrorObjectMissCommaOrCurlyBracket
Missing a comma or '}' after an object member.
Definition: error.h:74
rapidjson::kParseValidateEncodingFlag
@ kParseValidateEncodingFlag
Validate encoding of JSON strings.
Definition: reader.h:149
rapidjson::kParseErrorStringMissQuotationMark
@ kParseErrorStringMissQuotationMark
Missing a closing quotation mark in string.
Definition: error.h:81
rapidjson::kParseIterativeFlag
@ kParseIterativeFlag
Iterative(constant complexity in terms of function call stack size) parsing.
Definition: reader.h:150
RAPIDJSON_PARSE_DEFAULT_FLAGS
#define RAPIDJSON_PARSE_DEFAULT_FLAGS
User-defined kParseDefaultFlags definition.
Definition: reader.h:140
rapidjson::GenericReader::IterativeParseInit
void IterativeParseInit()
Initialize JSON text token-by-token parsing
Definition: reader.h:607
rapidjson::kParseErrorObjectMissName
@ kParseErrorObjectMissName
Missing a name for object member.
Definition: error.h:72
rapidjson::kParseErrorStringInvalidEncoding
@ kParseErrorStringInvalidEncoding
Invalid encoding in string.
Definition: error.h:82
rapidjson::GenericReader::IterativeParseNext
bool IterativeParseNext(InputStream &is, Handler &handler)
Parse one token from JSON text
Definition: reader.h:620
rapidjson::GenericStringStream
Read-only string stream.
Definition: stream.h:154
rapidjson::kParseFullPrecisionFlag
@ kParseFullPrecisionFlag
Parse number in full precision (but slower).
Definition: reader.h:152
rapidjson::ParseErrorCode
ParseErrorCode
Error code of parsing.
Definition: error.h:64
rapidjson::kParseErrorStringUnicodeSurrogateInvalid
@ kParseErrorStringUnicodeSurrogateInvalid
The surrogate pair in string is invalid.
Definition: error.h:79
rapidjson::SizeType
unsigned SizeType
Size type (for string lengths, array sizes, etc.)
Definition: rapidjson.h:384
rapidjson::kParseTrailingCommasFlag
@ kParseTrailingCommasFlag
Allow trailing commas at the end of objects and arrays.
Definition: reader.h:155
RAPIDJSON_ASSERT
#define RAPIDJSON_ASSERT(x)
Assertion.
Definition: rapidjson.h:406
rapidjson::GenericReader::Parse
ParseResult Parse(InputStream &is, Handler &handler)
Parse JSON text.
Definition: reader.h:559
rapidjson::GenericReader::Parse
ParseResult Parse(InputStream &is, Handler &handler)
Parse JSON text (with kParseDefaultFlags)
Definition: reader.h:600
RAPIDJSON_PARSE_ERROR_NORETURN
#define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset)
Macro to indicate a parse error.
Definition: reader.h:100
rapidjson::GenericReader::IterativeParseComplete
RAPIDJSON_FORCEINLINE bool IterativeParseComplete() const
Check if token-by-token parsing JSON text is complete
Definition: reader.h:677
rapidjson::kParseErrorDocumentEmpty
@ kParseErrorDocumentEmpty
The document is empty.
Definition: error.h:67
rapidjson::GenericReader
SAX-style JSON parser. Use Reader for UTF8 encoding and default allocator.
Definition: reader.h:539
rapidjson::GenericReader::GetParseErrorCode
ParseErrorCode GetParseErrorCode() const
Get the ParseErrorCode of last parsing.
Definition: reader.h:685
error.h
rapidjson::kParseEscapedApostropheFlag
@ kParseEscapedApostropheFlag
Allow escaped apostrophe in strings.
Definition: reader.h:157
rapidjson::kParseDefaultFlags
@ kParseDefaultFlags
Default parse flags. Can be customized by defining RAPIDJSON_PARSE_DEFAULT_FLAGS
Definition: reader.h:158
rapidjson::kParseErrorNumberTooBig
@ kParseErrorNumberTooBig
Number too big to be stored in double.
Definition: error.h:84
rapidjson::kParseStopWhenDoneFlag
@ kParseStopWhenDoneFlag
After parsing a complete JSON root from stream, stop further processing the rest of stream....
Definition: reader.h:151
rapidjson::kParseCommentsFlag
@ kParseCommentsFlag
Allow one-line (//) and multi-line (/‍**/) comments.
Definition: reader.h:153
rapidjson::SkipWhitespace
void SkipWhitespace(InputStream &is)
Skip the JSON white spaces in a stream.
Definition: reader.h:266
rapidjson::kParseInsituFlag
@ kParseInsituFlag
In-situ(destructive) parsing.
Definition: reader.h:148
rapidjson::BaseReaderHandler
Default implementation of Handler.
Definition: reader.h:198
rapidjson::kParseErrorTermination
@ kParseErrorTermination
Parsing was terminated.
Definition: error.h:88
rapidjson::kParseErrorArrayMissCommaOrSquareBracket
@ kParseErrorArrayMissCommaOrSquareBracket
Missing a comma or ']' after an array element.
Definition: error.h:76
rapidjson::GenericReader::Ch
SourceEncoding::Ch Ch
SourceEncoding character type
Definition: reader.h:541
rapidjson::kParseErrorNumberMissFraction
@ kParseErrorNumberMissFraction
Miss fraction part in number.
Definition: error.h:85
rapidjson::GenericReader::GenericReader
GenericReader(StackAllocator *stackAllocator=0, size_t stackCapacity=kDefaultStackCapacity)
Constructor.
Definition: reader.h:547
rapidjson::kParseErrorNumberMissExponent
@ kParseErrorNumberMissExponent
Miss exponent in number.
Definition: error.h:86
RAPIDJSON_LIKELY
#define RAPIDJSON_LIKELY(x)
Compiler branching hint for expression with high probability to be true.
Definition: rapidjson.h:463
rapidjson::kParseErrorStringEscapeInvalid
@ kParseErrorStringEscapeInvalid
Invalid escape character in string.
Definition: error.h:80
RAPIDJSON_PARSE_ERROR
#define RAPIDJSON_PARSE_ERROR(parseErrorCode, offset)
(Internal) macro to indicate and handle a parse error.
Definition: reader.h:119
rapidjson::Reader
GenericReader< UTF8< char >, UTF8< char >, CrtAllocator > Reader
Reader with UTF8 encoding and default allocator.
Definition: fwd.h:88
RAPIDJSON_UNLIKELY
#define RAPIDJSON_UNLIKELY(x)
Compiler branching hint for expression with low probability to be true.
Definition: rapidjson.h:476
rapidjson::kParseErrorValueInvalid
@ kParseErrorValueInvalid
Invalid value.
Definition: error.h:70
rapidjson::GenericReader::HasParseError
bool HasParseError() const
Whether a parse error has occurred in the last parsing.
Definition: reader.h:682
rapidjson::GenericReader::GetErrorOffset
size_t GetErrorOffset() const
Get the position of last parsing error in input, 0 otherwise.
Definition: reader.h:688
RAPIDJSON_UINT64_C2
#define RAPIDJSON_UINT64_C2(high32, low32)
Construct a 64-bit literal by a pair of 32-bit integer.
Definition: rapidjson.h:289
rapidjson::GenericStringStream::src_
const Ch * src_
Current read position.
Definition: stream.h:168
rapidjson::kParseNumbersAsStringsFlag
@ kParseNumbersAsStringsFlag
Parse all numbers (ints/doubles) as strings.
Definition: reader.h:154
Handler
Concept for receiving events from GenericReader upon parsing. The functions return true if no error o...
rapidjson::kParseErrorObjectMissColon
@ kParseErrorObjectMissColon
Missing a colon after a name of object member.
Definition: error.h:73
rapidjson::kParseErrorStringUnicodeEscapeInvalidHex
@ kParseErrorStringUnicodeEscapeInvalidHex
Incorrect hex digit after \u escape in string.
Definition: error.h:78