You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1370 lines
55 KiB
1370 lines
55 KiB
// Copyright (C) 2011 Milo Yip
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
// THE SOFTWARE.
|
|
|
|
#ifndef RAPIDJSON_READER_H_
|
|
#define RAPIDJSON_READER_H_
|
|
|
|
/*! \file reader.h */
|
|
|
|
#include "rapidjson.h"
|
|
#include "encodings.h"
|
|
#include "internal/meta.h"
|
|
#include "internal/pow10.h"
|
|
#include "internal/stack.h"
|
|
|
|
#if defined(RAPIDJSON_SIMD) && defined(_MSC_VER)
|
|
#include <intrin.h>
|
|
#pragma intrinsic(_BitScanForward)
|
|
#endif
|
|
#ifdef RAPIDJSON_SSE42
|
|
#include <nmmintrin.h>
|
|
#elif defined(RAPIDJSON_SSE2)
|
|
#include <emmintrin.h>
|
|
#endif
|
|
|
|
#ifdef _MSC_VER
|
|
RAPIDJSON_DIAG_PUSH
|
|
RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
|
|
RAPIDJSON_DIAG_OFF(4702) // unreachable code
|
|
#endif
|
|
|
|
//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
|
|
#define RAPIDJSON_NOTHING /* deliberately empty */
|
|
#ifndef RAPIDJSON_PARSE_ERROR_EARLY_RETURN
|
|
#define RAPIDJSON_PARSE_ERROR_EARLY_RETURN(value) \
|
|
RAPIDJSON_MULTILINEMACRO_BEGIN \
|
|
if (HasParseError()) { return value; } \
|
|
RAPIDJSON_MULTILINEMACRO_END
|
|
#endif
|
|
#define RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID \
|
|
RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
|
|
//!@endcond
|
|
|
|
/*! \def RAPIDJSON_PARSE_ERROR_NORETURN
|
|
\ingroup RAPIDJSON_ERRORS
|
|
\brief Macro to indicate a parse error.
|
|
\param parseErrorCode \ref rapidjson::ParseErrorCode of the error
|
|
\param offset position of the error in JSON input (\c size_t)
|
|
|
|
This macros can be used as a customization point for the internal
|
|
error handling mechanism of RapidJSON.
|
|
|
|
A common usage model is to throw an exception instead of requiring the
|
|
caller to explicitly check the \ref rapidjson::GenericReader::Parse's
|
|
return value:
|
|
|
|
\code
|
|
#define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode,offset) \
|
|
throw ParseException(parseErrorCode, #parseErrorCode, offset)
|
|
|
|
#include <stdexcept> // std::runtime_error
|
|
#include "rapidjson/error/error.h" // rapidjson::ParseResult
|
|
|
|
struct ParseException : std::runtime_error, rapidjson::ParseResult {
|
|
ParseException(rapidjson::ParseErrorCode code, const char* msg, size_t offset)
|
|
: std::runtime_error(msg), ParseResult(code, offset) {}
|
|
};
|
|
|
|
#include "rapidjson/reader.h"
|
|
\endcode
|
|
|
|
\see RAPIDJSON_PARSE_ERROR, rapidjson::GenericReader::Parse
|
|
*/
|
|
#ifndef RAPIDJSON_PARSE_ERROR_NORETURN
|
|
#define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset) \
|
|
RAPIDJSON_MULTILINEMACRO_BEGIN \
|
|
RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
|
|
SetParseError(parseErrorCode, offset); \
|
|
RAPIDJSON_MULTILINEMACRO_END
|
|
#endif
|
|
|
|
/*! \def RAPIDJSON_PARSE_ERROR
|
|
\ingroup RAPIDJSON_ERRORS
|
|
\brief (Internal) macro to indicate and handle a parse error.
|
|
\param parseErrorCode \ref rapidjson::ParseErrorCode of the error
|
|
\param offset position of the error in JSON input (\c size_t)
|
|
|
|
Invokes RAPIDJSON_PARSE_ERROR_NORETURN and stops the parsing.
|
|
|
|
\see RAPIDJSON_PARSE_ERROR_NORETURN
|
|
\hideinitializer
|
|
*/
|
|
#ifndef RAPIDJSON_PARSE_ERROR
|
|
#define RAPIDJSON_PARSE_ERROR(parseErrorCode, offset) \
|
|
RAPIDJSON_MULTILINEMACRO_BEGIN \
|
|
RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
|
|
RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
|
|
RAPIDJSON_MULTILINEMACRO_END
|
|
#endif
|
|
|
|
#include "error/error.h" // ParseErrorCode, ParseResult
|
|
|
|
namespace rapidjson {
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// ParseFlag
|
|
|
|
//! Combination of parseFlags
|
|
/*! \see Reader::Parse, Document::Parse, Document::ParseInsitu, Document::ParseStream
|
|
*/
|
|
enum ParseFlag {
|
|
kParseDefaultFlags = 0, //!< Default parse flags. Non-destructive parsing. Text strings are decoded into allocated buffer.
|
|
kParseInsituFlag = 1, //!< In-situ(destructive) parsing.
|
|
kParseValidateEncodingFlag = 2, //!< Validate encoding of JSON strings.
|
|
kParseIterativeFlag = 4, //!< Iterative(constant complexity in terms of function call stack size) parsing.
|
|
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.
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Handler
|
|
|
|
/*! \class rapidjson::Handler
|
|
\brief Concept for receiving events from GenericReader upon parsing.
|
|
The functions return true if no error occurs. If they return false,
|
|
the event publisher should terminate the process.
|
|
\code
|
|
concept Handler {
|
|
typename Ch;
|
|
|
|
bool Null();
|
|
bool Bool(bool b);
|
|
bool Int(int i);
|
|
bool Uint(unsigned i);
|
|
bool Int64(int64_t i);
|
|
bool Uint64(uint64_t i);
|
|
bool Double(double d);
|
|
bool String(const Ch* str, SizeType length, bool copy);
|
|
bool StartObject();
|
|
bool Key(const Ch* str, SizeType length, bool copy);
|
|
bool EndObject(SizeType memberCount);
|
|
bool StartArray();
|
|
bool EndArray(SizeType elementCount);
|
|
};
|
|
\endcode
|
|
*/
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// BaseReaderHandler
|
|
|
|
//! Default implementation of Handler.
|
|
/*! This can be used as base class of any reader handler.
|
|
\note implements Handler concept
|
|
*/
|
|
template<typename Encoding = UTF8<>, typename Derived = void>
|
|
struct BaseReaderHandler {
|
|
typedef typename Encoding::Ch Ch;
|
|
|
|
typedef typename internal::SelectIf<internal::IsSame<Derived, void>, BaseReaderHandler, Derived>::Type Override;
|
|
|
|
bool Default() { return true; }
|
|
bool Null() { return static_cast<Override&>(*this).Default(); }
|
|
bool Bool(bool) { return static_cast<Override&>(*this).Default(); }
|
|
bool Int(int) { return static_cast<Override&>(*this).Default(); }
|
|
bool Uint(unsigned) { return static_cast<Override&>(*this).Default(); }
|
|
bool Int64(int64_t) { return static_cast<Override&>(*this).Default(); }
|
|
bool Uint64(uint64_t) { return static_cast<Override&>(*this).Default(); }
|
|
bool Double(double) { return static_cast<Override&>(*this).Default(); }
|
|
bool String(const Ch*, SizeType, bool) { return static_cast<Override&>(*this).Default(); }
|
|
bool StartObject() { return static_cast<Override&>(*this).Default(); }
|
|
bool Key(const Ch* str, SizeType len, bool copy) { return static_cast<Override&>(*this).String(str, len, copy); }
|
|
bool EndObject(SizeType) { return static_cast<Override&>(*this).Default(); }
|
|
bool StartArray() { return static_cast<Override&>(*this).Default(); }
|
|
bool EndArray(SizeType) { return static_cast<Override&>(*this).Default(); }
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// StreamLocalCopy
|
|
|
|
namespace internal {
|
|
|
|
template<typename Stream, int = StreamTraits<Stream>::copyOptimization>
|
|
class StreamLocalCopy;
|
|
|
|
//! Do copy optimization.
|
|
template<typename Stream>
|
|
class StreamLocalCopy<Stream, 1> {
|
|
public:
|
|
StreamLocalCopy(Stream& original) : s(original), original_(original) {}
|
|
~StreamLocalCopy() { original_ = s; }
|
|
|
|
Stream s;
|
|
|
|
private:
|
|
StreamLocalCopy& operator=(const StreamLocalCopy&) /* = delete */;
|
|
|
|
Stream& original_;
|
|
};
|
|
|
|
//! Keep reference.
|
|
template<typename Stream>
|
|
class StreamLocalCopy<Stream, 0> {
|
|
public:
|
|
StreamLocalCopy(Stream& original) : s(original) {}
|
|
|
|
Stream& s;
|
|
|
|
private:
|
|
StreamLocalCopy& operator=(const StreamLocalCopy&) /* = delete */;
|
|
};
|
|
|
|
} // namespace internal
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// SkipWhitespace
|
|
|
|
//! Skip the JSON white spaces in a stream.
|
|
/*! \param is A input stream for skipping white spaces.
|
|
\note This function has SSE2/SSE4.2 specialization.
|
|
*/
|
|
template<typename InputStream>
|
|
void SkipWhitespace(InputStream& is) {
|
|
internal::StreamLocalCopy<InputStream> copy(is);
|
|
InputStream& s(copy.s);
|
|
|
|
while (s.Peek() == ' ' || s.Peek() == '\n' || s.Peek() == '\r' || s.Peek() == '\t')
|
|
s.Take();
|
|
}
|
|
|
|
#ifdef RAPIDJSON_SSE42
|
|
//! Skip whitespace with SSE 4.2 pcmpistrm instruction, testing 16 8-byte characters at once.
|
|
inline const char *SkipWhitespace_SIMD(const char* p) {
|
|
// Fast return for single non-whitespace
|
|
if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
|
|
++p;
|
|
else
|
|
return p;
|
|
|
|
// 16-byte align to the next boundary
|
|
const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & ~15);
|
|
while (p != nextAligned)
|
|
if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
|
|
++p;
|
|
else
|
|
return p;
|
|
|
|
// The rest of string using SIMD
|
|
static const char whitespace[16] = " \n\r\t";
|
|
const __m128i w = _mm_loadu_si128((const __m128i *)&whitespace[0]);
|
|
|
|
for (;; p += 16) {
|
|
const __m128i s = _mm_load_si128((const __m128i *)p);
|
|
const unsigned r = _mm_cvtsi128_si32(_mm_cmpistrm(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_BIT_MASK | _SIDD_NEGATIVE_POLARITY));
|
|
if (r != 0) { // some of characters is non-whitespace
|
|
#ifdef _MSC_VER // Find the index of first non-whitespace
|
|
unsigned long offset;
|
|
_BitScanForward(&offset, r);
|
|
return p + offset;
|
|
#else
|
|
return p + __builtin_ffs(r) - 1;
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
#elif defined(RAPIDJSON_SSE2)
|
|
|
|
//! Skip whitespace with SSE2 instructions, testing 16 8-byte characters at once.
|
|
inline const char *SkipWhitespace_SIMD(const char* p) {
|
|
// Fast return for single non-whitespace
|
|
if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
|
|
++p;
|
|
else
|
|
return p;
|
|
|
|
// 16-byte align to the next boundary
|
|
const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & ~15);
|
|
while (p != nextAligned)
|
|
if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
|
|
++p;
|
|
else
|
|
return p;
|
|
|
|
// The rest of string
|
|
static const char whitespaces[4][17] = {
|
|
" ",
|
|
"\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n",
|
|
"\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r",
|
|
"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t"};
|
|
|
|
const __m128i w0 = _mm_loadu_si128((const __m128i *)&whitespaces[0][0]);
|
|
const __m128i w1 = _mm_loadu_si128((const __m128i *)&whitespaces[1][0]);
|
|
const __m128i w2 = _mm_loadu_si128((const __m128i *)&whitespaces[2][0]);
|
|
const __m128i w3 = _mm_loadu_si128((const __m128i *)&whitespaces[3][0]);
|
|
|
|
for (;; p += 16) {
|
|
const __m128i s = _mm_load_si128((const __m128i *)p);
|
|
__m128i x = _mm_cmpeq_epi8(s, w0);
|
|
x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1));
|
|
x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2));
|
|
x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3));
|
|
unsigned short r = (unsigned short)~_mm_movemask_epi8(x);
|
|
if (r != 0) { // some of characters may be non-whitespace
|
|
#ifdef _MSC_VER // Find the index of first non-whitespace
|
|
unsigned long offset;
|
|
_BitScanForward(&offset, r);
|
|
return p + offset;
|
|
#else
|
|
return p + __builtin_ffs(r) - 1;
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif // RAPIDJSON_SSE2
|
|
|
|
#ifdef RAPIDJSON_SIMD
|
|
//! Template function specialization for InsituStringStream
|
|
template<> inline void SkipWhitespace(InsituStringStream& is) {
|
|
is.src_ = const_cast<char*>(SkipWhitespace_SIMD(is.src_));
|
|
}
|
|
|
|
//! Template function specialization for StringStream
|
|
template<> inline void SkipWhitespace(StringStream& is) {
|
|
is.src_ = SkipWhitespace_SIMD(is.src_);
|
|
}
|
|
#endif // RAPIDJSON_SIMD
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// GenericReader
|
|
|
|
//! SAX-style JSON parser. Use \ref Reader for UTF8 encoding and default allocator.
|
|
/*! GenericReader parses JSON text from a stream, and send events synchronously to an
|
|
object implementing Handler concept.
|
|
|
|
It needs to allocate a stack for storing a single decoded string during
|
|
non-destructive parsing.
|
|
|
|
For in-situ parsing, the decoded string is directly written to the source
|
|
text string, no temporary buffer is required.
|
|
|
|
A GenericReader object can be reused for parsing multiple JSON text.
|
|
|
|
\tparam SourceEncoding Encoding of the input stream.
|
|
\tparam TargetEncoding Encoding of the parse output.
|
|
\tparam StackAllocator Allocator type for stack.
|
|
*/
|
|
template <typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>
|
|
class GenericReader {
|
|
public:
|
|
typedef typename SourceEncoding::Ch Ch; //!< SourceEncoding character type
|
|
|
|
//! Constructor.
|
|
/*! \param allocator Optional allocator for allocating stack memory. (Only use for non-destructive parsing)
|
|
\param stackCapacity stack capacity in bytes for storing a single decoded string. (Only use for non-destructive parsing)
|
|
*/
|
|
GenericReader(StackAllocator* stackAllocator = 0, size_t stackCapacity = kDefaultStackCapacity) : stack_(stackAllocator, stackCapacity), parseResult_() {}
|
|
|
|
//! Parse JSON text.
|
|
/*! \tparam parseFlags Combination of \ref ParseFlag.
|
|
\tparam InputStream Type of input stream, implementing Stream concept.
|
|
\tparam Handler Type of handler, implementing Handler concept.
|
|
\param is Input stream to be parsed.
|
|
\param handler The handler to receive events.
|
|
\return Whether the parsing is successful.
|
|
*/
|
|
template <unsigned parseFlags, typename InputStream, typename Handler>
|
|
ParseResult Parse(InputStream& is, Handler& handler) {
|
|
if (parseFlags & kParseIterativeFlag)
|
|
return IterativeParse<parseFlags>(is, handler);
|
|
|
|
parseResult_.Clear();
|
|
|
|
ClearStackOnExit scope(*this);
|
|
|
|
SkipWhitespace(is);
|
|
|
|
if (is.Peek() == '\0') {
|
|
RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentEmpty, is.Tell());
|
|
RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
|
|
}
|
|
else {
|
|
ParseValue<parseFlags>(is, handler);
|
|
RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
|
|
|
|
if (!(parseFlags & kParseStopWhenDoneFlag)) {
|
|
SkipWhitespace(is);
|
|
|
|
if (is.Peek() != '\0') {
|
|
RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentRootNotSingular, is.Tell());
|
|
RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
|
|
}
|
|
}
|
|
}
|
|
|
|
return parseResult_;
|
|
}
|
|
|
|
//! Parse JSON text (with \ref kParseDefaultFlags)
|
|
/*! \tparam InputStream Type of input stream, implementing Stream concept
|
|
\tparam Handler Type of handler, implementing Handler concept.
|
|
\param is Input stream to be parsed.
|
|
\param handler The handler to receive events.
|
|
\return Whether the parsing is successful.
|
|
*/
|
|
template <typename InputStream, typename Handler>
|
|
ParseResult Parse(InputStream& is, Handler& handler) {
|
|
return Parse<kParseDefaultFlags>(is, handler);
|
|
}
|
|
|
|
//! Whether a parse error has occured in the last parsing.
|
|
bool HasParseError() const { return parseResult_.IsError(); }
|
|
|
|
//! Get the \ref ParseErrorCode of last parsing.
|
|
ParseErrorCode GetParseErrorCode() const { return parseResult_.Code(); }
|
|
|
|
//! Get the position of last parsing error in input, 0 otherwise.
|
|
size_t GetErrorOffset() const { return parseResult_.Offset(); }
|
|
|
|
protected:
|
|
void SetParseError(ParseErrorCode code, size_t offset) { parseResult_.Set(code, offset); }
|
|
|
|
private:
|
|
// Prohibit copy constructor & assignment operator.
|
|
GenericReader(const GenericReader&);
|
|
GenericReader& operator=(const GenericReader&);
|
|
|
|
void ClearStack() { stack_.Clear(); }
|
|
|
|
// clear stack on any exit from ParseStream, e.g. due to exception
|
|
struct ClearStackOnExit {
|
|
explicit ClearStackOnExit(GenericReader& r) : r_(r) {}
|
|
~ClearStackOnExit() { r_.ClearStack(); }
|
|
private:
|
|
GenericReader& r_;
|
|
ClearStackOnExit(const ClearStackOnExit&);
|
|
ClearStackOnExit& operator=(const ClearStackOnExit&);
|
|
};
|
|
|
|
// Parse object: { string : value, ... }
|
|
template<unsigned parseFlags, typename InputStream, typename Handler>
|
|
void ParseObject(InputStream& is, Handler& handler) {
|
|
RAPIDJSON_ASSERT(is.Peek() == '{');
|
|
is.Take(); // Skip '{'
|
|
|
|
if (!handler.StartObject())
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
|
|
|
|
SkipWhitespace(is);
|
|
|
|
if (is.Peek() == '}') {
|
|
is.Take();
|
|
if (!handler.EndObject(0)) // empty object
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
|
|
return;
|
|
}
|
|
|
|
for (SizeType memberCount = 0;;) {
|
|
if (is.Peek() != '"')
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell());
|
|
|
|
ParseString<parseFlags>(is, handler, true);
|
|
RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
|
|
|
|
SkipWhitespace(is);
|
|
|
|
if (is.Take() != ':')
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell());
|
|
|
|
SkipWhitespace(is);
|
|
|
|
ParseValue<parseFlags>(is, handler);
|
|
RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
|
|
|
|
SkipWhitespace(is);
|
|
|
|
++memberCount;
|
|
|
|
switch (is.Take()) {
|
|
case ',': SkipWhitespace(is); break;
|
|
case '}':
|
|
if (!handler.EndObject(memberCount))
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
|
|
else
|
|
return;
|
|
default: RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell());
|
|
}
|
|
}
|
|
}
|
|
|
|
// Parse array: [ value, ... ]
|
|
template<unsigned parseFlags, typename InputStream, typename Handler>
|
|
void ParseArray(InputStream& is, Handler& handler) {
|
|
RAPIDJSON_ASSERT(is.Peek() == '[');
|
|
is.Take(); // Skip '['
|
|
|
|
if (!handler.StartArray())
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
|
|
|
|
SkipWhitespace(is);
|
|
|
|
if (is.Peek() == ']') {
|
|
is.Take();
|
|
if (!handler.EndArray(0)) // empty array
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
|
|
return;
|
|
}
|
|
|
|
for (SizeType elementCount = 0;;) {
|
|
ParseValue<parseFlags>(is, handler);
|
|
RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
|
|
|
|
++elementCount;
|
|
SkipWhitespace(is);
|
|
|
|
switch (is.Take()) {
|
|
case ',': SkipWhitespace(is); break;
|
|
case ']':
|
|
if (!handler.EndArray(elementCount))
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
|
|
else
|
|
return;
|
|
default: RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());
|
|
}
|
|
}
|
|
}
|
|
|
|
template<unsigned parseFlags, typename InputStream, typename Handler>
|
|
void ParseNull(InputStream& is, Handler& handler) {
|
|
RAPIDJSON_ASSERT(is.Peek() == 'n');
|
|
is.Take();
|
|
|
|
if (is.Take() == 'u' && is.Take() == 'l' && is.Take() == 'l') {
|
|
if (!handler.Null())
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
|
|
}
|
|
else
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell() - 1);
|
|
}
|
|
|
|
template<unsigned parseFlags, typename InputStream, typename Handler>
|
|
void ParseTrue(InputStream& is, Handler& handler) {
|
|
RAPIDJSON_ASSERT(is.Peek() == 't');
|
|
is.Take();
|
|
|
|
if (is.Take() == 'r' && is.Take() == 'u' && is.Take() == 'e') {
|
|
if (!handler.Bool(true))
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
|
|
}
|
|
else
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell() - 1);
|
|
}
|
|
|
|
template<unsigned parseFlags, typename InputStream, typename Handler>
|
|
void ParseFalse(InputStream& is, Handler& handler) {
|
|
RAPIDJSON_ASSERT(is.Peek() == 'f');
|
|
is.Take();
|
|
|
|
if (is.Take() == 'a' && is.Take() == 'l' && is.Take() == 's' && is.Take() == 'e') {
|
|
if (!handler.Bool(false))
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
|
|
}
|
|
else
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell() - 1);
|
|
}
|
|
|
|
// Helper function to parse four hexidecimal digits in \uXXXX in ParseString().
|
|
template<typename InputStream>
|
|
unsigned ParseHex4(InputStream& is) {
|
|
unsigned codepoint = 0;
|
|
for (int i = 0; i < 4; i++) {
|
|
Ch c = is.Take();
|
|
codepoint <<= 4;
|
|
codepoint += static_cast<unsigned>(c);
|
|
if (c >= '0' && c <= '9')
|
|
codepoint -= '0';
|
|
else if (c >= 'A' && c <= 'F')
|
|
codepoint -= 'A' - 10;
|
|
else if (c >= 'a' && c <= 'f')
|
|
codepoint -= 'a' - 10;
|
|
else {
|
|
RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorStringUnicodeEscapeInvalidHex, is.Tell() - 1);
|
|
RAPIDJSON_PARSE_ERROR_EARLY_RETURN(0);
|
|
}
|
|
}
|
|
return codepoint;
|
|
}
|
|
|
|
class StackStream {
|
|
public:
|
|
typedef typename TargetEncoding::Ch Ch;
|
|
|
|
StackStream(internal::Stack<StackAllocator>& stack) : stack_(stack), length_(0) {}
|
|
RAPIDJSON_FORCEINLINE void Put(Ch c) {
|
|
*stack_.template Push<Ch>() = c;
|
|
++length_;
|
|
}
|
|
internal::Stack<StackAllocator>& stack_;
|
|
SizeType length_;
|
|
|
|
private:
|
|
StackStream(const StackStream&);
|
|
StackStream& operator=(const StackStream&);
|
|
};
|
|
|
|
// Parse string and generate String event. Different code paths for kParseInsituFlag.
|
|
template<unsigned parseFlags, typename InputStream, typename Handler>
|
|
void ParseString(InputStream& is, Handler& handler, bool isKey = false) {
|
|
internal::StreamLocalCopy<InputStream> copy(is);
|
|
InputStream& s(copy.s);
|
|
|
|
bool success = false;
|
|
if (parseFlags & kParseInsituFlag) {
|
|
typename InputStream::Ch *head = s.PutBegin();
|
|
ParseStringToStream<parseFlags, SourceEncoding, SourceEncoding>(s, s);
|
|
RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
|
|
size_t length = s.PutEnd(head) - 1;
|
|
RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
|
|
const typename TargetEncoding::Ch* const str = (typename TargetEncoding::Ch*)head;
|
|
success = (isKey ? handler.Key(str, SizeType(length), false) : handler.String(str, SizeType(length), false));
|
|
}
|
|
else {
|
|
StackStream stackStream(stack_);
|
|
ParseStringToStream<parseFlags, SourceEncoding, TargetEncoding>(s, stackStream);
|
|
RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
|
|
const typename TargetEncoding::Ch* const str = stack_.template Pop<typename TargetEncoding::Ch>(stackStream.length_);
|
|
success = (isKey ? handler.Key(str, stackStream.length_ - 1, true) : handler.String(str, stackStream.length_ - 1, true));
|
|
}
|
|
if (!success)
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorTermination, s.Tell());
|
|
}
|
|
|
|
// Parse string to an output is
|
|
// This function handles the prefix/suffix double quotes, escaping, and optional encoding validation.
|
|
template<unsigned parseFlags, typename SEncoding, typename TEncoding, typename InputStream, typename OutputStream>
|
|
RAPIDJSON_FORCEINLINE void ParseStringToStream(InputStream& is, OutputStream& os) {
|
|
//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
|
|
#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
|
|
static const char escape[256] = {
|
|
Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'/',
|
|
Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0,
|
|
0, 0,'\b', 0, 0, 0,'\f', 0, 0, 0, 0, 0, 0, 0,'\n', 0,
|
|
0, 0,'\r', 0,'\t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
|
|
};
|
|
#undef Z16
|
|
//!@endcond
|
|
|
|
RAPIDJSON_ASSERT(is.Peek() == '\"');
|
|
is.Take(); // Skip '\"'
|
|
|
|
for (;;) {
|
|
Ch c = is.Peek();
|
|
if (c == '\\') { // Escape
|
|
is.Take();
|
|
Ch e = is.Take();
|
|
if ((sizeof(Ch) == 1 || unsigned(e) < 256) && escape[(unsigned char)e]) {
|
|
os.Put(escape[(unsigned char)e]);
|
|
}
|
|
else if (e == 'u') { // Unicode
|
|
unsigned codepoint = ParseHex4(is);
|
|
if (codepoint >= 0xD800 && codepoint <= 0xDBFF) {
|
|
// Handle UTF-16 surrogate pair
|
|
if (is.Take() != '\\' || is.Take() != 'u')
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, is.Tell() - 2);
|
|
unsigned codepoint2 = ParseHex4(is);
|
|
if (codepoint2 < 0xDC00 || codepoint2 > 0xDFFF)
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, is.Tell() - 2);
|
|
codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000;
|
|
}
|
|
TEncoding::Encode(os, codepoint);
|
|
}
|
|
else
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorStringEscapeInvalid, is.Tell() - 1);
|
|
}
|
|
else if (c == '"') { // Closing double quote
|
|
is.Take();
|
|
os.Put('\0'); // null-terminate the string
|
|
return;
|
|
}
|
|
else if (c == '\0')
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorStringMissQuotationMark, is.Tell() - 1);
|
|
else if ((unsigned)c < 0x20) // RFC 4627: unescaped = %x20-21 / %x23-5B / %x5D-10FFFF
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorStringEscapeInvalid, is.Tell() - 1);
|
|
else {
|
|
if (parseFlags & kParseValidateEncodingFlag ?
|
|
!Transcoder<SEncoding, TEncoding>::Validate(is, os) :
|
|
!Transcoder<SEncoding, TEncoding>::Transcode(is, os))
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, is.Tell());
|
|
}
|
|
}
|
|
}
|
|
|
|
inline double StrtodFastPath(double significand, int exp) {
|
|
// Fast path only works on limited range of values.
|
|
// But for simplicity and performance, currently only implement this.
|
|
// see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion/
|
|
if (exp < -308)
|
|
return 0.0;
|
|
else if (exp >= 0)
|
|
return significand * internal::Pow10(exp);
|
|
else
|
|
return significand / internal::Pow10(-exp);
|
|
}
|
|
|
|
template<unsigned parseFlags, typename InputStream, typename Handler>
|
|
void ParseNumber(InputStream& is, Handler& handler) {
|
|
internal::StreamLocalCopy<InputStream> copy(is);
|
|
InputStream& s(copy.s);
|
|
|
|
// Parse minus
|
|
bool minus = false;
|
|
if (s.Peek() == '-') {
|
|
minus = true;
|
|
s.Take();
|
|
}
|
|
|
|
// Parse int: zero / ( digit1-9 *DIGIT )
|
|
unsigned i = 0;
|
|
uint64_t i64 = 0;
|
|
bool use64bit = false;
|
|
if (s.Peek() == '0') {
|
|
i = 0;
|
|
s.Take();
|
|
}
|
|
else if (s.Peek() >= '1' && s.Peek() <= '9') {
|
|
i = static_cast<unsigned>(s.Take() - '0');
|
|
|
|
if (minus)
|
|
while (s.Peek() >= '0' && s.Peek() <= '9') {
|
|
if (i >= 214748364) { // 2^31 = 2147483648
|
|
if (i != 214748364 || s.Peek() > '8') {
|
|
i64 = i;
|
|
use64bit = true;
|
|
break;
|
|
}
|
|
}
|
|
i = i * 10 + static_cast<unsigned>(s.Take() - '0');
|
|
}
|
|
else
|
|
while (s.Peek() >= '0' && s.Peek() <= '9') {
|
|
if (i >= 429496729) { // 2^32 - 1 = 4294967295
|
|
if (i != 429496729 || s.Peek() > '5') {
|
|
i64 = i;
|
|
use64bit = true;
|
|
break;
|
|
}
|
|
}
|
|
i = i * 10 + static_cast<unsigned>(s.Take() - '0');
|
|
}
|
|
}
|
|
else
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
|
|
|
|
// Parse 64bit int
|
|
double d = 0.0;
|
|
bool useDouble = false;
|
|
if (use64bit) {
|
|
if (minus)
|
|
while (s.Peek() >= '0' && s.Peek() <= '9') {
|
|
if (i64 >= RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC)) // 2^63 = 9223372036854775808
|
|
if (i64 != RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC) || s.Peek() > '8') {
|
|
d = (double)i64;
|
|
useDouble = true;
|
|
break;
|
|
}
|
|
i64 = i64 * 10 + static_cast<unsigned>(s.Take() - '0');
|
|
}
|
|
else
|
|
while (s.Peek() >= '0' && s.Peek() <= '9') {
|
|
if (i64 >= RAPIDJSON_UINT64_C2(0x19999999, 0x99999999)) // 2^64 - 1 = 18446744073709551615
|
|
if (i64 != RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) || s.Peek() > '5') {
|
|
d = (double)i64;
|
|
useDouble = true;
|
|
break;
|
|
}
|
|
i64 = i64 * 10 + static_cast<unsigned>(s.Take() - '0');
|
|
}
|
|
}
|
|
|
|
// Force double for big integer
|
|
if (useDouble) {
|
|
while (s.Peek() >= '0' && s.Peek() <= '9') {
|
|
if (d >= 1.7976931348623157e307) // DBL_MAX / 10.0
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, s.Tell());
|
|
d = d * 10 + (s.Take() - '0');
|
|
}
|
|
}
|
|
|
|
// Parse frac = decimal-point 1*DIGIT
|
|
int expFrac = 0;
|
|
if (s.Peek() == '.') {
|
|
s.Take();
|
|
|
|
#if RAPIDJSON_64BIT
|
|
// Use i64 to store significand in 64-bit architecture
|
|
if (!useDouble) {
|
|
if (!use64bit)
|
|
i64 = i;
|
|
|
|
while (s.Peek() >= '0' && s.Peek() <= '9') {
|
|
if (i64 >= RAPIDJSON_UINT64_C2(0x19999999, 0x99999999))
|
|
break;
|
|
else {
|
|
i64 = i64 * 10 + static_cast<unsigned>(s.Take() - '0');
|
|
--expFrac;
|
|
}
|
|
}
|
|
|
|
d = (double)i64;
|
|
}
|
|
#else
|
|
// Use double to store significand in 32-bit architecture
|
|
if (!useDouble)
|
|
d = use64bit ? (double)i64 : (double)i;
|
|
#endif
|
|
useDouble = true;
|
|
|
|
while (s.Peek() >= '0' && s.Peek() <= '9') {
|
|
d = d * 10 + (s.Take() - '0');
|
|
--expFrac;
|
|
}
|
|
|
|
if (expFrac == 0)
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissFraction, s.Tell());
|
|
}
|
|
|
|
// Parse exp = e [ minus / plus ] 1*DIGIT
|
|
int exp = 0;
|
|
if (s.Peek() == 'e' || s.Peek() == 'E') {
|
|
if (!useDouble) {
|
|
d = use64bit ? (double)i64 : (double)i;
|
|
useDouble = true;
|
|
}
|
|
s.Take();
|
|
|
|
bool expMinus = false;
|
|
if (s.Peek() == '+')
|
|
s.Take();
|
|
else if (s.Peek() == '-') {
|
|
s.Take();
|
|
expMinus = true;
|
|
}
|
|
|
|
if (s.Peek() >= '0' && s.Peek() <= '9') {
|
|
exp = s.Take() - '0';
|
|
while (s.Peek() >= '0' && s.Peek() <= '9') {
|
|
exp = exp * 10 + (s.Take() - '0');
|
|
if (exp > 308 && !expMinus) // exp > 308 should be rare, so it should be checked first.
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, s.Tell());
|
|
}
|
|
}
|
|
else
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissExponent, s.Tell());
|
|
|
|
if (expMinus)
|
|
exp = -exp;
|
|
}
|
|
|
|
// Finish parsing, call event according to the type of number.
|
|
bool cont = true;
|
|
if (useDouble) {
|
|
int expSum = exp + expFrac;
|
|
if (expSum < -308) {
|
|
// Prevent expSum < -308, making Pow10(expSum) = 0
|
|
d = StrtodFastPath(d, exp);
|
|
d = StrtodFastPath(d, expFrac);
|
|
}
|
|
else
|
|
d = StrtodFastPath(d, expSum);
|
|
|
|
cont = handler.Double(minus ? -d : d);
|
|
}
|
|
else {
|
|
if (use64bit) {
|
|
if (minus)
|
|
cont = handler.Int64(-(int64_t)i64);
|
|
else
|
|
cont = handler.Uint64(i64);
|
|
}
|
|
else {
|
|
if (minus)
|
|
cont = handler.Int(-(int)i);
|
|
else
|
|
cont = handler.Uint(i);
|
|
}
|
|
}
|
|
if (!cont)
|
|
RAPIDJSON_PARSE_ERROR(kParseErrorTermination, s.Tell());
|
|
}
|
|
|
|
// Parse any JSON value
|
|
template<unsigned parseFlags, typename InputStream, typename Handler>
|
|
void ParseValue(InputStream& is, Handler& handler) {
|
|
switch (is.Peek()) {
|
|
case 'n': ParseNull <parseFlags>(is, handler); break;
|
|
case 't': ParseTrue <parseFlags>(is, handler); break;
|
|
case 'f': ParseFalse <parseFlags>(is, handler); break;
|
|
case '"': ParseString<parseFlags>(is, handler); break;
|
|
case '{': ParseObject<parseFlags>(is, handler); break;
|
|
case '[': ParseArray <parseFlags>(is, handler); break;
|
|
default : ParseNumber<parseFlags>(is, handler);
|
|
}
|
|
}
|
|
|
|
// Iterative Parsing
|
|
|
|
// States
|
|
enum IterativeParsingState {
|
|
IterativeParsingStartState = 0,
|
|
IterativeParsingFinishState,
|
|
IterativeParsingErrorState,
|
|
|
|
// Object states
|
|
IterativeParsingObjectInitialState,
|
|
IterativeParsingMemberKeyState,
|
|
IterativeParsingKeyValueDelimiterState,
|
|
IterativeParsingMemberValueState,
|
|
IterativeParsingMemberDelimiterState,
|
|
IterativeParsingObjectFinishState,
|
|
|
|
// Array states
|
|
IterativeParsingArrayInitialState,
|
|
IterativeParsingElementState,
|
|
IterativeParsingElementDelimiterState,
|
|
IterativeParsingArrayFinishState,
|
|
|
|
// Single value state
|
|
IterativeParsingValueState,
|
|
|
|
cIterativeParsingStateCount
|
|
};
|
|
|
|
// Tokens
|
|
enum Token {
|
|
LeftBracketToken = 0,
|
|
RightBracketToken,
|
|
|
|
LeftCurlyBracketToken,
|
|
RightCurlyBracketToken,
|
|
|
|
CommaToken,
|
|
ColonToken,
|
|
|
|
StringToken,
|
|
FalseToken,
|
|
TrueToken,
|
|
NullToken,
|
|
NumberToken,
|
|
|
|
kTokenCount
|
|
};
|
|
|
|
RAPIDJSON_FORCEINLINE Token Tokenize(Ch c) {
|
|
|
|
//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
|
|
#define N NumberToken
|
|
#define N16 N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N
|
|
// Maps from ASCII to Token
|
|
static const unsigned char tokenMap[256] = {
|
|
N16, // 00~0F
|
|
N16, // 10~1F
|
|
N, N, StringToken, N, N, N, N, N, N, N, N, N, CommaToken, N, N, N, // 20~2F
|
|
N, N, N, N, N, N, N, N, N, N, ColonToken, N, N, N, N, N, // 30~3F
|
|
N16, // 40~4F
|
|
N, N, N, N, N, N, N, N, N, N, N, LeftBracketToken, N, RightBracketToken, N, N, // 50~5F
|
|
N, N, N, N, N, N, FalseToken, N, N, N, N, N, N, N, NullToken, N, // 60~6F
|
|
N, N, N, N, TrueToken, N, N, N, N, N, N, LeftCurlyBracketToken, N, RightCurlyBracketToken, N, N, // 70~7F
|
|
N16, N16, N16, N16, N16, N16, N16, N16 // 80~FF
|
|
};
|
|
#undef N
|
|
#undef N16
|
|
//!@endcond
|
|
|
|
if (sizeof(Ch) == 1 || unsigned(c) < 256)
|
|
return (Token)tokenMap[(unsigned char)c];
|
|
else
|
|
return NumberToken;
|
|
}
|
|
|
|
RAPIDJSON_FORCEINLINE IterativeParsingState Predict(IterativeParsingState state, Token token) {
|
|
// current state x one lookahead token -> new state
|
|
static const char G[cIterativeParsingStateCount][kTokenCount] = {
|
|
// Start
|
|
{
|
|
IterativeParsingArrayInitialState, // Left bracket
|
|
IterativeParsingErrorState, // Right bracket
|
|
IterativeParsingObjectInitialState, // Left curly bracket
|
|
IterativeParsingErrorState, // Right curly bracket
|
|
IterativeParsingErrorState, // Comma
|
|
IterativeParsingErrorState, // Colon
|
|
IterativeParsingValueState, // String
|
|
IterativeParsingValueState, // False
|
|
IterativeParsingValueState, // True
|
|
IterativeParsingValueState, // Null
|
|
IterativeParsingValueState // Number
|
|
},
|
|
// Finish(sink state)
|
|
{
|
|
IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
|
|
IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
|
|
IterativeParsingErrorState
|
|
},
|
|
// Error(sink state)
|
|
{
|
|
IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
|
|
IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
|
|
IterativeParsingErrorState
|
|
},
|
|
// ObjectInitial
|
|
{
|
|
IterativeParsingErrorState, // Left bracket
|
|
IterativeParsingErrorState, // Right bracket
|
|
IterativeParsingErrorState, // Left curly bracket
|
|
IterativeParsingObjectFinishState, // Right curly bracket
|
|
IterativeParsingErrorState, // Comma
|
|
IterativeParsingErrorState, // Colon
|
|
IterativeParsingMemberKeyState, // String
|
|
IterativeParsingErrorState, // False
|
|
IterativeParsingErrorState, // True
|
|
IterativeParsingErrorState, // Null
|
|
IterativeParsingErrorState // Number
|
|
},
|
|
// MemberKey
|
|
{
|
|
IterativeParsingErrorState, // Left bracket
|
|
IterativeParsingErrorState, // Right bracket
|
|
IterativeParsingErrorState, // Left curly bracket
|
|
IterativeParsingErrorState, // Right curly bracket
|
|
IterativeParsingErrorState, // Comma
|
|
IterativeParsingKeyValueDelimiterState, // Colon
|
|
IterativeParsingErrorState, // String
|
|
IterativeParsingErrorState, // False
|
|
IterativeParsingErrorState, // True
|
|
IterativeParsingErrorState, // Null
|
|
IterativeParsingErrorState // Number
|
|
},
|
|
// KeyValueDelimiter
|
|
{
|
|
IterativeParsingArrayInitialState, // Left bracket(push MemberValue state)
|
|
IterativeParsingErrorState, // Right bracket
|
|
IterativeParsingObjectInitialState, // Left curly bracket(push MemberValue state)
|
|
IterativeParsingErrorState, // Right curly bracket
|
|
IterativeParsingErrorState, // Comma
|
|
IterativeParsingErrorState, // Colon
|
|
IterativeParsingMemberValueState, // String
|
|
IterativeParsingMemberValueState, // False
|
|
IterativeParsingMemberValueState, // True
|
|
IterativeParsingMemberValueState, // Null
|
|
IterativeParsingMemberValueState // Number
|
|
},
|
|
// MemberValue
|
|
{
|
|
IterativeParsingErrorState, // Left bracket
|
|
IterativeParsingErrorState, // Right bracket
|
|
IterativeParsingErrorState, // Left curly bracket
|
|
IterativeParsingObjectFinishState, // Right curly bracket
|
|
IterativeParsingMemberDelimiterState, // Comma
|
|
IterativeParsingErrorState, // Colon
|
|
IterativeParsingErrorState, // String
|
|
IterativeParsingErrorState, // False
|
|
IterativeParsingErrorState, // True
|
|
IterativeParsingErrorState, // Null
|
|
IterativeParsingErrorState // Number
|
|
},
|
|
// MemberDelimiter
|
|
{
|
|
IterativeParsingErrorState, // Left bracket
|
|
IterativeParsingErrorState, // Right bracket
|
|
IterativeParsingErrorState, // Left curly bracket
|
|
IterativeParsingErrorState, // Right curly bracket
|
|
IterativeParsingErrorState, // Comma
|
|
IterativeParsingErrorState, // Colon
|
|
IterativeParsingMemberKeyState, // String
|
|
IterativeParsingErrorState, // False
|
|
IterativeParsingErrorState, // True
|
|
IterativeParsingErrorState, // Null
|
|
IterativeParsingErrorState // Number
|
|
},
|
|
// ObjectFinish(sink state)
|
|
{
|
|
IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
|
|
IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
|
|
IterativeParsingErrorState
|
|
},
|
|
// ArrayInitial
|
|
{
|
|
IterativeParsingArrayInitialState, // Left bracket(push Element state)
|
|
IterativeParsingArrayFinishState, // Right bracket
|
|
IterativeParsingObjectInitialState, // Left curly bracket(push Element state)
|
|
IterativeParsingErrorState, // Right curly bracket
|
|
IterativeParsingErrorState, // Comma
|
|
IterativeParsingErrorState, // Colon
|
|
IterativeParsingElementState, // String
|
|
IterativeParsingElementState, // False
|
|
IterativeParsingElementState, // True
|
|
IterativeParsingElementState, // Null
|
|
IterativeParsingElementState // Number
|
|
},
|
|
// Element
|
|
{
|
|
IterativeParsingErrorState, // Left bracket
|
|
IterativeParsingArrayFinishState, // Right bracket
|
|
IterativeParsingErrorState, // Left curly bracket
|
|
IterativeParsingErrorState, // Right curly bracket
|
|
IterativeParsingElementDelimiterState, // Comma
|
|
IterativeParsingErrorState, // Colon
|
|
IterativeParsingErrorState, // String
|
|
IterativeParsingErrorState, // False
|
|
IterativeParsingErrorState, // True
|
|
IterativeParsingErrorState, // Null
|
|
IterativeParsingErrorState // Number
|
|
},
|
|
// ElementDelimiter
|
|
{
|
|
IterativeParsingArrayInitialState, // Left bracket(push Element state)
|
|
IterativeParsingErrorState, // Right bracket
|
|
IterativeParsingObjectInitialState, // Left curly bracket(push Element state)
|
|
IterativeParsingErrorState, // Right curly bracket
|
|
IterativeParsingErrorState, // Comma
|
|
IterativeParsingErrorState, // Colon
|
|
IterativeParsingElementState, // String
|
|
IterativeParsingElementState, // False
|
|
IterativeParsingElementState, // True
|
|
IterativeParsingElementState, // Null
|
|
IterativeParsingElementState // Number
|
|
},
|
|
// ArrayFinish(sink state)
|
|
{
|
|
IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
|
|
IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
|
|
IterativeParsingErrorState
|
|
},
|
|
// Single Value (sink state)
|
|
{
|
|
IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
|
|
IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
|
|
IterativeParsingErrorState
|
|
}
|
|
}; // End of G
|
|
|
|
return (IterativeParsingState)G[state][token];
|
|
}
|
|
|
|
// Make an advance in the token stream and state based on the candidate destination state which was returned by Transit().
|
|
// May return a new state on state pop.
|
|
template <unsigned parseFlags, typename InputStream, typename Handler>
|
|
RAPIDJSON_FORCEINLINE IterativeParsingState Transit(IterativeParsingState src, Token token, IterativeParsingState dst, InputStream& is, Handler& handler) {
|
|
switch (dst) {
|
|
case IterativeParsingStartState:
|
|
RAPIDJSON_ASSERT(false);
|
|
return IterativeParsingErrorState;
|
|
|
|
case IterativeParsingFinishState:
|
|
return dst;
|
|
|
|
case IterativeParsingErrorState:
|
|
return dst;
|
|
|
|
case IterativeParsingObjectInitialState:
|
|
case IterativeParsingArrayInitialState:
|
|
{
|
|
// Push the state(Element or MemeberValue) if we are nested in another array or value of member.
|
|
// In this way we can get the correct state on ObjectFinish or ArrayFinish by frame pop.
|
|
IterativeParsingState n = src;
|
|
if (src == IterativeParsingArrayInitialState || src == IterativeParsingElementDelimiterState)
|
|
n = IterativeParsingElementState;
|
|
else if (src == IterativeParsingKeyValueDelimiterState)
|
|
n = IterativeParsingMemberValueState;
|
|
// Push current state.
|
|
*stack_.template Push<SizeType>(1) = n;
|
|
// Initialize and push the member/element count.
|
|
*stack_.template Push<SizeType>(1) = 0;
|
|
// Call handler
|
|
bool hr = (dst == IterativeParsingObjectInitialState) ? handler.StartObject() : handler.StartArray();
|
|
// On handler short circuits the parsing.
|
|
if (!hr) {
|
|
RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
|
|
return IterativeParsingErrorState;
|
|
}
|
|
else {
|
|
is.Take();
|
|
return dst;
|
|
}
|
|
}
|
|
|
|
case IterativeParsingMemberKeyState:
|
|
ParseString<parseFlags>(is, handler, true);
|
|
if (HasParseError())
|
|
return IterativeParsingErrorState;
|
|
else
|
|
return dst;
|
|
|
|
case IterativeParsingKeyValueDelimiterState:
|
|
if (token == ColonToken) {
|
|
is.Take();
|
|
return dst;
|
|
}
|
|
else
|
|
return IterativeParsingErrorState;
|
|
|
|
case IterativeParsingMemberValueState:
|
|
// Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
|
|
ParseValue<parseFlags>(is, handler);
|
|
if (HasParseError()) {
|
|
return IterativeParsingErrorState;
|
|
}
|
|
return dst;
|
|
|
|
case IterativeParsingElementState:
|
|
// Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
|
|
ParseValue<parseFlags>(is, handler);
|
|
if (HasParseError()) {
|
|
return IterativeParsingErrorState;
|
|
}
|
|
return dst;
|
|
|
|
case IterativeParsingMemberDelimiterState:
|
|
case IterativeParsingElementDelimiterState:
|
|
is.Take();
|
|
// Update member/element count.
|
|
*stack_.template Top<SizeType>() = *stack_.template Top<SizeType>() + 1;
|
|
return dst;
|
|
|
|
case IterativeParsingObjectFinishState:
|
|
{
|
|
// Get member count.
|
|
SizeType c = *stack_.template Pop<SizeType>(1);
|
|
// If the object is not empty, count the last member.
|
|
if (src == IterativeParsingMemberValueState)
|
|
++c;
|
|
// Restore the state.
|
|
IterativeParsingState n = static_cast<IterativeParsingState>(*stack_.template Pop<SizeType>(1));
|
|
// Transit to Finish state if this is the topmost scope.
|
|
if (n == IterativeParsingStartState)
|
|
n = IterativeParsingFinishState;
|
|
// Call handler
|
|
bool hr = handler.EndObject(c);
|
|
// On handler short circuits the parsing.
|
|
if (!hr) {
|
|
RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
|
|
return IterativeParsingErrorState;
|
|
}
|
|
else {
|
|
is.Take();
|
|
return n;
|
|
}
|
|
}
|
|
|
|
case IterativeParsingArrayFinishState:
|
|
{
|
|
// Get element count.
|
|
SizeType c = *stack_.template Pop<SizeType>(1);
|
|
// If the array is not empty, count the last element.
|
|
if (src == IterativeParsingElementState)
|
|
++c;
|
|
// Restore the state.
|
|
IterativeParsingState n = static_cast<IterativeParsingState>(*stack_.template Pop<SizeType>(1));
|
|
// Transit to Finish state if this is the topmost scope.
|
|
if (n == IterativeParsingStartState)
|
|
n = IterativeParsingFinishState;
|
|
// Call handler
|
|
bool hr = handler.EndArray(c);
|
|
// On handler short circuits the parsing.
|
|
if (!hr) {
|
|
RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
|
|
return IterativeParsingErrorState;
|
|
}
|
|
else {
|
|
is.Take();
|
|
return n;
|
|
}
|
|
}
|
|
|
|
case IterativeParsingValueState:
|
|
// Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
|
|
ParseValue<parseFlags>(is, handler);
|
|
if (HasParseError()) {
|
|
return IterativeParsingErrorState;
|
|
}
|
|
return IterativeParsingFinishState;
|
|
|
|
default:
|
|
RAPIDJSON_ASSERT(false);
|
|
return IterativeParsingErrorState;
|
|
}
|
|
}
|
|
|
|
template <typename InputStream>
|
|
void HandleError(IterativeParsingState src, InputStream& is) {
|
|
if (HasParseError()) {
|
|
// Error flag has been set.
|
|
return;
|
|
}
|
|
|
|
switch (src) {
|
|
case IterativeParsingStartState: RAPIDJSON_PARSE_ERROR(kParseErrorDocumentEmpty, is.Tell());
|
|
case IterativeParsingFinishState: RAPIDJSON_PARSE_ERROR(kParseErrorDocumentRootNotSingular, is.Tell());
|
|
case IterativeParsingObjectInitialState:
|
|
case IterativeParsingMemberDelimiterState: RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell());
|
|
case IterativeParsingMemberKeyState: RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell());
|
|
case IterativeParsingMemberValueState: RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell());
|
|
case IterativeParsingElementState: RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());
|
|
default: RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
|
|
}
|
|
}
|
|
|
|
template <unsigned parseFlags, typename InputStream, typename Handler>
|
|
ParseResult IterativeParse(InputStream& is, Handler& handler) {
|
|
parseResult_.Clear();
|
|
ClearStackOnExit scope(*this);
|
|
IterativeParsingState state = IterativeParsingStartState;
|
|
|
|
SkipWhitespace(is);
|
|
while (is.Peek() != '\0') {
|
|
Token t = Tokenize(is.Peek());
|
|
IterativeParsingState n = Predict(state, t);
|
|
IterativeParsingState d = Transit<parseFlags>(state, t, n, is, handler);
|
|
|
|
if (d == IterativeParsingErrorState) {
|
|
HandleError(state, is);
|
|
break;
|
|
}
|
|
|
|
state = d;
|
|
|
|
// Do not further consume streams if a root JSON has been parsed.
|
|
if ((parseFlags & kParseStopWhenDoneFlag) && state == IterativeParsingFinishState)
|
|
break;
|
|
|
|
SkipWhitespace(is);
|
|
}
|
|
|
|
// Handle the end of file.
|
|
if (state != IterativeParsingFinishState)
|
|
HandleError(state, is);
|
|
|
|
return parseResult_;
|
|
}
|
|
|
|
static const size_t kDefaultStackCapacity = 256; //!< Default stack capacity in bytes for storing a single decoded string.
|
|
internal::Stack<StackAllocator> stack_; //!< A stack for storing decoded string temporarily during non-destructive parsing.
|
|
ParseResult parseResult_;
|
|
}; // class GenericReader
|
|
|
|
//! Reader with UTF8 encoding and default allocator.
|
|
typedef GenericReader<UTF8<>, UTF8<> > Reader;
|
|
|
|
} // namespace rapidjson
|
|
|
|
#ifdef _MSC_VER
|
|
RAPIDJSON_DIAG_POP
|
|
#endif
|
|
|
|
#endif // RAPIDJSON_READER_H_
|