#include "json.h"

#include "jtckdint.h"

#include <cassert>

#include <cctype>

#include <climits>

#include <cstdint>

#include <cstdlib>

#include <stdexcept>

#include "double-conversion/double-to-string.h"

#include "double-conversion/string-to-double.h"

#define KEY 1

#define COMMA 2

#define COLON 4

#define ARRAY 8

#define OBJECT 16

#define DEPTH 20

#define ASCII 0

#define C0 1

#define DQUOTE 2

#define BACKSLASH 3

#define UTF8_2 4

#define UTF8_3 5

#define UTF8_4 6

#define C1 7

#define UTF8_3_E0 8

#define UTF8_3_ED 9

#define UTF8_4_F0 10

#define BADUTF8 11

#define EVILUTF8 12

#define UTF16_MASK 0xfc00

#define UTF16_MOAR 0xd800 // 0xD800..0xDBFF

#define UTF16_CONT 0xdc00 // 0xDC00..0xDFFF

#define READ32LE(S) \

((uint_least32_t)(255 & (S)[3]) << 030 | \

(uint_least32_t)(255 & (S)[2]) << 020 | \

(uint_least32_t)(255 & (S)[1]) << 010 | \

(uint_least32_t)(255 & (S)[0]) << 000)

#define ThomPikeCont(x) (0200 == (0300 & (x)))

#define ThomPikeByte(x) ((x) & (((1 << ThomPikeMsb(x)) - 1) | 3))

#define ThomPikeLen(x) (7 - ThomPikeMsb(x))

#define ThomPikeMsb(x) ((255 & (x)) < 252 ? Bsr(255 & ~(x)) : 1)

#define ThomPikeMerge(x, y) ((x) << 6 | (077 & (y)))

#define IsSurrogate(wc) ((0xf800 & (wc)) == 0xd800)

#define IsHighSurrogate(wc) (((wc) & UTF16_MASK) == UTF16_MOAR)

#define IsLowSurrogate(wc) (((wc) & UTF16_MASK) == UTF16_CONT)

#define MergeUtf16(hi, lo) ((((hi) - 0xD800) << 10) + ((lo) - 0xDC00) + 0x10000)

#define EncodeUtf16(wc) \

((0x0000 <= (wc) && (wc) <= 0xFFFF) || (0xE000 <= (wc) && (wc) <= 0xFFFF) \

? (wc) \

: 0x10000 <= (wc) && (wc) <= 0x10FFFF \

? (((((wc) - 0x10000) >> 10) + 0xD800) | \

(unsigned)((((wc) - 0x10000) & 1023) + 0xDC00) << 16) \

: 0xFFFD)

#if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)

#define ON_LOGIC_ERROR(s) throw std::logic_error(s)

#else

#define ON_LOGIC_ERROR(s) abort()

#endif

