MAXREFDES155# - DeepCover Embedded Security in IoT: Public-key Se…

Maxim Integrated » Code » MAXREFDES155#

Maxim Integrated / Mbed OS MAXREFDES155#

DeepCover Embedded Security in IoT: Public-key Secured Data Paths

The MAXREFDES155# is an internet-of-things (IoT) embedded-security reference design, built to authenticate and control a sensing node using elliptic-curve-based public-key cryptography with control and notification from a web server.

The hardware includes an ARM® mbed™ shield and attached sensor endpoint. The shield contains a DS2476 DeepCover® ECDSA/SHA-2 coprocessor, Wifi communication, LCD push-button controls, and status LEDs. The sensor endpoint is attached to the shield using a 300mm cable and contains a DS28C36 DeepCover ECDSA/SHA-2 authenticator, IR-thermal sensor, and aiming laser for the IR sensor. The MAXREFDES155# is equipped with a standard Arduino® form-factor shield connector for immediate testing using an mbed board such as the MAX32600MBED#. The combination of these two devices represent an IoT device. Communication to the web server is accomplished with the shield Wifi circuitry. Communication from the shield to the attached sensor module is accomplished over I2C . The sensor module represents an IoT endpoint that generates small data with a requirement for message authenticity/integrity and secure on/off operational control.

The design is hierarchical with each mbed platform and shield communicating data from the sensor node to a web server that maintains a centralized log and dispatches notifications as necessary. The simplicity of this design enables rapid integration into any star-topology IoT network to provide security with the low overhead and cost provided by the ECDSA-P256 asymmetric-key and SHA-256 symmetric-key algorithms.

More information about the MAXREFDES155# is available on the Maxim Integrated website.

xternal/rapidjson/reader.h@16:a004191a79ab, 2019-10-03 (annotated)

Committer:: IanBenzMaxim
Date:: Thu Oct 03 11:40:13 2019 -0500
Revision:: 16:a004191a79ab
Parent:: rapidjson/reader.h@0:33d4e66780c0

Updated MaximInterface to version 2.0. Updated mbed-os to version 5.5.7. Cleaned up code styling.

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Build repository

Repository details

Type:	Program
Mbed OS support:	Mbed OS
Created:	20 Feb 2017
Imports:	153
Forks:	0
Commits:	19
Dependents:	0
Dependencies:	1
Followers:	64

xternal/rapidjson/reader.h@16:a004191a79ab, 2019-10-03 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning