GenericReader< SourceEncoding, TargetEncoding, StackAllocator > Class Template Reference

SAX-style JSON parser. Use Reader for UTF8 encoding and default allocator. More...

#include <reader.h>

Classes
struct	ClearStackOnExit
singleton	NumberStream
class	NumberStream< InputStream, false >
class	NumberStream< InputStream, true >
class	StackStream

Public Types
typedef SourceEncoding::Ch	Ch
	SourceEncoding character type. More...

Public Member Functions
	GenericReader (StackAllocator *stackAllocator=0, size_t stackCapacity=kDefaultStackCapacity)
	Constructor. More...
template<unsigned parseFlags, typename InputStream , typename Handler >
ParseResult	Parse (InputStream &is, Handler &handler)
	Parse JSON text. More...
template<typename InputStream , typename Handler >
ParseResult	Parse (InputStream &is, Handler &handler)
	Parse JSON text (with kParseDefaultFlags) More...
bool	HasParseError () const
	Whether a parse error has occured in the last parsing. More...
ParseErrorCode	GetParseErrorCode () const
	Get the ParseErrorCode of last parsing. More...
size_t	GetErrorOffset () const
	Get the position of last parsing error in input, 0 otherwise. More...

Protected Member Functions
void	SetParseError (ParseErrorCode code, size_t offset)

Private Types
enum	IterativeParsingState {   IterativeParsingStartState = 0, IterativeParsingFinishState, IterativeParsingErrorState, IterativeParsingObjectInitialState,   IterativeParsingMemberKeyState, IterativeParsingKeyValueDelimiterState, IterativeParsingMemberValueState, IterativeParsingMemberDelimiterState,   IterativeParsingObjectFinishState, IterativeParsingArrayInitialState, IterativeParsingElementState, IterativeParsingElementDelimiterState,   IterativeParsingArrayFinishState, IterativeParsingValueState, cIterativeParsingStateCount }
enum	Token {   LeftBracketToken = 0, RightBracketToken, LeftCurlyBracketToken, RightCurlyBracketToken,   CommaToken, ColonToken, StringToken, FalseToken,   TrueToken, NullToken, NumberToken, kTokenCount }

Private Member Functions
	GenericReader (const GenericReader &)
GenericReader &	operator= (const GenericReader &)
void	ClearStack ()
template<unsigned parseFlags, typename InputStream , typename Handler >
void	ParseObject (InputStream &is, Handler &handler)
template<unsigned parseFlags, typename InputStream , typename Handler >
void	ParseArray (InputStream &is, Handler &handler)
template<unsigned parseFlags, typename InputStream , typename Handler >
void	ParseNull (InputStream &is, Handler &handler)
template<unsigned parseFlags, typename InputStream , typename Handler >
void	ParseTrue (InputStream &is, Handler &handler)
template<unsigned parseFlags, typename InputStream , typename Handler >
void	ParseFalse (InputStream &is, Handler &handler)
template<typename InputStream >
unsigned	ParseHex4 (InputStream &is)
template<unsigned parseFlags, typename InputStream , typename Handler >
void	ParseString (InputStream &is, Handler &handler, bool isKey=false)
template<unsigned parseFlags, typename SEncoding , typename TEncoding , typename InputStream , typename OutputStream >
RAPIDJSON_FORCEINLINE void	ParseStringToStream (InputStream &is, OutputStream &os)
template<unsigned parseFlags, typename InputStream , typename Handler >
void	ParseNumber (InputStream &is, Handler &handler)
template<unsigned parseFlags, typename InputStream , typename Handler >
void	ParseValue (InputStream &is, Handler &handler)
RAPIDJSON_FORCEINLINE Token	Tokenize (Ch c)
RAPIDJSON_FORCEINLINE IterativeParsingState	Predict (IterativeParsingState state, Token token)
template<unsigned parseFlags, typename InputStream , typename Handler >
RAPIDJSON_FORCEINLINE IterativeParsingState	Transit (IterativeParsingState src, Token token, IterativeParsingState dst, InputStream &is, Handler &handler)
template<typename InputStream >
void	HandleError (IterativeParsingState src, InputStream &is)
template<unsigned parseFlags, typename InputStream , typename Handler >
ParseResult	IterativeParse (InputStream &is, Handler &handler)

Private Attributes
internal::Stack< StackAllocator >	stack_
	A stack for storing decoded string temporarily during non-destructive parsing. More...
ParseResult	parseResult_

Static Private Attributes
static const size_t	kDefaultStackCapacity = 256
	Default stack capacity in bytes for storing a single decoded string. More...

