#include "stdafx.h"

#include <cstdlib>

#if defined(_MSC_VER)

#pragma warning(disable : 4127) // allow expressions like while(true) pass

#endif

using namespace web;

using namespace web::json;

using namespace utility;

using namespace utility::conversions;

std::array<signed char,128> _hexval = {{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,

-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }};

namespace web {

namespace json

{

namespace details

{

template <typename Token>

#if defined(_WIN32)

__declspec(noreturn)

#else

__attribute__((noreturn))

#endif

void CreateException(const Token &tk, const utility::string_t &message)

}

template <typename Token>

void SetErrorCode(Token &tk, json_error jsonErrorCode)

{

tk.m_error = std::error_code(jsonErrorCode, json_error_category());

}

template <typename CharType>

class JSON_Parser

};

template <typename CharType>

typename std::char_traits<CharType>::int_type eof()

{

return std::char_traits<CharType>::eof();

}

template <typename CharType>

class JSON_StreamParser : public JSON_Parser<CharType>

};

template <typename CharType>

class JSON_StringParser : public JSON_Parser<CharType>

};

template <typename CharType>

typename JSON_Parser<CharType>::int_type JSON_StreamParser<CharType>::NextCharacter()

{

auto ch = m_streambuf->sbumpc();

if (ch == '\n')

{

this->m_currentLine += 1;

this->m_currentColumn = 0;

}

else

{

this->m_currentColumn += 1;

}

return ch;

}

template <typename CharType>

typename JSON_Parser<CharType>::int_type JSON_StreamParser<CharType>::PeekCharacter()

{

return m_streambuf->sgetc();

}

template <typename CharType>

typename JSON_Parser<CharType>::int_type JSON_StringParser<CharType>::NextCharacter()

{

if (m_position == m_endpos)

return eof<CharType>();

CharType ch = *m_position;

m_position += 1;

if ( ch == '\n' )

{

this->m_currentLine += 1;

this->m_currentColumn = 0;

}

else

{

this->m_currentColumn += 1;

}

return ch;

}

template <typename CharType>

typename JSON_Parser<CharType>::int_type JSON_StringParser<CharType>::PeekCharacter()

{

if ( m_position == m_endpos ) return eof<CharType>();

return *m_position;

}

template <typename CharType>

typename JSON_Parser<CharType>::int_type JSON_Parser<CharType>::EatWhitespace()

{

auto ch = NextCharacter();

while ( ch != eof<CharType>() && iswspace(static_cast<wint_t>(ch)))

{

ch = NextCharacter();

}

return ch;

}

template <typename CharType>

bool JSON_Parser<CharType>::CompleteKeywordTrue(Token &token)

{

if (NextCharacter() != 'r')

return false;

if (NextCharacter() != 'u')

return false;

if (NextCharacter() != 'e')

return false;

token.kind = Token::TKN_BooleanLiteral;

token.boolean_val = true;

return true;

}

template <typename CharType>

bool JSON_Parser<CharType>::CompleteKeywordFalse(Token &token)

{

if (NextCharacter() != 'a')

return false;

if (NextCharacter() != 'l')

return false;

if (NextCharacter() != 's')

return false;

if (NextCharacter() != 'e')

return false;

token.kind = Token::TKN_BooleanLiteral;

token.boolean_val = false;

return true;

}

template <typename CharType>

bool JSON_Parser<CharType>::CompleteKeywordNull(Token &token)

{

if (NextCharacter() != 'u')

return false;

if (NextCharacter() != 'l')

return false;

if (NextCharacter() != 'l')

return false;

token.kind = Token::TKN_NullLiteral;

return true;

}

template <typename CharType>

inline bool JSON_Parser<CharType>::ParseInt64(CharType first, uint64_t& value)