namespace jt {

static const char kJsonStr[256] = {

1, 1, 1, 1, 1, 1, 1, 1, // 0000 ascii (0)

1, 1, 1, 1, 1, 1, 1, 1, // 0010

1, 1, 1, 1, 1, 1, 1, 1, // 0020 c0 (1)

1, 1, 1, 1, 1, 1, 1, 1, // 0030

0, 0, 2, 0, 0, 0, 0, 0, // 0040 dquote (2)

0, 0, 0, 0, 0, 0, 0, 0, // 0050

0, 0, 0, 0, 0, 0, 0, 0, // 0060

0, 0, 0, 0, 0, 0, 0, 0, // 0070

0, 0, 0, 0, 0, 0, 0, 0, // 0100

0, 0, 0, 0, 0, 0, 0, 0, // 0110

0, 0, 0, 0, 0, 0, 0, 0, // 0120

0, 0, 0, 0, 3, 0, 0, 0, // 0130 backslash (3)

0, 0, 0, 0, 0, 0, 0, 0, // 0140

0, 0, 0, 0, 0, 0, 0, 0, // 0150

0, 0, 0, 0, 0, 0, 0, 0, // 0160

0, 0, 0, 0, 0, 0, 0, 0, // 0170

7, 7, 7, 7, 7, 7, 7, 7, // 0200 c1 (8)

7, 7, 7, 7, 7, 7, 7, 7, // 0210

7, 7, 7, 7, 7, 7, 7, 7, // 0220

7, 7, 7, 7, 7, 7, 7, 7, // 0230

11, 11, 11, 11, 11, 11, 11, 11, // 0240 latin1 (4)

11, 11, 11, 11, 11, 11, 11, 11, // 0250

11, 11, 11, 11, 11, 11, 11, 11, // 0260

11, 11, 11, 11, 11, 11, 11, 11, // 0270

12, 12, 4, 4, 4, 4, 4, 4, // 0300 utf8-2 (5)

4, 4, 4, 4, 4, 4, 4, 4, // 0310

4, 4, 4, 4, 4, 4, 4, 4, // 0320 utf8-2

4, 4, 4, 4, 4, 4, 4, 4, // 0330

8, 5, 5, 5, 5, 5, 5, 5, // 0340 utf8-3 (6)

5, 5, 5, 5, 5, 9, 5, 5, // 0350

10, 6, 6, 6, 6, 11, 11, 11, // 0360 utf8-4 (7)

11, 11, 11, 11, 11, 11, 11, 11, // 0370

};

static const char kEscapeLiteral[128] = {

9, 9, 9, 9, 9, 9, 9, 9, 9, 1, 2, 9, 4, 3, 9, 9, // 0x00

9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 0x10

0, 0, 7, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 6, // 0x20

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 0, // 0x30

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x40

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, // 0x50

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x60

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, // 0x70

};

alignas(signed char) static const signed char kHexToInt[256] = {

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x00

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x10

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x20

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

-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x40

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x50

-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x60

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x70

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x80

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x90

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0xa0

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0xb0

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0xc0

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0xd0

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0xe0

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0xf0

};

static const double_conversion::DoubleToStringConverter kDoubleToJson(

double_conversion::DoubleToStringConverter::UNIQUE_ZERO |

double_conversion::DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN,

"1e5000",

"null",

'e',

-6,

21,

6,

0);

static const double_conversion::StringToDoubleConverter kJsonToDouble(

double_conversion::StringToDoubleConverter::ALLOW_CASE_INSENSITIVITY |

double_conversion::StringToDoubleConverter::ALLOW_LEADING_SPACES |

double_conversion::StringToDoubleConverter::ALLOW_TRAILING_JUNK |

double_conversion::StringToDoubleConverter::ALLOW_TRAILING_SPACES,

0.0,

1.0,

"Infinity",

"NaN");

#if defined(__GNUC__) || defined(__clang__)

#define Bsr(x) (__builtin_clz(x) ^ (sizeof(int) * CHAR_BIT - 1))

#else

static int

Bsr(int x)

}

#endif

static double

StringToDouble(const char* s, size_t n, int* out_processed)

}

static char*

UlongToString(char* p, unsigned long long x)

{

char t;

size_t i, a, b;

i = 0;

do {

p[i++] = x % 10 + '0';

x = x / 10;

} while (x > 0);

p[i] = '\0';

if (i) {

for (a = 0, b = i - 1; a < b; ++a, --b) {

t = p[a];

p[a] = p[b];

p[b] = t;

}

}

return p + i;

}

static char*

LongToString(char* p, long long x)

{

if (x < 0)

*p++ = '-', x = 0 - (unsigned long long)x;

return UlongToString(p, x);

}

Json::Json(unsigned long value)

}

Json::Json(unsigned long long value)

}

Json::Json(const char* value)

}

Json::Json(const std::string& value) : type_(String), string_value(value)

{

}

Json::~Json()

{

if (type_ >= String)

clear();

}

Json::clear()

}

Json::Json(const Json& other) : type_(other.type_)

}

Json&

Json::operator=(const Json& other)