Detailed Description

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>
class GenericReader< SourceEncoding, TargetEncoding, StackAllocator >

SAX-style JSON parser. Use 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.

Template Parameters

SourceEncoding	Encoding of the input stream.
TargetEncoding	Encoding of the parse output.
StackAllocator	Allocator type for stack.

Member Typedef Documentation

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

typedef SourceEncoding::Ch GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::Ch

SourceEncoding character type.

Member Enumeration Documentation

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

enum GenericReader::IterativeParsingState

private

Enumerator
IterativeParsingStartState
IterativeParsingFinishState
IterativeParsingErrorState
IterativeParsingObjectInitialState
IterativeParsingMemberKeyState
IterativeParsingKeyValueDelimiterState
IterativeParsingMemberValueState
IterativeParsingMemberDelimiterState
IterativeParsingObjectFinishState
IterativeParsingArrayInitialState
IterativeParsingElementState
IterativeParsingElementDelimiterState
IterativeParsingArrayFinishState
IterativeParsingValueState
cIterativeParsingStateCount

 {
 IterativeParsingStartState = 0,
 IterativeParsingFinishState,
 IterativeParsingErrorState,

 // Object states
 IterativeParsingObjectInitialState,
 IterativeParsingMemberKeyState,
 IterativeParsingKeyValueDelimiterState,
 IterativeParsingMemberValueState,
 IterativeParsingMemberDelimiterState,
 IterativeParsingObjectFinishState,

 // Array states
 IterativeParsingArrayInitialState,
 IterativeParsingElementState,
 IterativeParsingElementDelimiterState,
 IterativeParsingArrayFinishState,

 // Single value state
 IterativeParsingValueState,

 cIterativeParsingStateCount
 };

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

enum GenericReader::Token

private

Enumerator
LeftBracketToken
RightBracketToken
LeftCurlyBracketToken
RightCurlyBracketToken
CommaToken
ColonToken
StringToken
FalseToken
TrueToken
NullToken
NumberToken
kTokenCount

 {
 LeftBracketToken = 0,
 RightBracketToken,

 LeftCurlyBracketToken,
 RightCurlyBracketToken,

 CommaToken,
 ColonToken,

 StringToken,
 FalseToken,
 TrueToken,
 NullToken,
 NumberToken,

 kTokenCount
 };

Constructor & Destructor Documentation

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::GenericReader ( StackAllocator *  stackAllocator = 0, size_t  stackCapacity = kDefaultStackCapacity  )

inline

Constructor.

Parameters

stackAllocator	Optional allocator for allocating stack memory. (Only use for non-destructive parsing)
stackCapacity	stack capacity in bytes for storing a single decoded string. (Only use for non-destructive parsing)

: stack_(stackAllocator, stackCapacity), parseResult_() {}

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::GenericReader ( const GenericReader< SourceEncoding, TargetEncoding, StackAllocator > &  )

private

Member Function Documentation

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

void GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::ClearStack ( )

inlineprivate

{ stack_.Clear(); }

Here is the caller graph for this function:

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

size_t GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::GetErrorOffset ( ) const

inline

Get the position of last parsing error in input, 0 otherwise.

{ return parseResult_.Offset(); }

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

ParseErrorCode GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::GetParseErrorCode ( ) const

inline

Get the ParseErrorCode of last parsing.

{ return parseResult_.Code(); }

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

template<typename InputStream >

void GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::HandleError ( IterativeParsingState  src, InputStream &  is  )

inlineprivate

 {
 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());
 } 
 }

Here is the caller graph for this function:

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

bool GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::HasParseError ( ) const

inline

Whether a parse error has occured in the last parsing.

{ return parseResult_.IsError(); }

Here is the caller graph for this function:

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

template<unsigned parseFlags, typename InputStream , typename Handler >

ParseResult GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::IterativeParse ( InputStream &  is, Handler &  handler  )

inlineprivate

 {
 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_;
 }

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

GenericReader& GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::operator= ( const GenericReader< SourceEncoding, TargetEncoding, StackAllocator > &  )

private

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

template<unsigned parseFlags, typename InputStream , typename Handler >

ParseResult GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::Parse ( InputStream &  is, Handler &  handler  )

inline

Parse JSON text.

Template Parameters

parseFlags	Combination of ParseFlag.
InputStream	Type of input stream, implementing Stream concept.
Handler	Type of handler, implementing Handler concept.

Parameters

is	Input stream to be parsed.
handler	The handler to receive events.

Returns

