15#ifndef RAPIDJSON_READER_H_
16#define RAPIDJSON_READER_H_
20#include "allocators.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"
29#if defined(RAPIDJSON_SIMD) && defined(_MSC_VER)
31#pragma intrinsic(_BitScanForward)
35#elif defined(RAPIDJSON_SSE2)
37#elif defined(RAPIDJSON_NEON)
43RAPIDJSON_DIAG_OFF(old-style-cast)
44RAPIDJSON_DIAG_OFF(padded)
45RAPIDJSON_DIAG_OFF(
switch-
enum)
46#elif defined(_MSC_VER)
48RAPIDJSON_DIAG_OFF(4127)
49RAPIDJSON_DIAG_OFF(4702)
54RAPIDJSON_DIAG_OFF(effc++)
58#define RAPIDJSON_NOTHING
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
65#define RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID \
66 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
99#ifndef RAPIDJSON_PARSE_ERROR_NORETURN
100#define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset) \
101 RAPIDJSON_MULTILINEMACRO_BEGIN \
102 RAPIDJSON_ASSERT(!HasParseError()); \
103 SetParseError(parseErrorCode, offset); \
104 RAPIDJSON_MULTILINEMACRO_END
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
128RAPIDJSON_NAMESPACE_BEGIN
139#ifndef RAPIDJSON_PARSE_DEFAULT_FLAGS
140#define RAPIDJSON_PARSE_DEFAULT_FLAGS kParseNoFlags
179 bool RawNumber(const Ch* str, SizeType length, bool copy);
180 bool String(const Ch* str, SizeType length, bool copy);
182 bool Key(const Ch* str, SizeType length, bool copy);
183 bool EndObject(SizeType memberCount);
185 bool EndArray(SizeType elementCount);
196template<
typename Encoding = UTF8<>,
typename Derived =
void>
198 typedef typename Encoding::Ch Ch;
200 typedef typename internal::SelectIf<internal::IsSame<Derived, void>,
BaseReaderHandler, Derived>
::Type Override;
202 bool Default() {
return true; }
203 bool Null() {
return static_cast<Override&
>(*this).Default(); }
204 bool Bool(
bool) {
return static_cast<Override&
>(*this).Default(); }
205 bool Int(
int) {
return static_cast<Override&
>(*this).Default(); }
206 bool Uint(
unsigned) {
return static_cast<Override&
>(*this).Default(); }
207 bool Int64(int64_t) {
return static_cast<Override&
>(*this).Default(); }
208 bool Uint64(uint64_t) {
return static_cast<Override&
>(*this).Default(); }
209 bool Double(
double) {
return static_cast<Override&
>(*this).Default(); }
211 bool RawNumber(
const Ch* str,
SizeType len,
bool copy) {
return static_cast<Override&
>(*this).String(str, len, copy); }
212 bool String(
const Ch*,
SizeType,
bool) {
return static_cast<Override&
>(*this).Default(); }
213 bool StartObject() {
return static_cast<Override&
>(*this).Default(); }
214 bool Key(
const Ch* str,
SizeType len,
bool copy) {
return static_cast<Override&
>(*this).String(str, len, copy); }
215 bool EndObject(
SizeType) {
return static_cast<Override&
>(*this).Default(); }
216 bool StartArray() {
return static_cast<Override&
>(*this).Default(); }
217 bool EndArray(
SizeType) {
return static_cast<Override&
>(*this).Default(); }
225template<typename Stream, int = StreamTraits<Stream>::copyOptimization>
226class StreamLocalCopy;
229template<
typename Stream>
230class StreamLocalCopy<
Stream, 1> {
232 StreamLocalCopy(
Stream& original) : s(original), original_(original) {}
233 ~StreamLocalCopy() { original_ = s; }
238 StreamLocalCopy& operator=(
const StreamLocalCopy&) ;
244template<
typename Stream>
245class StreamLocalCopy<
Stream, 0> {
247 StreamLocalCopy(
Stream& original) : s(original) {}
252 StreamLocalCopy& operator=(
const StreamLocalCopy&) ;
264template<
typename InputStream>
266 internal::StreamLocalCopy<InputStream> copy(is);
267 InputStream& s(copy.s);
269 typename InputStream::Ch c;
270 while ((c = s.Peek()) ==
' ' || c ==
'\n' || c ==
'\r' || c ==
'\t')
274inline const char* SkipWhitespace(
const char* p,
const char* end) {
275 while (p != end && (*p ==
' ' || *p ==
'\n' || *p ==
'\r' || *p ==
'\t'))
280#ifdef RAPIDJSON_SSE42
282inline const char *SkipWhitespace_SIMD(
const char* p) {
284 if (*p ==
' ' || *p ==
'\n' || *p ==
'\r' || *p ==
'\t')
290 const char* nextAligned =
reinterpret_cast<const char*
>((
reinterpret_cast<size_t>(p) + 15) &
static_cast<size_t>(~15));
291 while (p != nextAligned)
292 if (*p ==
' ' || *p ==
'\n' || *p ==
'\r' || *p ==
'\t')
298 static const char whitespace[16] =
" \n\r\t";
299 const __m128i w = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&whitespace[0]));
302 const __m128i s = _mm_load_si128(
reinterpret_cast<const __m128i *
>(p));
303 const int r = _mm_cmpistri(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT | _SIDD_NEGATIVE_POLARITY);
309inline const char *SkipWhitespace_SIMD(
const char* p,
const char* end) {
311 if (p != end && (*p ==
' ' || *p ==
'\n' || *p ==
'\r' || *p ==
'\t'))
317 static const char whitespace[16] =
" \n\r\t";
318 const __m128i w = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&whitespace[0]));
320 for (; p <= end - 16; p += 16) {
321 const __m128i s = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(p));
322 const int r = _mm_cmpistri(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT | _SIDD_NEGATIVE_POLARITY);
330#elif defined(RAPIDJSON_SSE2)
333inline const char *SkipWhitespace_SIMD(
const char* p) {
335 if (*p ==
' ' || *p ==
'\n' || *p ==
'\r' || *p ==
'\t')
341 const char* nextAligned =
reinterpret_cast<const char*
>((
reinterpret_cast<size_t>(p) + 15) &
static_cast<size_t>(~15));
342 while (p != nextAligned)
343 if (*p ==
' ' || *p ==
'\n' || *p ==
'\r' || *p ==
'\t')
349 #define C16(c) { c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c }
350 static const char whitespaces[4][16] = { C16(
' '), C16(
'\n'), C16(
'\r'), C16(
'\t') };
353 const __m128i w0 = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&whitespaces[0][0]));
354 const __m128i w1 = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&whitespaces[1][0]));
355 const __m128i w2 = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&whitespaces[2][0]));
356 const __m128i w3 = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&whitespaces[3][0]));
359 const __m128i s = _mm_load_si128(
reinterpret_cast<const __m128i *
>(p));
360 __m128i x = _mm_cmpeq_epi8(s, w0);
361 x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1));
362 x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2));
363 x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3));
364 unsigned short r =
static_cast<unsigned short>(~_mm_movemask_epi8(x));
367 unsigned long offset;
368 _BitScanForward(&offset, r);
371 return p + __builtin_ffs(r) - 1;
377inline const char *SkipWhitespace_SIMD(
const char* p,
const char* end) {
379 if (p != end && (*p ==
' ' || *p ==
'\n' || *p ==
'\r' || *p ==
'\t'))
385 #define C16(c) { c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c }
386 static const char whitespaces[4][16] = { C16(
' '), C16(
'\n'), C16(
'\r'), C16(
'\t') };
389 const __m128i w0 = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&whitespaces[0][0]));
390 const __m128i w1 = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&whitespaces[1][0]));
391 const __m128i w2 = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&whitespaces[2][0]));
392 const __m128i w3 = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&whitespaces[3][0]));
394 for (; p <= end - 16; p += 16) {
395 const __m128i s = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(p));
396 __m128i x = _mm_cmpeq_epi8(s, w0);
397 x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1));
398 x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2));
399 x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3));
400 unsigned short r =
static_cast<unsigned short>(~_mm_movemask_epi8(x));
403 unsigned long offset;
404 _BitScanForward(&offset, r);
407 return p + __builtin_ffs(r) - 1;
415#elif defined(RAPIDJSON_NEON)
418inline const char *SkipWhitespace_SIMD(
const char* p) {
420 if (*p ==
' ' || *p ==
'\n' || *p ==
'\r' || *p ==
'\t')
426 const char* nextAligned =
reinterpret_cast<const char*
>((
reinterpret_cast<size_t>(p) + 15) &
static_cast<size_t>(~15));
427 while (p != nextAligned)
428 if (*p ==
' ' || *p ==
'\n' || *p ==
'\r' || *p ==
'\t')
433 const uint8x16_t w0 = vmovq_n_u8(
' ');
434 const uint8x16_t w1 = vmovq_n_u8(
'\n');
435 const uint8x16_t w2 = vmovq_n_u8(
'\r');
436 const uint8x16_t w3 = vmovq_n_u8(
'\t');
439 const uint8x16_t s = vld1q_u8(
reinterpret_cast<const uint8_t *
>(p));
440 uint8x16_t x = vceqq_u8(s, w0);
441 x = vorrq_u8(x, vceqq_u8(s, w1));
442 x = vorrq_u8(x, vceqq_u8(s, w2));
443 x = vorrq_u8(x, vceqq_u8(s, w3));
447 uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);
448 uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);
452 uint32_t lz = RAPIDJSON_CLZLL(high);
453 return p + 8 + (lz >> 3);
456 uint32_t lz = RAPIDJSON_CLZLL(low);
457 return p + (lz >> 3);
462inline const char *SkipWhitespace_SIMD(
const char* p,
const char* end) {
464 if (p != end && (*p ==
' ' || *p ==
'\n' || *p ==
'\r' || *p ==
'\t'))
469 const uint8x16_t w0 = vmovq_n_u8(
' ');
470 const uint8x16_t w1 = vmovq_n_u8(
'\n');
471 const uint8x16_t w2 = vmovq_n_u8(
'\r');
472 const uint8x16_t w3 = vmovq_n_u8(
'\t');
474 for (; p <= end - 16; p += 16) {
475 const uint8x16_t s = vld1q_u8(
reinterpret_cast<const uint8_t *
>(p));
476 uint8x16_t x = vceqq_u8(s, w0);
477 x = vorrq_u8(x, vceqq_u8(s, w1));
478 x = vorrq_u8(x, vceqq_u8(s, w2));
479 x = vorrq_u8(x, vceqq_u8(s, w3));
483 uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);
484 uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);
488 uint32_t lz = RAPIDJSON_CLZLL(high);
489 return p + 8 + (lz >> 3);
492 uint32_t lz = RAPIDJSON_CLZLL(low);
493 return p + (lz >> 3);
505 is.src_ =
const_cast<char*
>(SkipWhitespace_SIMD(is.src_));
510 is.
src_ = SkipWhitespace_SIMD(is.
src_);
513template<>
inline void SkipWhitespace(EncodedInputStream<UTF8<>, MemoryStream>& is) {
514 is.is_.src_ = SkipWhitespace_SIMD(is.is_.src_, is.is_.end_);
537template <
typename SourceEncoding,
typename TargetEncoding,
typename StackAllocator = CrtAllocator>
540 typedef typename SourceEncoding::Ch
Ch;
546 GenericReader(StackAllocator* stackAllocator = 0,
size_t stackCapacity = kDefaultStackCapacity) :
547 stack_(stackAllocator, stackCapacity), parseResult_(), state_(IterativeParsingStartState) {}
557 template <
unsigned parseFlags,
typename InputStream,
typename Handler>
560 return IterativeParse<parseFlags>(is, handler);
562 parseResult_.Clear();
564 ClearStackOnExit scope(*
this);
566 SkipWhitespaceAndComments<parseFlags>(is);
567 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
571 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
574 ParseValue<parseFlags>(is, handler);
575 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
578 SkipWhitespaceAndComments<parseFlags>(is);
579 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
583 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
598 template <
typename InputStream,
typename Handler>
600 return Parse<kParseDefaultFlags>(is, handler);
607 parseResult_.Clear();
608 state_ = IterativeParsingStartState;
618 template <
unsigned parseFlags,
typename InputStream,
typename Handler>
621 SkipWhitespaceAndComments<parseFlags>(is);
623 Token t = Tokenize(is.Peek());
624 IterativeParsingState n = Predict(state_, t);
625 IterativeParsingState d = Transit<parseFlags>(state_, t, n, is, handler);
630 if (d == IterativeParsingErrorState) {
631 HandleError(state_, is);
642 SkipWhitespaceAndComments<parseFlags>(is);
643 if (is.Peek() !=
'\0') {
645 HandleError(state_, is);
658 if (!IsIterativeParsingDelimiterState(n))
665 if (state_ != IterativeParsingFinishState) {
666 HandleError(state_, is);
677 return IsIterativeParsingCompleteState(state_);
690 void SetParseError(
ParseErrorCode code,
size_t offset) { parseResult_.Set(code, offset); }
694 GenericReader(
const GenericReader&);
695 GenericReader& operator=(
const GenericReader&);
697 void ClearStack() { stack_.Clear(); }
700 struct ClearStackOnExit {
701 explicit ClearStackOnExit(GenericReader& r) : r_(r) {}
702 ~ClearStackOnExit() { r_.ClearStack(); }
705 ClearStackOnExit(
const ClearStackOnExit&);
706 ClearStackOnExit& operator=(
const ClearStackOnExit&);
709 template<
unsigned parseFlags,
typename InputStream>
710 void SkipWhitespaceAndComments(InputStream& is) {
715 if (Consume(is,
'*')) {
719 else if (Consume(is,
'*')) {
720 if (Consume(is,
'/'))
728 while (is.Peek() !=
'\0' && is.Take() !=
'\n') {}
738 template<
unsigned parseFlags,
typename InputStream,
typename Handler>
739 void ParseObject(InputStream& is,
Handler& handler) {
746 SkipWhitespaceAndComments<parseFlags>(is);
747 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
749 if (Consume(is,
'}')) {
759 ParseString<parseFlags>(is, handler,
true);
760 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
762 SkipWhitespaceAndComments<parseFlags>(is);
763 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
768 SkipWhitespaceAndComments<parseFlags>(is);
769 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
771 ParseValue<parseFlags>(is, handler);
772 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
774 SkipWhitespaceAndComments<parseFlags>(is);
775 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
782 SkipWhitespaceAndComments<parseFlags>(is);
783 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
795 if (is.Peek() ==
'}') {
806 template<
unsigned parseFlags,
typename InputStream,
typename Handler>
807 void ParseArray(InputStream& is,
Handler& handler) {
814 SkipWhitespaceAndComments<parseFlags>(is);
815 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
817 if (Consume(is,
']')) {
824 ParseValue<parseFlags>(is, handler);
825 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
828 SkipWhitespaceAndComments<parseFlags>(is);
829 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
831 if (Consume(is,
',')) {
832 SkipWhitespaceAndComments<parseFlags>(is);
833 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
835 else if (Consume(is,
']')) {
844 if (is.Peek() ==
']') {
854 template<
unsigned parseFlags,
typename InputStream,
typename Handler>
855 void ParseNull(InputStream& is,
Handler& handler) {
859 if (
RAPIDJSON_LIKELY(Consume(is,
'u') && Consume(is,
'l') && Consume(is,
'l'))) {
867 template<
unsigned parseFlags,
typename InputStream,
typename Handler>
868 void ParseTrue(InputStream& is,
Handler& handler) {
872 if (
RAPIDJSON_LIKELY(Consume(is,
'r') && Consume(is,
'u') && Consume(is,
'e'))) {
880 template<
unsigned parseFlags,
typename InputStream,
typename Handler>
881 void ParseFalse(InputStream& is,
Handler& handler) {
885 if (
RAPIDJSON_LIKELY(Consume(is,
'a') && Consume(is,
'l') && Consume(is,
's') && Consume(is,
'e'))) {
893 template<
typename InputStream>
894 RAPIDJSON_FORCEINLINE
static bool Consume(InputStream& is,
typename InputStream::Ch expect) {
904 template<
typename InputStream>
905 unsigned ParseHex4(InputStream& is,
size_t escapeOffset) {
906 unsigned codepoint = 0;
907 for (
int i = 0; i < 4; i++) {
910 codepoint +=
static_cast<unsigned>(c);
911 if (c >=
'0' && c <=
'9')
913 else if (c >=
'A' && c <=
'F')
914 codepoint -=
'A' - 10;
915 else if (c >=
'a' && c <=
'f')
916 codepoint -=
'a' - 10;
919 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(0);
926 template <
typename CharType>
931 StackStream(internal::Stack<StackAllocator>& stack) : stack_(stack), length_(0) {}
932 RAPIDJSON_FORCEINLINE
void Put(Ch c) {
933 *stack_.template Push<Ch>() = c;
937 RAPIDJSON_FORCEINLINE
void* Push(
SizeType count) {
939 return stack_.template Push<Ch>(count);
942 size_t Length()
const {
return length_; }
945 return stack_.template Pop<Ch>(length_);
949 StackStream(
const StackStream&);
950 StackStream& operator=(
const StackStream&);
952 internal::Stack<StackAllocator>& stack_;
957 template<
unsigned parseFlags,
typename InputStream,
typename Handler>
958 void ParseString(InputStream& is,
Handler& handler,
bool isKey =
false) {
959 internal::StreamLocalCopy<InputStream> copy(is);
960 InputStream& s(copy.s);
965 bool success =
false;
967 typename InputStream::Ch *head = s.PutBegin();
968 ParseStringToStream<parseFlags, SourceEncoding, SourceEncoding>(s, s);
969 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
970 size_t length = s.PutEnd(head) - 1;
972 const typename TargetEncoding::Ch*
const str =
reinterpret_cast<typename TargetEncoding::Ch*
>(head);
973 success = (isKey ? handler.Key(str,
SizeType(length),
false) : handler.String(str,
SizeType(length),
false));
976 StackStream<typename TargetEncoding::Ch> stackStream(stack_);
977 ParseStringToStream<parseFlags, SourceEncoding, TargetEncoding>(s, stackStream);
978 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
980 const typename TargetEncoding::Ch*
const str = stackStream.Pop();
981 success = (isKey ? handler.Key(str, length,
true) : handler.String(str, length,
true));
989 template<
unsigned parseFlags,
typename SEncoding,
typename TEncoding,
typename InputStream,
typename OutputStream>
990 RAPIDJSON_FORCEINLINE
void ParseStringToStream(InputStream& is, OutputStream& os) {
992#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
993 static const char escape[256] = {
994 Z16, Z16, 0, 0,
'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
'/',
995 Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
'\\', 0, 0, 0,
996 0, 0,
'\b', 0, 0, 0,
'\f', 0, 0, 0, 0, 0, 0, 0,
'\n', 0,
997 0, 0,
'\r', 0,
'\t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
998 Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
1006 ScanCopyUnescapedString(is, os);
1010 size_t escapeOffset = is.Tell();
1013 if ((
sizeof(Ch) == 1 ||
unsigned(e) < 256) &&
RAPIDJSON_LIKELY(escape[
static_cast<unsigned char>(e)])) {
1015 os.Put(
static_cast<typename TEncoding::Ch
>(escape[
static_cast<unsigned char>(e)]));
1019 unsigned codepoint = ParseHex4(is, escapeOffset);
1020 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
1025 unsigned codepoint2 = ParseHex4(is, escapeOffset);
1026 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
1029 codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000;
1031 TEncoding::Encode(os, codepoint);
1048 size_t offset = is.Tell();
1050 !Transcoder<SEncoding, TEncoding>::Validate(is, os) :
1051 !Transcoder<SEncoding, TEncoding>::Transcode(is, os))))
1057 template<
typename InputStream,
typename OutputStream>
1058 static RAPIDJSON_FORCEINLINE
void ScanCopyUnescapedString(InputStream&, OutputStream&) {
1062#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42)
1064 static RAPIDJSON_FORCEINLINE
void ScanCopyUnescapedString(StringStream& is, StackStream<char>& os) {
1065 const char* p = is.src_;
1068 const char* nextAligned =
reinterpret_cast<const char*
>((
reinterpret_cast<size_t>(p) + 15) &
static_cast<size_t>(~15));
1069 while (p != nextAligned)
1078 static const char dquote[16] = {
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"' };
1079 static const char bslash[16] = {
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\' };
1080 static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
1081 const __m128i dq = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&dquote[0]));
1082 const __m128i bs = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&bslash[0]));
1083 const __m128i sp = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&space[0]));
1086 const __m128i s = _mm_load_si128(
reinterpret_cast<const __m128i *
>(p));
1087 const __m128i t1 = _mm_cmpeq_epi8(s, dq);
1088 const __m128i t2 = _mm_cmpeq_epi8(s, bs);
1089 const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp);
1090 const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
1091 unsigned short r =
static_cast<unsigned short>(_mm_movemask_epi8(x));
1095 unsigned long offset;
1096 _BitScanForward(&offset, r);
1099 length =
static_cast<SizeType>(__builtin_ffs(r) - 1);
1102 char* q =
reinterpret_cast<char*
>(os.Push(length));
1103 for (
size_t i = 0; i < length; i++)
1110 _mm_storeu_si128(
reinterpret_cast<__m128i *
>(os.Push(16)), s);
1117 static RAPIDJSON_FORCEINLINE
void ScanCopyUnescapedString(InsituStringStream& is, InsituStringStream& os) {
1121 if (is.src_ == is.dst_) {
1122 SkipUnescapedString(is);
1130 const char* nextAligned =
reinterpret_cast<const char*
>((
reinterpret_cast<size_t>(p) + 15) &
static_cast<size_t>(~15));
1131 while (p != nextAligned)
1141 static const char dquote[16] = {
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"' };
1142 static const char bslash[16] = {
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\' };
1143 static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
1144 const __m128i dq = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&dquote[0]));
1145 const __m128i bs = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&bslash[0]));
1146 const __m128i sp = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&space[0]));
1148 for (;; p += 16, q += 16) {
1149 const __m128i s = _mm_load_si128(
reinterpret_cast<const __m128i *
>(p));
1150 const __m128i t1 = _mm_cmpeq_epi8(s, dq);
1151 const __m128i t2 = _mm_cmpeq_epi8(s, bs);
1152 const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp);
1153 const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
1154 unsigned short r =
static_cast<unsigned short>(_mm_movemask_epi8(x));
1158 unsigned long offset;
1159 _BitScanForward(&offset, r);
1162 length =
static_cast<size_t>(__builtin_ffs(r) - 1);
1164 for (
const char* pend = p + length; p != pend; )
1168 _mm_storeu_si128(
reinterpret_cast<__m128i *
>(q), s);
1176 static RAPIDJSON_FORCEINLINE
void SkipUnescapedString(InsituStringStream& is) {
1181 const char* nextAligned =
reinterpret_cast<const char*
>((
reinterpret_cast<size_t>(p) + 15) &
static_cast<size_t>(~15));
1182 for (; p != nextAligned; p++)
1184 is.src_ = is.dst_ = p;
1189 static const char dquote[16] = {
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"' };
1190 static const char bslash[16] = {
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\' };
1191 static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
1192 const __m128i dq = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&dquote[0]));
1193 const __m128i bs = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&bslash[0]));
1194 const __m128i sp = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&space[0]));
1197 const __m128i s = _mm_load_si128(
reinterpret_cast<const __m128i *
>(p));
1198 const __m128i t1 = _mm_cmpeq_epi8(s, dq);
1199 const __m128i t2 = _mm_cmpeq_epi8(s, bs);
1200 const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp);
1201 const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
1202 unsigned short r =
static_cast<unsigned short>(_mm_movemask_epi8(x));
1206 unsigned long offset;
1207 _BitScanForward(&offset, r);
1210 length =
static_cast<size_t>(__builtin_ffs(r) - 1);
1217 is.src_ = is.dst_ = p;
1219#elif defined(RAPIDJSON_NEON)
1221 static RAPIDJSON_FORCEINLINE
void ScanCopyUnescapedString(StringStream& is, StackStream<char>& os) {
1222 const char* p = is.src_;
1225 const char* nextAligned =
reinterpret_cast<const char*
>((
reinterpret_cast<size_t>(p) + 15) &
static_cast<size_t>(~15));
1226 while (p != nextAligned)
1235 const uint8x16_t s0 = vmovq_n_u8(
'"');
1236 const uint8x16_t s1 = vmovq_n_u8(
'\\');
1237 const uint8x16_t s2 = vmovq_n_u8(
'\b');
1238 const uint8x16_t s3 = vmovq_n_u8(32);
1241 const uint8x16_t s = vld1q_u8(
reinterpret_cast<const uint8_t *
>(p));
1242 uint8x16_t x = vceqq_u8(s, s0);
1243 x = vorrq_u8(x, vceqq_u8(s, s1));
1244 x = vorrq_u8(x, vceqq_u8(s, s2));
1245 x = vorrq_u8(x, vcltq_u8(s, s3));
1248 uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);
1249 uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);
1252 bool escaped =
false;
1255 uint32_t lz = RAPIDJSON_CLZLL(high);
1256 length = 8 + (lz >> 3);
1260 uint32_t lz = RAPIDJSON_CLZLL(low);
1266 char* q =
reinterpret_cast<char*
>(os.Push(length));
1267 for (
size_t i = 0; i < length; i++)
1274 vst1q_u8(
reinterpret_cast<uint8_t *
>(os.Push(16)), s);
1281 static RAPIDJSON_FORCEINLINE
void ScanCopyUnescapedString(InsituStringStream& is, InsituStringStream& os) {
1285 if (is.src_ == is.dst_) {
1286 SkipUnescapedString(is);
1294 const char* nextAligned =
reinterpret_cast<const char*
>((
reinterpret_cast<size_t>(p) + 15) &
static_cast<size_t>(~15));
1295 while (p != nextAligned)
1305 const uint8x16_t s0 = vmovq_n_u8(
'"');
1306 const uint8x16_t s1 = vmovq_n_u8(
'\\');
1307 const uint8x16_t s2 = vmovq_n_u8(
'\b');
1308 const uint8x16_t s3 = vmovq_n_u8(32);
1310 for (;; p += 16, q += 16) {
1311 const uint8x16_t s = vld1q_u8(
reinterpret_cast<uint8_t *
>(p));
1312 uint8x16_t x = vceqq_u8(s, s0);
1313 x = vorrq_u8(x, vceqq_u8(s, s1));
1314 x = vorrq_u8(x, vceqq_u8(s, s2));
1315 x = vorrq_u8(x, vcltq_u8(s, s3));
1318 uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);
1319 uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);
1322 bool escaped =
false;
1325 uint32_t lz = RAPIDJSON_CLZLL(high);
1326 length = 8 + (lz >> 3);
1330 uint32_t lz = RAPIDJSON_CLZLL(low);
1335 for (
const char* pend = p + length; p != pend; ) {
1340 vst1q_u8(
reinterpret_cast<uint8_t *
>(q), s);
1348 static RAPIDJSON_FORCEINLINE
void SkipUnescapedString(InsituStringStream& is) {
1353 const char* nextAligned =
reinterpret_cast<const char*
>((
reinterpret_cast<size_t>(p) + 15) &
static_cast<size_t>(~15));
1354 for (; p != nextAligned; p++)
1356 is.src_ = is.dst_ = p;
1361 const uint8x16_t s0 = vmovq_n_u8(
'"');
1362 const uint8x16_t s1 = vmovq_n_u8(
'\\');
1363 const uint8x16_t s2 = vmovq_n_u8(
'\b');
1364 const uint8x16_t s3 = vmovq_n_u8(32);
1367 const uint8x16_t s = vld1q_u8(
reinterpret_cast<uint8_t *
>(p));
1368 uint8x16_t x = vceqq_u8(s, s0);
1369 x = vorrq_u8(x, vceqq_u8(s, s1));
1370 x = vorrq_u8(x, vceqq_u8(s, s2));
1371 x = vorrq_u8(x, vcltq_u8(s, s3));
1374 uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);
1375 uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);
1379 uint32_t lz = RAPIDJSON_CLZLL(high);
1384 uint32_t lz = RAPIDJSON_CLZLL(low);
1390 is.src_ = is.dst_ = p;
1394 template<
typename InputStream,
bool backup,
bool pushOnTake>
1397 template<
typename InputStream>
1398 class NumberStream<InputStream, false, false> {
1400 typedef typename InputStream::Ch Ch;
1402 NumberStream(GenericReader& reader, InputStream& s) : is(s) { (void)reader; }
1404 RAPIDJSON_FORCEINLINE Ch Peek()
const {
return is.Peek(); }
1405 RAPIDJSON_FORCEINLINE Ch TakePush() {
return is.Take(); }
1406 RAPIDJSON_FORCEINLINE Ch Take() {
return is.Take(); }
1407 RAPIDJSON_FORCEINLINE
void Push(
char) {}
1409 size_t Tell() {
return is.Tell(); }
1410 size_t Length() {
return 0; }
1411 const char* Pop() {
return 0; }
1414 NumberStream& operator=(
const NumberStream&);
1419 template<
typename InputStream>
1420 class NumberStream<InputStream, true, false> :
public NumberStream<InputStream, false, false> {
1421 typedef NumberStream<InputStream, false, false> Base;
1423 NumberStream(GenericReader& reader, InputStream& is) : Base(reader, is), stackStream(reader.stack_) {}
1425 RAPIDJSON_FORCEINLINE Ch TakePush() {
1426 stackStream.Put(
static_cast<char>(Base::is.Peek()));
1427 return Base::is.Take();
1430 RAPIDJSON_FORCEINLINE
void Push(
char c) {
1434 size_t Length() {
return stackStream.Length(); }
1437 stackStream.Put(
'\0');
1438 return stackStream.Pop();
1442 StackStream<char> stackStream;
1445 template<
typename InputStream>
1446 class NumberStream<InputStream, true, true> :
public NumberStream<InputStream, true, false> {
1447 typedef NumberStream<InputStream, true, false> Base;
1449 NumberStream(GenericReader& reader, InputStream& is) : Base(reader, is) {}
1451 RAPIDJSON_FORCEINLINE Ch Take() {
return Base::TakePush(); }
1454 template<
unsigned parseFlags,
typename InputStream,
typename Handler>
1455 void ParseNumber(InputStream& is,
Handler& handler) {
1456 internal::StreamLocalCopy<InputStream> copy(is);
1457 NumberStream<InputStream,
1464 size_t startOffset = s.Tell();
1466 bool useNanOrInf =
false;
1469 bool minus = Consume(s,
'-');
1474 bool use64bit =
false;
1475 int significandDigit = 0;
1481 i =
static_cast<unsigned>(s.TakePush() -
'0');
1492 i = i * 10 +
static_cast<unsigned>(s.TakePush() -
'0');
1504 i = i * 10 +
static_cast<unsigned>(s.TakePush() -
'0');
1510 if (Consume(s,
'N')) {
1511 if (Consume(s,
'a') && Consume(s,
'N')) {
1512 d = std::numeric_limits<double>::quiet_NaN();
1517 if (Consume(s,
'n') && Consume(s,
'f')) {
1518 d = (minus ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity());
1522 && Consume(s,
'i') && Consume(s,
't') && Consume(s,
'y')))) {
1536 bool useDouble =
false;
1542 d =
static_cast<double>(i64);
1546 i64 = i64 * 10 +
static_cast<unsigned>(s.TakePush() -
'0');
1553 d =
static_cast<double>(i64);
1557 i64 = i64 * 10 +
static_cast<unsigned>(s.TakePush() -
'0');
1565 d = d * 10 + (s.TakePush() -
'0');
1571 size_t decimalPosition;
1572 if (Consume(s,
'.')) {
1573 decimalPosition = s.Length();
1588 i64 = i64 * 10 +
static_cast<unsigned>(s.TakePush() -
'0');
1595 d =
static_cast<double>(i64);
1598 d =
static_cast<double>(use64bit ? i64 : i);
1604 if (significandDigit < 17) {
1605 d = d * 10.0 + (s.TakePush() -
'0');
1615 decimalPosition = s.Length();
1619 if (Consume(s,
'e') || Consume(s,
'E')) {
1621 d =
static_cast<double>(use64bit ? i64 : i);
1625 bool expMinus =
false;
1626 if (Consume(s,
'+'))
1628 else if (Consume(s,
'-'))
1632 exp =
static_cast<int>(s.Take() -
'0');
1641 int maxExp = (expFrac + 2147483639) / 10;
1644 exp = exp * 10 +
static_cast<int>(s.Take() -
'0');
1652 int maxExp = 308 - expFrac;
1654 exp = exp * 10 +
static_cast<int>(s.Take() -
'0');
1673 typename InputStream::Ch* head = is.PutBegin();
1674 const size_t length = s.Tell() - startOffset;
1677 const typename TargetEncoding::Ch*
const str =
reinterpret_cast<typename TargetEncoding::Ch*
>(head);
1678 cont = handler.RawNumber(str,
SizeType(length),
false);
1683 StackStream<typename TargetEncoding::Ch> dstStream(stack_);
1684 while (numCharsToCopy--) {
1685 Transcoder<UTF8<>, TargetEncoding>::Transcode(srcStream, dstStream);
1687 dstStream.Put(
'\0');
1688 const typename TargetEncoding::Ch* str = dstStream.Pop();
1690 cont = handler.RawNumber(str,
SizeType(length),
true);
1694 size_t length = s.Length();
1695 const char* decimal = s.Pop();
1698 int p = exp + expFrac;
1700 d = internal::StrtodFullPrecision(d, p, decimal, length, decimalPosition, exp);
1702 d = internal::StrtodNormalPrecision(d, p);
1705 if (d > (std::numeric_limits<double>::max)()) {
1711 cont = handler.Double(minus ? -d : d);
1713 else if (useNanOrInf) {
1714 cont = handler.Double(d);
1719 cont = handler.Int64(
static_cast<int64_t
>(~i64 + 1));
1721 cont = handler.Uint64(i64);
1725 cont = handler.Int(
static_cast<int32_t
>(~i + 1));
1727 cont = handler.Uint(i);
1736 template<
unsigned parseFlags,
typename InputStream,
typename Handler>
1737 void ParseValue(InputStream& is,
Handler& handler) {
1738 switch (is.Peek()) {
1739 case 'n': ParseNull <parseFlags>(is, handler);
break;
1740 case 't': ParseTrue <parseFlags>(is, handler);
break;
1741 case 'f': ParseFalse <parseFlags>(is, handler);
break;
1742 case '"': ParseString<parseFlags>(is, handler);
break;
1743 case '{': ParseObject<parseFlags>(is, handler);
break;
1744 case '[': ParseArray <parseFlags>(is, handler);
break;
1746 ParseNumber<parseFlags>(is, handler);
1755 enum IterativeParsingState {
1756 IterativeParsingFinishState = 0,
1757 IterativeParsingErrorState,
1758 IterativeParsingStartState,
1761 IterativeParsingObjectInitialState,
1762 IterativeParsingMemberKeyState,
1763 IterativeParsingMemberValueState,
1764 IterativeParsingObjectFinishState,
1767 IterativeParsingArrayInitialState,
1768 IterativeParsingElementState,
1769 IterativeParsingArrayFinishState,
1772 IterativeParsingValueState,
1775 IterativeParsingElementDelimiterState,
1776 IterativeParsingMemberDelimiterState,
1777 IterativeParsingKeyValueDelimiterState,
1779 cIterativeParsingStateCount
1784 LeftBracketToken = 0,
1787 LeftCurlyBracketToken,
1788 RightCurlyBracketToken,
1802 RAPIDJSON_FORCEINLINE Token Tokenize(Ch c)
const {
1805#define N NumberToken
1806#define N16 N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N
1808 static const unsigned char tokenMap[256] = {
1811 N, N, StringToken, N, N, N, N, N, N, N, N, N, CommaToken, N, N, N,
1812 N, N, N, N, N, N, N, N, N, N, ColonToken, N, N, N, N, N,
1814 N, N, N, N, N, N, N, N, N, N, N, LeftBracketToken, N, RightBracketToken, N, N,
1815 N, N, N, N, N, N, FalseToken, N, N, N, N, N, N, N, NullToken, N,
1816 N, N, N, N, TrueToken, N, N, N, N, N, N, LeftCurlyBracketToken, N, RightCurlyBracketToken, N, N,
1817 N16, N16, N16, N16, N16, N16, N16, N16
1823 if (
sizeof(Ch) == 1 ||
static_cast<unsigned>(c) < 256)
1824 return static_cast<Token
>(tokenMap[
static_cast<unsigned char>(c)]);
1829 RAPIDJSON_FORCEINLINE IterativeParsingState Predict(IterativeParsingState state, Token token)
const {
1831 static const char G[cIterativeParsingStateCount][kTokenCount] = {
1834 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1835 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1836 IterativeParsingErrorState
1840 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1841 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1842 IterativeParsingErrorState
1846 IterativeParsingArrayInitialState,
1847 IterativeParsingErrorState,
1848 IterativeParsingObjectInitialState,
1849 IterativeParsingErrorState,
1850 IterativeParsingErrorState,
1851 IterativeParsingErrorState,
1852 IterativeParsingValueState,
1853 IterativeParsingValueState,
1854 IterativeParsingValueState,
1855 IterativeParsingValueState,
1856 IterativeParsingValueState
1860 IterativeParsingErrorState,
1861 IterativeParsingErrorState,
1862 IterativeParsingErrorState,
1863 IterativeParsingObjectFinishState,
1864 IterativeParsingErrorState,
1865 IterativeParsingErrorState,
1866 IterativeParsingMemberKeyState,
1867 IterativeParsingErrorState,
1868 IterativeParsingErrorState,
1869 IterativeParsingErrorState,
1870 IterativeParsingErrorState
1874 IterativeParsingErrorState,
1875 IterativeParsingErrorState,
1876 IterativeParsingErrorState,
1877 IterativeParsingErrorState,
1878 IterativeParsingErrorState,
1879 IterativeParsingKeyValueDelimiterState,
1880 IterativeParsingErrorState,
1881 IterativeParsingErrorState,
1882 IterativeParsingErrorState,
1883 IterativeParsingErrorState,
1884 IterativeParsingErrorState
1888 IterativeParsingErrorState,
1889 IterativeParsingErrorState,
1890 IterativeParsingErrorState,
1891 IterativeParsingObjectFinishState,
1892 IterativeParsingMemberDelimiterState,
1893 IterativeParsingErrorState,
1894 IterativeParsingErrorState,
1895 IterativeParsingErrorState,
1896 IterativeParsingErrorState,
1897 IterativeParsingErrorState,
1898 IterativeParsingErrorState
1902 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1903 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1904 IterativeParsingErrorState
1908 IterativeParsingArrayInitialState,
1909 IterativeParsingArrayFinishState,
1910 IterativeParsingObjectInitialState,
1911 IterativeParsingErrorState,
1912 IterativeParsingErrorState,
1913 IterativeParsingErrorState,
1914 IterativeParsingElementState,
1915 IterativeParsingElementState,
1916 IterativeParsingElementState,
1917 IterativeParsingElementState,
1918 IterativeParsingElementState
1922 IterativeParsingErrorState,
1923 IterativeParsingArrayFinishState,
1924 IterativeParsingErrorState,
1925 IterativeParsingErrorState,
1926 IterativeParsingElementDelimiterState,
1927 IterativeParsingErrorState,
1928 IterativeParsingErrorState,
1929 IterativeParsingErrorState,
1930 IterativeParsingErrorState,
1931 IterativeParsingErrorState,
1932 IterativeParsingErrorState
1936 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1937 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1938 IterativeParsingErrorState
1942 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1943 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1944 IterativeParsingErrorState
1948 IterativeParsingArrayInitialState,
1949 IterativeParsingArrayFinishState,
1950 IterativeParsingObjectInitialState,
1951 IterativeParsingErrorState,
1952 IterativeParsingErrorState,
1953 IterativeParsingErrorState,
1954 IterativeParsingElementState,
1955 IterativeParsingElementState,
1956 IterativeParsingElementState,
1957 IterativeParsingElementState,
1958 IterativeParsingElementState
1962 IterativeParsingErrorState,
1963 IterativeParsingErrorState,
1964 IterativeParsingErrorState,
1965 IterativeParsingObjectFinishState,
1966 IterativeParsingErrorState,
1967 IterativeParsingErrorState,
1968 IterativeParsingMemberKeyState,
1969 IterativeParsingErrorState,
1970 IterativeParsingErrorState,
1971 IterativeParsingErrorState,
1972 IterativeParsingErrorState
1976 IterativeParsingArrayInitialState,
1977 IterativeParsingErrorState,
1978 IterativeParsingObjectInitialState,
1979 IterativeParsingErrorState,
1980 IterativeParsingErrorState,
1981 IterativeParsingErrorState,
1982 IterativeParsingMemberValueState,
1983 IterativeParsingMemberValueState,
1984 IterativeParsingMemberValueState,
1985 IterativeParsingMemberValueState,
1986 IterativeParsingMemberValueState
1990 return static_cast<IterativeParsingState
>(G[state][token]);
1995 template <
unsigned parseFlags,
typename InputStream,
typename Handler>
1996 RAPIDJSON_FORCEINLINE IterativeParsingState Transit(IterativeParsingState src, Token token, IterativeParsingState dst, InputStream& is,
Handler& handler) {
2000 case IterativeParsingErrorState:
2003 case IterativeParsingObjectInitialState:
2004 case IterativeParsingArrayInitialState:
2008 IterativeParsingState n = src;
2009 if (src == IterativeParsingArrayInitialState || src == IterativeParsingElementDelimiterState)
2010 n = IterativeParsingElementState;
2011 else if (src == IterativeParsingKeyValueDelimiterState)
2012 n = IterativeParsingMemberValueState;
2014 *stack_.template Push<SizeType>(1) = n;
2016 *stack_.template Push<SizeType>(1) = 0;
2018 bool hr = (dst == IterativeParsingObjectInitialState) ? handler.StartObject() : handler.StartArray();
2022 return IterativeParsingErrorState;
2030 case IterativeParsingMemberKeyState:
2031 ParseString<parseFlags>(is, handler,
true);
2032 if (HasParseError())
2033 return IterativeParsingErrorState;
2037 case IterativeParsingKeyValueDelimiterState:
2042 case IterativeParsingMemberValueState:
2044 ParseValue<parseFlags>(is, handler);
2045 if (HasParseError()) {
2046 return IterativeParsingErrorState;
2050 case IterativeParsingElementState:
2052 ParseValue<parseFlags>(is, handler);
2053 if (HasParseError()) {
2054 return IterativeParsingErrorState;
2058 case IterativeParsingMemberDelimiterState:
2059 case IterativeParsingElementDelimiterState:
2062 *stack_.template Top<SizeType>() = *stack_.template Top<SizeType>() + 1;
2065 case IterativeParsingObjectFinishState:
2070 return IterativeParsingErrorState;
2073 SizeType c = *stack_.template Pop<SizeType>(1);
2075 if (src == IterativeParsingMemberValueState)
2078 IterativeParsingState n =
static_cast<IterativeParsingState
>(*stack_.template Pop<SizeType>(1));
2080 if (n == IterativeParsingStartState)
2081 n = IterativeParsingFinishState;
2083 bool hr = handler.EndObject(c);
2087 return IterativeParsingErrorState;
2095 case IterativeParsingArrayFinishState:
2100 return IterativeParsingErrorState;
2103 SizeType c = *stack_.template Pop<SizeType>(1);
2105 if (src == IterativeParsingElementState)
2108 IterativeParsingState n =
static_cast<IterativeParsingState
>(*stack_.template Pop<SizeType>(1));
2110 if (n == IterativeParsingStartState)
2111 n = IterativeParsingFinishState;
2113 bool hr = handler.EndArray(c);
2117 return IterativeParsingErrorState;
2139 ParseValue<parseFlags>(is, handler);
2140 if (HasParseError()) {
2141 return IterativeParsingErrorState;
2143 return IterativeParsingFinishState;
2147 template <
typename InputStream>
2148 void HandleError(IterativeParsingState src, InputStream& is) {
2149 if (HasParseError()) {
2157 case IterativeParsingObjectInitialState:
2161 case IterativeParsingKeyValueDelimiterState:
2162 case IterativeParsingArrayInitialState:
2168 RAPIDJSON_FORCEINLINE
bool IsIterativeParsingDelimiterState(IterativeParsingState s)
const {
2169 return s >= IterativeParsingElementDelimiterState;
2172 RAPIDJSON_FORCEINLINE
bool IsIterativeParsingCompleteState(IterativeParsingState s)
const {
2173 return s <= IterativeParsingErrorState;
2176 template <
unsigned parseFlags,
typename InputStream,
typename Handler>
2177 ParseResult IterativeParse(InputStream& is,
Handler& handler) {
2178 parseResult_.Clear();
2179 ClearStackOnExit scope(*
this);
2180 IterativeParsingState state = IterativeParsingStartState;
2182 SkipWhitespaceAndComments<parseFlags>(is);
2183 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
2184 while (is.Peek() !=
'\0') {
2185 Token t = Tokenize(is.Peek());
2186 IterativeParsingState n = Predict(state, t);
2187 IterativeParsingState d = Transit<parseFlags>(state, t, n, is, handler);
2189 if (d == IterativeParsingErrorState) {
2190 HandleError(state, is);
2200 SkipWhitespaceAndComments<parseFlags>(is);
2201 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
2205 if (state != IterativeParsingFinishState)
2206 HandleError(state, is);
2208 return parseResult_;
2211 static const size_t kDefaultStackCapacity = 256;
2212 internal::Stack<StackAllocator> stack_;
2213 ParseResult parseResult_;
2214 IterativeParsingState state_;
2218typedef GenericReader<UTF8<>, UTF8<> >
Reader;
2220RAPIDJSON_NAMESPACE_END
2222#if defined(__clang__) || defined(_MSC_VER)
SAX-style JSON parser. Use Reader for UTF8 encoding and default allocator.
Definition: reader.h:538
RAPIDJSON_FORCEINLINE bool IterativeParseComplete() const
Check if token-by-token parsing JSON text is complete.
Definition: reader.h:676
ParseErrorCode GetParseErrorCode() const
Get the ParseErrorCode of last parsing.
Definition: reader.h:684
SourceEncoding::Ch Ch
SourceEncoding character type.
Definition: reader.h:540
ParseResult Parse(InputStream &is, Handler &handler)
Parse JSON text (with kParseDefaultFlags)
Definition: reader.h:599
GenericReader(StackAllocator *stackAllocator=0, size_t stackCapacity=kDefaultStackCapacity)
Constructor.
Definition: reader.h:546
void IterativeParseInit()
Initialize JSON text token-by-token parsing.
Definition: reader.h:606
size_t GetErrorOffset() const
Get the position of last parsing error in input, 0 otherwise.
Definition: reader.h:687
bool IterativeParseNext(InputStream &is, Handler &handler)
Parse one token from JSON text.
Definition: reader.h:619
bool HasParseError() const
Whether a parse error has occurred in the last parsing.
Definition: reader.h:681
ParseResult Parse(InputStream &is, Handler &handler)
Parse JSON text.
Definition: reader.h:558
Concept for receiving events from GenericReader upon parsing. The functions return true if no error o...
Concept for reading and writing characters.
#define RAPIDJSON_LIKELY(x)
Compiler branching hint for expression with high probability to be true.
Definition: rapidjson.h:463
#define RAPIDJSON_UNLIKELY(x)
Compiler branching hint for expression with low probability to be true.
Definition: rapidjson.h:476
#define RAPIDJSON_PARSE_DEFAULT_FLAGS
User-defined kParseDefaultFlags definition.
Definition: reader.h:140
#define RAPIDJSON_ASSERT(x)
Assertion.
Definition: rapidjson.h:406
ParseErrorCode
Error code of parsing.
Definition: error.h:64
#define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset)
Macro to indicate a parse error.
Definition: reader.h:100
#define RAPIDJSON_PARSE_ERROR(parseErrorCode, offset)
(Internal) macro to indicate and handle a parse error.
Definition: reader.h:119
@ kParseErrorDocumentEmpty
The document is empty.
Definition: error.h:67
@ kParseErrorArrayMissCommaOrSquareBracket
Missing a comma or ']' after an array element.
Definition: error.h:76
@ kParseErrorDocumentRootNotSingular
The document root must not follow by other values.
Definition: error.h:68
@ kParseErrorStringUnicodeEscapeInvalidHex
Incorrect hex digit after \u escape in string.
Definition: error.h:78
@ kParseErrorNumberTooBig
Number too big to be stored in double.
Definition: error.h:84
@ kParseErrorNumberMissExponent
Miss exponent in number.
Definition: error.h:86
@ kParseErrorObjectMissCommaOrCurlyBracket
Missing a comma or '}' after an object member.
Definition: error.h:74
@ kParseErrorObjectMissColon
Missing a colon after a name of object member.
Definition: error.h:73
@ kParseErrorStringInvalidEncoding
Invalid encoding in string.
Definition: error.h:82
@ kParseErrorStringUnicodeSurrogateInvalid
The surrogate pair in string is invalid.
Definition: error.h:79
@ kParseErrorUnspecificSyntaxError
Unspecific syntax error.
Definition: error.h:89
@ kParseErrorStringEscapeInvalid
Invalid escape character in string.
Definition: error.h:80
@ kParseErrorTermination
Parsing was terminated.
Definition: error.h:88
@ kParseErrorObjectMissName
Missing a name for object member.
Definition: error.h:72
@ kParseErrorValueInvalid
Invalid value.
Definition: error.h:70
@ kParseErrorNumberMissFraction
Miss fraction part in number.
Definition: error.h:85
@ kParseErrorStringMissQuotationMark
Missing a closing quotation mark in string.
Definition: error.h:81
Result of parsing (wraps ParseErrorCode)
Definition: error.h:106
GenericStringStream< UTF8< char > > StringStream
String stream with UTF8 encoding.
Definition: fwd.h:49
unsigned SizeType
Size type (for string lengths, array sizes, etc.)
Definition: rapidjson.h:384
void SkipWhitespace(InputStream &is)
Skip the JSON white spaces in a stream.
Definition: reader.h:265
ParseFlag
Combination of parseFlags.
Definition: reader.h:146
@ kParseInsituFlag
In-situ(destructive) parsing.
Definition: reader.h:148
@ kParseNumbersAsStringsFlag
Parse all numbers (ints/doubles) as strings.
Definition: reader.h:154
@ kParseValidateEncodingFlag
Validate encoding of JSON strings.
Definition: reader.h:149
@ kParseDefaultFlags
Default parse flags. Can be customized by defining RAPIDJSON_PARSE_DEFAULT_FLAGS.
Definition: reader.h:157
@ kParseIterativeFlag
Iterative(constant complexity in terms of function call stack size) parsing.
Definition: reader.h:150
@ kParseNanAndInfFlag
Allow parsing NaN, Inf, Infinity, -Inf and -Infinity as doubles.
Definition: reader.h:156
@ kParseCommentsFlag
Allow one-line (//) and multi-line (/**/) comments.
Definition: reader.h:153
@ kParseFullPrecisionFlag
Parse number in full precision (but slower).
Definition: reader.h:152
@ kParseNoFlags
No flags are set.
Definition: reader.h:147
@ kParseStopWhenDoneFlag
After parsing a complete JSON root from stream, stop further processing the rest of stream....
Definition: reader.h:151
@ kParseTrailingCommasFlag
Allow trailing commas at the end of objects and arrays.
Definition: reader.h:155
GenericReader< UTF8< char >, UTF8< char >, CrtAllocator > Reader
Reader with UTF8 encoding and default allocator.
Definition: fwd.h:90
Type
Type of JSON value.
Definition: rapidjson.h:663
#define RAPIDJSON_UINT64_C2(high32, low32)
Construct a 64-bit literal by a pair of 32-bit integer.
Definition: rapidjson.h:289
Default implementation of Handler.
Definition: reader.h:197
bool RawNumber(const Ch *str, SizeType len, bool copy)
enabled via kParseNumbersAsStringsFlag, string is not null-terminated (use length)
Definition: reader.h:211
A read-write string stream.
Definition: stream.h:188
Read-only string stream.
Definition: stream.h:154
const Ch * src_
Current read position.
Definition: stream.h:168