{

value = first - '0';

auto ch = PeekCharacter();

while (ch >= '0' && ch <= '9')

{

unsigned int next_digit = (unsigned int)(ch - '0');

if (value > (ULLONG_MAX / 10) || (value == ULLONG_MAX/10 && next_digit > ULLONG_MAX%10))

return false;

NextCharacter();

value *= 10;

value += next_digit;

ch = PeekCharacter();

}

return true;

}

{

#if defined(_WIN32)

static int print_llu(char* ptr, size_t n, uint64_t val64)

{

return _snprintf_s_l(ptr, n, _TRUNCATE, "%I64u", utility::details::scoped_c_thread_locale::c_locale(), val64);

}

static int print_llu(wchar_t* ptr, size_t n, uint64_t val64)

{

return _snwprintf_s_l(ptr, n, _TRUNCATE, L"%I64u", utility::details::scoped_c_thread_locale::c_locale(), val64);

}

static double anystod(const char* str)

{

return _strtod_l(str, nullptr, utility::details::scoped_c_thread_locale::c_locale());

}

static double anystod(const wchar_t* str)

{

return _wcstod_l(str, nullptr, utility::details::scoped_c_thread_locale::c_locale());

}

#else

static int __attribute__((__unused__)) print_llu(char* ptr, size_t n, unsigned long long val64)

{

return snprintf(ptr, n, "%llu", val64);

}

static int __attribute__((__unused__)) print_llu(char* ptr, size_t n, unsigned long val64)

{

return snprintf(ptr, n, "%lu", val64);

}

static double __attribute__((__unused__)) anystod(const char* str)

{

return strtod(str, nullptr);

}

static double __attribute__((__unused__)) anystod(const wchar_t* str)

{

return wcstod(str, nullptr);

}

#endif

}

template <typename CharType>

bool JSON_Parser<CharType>::CompleteNumberLiteral(CharType first, Token &token)

{

bool minus_sign;

if (first == '-')

{

minus_sign = true;

// Safe to cast because the check after this if/else statement will cover EOF.

first = static_cast<CharType>(NextCharacter());

}

else

{

minus_sign = false;

}

if (first < '0' || first > '9')

return false;

auto ch = PeekCharacter();

//Check for two (or more) zeros at the beginning

if (first == '0' && ch == '0')

return false;

// Parse the number assuming its integer

uint64_t val64;

bool complete = ParseInt64(first, val64);

ch = PeekCharacter();

if (complete && ch!='.' && ch!='E' && ch!='e')

{

if (minus_sign)

{

if (val64 > static_cast<uint64_t>(1) << 63 )

{

// It is negative and cannot be represented in int64, so we resort to double

token.double_val = 0 - static_cast<double>(val64);

token.signed_number = true;

token.kind = JSON_Parser<CharType>::Token::TKN_NumberLiteral;

return true;

}

// It is negative, but fits into int64

token.int64_val = 0 - static_cast<int64_t>(val64);

token.kind = JSON_Parser<CharType>::Token::TKN_IntegerLiteral;

token.signed_number = true;

return true;

}

// It is positive so we use unsigned int64

token.uint64_val = val64;

token.kind = JSON_Parser<CharType>::Token::TKN_IntegerLiteral;

token.signed_number = false;

return true;

}

// Magic number 5 leaves room for decimal point, null terminator, etc (in most cases)

::std::vector<CharType> buf(::std::numeric_limits<uint64_t>::digits10 + 5);

int count = print_llu(buf.data(), buf.size(), val64);

_ASSERTE(count >= 0);

_ASSERTE((size_t)count < buf.size());

// Resize to cut off the null terminator

buf.resize(count);

bool decimal = false;

while (ch != eof<CharType>())

{

// Digit encountered?

if (ch >= '0' && ch <= '9')

{

buf.push_back(static_cast<CharType>(ch));

NextCharacter();

ch = PeekCharacter();

}

// Decimal dot?

else if (ch == '.')

{

if (decimal)

return false;

decimal = true;

buf.push_back(static_cast<CharType>(ch));

NextCharacter();

ch = PeekCharacter();

// Check that the following char is a digit

if (ch < '0' || ch > '9')

return false;

buf.push_back(static_cast<CharType>(ch));

NextCharacter();

ch = PeekCharacter();

}

// Exponent?

else if (ch == 'E' || ch == 'e')

{

buf.push_back(static_cast<CharType>(ch));

NextCharacter();

ch = PeekCharacter();

// Check for the exponent sign

if (ch == '+')

{

buf.push_back(static_cast<CharType>(ch));

NextCharacter();

ch = PeekCharacter();

}

else if (ch == '-')

{

buf.push_back(static_cast<CharType>(ch));

NextCharacter();

ch = PeekCharacter();

}

// First number of the exponent

if (ch >= '0' && ch <= '9')

{

buf.push_back(static_cast<CharType>(ch));

NextCharacter();

ch = PeekCharacter();

}

else return false;

// The rest of the exponent

while (ch >= '0' && ch <= '9')

{

buf.push_back(static_cast<CharType>(ch));

NextCharacter();

ch = PeekCharacter();

}

// The peeked character is not a number, so we can break from the loop and construct the number

break;

}

else

{

// Not expected number character?

break;

}

};

buf.push_back('\0');

token.double_val = anystod(buf.data());

if (minus_sign)

{

token.double_val = -token.double_val;

}

token.kind = (JSON_Parser<CharType>::Token::TKN_NumberLiteral);

return true;

}