Whether the parsing is successful.

 {
 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_;
 }

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

template<typename InputStream , typename Handler >

ParseResult GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::Parse ( InputStream &  is, Handler &  handler  )

inline

Parse JSON text (with kParseDefaultFlags)

Template Parameters

InputStream	Type of input stream, implementing Stream concept
Handler	Type of handler, implementing Handler concept.

Parameters

is	Input stream to be parsed.
handler	The handler to receive events.

Returns

Whether the parsing is successful.

 {
 return Parse<kParseDefaultFlags>(is, handler);
 }

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

template<unsigned parseFlags, typename InputStream , typename Handler >

void GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::ParseArray ( InputStream &  is, Handler &  handler  )

inlineprivate

 {
 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());
 return;
 default: RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());
 }
 }
 }

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

template<unsigned parseFlags, typename InputStream , typename Handler >

void GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::ParseFalse ( InputStream &  is, Handler &  handler  )

inlineprivate

 {
 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);
 }

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

template<typename InputStream >

unsigned GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::ParseHex4 ( InputStream &  is )

inlineprivate

 {
 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;
 }

Here is the caller graph for this function:

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

template<unsigned parseFlags, typename InputStream , typename Handler >

void GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::ParseNull ( InputStream &  is, Handler &  handler  )

inlineprivate

 {
 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<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

template<unsigned parseFlags, typename InputStream , typename Handler >

void GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::ParseNumber ( InputStream &  is, Handler &  handler  )

inlineprivate

 {
 internal::StreamLocalCopy<InputStream> copy(is);
 NumberStream<InputStream, (parseFlags & kParseFullPrecisionFlag) != 0> s(*this, 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;
 int significandDigit = 0;
 if (s.Peek() == '0') {
 i = 0;
 s.TakePush();
 }
 else if (s.Peek() >= '1' && s.Peek() <= '9') {
 i = static_cast<unsigned>(s.TakePush() - '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.TakePush() - '0');
 significandDigit++;
 }
 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.TakePush() - '0');
 significandDigit++;
 }
 }
 else
 RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());

 // Parse 64bit int
 bool useDouble = false;
 double d = 0.0;
 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 = i64;
 useDouble = true;
 break;
 }
 i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
 significandDigit++;
 }
 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 = i64;
 useDouble = true;
 break;
 }
 i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
 significandDigit++;
 }
 }

 // 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.TakePush() - '0');
 }
 }

 // Parse frac = decimal-point 1*DIGIT
 int expFrac = 0;
 size_t decimalPosition;
 if (s.Peek() == '.') {
 s.Take();
 decimalPosition = s.Length();

 if (!(s.Peek() >= '0' && s.Peek() <= '9'))
 RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissFraction, s.Tell());

 if (!useDouble) {
#if RAPIDJSON_64BIT
 // Use i64 to store significand in 64-bit architecture
 if (!use64bit)
 i64 = i;
 
 while (s.Peek() >= '0' && s.Peek() <= '9') {
 if (i64 > RAPIDJSON_UINT64_C2(0x1FFFFF, 0xFFFFFFFF)) // 2^53 - 1 for fast path
 break;
 else {
 i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
 --expFrac;
 if (i64 != 0)
 significandDigit++;
 }
 }

 d = (double)i64;
#else
 // Use double to store significand in 32-bit architecture
 d = use64bit ? (double)i64 : (double)i;
#endif
 useDouble = true;
 }

 while (s.Peek() >= '0' && s.Peek() <= '9') {
 if (significandDigit < 17) {
 d = d * 10.0 + (s.TakePush() - '0');
 --expFrac;
 if (d > 0.0)
 significandDigit++;
 }
 else
 s.TakePush();
 }
 }
 else
 decimalPosition = s.Length(); // decimal position at the end of integer.

 // Parse exp = e [ minus / plus ] 1*DIGIT
 int exp = 0;
 if (s.Peek() == 'e' || s.Peek() == 'E') {
 if (!useDouble) {
 d = use64bit ? i64 : 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';
 if (expMinus) {
 while (s.Peek() >= '0' && s.Peek() <= '9') {
 exp = exp * 10 + (s.Take() - '0');
 if (exp >= 214748364) { // Issue #313: prevent overflow exponent
 while (s.Peek() >= '0' && s.Peek() <= '9') // Consume the rest of exponent
 s.Take();
 }
 }
 }
 else { // positive exp
 int maxExp = 308 - expFrac;
 while (s.Peek() >= '0' && s.Peek() <= '9') {
 exp = exp * 10 + (s.Take() - '0');
 if (exp > maxExp)
 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;
 size_t length = s.Length();
 const char* decimal = s.Pop(); // Pop stack no matter if it will be used or not.

 if (useDouble) {
 int p = exp + expFrac;
 if (parseFlags & kParseFullPrecisionFlag)
 d = internal::StrtodFullPrecision(d, p, decimal, length, decimalPosition, exp);
 else
 d = internal::StrtodNormalPrecision(d, p);

 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());
 }

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

template<unsigned parseFlags, typename InputStream , typename Handler >

void GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::ParseObject ( InputStream &  is, Handler &  handler  )

inlineprivate

 {
 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());
 return;
 default: RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell());
 }
 }
 }

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

