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