template <typename CharType>

bool JSON_Parser<CharType>::CompleteComment(Token &token)

{

// We already found a '/' character as the first of a token -- what kind of comment is it?

auto ch = NextCharacter();

if ( ch == eof<CharType>() || (ch != '/' && ch != '*') )

return false;

if ( ch == '/' )

{

// Line comment -- look for a newline or EOF to terminate.

ch = NextCharacter();

while ( ch != eof<CharType>() && ch != '\n')

{

ch = NextCharacter();

}

}

else

{

// Block comment -- look for a terminating "*/" sequence.

ch = NextCharacter();

while ( true )

{

if ( ch == eof<CharType>())

return false;

if ( ch == '*' )

{

auto ch1 = PeekCharacter();

if ( ch1 == eof<CharType>())

return false;

if ( ch1 == '/' )

{

// Consume the character

NextCharacter();

break;

}

ch = ch1;

}

ch = NextCharacter();

}

}

token.kind = Token::TKN_Comment;

return true;

}

template <typename CharType>

bool JSON_StringParser<CharType>::CompleteComment(typename JSON_Parser<CharType>::Token &token)

{

// This function is specialized for the string parser, since we can be slightly more

// efficient in copying data from the input to the token: do a memcpy() rather than

// one character at a time.

auto ch = JSON_StringParser<CharType>::NextCharacter();

if ( ch == eof<CharType>() || (ch != '/' && ch != '*') )

return false;

if ( ch == '/' )

{

// Line comment -- look for a newline or EOF to terminate.

ch = JSON_StringParser<CharType>::NextCharacter();

while ( ch != eof<CharType>() && ch != '\n')

{

ch = JSON_StringParser<CharType>::NextCharacter();

}

}

else

{

// Block comment -- look for a terminating "*/" sequence.

ch = JSON_StringParser<CharType>::NextCharacter();

while ( true )

{

if ( ch == eof<CharType>())

return false;

if ( ch == '*' )

{

ch = JSON_StringParser<CharType>::PeekCharacter();

if ( ch == eof<CharType>())

return false;

if ( ch == '/' )

{

// Consume the character

JSON_StringParser<CharType>::NextCharacter();

break;

}

}

ch = JSON_StringParser<CharType>::NextCharacter();

}

}

token.kind = JSON_Parser<CharType>::Token::TKN_Comment;

return true;

}