template<unsigned parseFlags, typename InputStream , typename Handler >

void GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::ParseString ( InputStream &  is, Handler &  handler, bool  isKey = false  )

inlineprivate

 {
 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<typename TargetEncoding::Ch> stackStream(stack_);
 ParseStringToStream<parseFlags, SourceEncoding, TargetEncoding>(s, stackStream);
 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
 SizeType length = static_cast<SizeType>(stackStream.Length()) - 1;
 const typename TargetEncoding::Ch* const str = stackStream.Pop();
 success = (isKey ? handler.Key(str, length, true) : handler.String(str, length, true));
 }
 if (!success)
 RAPIDJSON_PARSE_ERROR(kParseErrorTermination, s.Tell());
 }

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

template<unsigned parseFlags, typename SEncoding , typename TEncoding , typename InputStream , typename OutputStream >

RAPIDJSON_FORCEINLINE void GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::ParseStringToStream ( InputStream &  is, OutputStream &  os  )

inlineprivate

 {
#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

 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);
 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
 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);
 RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
 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());
 }
 }
 }

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

template<unsigned parseFlags, typename InputStream , typename Handler >

void GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::ParseTrue ( InputStream &  is, Handler &  handler  )

inlineprivate

 {
 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<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

template<unsigned parseFlags, typename InputStream , typename Handler >

void GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::ParseValue ( InputStream &  is, Handler &  handler  )

inlineprivate

 {
 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);
 }
 }

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

RAPIDJSON_FORCEINLINE IterativeParsingState GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::Predict ( IterativeParsingState  state, Token  token  )

inlineprivate

 {
 // 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];
 }

Here is the caller graph for this function:

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

void GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::SetParseError ( ParseErrorCode  code, size_t  offset  )

inlineprotected

{ parseResult_.Set(code, offset); }

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

RAPIDJSON_FORCEINLINE Token GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::Tokenize ( Ch  c )

inlineprivate

 {

#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
 
 if (sizeof(Ch) == 1 || unsigned(c) < 256)
 return (Token)tokenMap[(unsigned char)c];
 else
 return NumberToken;
 }

Here is the caller graph for this function:

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

template<unsigned parseFlags, typename InputStream , typename Handler >

RAPIDJSON_FORCEINLINE IterativeParsingState GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::Transit ( IterativeParsingState  src, Token  token, IterativeParsingState  dst, InputStream &  is, Handler &  handler  )

inlineprivate

 {
 (void)token;

 switch (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:
 RAPIDJSON_ASSERT(token == ColonToken);
 is.Take();
 return dst;

 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;
 }
 }

 default:
 // This branch is for IterativeParsingValueState actually.
 // Use `default:` rather than
 // `case IterativeParsingValueState:` is for code coverage.

 // The IterativeParsingStartState is not enumerated in this switch-case.
 // It is impossible for that case. And it can be caught by following assertion.

 // The IterativeParsingFinishState is not enumerated in this switch-case either.
 // It is a "derivative" state which cannot triggered from Predict() directly.
 // Therefore it cannot happen here. And it can be caught by following assertion.
 RAPIDJSON_ASSERT(dst == IterativeParsingValueState);

 // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
 ParseValue<parseFlags>(is, handler);
 if (HasParseError()) {
 return IterativeParsingErrorState;
 }
 return IterativeParsingFinishState;
 }
 }

Member Data Documentation

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

const size_t GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::kDefaultStackCapacity = 256

staticprivate

Default stack capacity in bytes for storing a single decoded string.

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

ParseResult GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::parseResult_

private

template<typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>

internal::Stack<StackAllocator> GenericReader< SourceEncoding, TargetEncoding, StackAllocator >::stack_

private

A stack for storing decoded string temporarily during non-destructive parsing.

---

The documentation for this class was generated from the following file:

• dep/rapidjson/rapidjson/reader.h