{

if (this != &other) {

if (type_ >= String)

clear();

type_ = other.type_;

switch (type_) {

case Null:

break;

case Bool:

bool_value = other.bool_value;

break;

case Long:

long_value = other.long_value;

break;

case Float:

float_value = other.float_value;

break;

case Double:

double_value = other.double_value;

break;

case String:

new (&string_value) std::string(other.string_value);

break;

case Array:

new (&array_value) std::vector<Json>(other.array_value);

break;

case Object:

new (&object_value)

std::map<std::string, Json>(other.object_value);

break;

default:

ON_LOGIC_ERROR("Unhandled JSON type.");

}

}

return *this;

}

Json::Json(Json&& other) : type_(other.type_)

}

Json&

Json::operator=(Json&& other)

{

if (this != &other) {

if (type_ >= String)

clear();

type_ = other.type_;

switch (type_) {

case Null:

break;

case Bool:

bool_value = other.bool_value;

break;

case Long:

long_value = other.long_value;

break;

case Float:

float_value = other.float_value;

break;

case Double:

double_value = other.double_value;

break;

case String:

new (&string_value) std::string(std::move(other.string_value));

break;

case Array:

new (&array_value)

std::vector<Json>(std::move(other.array_value));

break;

case Object:

new (&object_value)

std::map<std::string, Json>(std::move(other.object_value));

break;

default:

ON_LOGIC_ERROR("Unhandled JSON type.");;

}

other.type_ = Null;

}

return *this;

}

Json::getNumber() const

}

long long

Json::getLong() const

}

Json::getBool() const

}

Json::getFloat() const

}

Json::getDouble() const

}

std::string&

Json::getString()

{

switch (type_) {

case String:

return string_value;

default:

ON_LOGIC_ERROR("JSON value is not a string.");

}

}

const std::string&

Json::getString() const

{

switch (type_) {

case String:

return string_value;

default:

ON_LOGIC_ERROR("JSON value is not a string.");

}

}

std::vector<Json>&

Json::getArray()

{

switch (type_) {

case Array:

return array_value;

default:

ON_LOGIC_ERROR("JSON value is not an array.");

}

}

const std::vector<Json>&

Json::getArray() const

{

switch (type_) {

case Array:

return array_value;

default:

ON_LOGIC_ERROR("JSON value is not an array.");

}

}

std::map<std::string, Json>&

Json::getObject()

{

switch (type_) {

case Object:

return object_value;

default:

ON_LOGIC_ERROR("JSON value is not an object.");

}

}

const std::map<std::string, Json>&

Json::getObject() const

{

switch (type_) {

case Object:

return object_value;

default:

ON_LOGIC_ERROR("JSON value is not an object.");

}

}

Json::setArray()

}

Json::setObject()

}

Json::contains(const std::string& key) const

}

Json&

Json::operator[](size_t index)

{

if (!isArray())

setArray();

if (index >= array_value.size()) {

array_value.resize(index + 1);

}

return array_value[index];

}

const Json&

Json::operator[](size_t index) const

{

if (!isArray())

ON_LOGIC_ERROR("JSON value is not an array.");

if (index >= array_value.size()) {

ON_LOGIC_ERROR("JSON index not in array.");

}

return array_value[index];

}

Json&

Json::operator[](const std::string& key)

{

if (!isObject())

setObject();

return object_value[key];

}

const Json&

Json::operator[](const std::string& key) const

{

if (!isObject())

ON_LOGIC_ERROR("JSON value is not an object.");

auto it = object_value.find(key);

if (it == object_value.end())

ON_LOGIC_ERROR("JSON object does not contain key.");

return it->second;

}

std::string

Json::toString() const

}

std::string

Json::toStringPretty() const

}

Json::marshal(std::string& b, bool pretty, int indent) const

}

Json::stringify(std::string& b, const std::string& s)

}

Json::serialize(std::string& sb, const std::string& s)

}

Json::Status

Json::parse(Json& json, const char*& p, const char* e, int context, int depth)