void convert_append_unicode_code_unit(JSON_Parser<wchar_t>::Token &token, utf16char value)

{

token.string_val.push_back(value);

}

void convert_append_unicode_code_unit(JSON_Parser<char>::Token &token, utf16char value)

}

template <typename CharType>

inline bool JSON_Parser<CharType>::handle_unescape_char(Token &token)

{

token.has_unescape_symbol = true;

// This function converts unescaped character pairs (e.g. "\t") into their ASCII or Unicode representations (e.g. tab sign)

// Also it handles \u + 4 hexadecimal digits

auto ch = NextCharacter();

switch (ch)

{

case '\"':

token.string_val.push_back('\"');

return true;

case '\\':

token.string_val.push_back('\\');

return true;

case '/':

token.string_val.push_back('/');

return true;

case 'b':

token.string_val.push_back('\b');

return true;

case 'f':

token.string_val.push_back('\f');

return true;

case 'r':

token.string_val.push_back('\r');

return true;

case 'n':

token.string_val.push_back('\n');

return true;

case 't':

token.string_val.push_back('\t');

return true;

case 'u':

{

// A four-hexdigit Unicode character.

// Transform into a 16 bit code point.

int decoded = 0;

for (int i = 0; i < 4; ++i)

{

ch = NextCharacter();

int ch_int = static_cast<int>(ch);

if (ch_int < 0 || ch_int > 127)

return false;

#ifdef _WIN32

const int isxdigitResult = _isxdigit_l(ch_int, utility::details::scoped_c_thread_locale::c_locale());

#else

const int isxdigitResult = isxdigit(ch_int);

#endif

if (!isxdigitResult)

return false;

int val = _hexval[static_cast<size_t>(ch_int)];

_ASSERTE(val != -1);

// Add the input char to the decoded number

decoded |= (val << (4 * (3 - i)));

}

// Construct the character based on the decoded number

convert_append_unicode_code_unit(token, static_cast<utf16char>(decoded));

return true;

}

default:

return false;

}

}

template <typename CharType>

bool JSON_Parser<CharType>::CompleteStringLiteral(Token &token)

{

token.has_unescape_symbol = false;

auto ch = NextCharacter();

while ( ch != '"' )

{

if ( ch == '\\' )

{

handle_unescape_char(token);

}

else if (ch >= CharType(0x0) && ch < CharType(0x20))

{

return false;

}

else

{

if (ch == eof<CharType>())

return false;

token.string_val.push_back(static_cast<CharType>(ch));

}

ch = NextCharacter();

}

if ( ch == '"' )

{

token.kind = Token::TKN_StringLiteral;

}

else

{

return false;

}

return true;

}

template <typename CharType>

bool JSON_StringParser<CharType>::CompleteStringLiteral(typename JSON_Parser<CharType>::Token &token)

{

// This function is specialized for the string parser, since we can be slightly more

// efficient in copying data from the input to the token: do a memcpy() rather than

// one character at a time.

auto start = m_position;

token.has_unescape_symbol = false;

auto ch = JSON_StringParser<CharType>::NextCharacter();

while (ch != '"')

{

if (ch == eof<CharType>())

return false;

if (ch == '\\')

{

const size_t numChars = m_position - start - 1;

const size_t prevSize = token.string_val.size();

token.string_val.resize(prevSize + numChars);

memcpy(const_cast<CharType *>(token.string_val.c_str() + prevSize), start, numChars * sizeof(CharType));

if (!JSON_StringParser<CharType>::handle_unescape_char(token))

{

return false;

}

// Reset start position and continue.

start = m_position;

}

else if (ch >= CharType(0x0) && ch < CharType(0x20))

{

return false;

}

ch = JSON_StringParser<CharType>::NextCharacter();

}

const size_t numChars = m_position - start - 1;

const size_t prevSize = token.string_val.size();

token.string_val.resize(prevSize + numChars);

memcpy(const_cast<CharType *>(token.string_val.c_str() + prevSize), start, numChars * sizeof(CharType));

token.kind = JSON_Parser<CharType>::Token::TKN_StringLiteral;

return true;

}

