542 typedef typename SourceEncoding::Ch
Ch;
549 stack_(stackAllocator, stackCapacity), parseResult_(), state_(IterativeParsingStartState) {}
559 template <
unsigned parseFlags,
typename InputStream,
typename Handler>
562 return IterativeParse<parseFlags>(is, handler);
564 parseResult_.Clear();
566 ClearStackOnExit scope(*
this);
568 SkipWhitespaceAndComments<parseFlags>(is);
569 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
573 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
576 ParseValue<parseFlags>(is, handler);
577 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
580 SkipWhitespaceAndComments<parseFlags>(is);
581 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
585 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
600 template <
typename InputStream,
typename Handler>
609 parseResult_.Clear();
610 state_ = IterativeParsingStartState;
620 template <
unsigned parseFlags,
typename InputStream,
typename Handler>
623 SkipWhitespaceAndComments<parseFlags>(is);
625 Token t = Tokenize(is.Peek());
626 IterativeParsingState n = Predict(state_, t);
627 IterativeParsingState d = Transit<parseFlags>(state_, t, n, is, handler);
632 if (d == IterativeParsingErrorState) {
633 HandleError(state_, is);
644 SkipWhitespaceAndComments<parseFlags>(is);
645 if (is.Peek() !=
'\0') {
647 HandleError(state_, is);
660 if (!IsIterativeParsingDelimiterState(n))
667 if (state_ != IterativeParsingFinishState) {
668 HandleError(state_, is);
679 return IsIterativeParsingCompleteState(state_);
692 void SetParseError(
ParseErrorCode code,
size_t offset) { parseResult_.
Set(code, offset); }
699 void ClearStack() {
stack_.Clear(); }
702 struct ClearStackOnExit {
704 ~ClearStackOnExit() { r_.ClearStack(); }
707 ClearStackOnExit(
const ClearStackOnExit&);
708 ClearStackOnExit& operator=(
const ClearStackOnExit&);
711 template<
unsigned parseFlags,
typename InputStream>
712 void SkipWhitespaceAndComments(InputStream& is) {
717 if (Consume(is,
'*')) {
721 else if (Consume(is,
'*')) {
722 if (Consume(is,
'/'))
730 while (is.Peek() !=
'\0' && is.Take() !=
'\n') {}
740 template<
unsigned parseFlags,
typename InputStream,
typename Handler>
741 void ParseObject(InputStream& is, Handler& handler) {
748 SkipWhitespaceAndComments<parseFlags>(is);
749 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
751 if (Consume(is,
'}')) {
761 ParseString<parseFlags>(is, handler,
true);
762 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
764 SkipWhitespaceAndComments<parseFlags>(is);
765 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
770 SkipWhitespaceAndComments<parseFlags>(is);
771 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
773 ParseValue<parseFlags>(is, handler);
774 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
776 SkipWhitespaceAndComments<parseFlags>(is);
777 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
784 SkipWhitespaceAndComments<parseFlags>(is);
785 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
797 if (is.Peek() ==
'}') {
808 template<
unsigned parseFlags,
typename InputStream,
typename Handler>
809 void ParseArray(InputStream& is, Handler& handler) {
816 SkipWhitespaceAndComments<parseFlags>(is);
817 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
819 if (Consume(is,
']')) {
826 ParseValue<parseFlags>(is, handler);
827 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
830 SkipWhitespaceAndComments<parseFlags>(is);
831 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
833 if (Consume(is,
',')) {
834 SkipWhitespaceAndComments<parseFlags>(is);
835 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
837 else if (Consume(is,
']')) {
846 if (is.Peek() ==
']') {
856 template<
unsigned parseFlags,
typename InputStream,
typename Handler>
857 void ParseNull(InputStream& is, Handler& handler) {
861 if (
RAPIDJSON_LIKELY(Consume(is,
'u') && Consume(is,
'l') && Consume(is,
'l'))) {
869 template<
unsigned parseFlags,
typename InputStream,
typename Handler>
870 void ParseTrue(InputStream& is, Handler& handler) {
874 if (
RAPIDJSON_LIKELY(Consume(is,
'r') && Consume(is,
'u') && Consume(is,
'e'))) {
882 template<
unsigned parseFlags,
typename InputStream,
typename Handler>
883 void ParseFalse(InputStream& is, Handler& handler) {
887 if (
RAPIDJSON_LIKELY(Consume(is,
'a') && Consume(is,
'l') && Consume(is,
's') && Consume(is,
'e'))) {
895 template<
typename InputStream>
896 RAPIDJSON_FORCEINLINE
static bool Consume(InputStream& is,
typename InputStream::Ch expect) {
906 template<
typename InputStream>
907 unsigned ParseHex4(InputStream& is,
size_t escapeOffset) {
908 unsigned codepoint = 0;
909 for (
int i = 0; i < 4; i++) {
912 codepoint +=
static_cast<unsigned>(c);
913 if (c >=
'0' && c <=
'9')
915 else if (c >=
'A' && c <=
'F')
916 codepoint -=
'A' - 10;
917 else if (c >=
'a' && c <=
'f')
918 codepoint -=
'a' - 10;
921 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(0);
928 template <
typename CharType>
934 RAPIDJSON_FORCEINLINE
void Put(Ch c) {
935 *stack_.template Push<Ch>() = c;
939 RAPIDJSON_FORCEINLINE
void* Push(
SizeType count) {
941 return stack_.template Push<Ch>(count);
944 size_t Length()
const {
return length_; }
947 return stack_.template Pop<Ch>(length_);
951 StackStream(
const StackStream&);
952 StackStream& operator=(
const StackStream&);
959 template<
unsigned parseFlags,
typename InputStream,
typename Handler>
960 void ParseString(InputStream& is,
Handler& handler,
bool isKey =
false) {
962 InputStream& s(copy.s);
967 bool success =
false;
969 typename InputStream::Ch *head = s.PutBegin();
970 ParseStringToStream<parseFlags, SourceEncoding, SourceEncoding>(s, s);
971 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
972 size_t length = s.PutEnd(head) - 1;
974 const typename TargetEncoding::Ch*
const str =
reinterpret_cast<typename TargetEncoding::Ch*
>(head);
975 success = (isKey ? handler.Key(str,
SizeType(length),
false) : handler.String(str,
SizeType(length),
false));
978 StackStream<typename TargetEncoding::Ch> stackStream(
stack_);
979 ParseStringToStream<parseFlags, SourceEncoding, TargetEncoding>(s, stackStream);
980 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
982 const typename TargetEncoding::Ch*
const str = stackStream.Pop();
983 success = (isKey ? handler.Key(str, length,
true) : handler.String(str, length,
true));
991 template<
unsigned parseFlags,
typename SEncoding,
typename TEncoding,
typename InputStream,
typename OutputStream>
992 RAPIDJSON_FORCEINLINE
void ParseStringToStream(InputStream& is, OutputStream& os) {
994#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
995 static const char escape[256] = {
996 Z16, Z16, 0, 0,
'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
'/',
997 Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
'\\', 0, 0, 0,
998 0, 0,
'\b', 0, 0, 0,
'\f', 0, 0, 0, 0, 0, 0, 0,
'\n', 0,
999 0, 0,
'\r', 0,
'\t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1000 Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
1008 ScanCopyUnescapedString(is, os);
1012 size_t escapeOffset = is.Tell();
1015 if ((
sizeof(
Ch) == 1 ||
unsigned(e) < 256) &&
RAPIDJSON_LIKELY(escape[
static_cast<unsigned char>(e)])) {
1017 os.Put(
static_cast<typename TEncoding::Ch
>(escape[
static_cast<unsigned char>(e)]));
1025 unsigned codepoint = ParseHex4(is, escapeOffset);
1026 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
1033 unsigned codepoint2 = ParseHex4(is, escapeOffset);
1034 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
1037 codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000;
1045 TEncoding::Encode(os, codepoint);
1062 size_t offset = is.Tell();
1071 template<
typename InputStream,
typename OutputStream>
1072 static RAPIDJSON_FORCEINLINE
void ScanCopyUnescapedString(InputStream&, OutputStream&) {
1076#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42)
1078 static RAPIDJSON_FORCEINLINE
void ScanCopyUnescapedString(StringStream& is,
StackStream<char>& os) {
1079 const char* p = is.
src_;
1082 const char* nextAligned =
reinterpret_cast<const char*
>((
reinterpret_cast<size_t>(p) + 15) &
static_cast<size_t>(~15));
1083 while (p != nextAligned)
1092 static const char dquote[16] = {
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"' };
1093 static const char bslash[16] = {
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\' };
1094 static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
1095 const __m128i dq = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&dquote[0]));
1096 const __m128i bs = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&bslash[0]));
1097 const __m128i sp = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&space[0]));
1100 const __m128i s = _mm_load_si128(
reinterpret_cast<const __m128i *
>(p));
1101 const __m128i t1 = _mm_cmpeq_epi8(s, dq);
1102 const __m128i t2 = _mm_cmpeq_epi8(s, bs);
1103 const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp);
1104 const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
1105 unsigned short r =
static_cast<unsigned short>(_mm_movemask_epi8(x));
1109 unsigned long offset;
1110 _BitScanForward(&offset, r);
1113 length =
static_cast<SizeType>(__builtin_ffs(r) - 1);
1116 char* q =
reinterpret_cast<char*
>(os.Push(length));
1117 for (
size_t i = 0; i < length; i++)
1124 _mm_storeu_si128(
reinterpret_cast<__m128i *
>(os.Push(16)), s);
1131 static RAPIDJSON_FORCEINLINE
void ScanCopyUnescapedString(InsituStringStream& is, InsituStringStream& os) {
1135 if (is.src_ == is.dst_) {
1136 SkipUnescapedString(is);
1144 const char* nextAligned =
reinterpret_cast<const char*
>((
reinterpret_cast<size_t>(p) + 15) &
static_cast<size_t>(~15));
1145 while (p != nextAligned)
1155 static const char dquote[16] = {
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"' };
1156 static const char bslash[16] = {
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\' };
1157 static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
1158 const __m128i dq = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&dquote[0]));
1159 const __m128i bs = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&bslash[0]));
1160 const __m128i sp = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&space[0]));
1162 for (;; p += 16, q += 16) {
1163 const __m128i s = _mm_load_si128(
reinterpret_cast<const __m128i *
>(p));
1164 const __m128i t1 = _mm_cmpeq_epi8(s, dq);
1165 const __m128i t2 = _mm_cmpeq_epi8(s, bs);
1166 const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp);
1167 const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
1168 unsigned short r =
static_cast<unsigned short>(_mm_movemask_epi8(x));
1172 unsigned long offset;
1173 _BitScanForward(&offset, r);
1176 length =
static_cast<size_t>(__builtin_ffs(r) - 1);
1178 for (
const char* pend = p + length; p != pend; )
1182 _mm_storeu_si128(
reinterpret_cast<__m128i *
>(q), s);
1190 static RAPIDJSON_FORCEINLINE
void SkipUnescapedString(InsituStringStream& is) {
1195 const char* nextAligned =
reinterpret_cast<const char*
>((
reinterpret_cast<size_t>(p) + 15) &
static_cast<size_t>(~15));
1196 for (; p != nextAligned; p++)
1198 is.src_ = is.dst_ = p;
1203 static const char dquote[16] = {
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"',
'\"' };
1204 static const char bslash[16] = {
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\',
'\\' };
1205 static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
1206 const __m128i dq = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&dquote[0]));
1207 const __m128i bs = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&bslash[0]));
1208 const __m128i sp = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(&space[0]));
1211 const __m128i s = _mm_load_si128(
reinterpret_cast<const __m128i *
>(p));
1212 const __m128i t1 = _mm_cmpeq_epi8(s, dq);
1213 const __m128i t2 = _mm_cmpeq_epi8(s, bs);
1214 const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp);
1215 const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
1216 unsigned short r =
static_cast<unsigned short>(_mm_movemask_epi8(x));
1220 unsigned long offset;
1221 _BitScanForward(&offset, r);
1224 length =
static_cast<size_t>(__builtin_ffs(r) - 1);
1231 is.src_ = is.dst_ = p;
1233#elif defined(RAPIDJSON_NEON)
1235 static RAPIDJSON_FORCEINLINE
void ScanCopyUnescapedString(StringStream& is,
StackStream<char>& os) {
1236 const char* p = is.
src_;
1239 const char* nextAligned =
reinterpret_cast<const char*
>((
reinterpret_cast<size_t>(p) + 15) &
static_cast<size_t>(~15));
1240 while (p != nextAligned)
1249 const uint8x16_t s0 = vmovq_n_u8(
'"');
1250 const uint8x16_t s1 = vmovq_n_u8(
'\\');
1251 const uint8x16_t s2 = vmovq_n_u8(
'\b');
1252 const uint8x16_t s3 = vmovq_n_u8(32);
1255 const uint8x16_t s = vld1q_u8(
reinterpret_cast<const uint8_t *
>(p));
1256 uint8x16_t x = vceqq_u8(s, s0);
1257 x = vorrq_u8(x, vceqq_u8(s, s1));
1258 x = vorrq_u8(x, vceqq_u8(s, s2));
1259 x = vorrq_u8(x, vcltq_u8(s, s3));
1262 uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);
1263 uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);
1266 bool escaped =
false;
1269 uint32_t lz = internal::clzll(high);
1270 length = 8 + (lz >> 3);
1274 uint32_t lz = internal::clzll(low);
1280 char* q =
reinterpret_cast<char*
>(os.Push(length));
1281 for (
size_t i = 0; i < length; i++)
1288 vst1q_u8(
reinterpret_cast<uint8_t *
>(os.Push(16)), s);
1295 static RAPIDJSON_FORCEINLINE
void ScanCopyUnescapedString(InsituStringStream& is, InsituStringStream& os) {
1299 if (is.src_ == is.dst_) {
1300 SkipUnescapedString(is);
1308 const char* nextAligned =
reinterpret_cast<const char*
>((
reinterpret_cast<size_t>(p) + 15) &
static_cast<size_t>(~15));
1309 while (p != nextAligned)
1319 const uint8x16_t s0 = vmovq_n_u8(
'"');
1320 const uint8x16_t s1 = vmovq_n_u8(
'\\');
1321 const uint8x16_t s2 = vmovq_n_u8(
'\b');
1322 const uint8x16_t s3 = vmovq_n_u8(32);
1324 for (;; p += 16, q += 16) {
1325 const uint8x16_t s = vld1q_u8(
reinterpret_cast<uint8_t *
>(p));
1326 uint8x16_t x = vceqq_u8(s, s0);
1327 x = vorrq_u8(x, vceqq_u8(s, s1));
1328 x = vorrq_u8(x, vceqq_u8(s, s2));
1329 x = vorrq_u8(x, vcltq_u8(s, s3));
1332 uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);
1333 uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);
1336 bool escaped =
false;
1339 uint32_t lz = internal::clzll(high);
1340 length = 8 + (lz >> 3);
1344 uint32_t lz = internal::clzll(low);
1349 for (
const char* pend = p + length; p != pend; ) {
1354 vst1q_u8(
reinterpret_cast<uint8_t *
>(q), s);
1362 static RAPIDJSON_FORCEINLINE
void SkipUnescapedString(InsituStringStream& is) {
1367 const char* nextAligned =
reinterpret_cast<const char*
>((
reinterpret_cast<size_t>(p) + 15) &
static_cast<size_t>(~15));
1368 for (; p != nextAligned; p++)
1370 is.src_ = is.dst_ = p;
1375 const uint8x16_t s0 = vmovq_n_u8(
'"');
1376 const uint8x16_t s1 = vmovq_n_u8(
'\\');
1377 const uint8x16_t s2 = vmovq_n_u8(
'\b');
1378 const uint8x16_t s3 = vmovq_n_u8(32);
1381 const uint8x16_t s = vld1q_u8(
reinterpret_cast<uint8_t *
>(p));
1382 uint8x16_t x = vceqq_u8(s, s0);
1383 x = vorrq_u8(x, vceqq_u8(s, s1));
1384 x = vorrq_u8(x, vceqq_u8(s, s2));
1385 x = vorrq_u8(x, vcltq_u8(s, s3));
1388 uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);
1389 uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);
1393 uint32_t lz = internal::clzll(high);
1398 uint32_t lz = internal::clzll(low);
1404 is.src_ = is.dst_ = p;
1408 template<
typename InputStream,
typename StackCharacter,
bool backup,
bool pushOnTake>
1411 template<
typename InputStream,
typename StackCharacter>
1412 class NumberStream<InputStream, StackCharacter, false, false> {
1414 typedef typename InputStream::Ch
Ch;
1418 RAPIDJSON_FORCEINLINE
Ch Peek()
const {
return is.Peek(); }
1419 RAPIDJSON_FORCEINLINE
Ch TakePush() {
return is.Take(); }
1420 RAPIDJSON_FORCEINLINE
Ch Take() {
return is.Take(); }
1421 RAPIDJSON_FORCEINLINE
void Push(
char) {}
1423 size_t Tell() {
return is.Tell(); }
1424 size_t Length() {
return 0; }
1425 const StackCharacter* Pop() {
return 0; }
1428 NumberStream& operator=(
const NumberStream&);
1433 template<
typename InputStream,
typename StackCharacter>
1434 class NumberStream<InputStream, StackCharacter, true, false> :
public NumberStream<InputStream, StackCharacter, false, false> {
1435 typedef NumberStream<InputStream, StackCharacter, false, false> Base;
1437 NumberStream(
GenericReader& reader, InputStream& s) : Base(reader, s), stackStream(reader.
stack_) {}
1439 RAPIDJSON_FORCEINLINE
Ch TakePush() {
1440 stackStream.Put(
static_cast<StackCharacter
>(Base::is.Peek()));
1441 return Base::is.Take();
1444 RAPIDJSON_FORCEINLINE
void Push(StackCharacter c) {
1448 size_t Length() {
return stackStream.Length(); }
1450 const StackCharacter* Pop() {
1451 stackStream.Put(
'\0');
1452 return stackStream.Pop();
1456 StackStream<StackCharacter> stackStream;
1459 template<
typename InputStream,
typename StackCharacter>
1460 class NumberStream<InputStream, StackCharacter, true, true> :
public NumberStream<InputStream, StackCharacter, true, false> {
1461 typedef NumberStream<InputStream, StackCharacter, true, false> Base;
1463 NumberStream(
GenericReader& reader, InputStream& s) : Base(reader, s) {}
1465 RAPIDJSON_FORCEINLINE
Ch Take() {
return Base::TakePush(); }
1468 template<
unsigned parseFlags,
typename InputStream,
typename Handler>
1469 void ParseNumber(InputStream& is,
Handler& handler) {
1470 typedef typename internal::SelectIf<internal::BoolType<(parseFlags &
kParseNumbersAsStringsFlag) != 0>,
typename TargetEncoding::Ch,
char>
::Type NumberCharacter;
1480 size_t startOffset = s.Tell();
1482 bool useNanOrInf =
false;
1485 bool minus = Consume(s,
'-');
1490 bool use64bit =
false;
1491 int significandDigit = 0;
1497 i =
static_cast<unsigned>(s.TakePush() -
'0');
1508 i = i * 10 +
static_cast<unsigned>(s.TakePush() -
'0');
1520 i = i * 10 +
static_cast<unsigned>(s.TakePush() -
'0');
1526 if (Consume(s,
'N')) {
1527 if (Consume(s,
'a') && Consume(s,
'N')) {
1528 d = std::numeric_limits<double>::quiet_NaN();
1533 if (Consume(s,
'n') && Consume(s,
'f')) {
1534 d = (minus ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity());
1538 && Consume(s,
'i') && Consume(s,
't') && Consume(s,
'y')))) {
1552 bool useDouble =
false;
1558 d =
static_cast<double>(i64);
1562 i64 = i64 * 10 +
static_cast<unsigned>(s.TakePush() -
'0');
1569 d =
static_cast<double>(i64);
1573 i64 = i64 * 10 +
static_cast<unsigned>(s.TakePush() -
'0');
1581 d = d * 10 + (s.TakePush() -
'0');
1587 size_t decimalPosition;
1588 if (!useNanOrInf && Consume(s,
'.')) {
1589 decimalPosition = s.Length();
1604 i64 = i64 * 10 +
static_cast<unsigned>(s.TakePush() -
'0');
1611 d =
static_cast<double>(i64);
1614 d =
static_cast<double>(use64bit ? i64 : i);
1620 if (significandDigit < 17) {
1621 d = d * 10.0 + (s.TakePush() -
'0');
1631 decimalPosition = s.Length();
1635 if (!useNanOrInf && (Consume(s,
'e') || Consume(s,
'E'))) {
1637 d =
static_cast<double>(use64bit ? i64 : i);
1641 bool expMinus =
false;
1642 if (Consume(s,
'+'))
1644 else if (Consume(s,
'-'))
1648 exp =
static_cast<int>(s.Take() -
'0');
1657 int maxExp = (expFrac + 2147483639) / 10;
1660 exp =
exp * 10 +
static_cast<int>(s.Take() -
'0');
1668 int maxExp = 308 - expFrac;
1670 exp =
exp * 10 +
static_cast<int>(s.Take() -
'0');
1689 typename InputStream::Ch* head = is.PutBegin();
1690 const size_t length = s.Tell() - startOffset;
1693 const typename TargetEncoding::Ch*
const str =
reinterpret_cast<typename TargetEncoding::Ch*
>(head);
1694 cont = handler.RawNumber(str,
SizeType(length),
false);
1698 GenericStringStream<UTF8<NumberCharacter> > srcStream(s.Pop());
1700 while (numCharsToCopy--) {
1701 Transcoder<UTF8<typename TargetEncoding::Ch>, TargetEncoding>::Transcode(srcStream, dstStream);
1703 dstStream.Put(
'\0');
1704 const typename TargetEncoding::Ch* str = dstStream.Pop();
1706 cont = handler.RawNumber(str,
SizeType(length),
true);
1710 size_t length = s.Length();
1711 const NumberCharacter* decimal = s.Pop();
1714 int p =
exp + expFrac;
1716 d = internal::StrtodFullPrecision(d, p, decimal, length, decimalPosition, exp);
1718 d = internal::StrtodNormalPrecision(d, p);
1721 if (d > (std::numeric_limits<double>::max)()) {
1727 cont = handler.Double(minus ? -d : d);
1729 else if (useNanOrInf) {
1730 cont = handler.Double(d);
1735 cont = handler.Int64(
static_cast<int64_t
>(~i64 + 1));
1737 cont = handler.Uint64(i64);
1741 cont = handler.Int(
static_cast<int32_t
>(~i + 1));
1743 cont = handler.Uint(i);
1752 template<
unsigned parseFlags,
typename InputStream,
typename Handler>
1753 void ParseValue(InputStream& is, Handler& handler) {
1754 switch (is.Peek()) {
1755 case 'n': ParseNull <parseFlags>(is, handler);
break;
1756 case 't': ParseTrue <parseFlags>(is, handler);
break;
1757 case 'f': ParseFalse <parseFlags>(is, handler);
break;
1758 case '"': ParseString<parseFlags>(is, handler);
break;
1759 case '{': ParseObject<parseFlags>(is, handler);
break;
1760 case '[': ParseArray <parseFlags>(is, handler);
break;
1762 ParseNumber<parseFlags>(is, handler);
1771 enum IterativeParsingState {
1772 IterativeParsingFinishState = 0,
1773 IterativeParsingErrorState,
1774 IterativeParsingStartState,
1777 IterativeParsingObjectInitialState,
1778 IterativeParsingMemberKeyState,
1779 IterativeParsingMemberValueState,
1780 IterativeParsingObjectFinishState,
1783 IterativeParsingArrayInitialState,
1784 IterativeParsingElementState,
1785 IterativeParsingArrayFinishState,
1788 IterativeParsingValueState,
1791 IterativeParsingElementDelimiterState,
1792 IterativeParsingMemberDelimiterState,
1793 IterativeParsingKeyValueDelimiterState,
1795 cIterativeParsingStateCount
1800 LeftBracketToken = 0,
1803 LeftCurlyBracketToken,
1804 RightCurlyBracketToken,
1818 RAPIDJSON_FORCEINLINE Token Tokenize(
Ch c)
const {
1821#define N NumberToken
1822#define N16 N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N
1824 static const unsigned char tokenMap[256] = {
1827 N, N, StringToken, N, N, N, N, N, N, N, N, N, CommaToken, N, N, N,
1828 N, N, N, N, N, N, N, N, N, N, ColonToken, N, N, N, N, N,
1830 N, N, N, N, N, N, N, N, N, N, N, LeftBracketToken, N, RightBracketToken, N, N,
1831 N, N, N, N, N, N, FalseToken, N, N, N, N, N, N, N, NullToken, N,
1832 N, N, N, N, TrueToken, N, N, N, N, N, N, LeftCurlyBracketToken, N, RightCurlyBracketToken, N, N,
1833 N16, N16, N16, N16, N16, N16, N16, N16
1839 if (
sizeof(
Ch) == 1 ||
static_cast<unsigned>(c) < 256)
1840 return static_cast<Token
>(tokenMap[
static_cast<unsigned char>(c)]);
1845 RAPIDJSON_FORCEINLINE IterativeParsingState Predict(IterativeParsingState state, Token token)
const {
1847 static const char G[cIterativeParsingStateCount][kTokenCount] = {
1850 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1851 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1852 IterativeParsingErrorState
1856 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1857 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1858 IterativeParsingErrorState
1862 IterativeParsingArrayInitialState,
1863 IterativeParsingErrorState,
1864 IterativeParsingObjectInitialState,
1865 IterativeParsingErrorState,
1866 IterativeParsingErrorState,
1867 IterativeParsingErrorState,
1868 IterativeParsingValueState,
1869 IterativeParsingValueState,
1870 IterativeParsingValueState,
1871 IterativeParsingValueState,
1872 IterativeParsingValueState
1876 IterativeParsingErrorState,
1877 IterativeParsingErrorState,
1878 IterativeParsingErrorState,
1879 IterativeParsingObjectFinishState,
1880 IterativeParsingErrorState,
1881 IterativeParsingErrorState,
1882 IterativeParsingMemberKeyState,
1883 IterativeParsingErrorState,
1884 IterativeParsingErrorState,
1885 IterativeParsingErrorState,
1886 IterativeParsingErrorState
1890 IterativeParsingErrorState,
1891 IterativeParsingErrorState,
1892 IterativeParsingErrorState,
1893 IterativeParsingErrorState,
1894 IterativeParsingErrorState,
1895 IterativeParsingKeyValueDelimiterState,
1896 IterativeParsingErrorState,
1897 IterativeParsingErrorState,
1898 IterativeParsingErrorState,
1899 IterativeParsingErrorState,
1900 IterativeParsingErrorState
1904 IterativeParsingErrorState,
1905 IterativeParsingErrorState,
1906 IterativeParsingErrorState,
1907 IterativeParsingObjectFinishState,
1908 IterativeParsingMemberDelimiterState,
1909 IterativeParsingErrorState,
1910 IterativeParsingErrorState,
1911 IterativeParsingErrorState,
1912 IterativeParsingErrorState,
1913 IterativeParsingErrorState,
1914 IterativeParsingErrorState
1918 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1919 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1920 IterativeParsingErrorState
1924 IterativeParsingArrayInitialState,
1925 IterativeParsingArrayFinishState,
1926 IterativeParsingObjectInitialState,
1927 IterativeParsingErrorState,
1928 IterativeParsingErrorState,
1929 IterativeParsingErrorState,
1930 IterativeParsingElementState,
1931 IterativeParsingElementState,
1932 IterativeParsingElementState,
1933 IterativeParsingElementState,
1934 IterativeParsingElementState
1938 IterativeParsingErrorState,
1939 IterativeParsingArrayFinishState,
1940 IterativeParsingErrorState,
1941 IterativeParsingErrorState,
1942 IterativeParsingElementDelimiterState,
1943 IterativeParsingErrorState,
1944 IterativeParsingErrorState,
1945 IterativeParsingErrorState,
1946 IterativeParsingErrorState,
1947 IterativeParsingErrorState,
1948 IterativeParsingErrorState
1952 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1953 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1954 IterativeParsingErrorState
1958 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1959 IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
1960 IterativeParsingErrorState
1964 IterativeParsingArrayInitialState,
1965 IterativeParsingArrayFinishState,
1966 IterativeParsingObjectInitialState,
1967 IterativeParsingErrorState,
1968 IterativeParsingErrorState,
1969 IterativeParsingErrorState,
1970 IterativeParsingElementState,
1971 IterativeParsingElementState,
1972 IterativeParsingElementState,
1973 IterativeParsingElementState,
1974 IterativeParsingElementState
1978 IterativeParsingErrorState,
1979 IterativeParsingErrorState,
1980 IterativeParsingErrorState,
1981 IterativeParsingObjectFinishState,
1982 IterativeParsingErrorState,
1983 IterativeParsingErrorState,
1984 IterativeParsingMemberKeyState,
1985 IterativeParsingErrorState,
1986 IterativeParsingErrorState,
1987 IterativeParsingErrorState,
1988 IterativeParsingErrorState
1992 IterativeParsingArrayInitialState,
1993 IterativeParsingErrorState,
1994 IterativeParsingObjectInitialState,
1995 IterativeParsingErrorState,
1996 IterativeParsingErrorState,
1997 IterativeParsingErrorState,
1998 IterativeParsingMemberValueState,
1999 IterativeParsingMemberValueState,
2000 IterativeParsingMemberValueState,
2001 IterativeParsingMemberValueState,
2002 IterativeParsingMemberValueState
2006 return static_cast<IterativeParsingState
>(G[state][token]);
2011 template <
unsigned parseFlags,
typename InputStream,
typename Handler>
2012 RAPIDJSON_FORCEINLINE IterativeParsingState Transit(IterativeParsingState src, Token token, IterativeParsingState dst, InputStream& is, Handler& handler) {
2016 case IterativeParsingErrorState:
2019 case IterativeParsingObjectInitialState:
2020 case IterativeParsingArrayInitialState:
2024 IterativeParsingState n = src;
2025 if (src == IterativeParsingArrayInitialState || src == IterativeParsingElementDelimiterState)
2026 n = IterativeParsingElementState;
2027 else if (src == IterativeParsingKeyValueDelimiterState)
2028 n = IterativeParsingMemberValueState;
2030 *
stack_.template Push<SizeType>(1) = n;
2032 *
stack_.template Push<SizeType>(1) = 0;
2034 bool hr = (dst == IterativeParsingObjectInitialState) ? handler.StartObject() : handler.StartArray();
2038 return IterativeParsingErrorState;
2046 case IterativeParsingMemberKeyState:
2047 ParseString<parseFlags>(is, handler,
true);
2049 return IterativeParsingErrorState;
2053 case IterativeParsingKeyValueDelimiterState:
2058 case IterativeParsingMemberValueState:
2060 ParseValue<parseFlags>(is, handler);
2062 return IterativeParsingErrorState;
2066 case IterativeParsingElementState:
2068 ParseValue<parseFlags>(is, handler);
2070 return IterativeParsingErrorState;
2074 case IterativeParsingMemberDelimiterState:
2075 case IterativeParsingElementDelimiterState:
2078 *
stack_.template Top<SizeType>() = *
stack_.template Top<SizeType>() + 1;
2081 case IterativeParsingObjectFinishState:
2086 return IterativeParsingErrorState;
2091 if (src == IterativeParsingMemberValueState)
2094 IterativeParsingState n =
static_cast<IterativeParsingState
>(*
stack_.template Pop<SizeType>(1));
2096 if (n == IterativeParsingStartState)
2097 n = IterativeParsingFinishState;
2099 bool hr = handler.EndObject(c);
2103 return IterativeParsingErrorState;
2111 case IterativeParsingArrayFinishState:
2116 return IterativeParsingErrorState;
2121 if (src == IterativeParsingElementState)
2124 IterativeParsingState n =
static_cast<IterativeParsingState
>(*
stack_.template Pop<SizeType>(1));
2126 if (n == IterativeParsingStartState)
2127 n = IterativeParsingFinishState;
2129 bool hr = handler.EndArray(c);
2133 return IterativeParsingErrorState;
2155 ParseValue<parseFlags>(is, handler);
2157 return IterativeParsingErrorState;
2159 return IterativeParsingFinishState;
2163 template <
typename InputStream>
2164 void HandleError(IterativeParsingState src, InputStream& is) {
2173 case IterativeParsingObjectInitialState:
2177 case IterativeParsingKeyValueDelimiterState:
2178 case IterativeParsingArrayInitialState:
2184 RAPIDJSON_FORCEINLINE
bool IsIterativeParsingDelimiterState(IterativeParsingState s)
const {
2185 return s >= IterativeParsingElementDelimiterState;
2188 RAPIDJSON_FORCEINLINE
bool IsIterativeParsingCompleteState(IterativeParsingState s)
const {
2189 return s <= IterativeParsingErrorState;
2192 template <
unsigned parseFlags,
typename InputStream,
typename Handler>
2193 ParseResult IterativeParse(InputStream& is, Handler& handler) {
2194 parseResult_.Clear();
2196 IterativeParsingState state = IterativeParsingStartState;
2198 SkipWhitespaceAndComments<parseFlags>(is);
2199 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
2200 while (is.Peek() !=
'\0') {
2201 Token t = Tokenize(is.Peek());
2202 IterativeParsingState n = Predict(state, t);
2203 IterativeParsingState d = Transit<parseFlags>(state, t, n, is, handler);
2205 if (d == IterativeParsingErrorState) {
2206 HandleError(state, is);
2216 SkipWhitespaceAndComments<parseFlags>(is);
2217 RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
2221 if (state != IterativeParsingFinishState)
2222 HandleError(state, is);
2224 return parseResult_;
2230 IterativeParsingState state_;