template <typename CharType>

void JSON_Parser<CharType>::GetNextToken(typename JSON_Parser<CharType>::Token& result)

{

try_again:

auto ch = EatWhitespace();

CreateToken(result, Token::TKN_EOF);

if (ch == eof<CharType>()) return;

switch (ch)

{

case '{':

case '[':

{

if(++m_currentParsingDepth > JSON_Parser<CharType>::maxParsingDepth)

{

SetErrorCode(result, json_error::nesting);

break;

}

typename JSON_Parser<CharType>::Token::Kind tk = ch == '{' ? Token::TKN_OpenBrace : Token::TKN_OpenBracket;

CreateToken(result, tk, result.start);

break;

}

case '}':

case ']':

{

if((signed int)(--m_currentParsingDepth) < 0)

{

SetErrorCode(result, json_error::mismatched_brances);

break;

}

typename JSON_Parser<CharType>::Token::Kind tk = ch == '}' ? Token::TKN_CloseBrace : Token::TKN_CloseBracket;

CreateToken(result, tk, result.start);

break;

}

case ',':

CreateToken(result, Token::TKN_Comma, result.start);

break;

case ':':

CreateToken(result, Token::TKN_Colon, result.start);

break;

case 't':

if (!CompleteKeywordTrue(result))

{

SetErrorCode(result, json_error::malformed_literal);

}

break;

case 'f':

if (!CompleteKeywordFalse(result))

{

SetErrorCode(result, json_error::malformed_literal);

}

break;

case 'n':

if (!CompleteKeywordNull(result))

{

SetErrorCode(result, json_error::malformed_literal);

}

break;

case '/':

if (!CompleteComment(result))

{

SetErrorCode(result, json_error::malformed_comment);

break;

}

// For now, we're ignoring comments.

goto try_again;

case '"':

if (!CompleteStringLiteral(result))

{

SetErrorCode(result, json_error::malformed_string_literal);

}

break;

case '-':

case '0':

case '1':

case '2':

case '3':

case '4':

case '5':

case '6':

case '7':

case '8':

case '9':

if (!CompleteNumberLiteral(static_cast<CharType>(ch), result))

{

SetErrorCode(result, json_error::malformed_numeric_literal);

}

break;

default:

SetErrorCode(result, json_error::malformed_token);

break;

}

}

template <typename CharType>

std::unique_ptr<web::json::details::_Value> JSON_Parser<CharType>::_ParseObject(typename JSON_Parser<CharType>::Token &tkn)

{

auto obj = utility::details::make_unique<web::json::details::_Object>(g_keep_json_object_unsorted);

auto& elems = obj->m_object.m_elements;

GetNextToken(tkn);

if (tkn.m_error) goto error;

if (tkn.kind != JSON_Parser<CharType>::Token::TKN_CloseBrace)

{

while (true)

{

// State 1: New field or end of object, looking for field name or closing brace

std::basic_string<CharType> fieldName;

switch (tkn.kind)

{

case JSON_Parser<CharType>::Token::TKN_StringLiteral:

fieldName = std::move(tkn.string_val);

break;

default:

goto error;

}

GetNextToken(tkn);

if (tkn.m_error) goto error;

// State 2: Looking for a colon.

if (tkn.kind != JSON_Parser<CharType>::Token::TKN_Colon) goto done;

GetNextToken(tkn);

if (tkn.m_error) goto error;

// State 3: Looking for an expression.

#ifdef ENABLE_JSON_VALUE_VISUALIZER

auto fieldValue = _ParseValue(tkn);

auto type = fieldValue->type();

elems.emplace_back(utility::conversions::to_string_t(std::move(fieldName)), json::value(std::move(fieldValue), type));