#include "json.hpp"

#include <fstream>

#ifndef LIB_JSONCPP_JSON_TOOL_H_INCLUDED

#define LIB_JSONCPP_JSON_TOOL_H_INCLUDED

#ifdef NO_LOCALE_SUPPORT

#define JSONCPP_NO_LOCALE_SUPPORT

#endif

#ifndef JSONCPP_NO_LOCALE_SUPPORT

#include <clocale>

#endif

namespace Json {

static char getDecimalPoint() {

}

static inline JSONCPP_STRING codePointToUTF8(unsigned int cp) {

}

static inline bool isControlCharacter(char ch) { return ch > 0 && ch <= 0x1F; }

enum {

/// Constant that specify the size of the buffer that must be passed to

/// uintToString.

uintToStringBufferSize = 3 * sizeof(LargestUInt) + 1

};

typedef char UIntToStringBuffer[uintToStringBufferSize];

static inline void uintToString(LargestUInt value, char*& current) {

}

static inline void fixNumericLocale(char* begin, char* end) {

}

static inline void fixNumericLocaleInput(char* begin, char* end) {

}

} // namespace Json {

#endif // LIB_JSONCPP_JSON_TOOL_H_INCLUDED

namespace Json {

ValueIteratorBase::ValueIteratorBase()

: current_(), isNull_(true) {

}

ValueIteratorBase::ValueIteratorBase(

const Value::ObjectValues::iterator& current)

: current_(current), isNull_(false) {}

Value& ValueIteratorBase::deref() const {

return current_->second;

}

void ValueIteratorBase::increment() {

++current_;

}

void ValueIteratorBase::decrement() {

--current_;

}

ValueIteratorBase::difference_type

ValueIteratorBase::computeDistance(const SelfType& other) const {

}

bool ValueIteratorBase::isEqual(const SelfType& other) const {

}

void ValueIteratorBase::copy(const SelfType& other) {

current_ = other.current_;

isNull_ = other.isNull_;

}

Value ValueIteratorBase::key() const {

}

UInt ValueIteratorBase::index() const {

}

JSONCPP_STRING ValueIteratorBase::name() const {

}

char const* ValueIteratorBase::memberName() const {

const char* cname = (*current_).first.data();

return cname ? cname : "";

}

char const* ValueIteratorBase::memberName(char const** end) const {

const char* cname = (*current_).first.data();

if (!cname) {

*end = NULL;

return NULL;

}

*end = cname + (*current_).first.length();

return cname;

}

ValueConstIterator::ValueConstIterator() {}

ValueConstIterator::ValueConstIterator(

const Value::ObjectValues::iterator& current)

: ValueIteratorBase(current) {}

ValueConstIterator::ValueConstIterator(ValueIterator const& other)

: ValueIteratorBase(other) {}

ValueConstIterator& ValueConstIterator::

operator=(const ValueIteratorBase& other) {

copy(other);

return *this;

}

ValueIterator::ValueIterator() {}

ValueIterator::ValueIterator(const Value::ObjectValues::iterator& current)

: ValueIteratorBase(current) {}

ValueIterator::ValueIterator(const ValueConstIterator& other)

: ValueIteratorBase(other) {

throwRuntimeError("ConstIterator to Iterator should never be allowed.");

}

ValueIterator::ValueIterator(const ValueIterator& other)

: ValueIteratorBase(other) {}

ValueIterator& ValueIterator::operator=(const SelfType& other) {

copy(other);

return *this;

}

} // namespace Json

#if !defined(JSON_IS_AMALGAMATION)

#endif // if !defined(JSON_IS_AMALGAMATION)

#include <math.h>

#include <sstream>

#include <utility>

#include <cstring>

#include <cassert>

#ifdef JSON_USE_CPPTL

#include <cpptl/conststring.h>

#endif

#include <cstddef> // size_t

#include <algorithm> // min()

#define JSON_ASSERT_UNREACHABLE assert(false)

namespace Json {

#if defined(__ARMEL__)

#define ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment)))

#else

#define ALIGNAS(byte_alignment)

#endif

Value const& Value::nullSingleton()

{

static Value const nullStatic;

return nullStatic;

}

Value const& Value::null = Value::nullSingleton();

Value const& Value::nullRef = Value::nullSingleton();

const Int Value::minInt = Int(~(UInt(-1) / 2));

const Int Value::maxInt = Int(UInt(-1) / 2);

const UInt Value::maxUInt = UInt(-1);

#if defined(JSON_HAS_INT64)

const Int64 Value::minInt64 = Int64(~(UInt64(-1) / 2));

const Int64 Value::maxInt64 = Int64(UInt64(-1) / 2);

const UInt64 Value::maxUInt64 = UInt64(-1);

static const double maxUInt64AsDouble = 18446744073709551615.0;

#endif // defined(JSON_HAS_INT64)

const LargestInt Value::minLargestInt = LargestInt(~(LargestUInt(-1) / 2));

const LargestInt Value::maxLargestInt = LargestInt(LargestUInt(-1) / 2);

const LargestUInt Value::maxLargestUInt = LargestUInt(-1);

#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)

template <typename T, typename U>

static inline bool InRange(double d, T min, U max) {

}

#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)

static inline double integerToDouble(Json::UInt64 value) {

return static_cast<double>(Int64(value / 2)) * 2.0 + static_cast<double>(Int64(value & 1));

}

template <typename T> static inline double integerToDouble(T value) {

return static_cast<double>(value);

}

template <typename T, typename U>

static inline bool InRange(double d, T min, U max) {

return d >= integerToDouble(min) && d <= integerToDouble(max);

}

#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)

static inline char* duplicateStringValue(const char* value,

size_t length)

{

// Avoid an integer overflow in the call to malloc below by limiting length

// to a sane value.

if (length >= static_cast<size_t>(Value::maxInt))

length = Value::maxInt - 1;

char* newString = static_cast<char*>(malloc(length + 1));

if (newString == NULL) {

throwRuntimeError(

"in Json::Value::duplicateStringValue(): "

"Failed to allocate string value buffer");

}

memcpy(newString, value, length);

newString[length] = 0;

return newString;

}

static inline char* duplicateAndPrefixStringValue(

const char* value,

unsigned int length)

{

// Avoid an integer overflow in the call to malloc below by limiting length

// to a sane value.

JSON_ASSERT_MESSAGE(length <= static_cast<unsigned>(Value::maxInt) - sizeof(unsigned) - 1U,

"in Json::Value::duplicateAndPrefixStringValue(): "

"length too big for prefixing");

unsigned actualLength = length + static_cast<unsigned>(sizeof(unsigned)) + 1U;

char* newString = static_cast<char*>(malloc(actualLength));

if (newString == 0) {

throwRuntimeError(

"in Json::Value::duplicateAndPrefixStringValue(): "

"Failed to allocate string value buffer");

}

*reinterpret_cast<unsigned*>(newString) = length;

memcpy(newString + sizeof(unsigned), value, length);

newString[actualLength - 1U] = 0; // to avoid buffer over-run accidents by users later

return newString;

}

inline static void decodePrefixedString(

}

#if JSONCPP_USING_SECURE_MEMORY

static inline void releasePrefixedStringValue(char* value) {

}

static inline void releaseStringValue(char* value, unsigned length) {

}

#else // !JSONCPP_USING_SECURE_MEMORY

static inline void releasePrefixedStringValue(char* value) {

free(value);

}

static inline void releaseStringValue(char* value, unsigned) {

free(value);

}

#endif // JSONCPP_USING_SECURE_MEMORY

} // namespace Json

#if !defined(JSON_IS_AMALGAMATION)

#endif // if !defined(JSON_IS_AMALGAMATION)

namespace Json {

Exception::Exception(JSONCPP_STRING const& msg)

: msg_(msg)

{}

Exception::~Exception() JSONCPP_NOEXCEPT

{}

char const* Exception::what() const JSONCPP_NOEXCEPT

{

return msg_.c_str();

}

RuntimeError::RuntimeError(JSONCPP_STRING const& msg)

: Exception(msg)

{}

LogicError::LogicError(JSONCPP_STRING const& msg)

: Exception(msg)

{}

JSONCPP_NORETURN void throwRuntimeError(JSONCPP_STRING const& msg)

{

throw RuntimeError(msg);

}

JSONCPP_NORETURN void throwLogicError(JSONCPP_STRING const& msg)

{

throw LogicError(msg);

}

Value::CommentInfo::CommentInfo() : comment_(0)

{}

Value::CommentInfo::~CommentInfo() {

if (comment_)

releaseStringValue(comment_, 0u);

}

void Value::CommentInfo::setComment(const char* text, size_t len) {

if (comment_) {

releaseStringValue(comment_, 0u);

comment_ = 0;

}

JSON_ASSERT(text != 0);

JSON_ASSERT_MESSAGE(

text[0] == '\0' || text[0] == '/',

"in Json::Value::setComment(): Comments must start with /");

// It seems that /**/ style comments are acceptable as well.

comment_ = duplicateStringValue(text, len);

}

Value::CZString::CZString(ArrayIndex aindex) : cstr_(0), index_(aindex) {}

Value::CZString::CZString(char const* str, unsigned ulength, DuplicationPolicy allocate)

: cstr_(str) {

// allocate != duplicate

storage_.policy_ = allocate & 0x3;

storage_.length_ = ulength & 0x3FFFFFFF;

}

Value::CZString::CZString(const CZString& other) {

cstr_ = (other.storage_.policy_ != noDuplication && other.cstr_ != 0

? duplicateStringValue(other.cstr_, other.storage_.length_)

: other.cstr_);

storage_.policy_ = static_cast<unsigned>(other.cstr_

? (static_cast<DuplicationPolicy>(other.storage_.policy_) == noDuplication

? noDuplication : duplicate)

: static_cast<DuplicationPolicy>(other.storage_.policy_)) & 3U;

storage_.length_ = other.storage_.length_;

}

#if JSON_HAS_RVALUE_REFERENCES

Value::CZString::CZString(CZString&& other)

: cstr_(other.cstr_), index_(other.index_) {

other.cstr_ = nullptr;

}

#endif

Value::CZString::~CZString() {

if (cstr_ && storage_.policy_ == duplicate) {

releaseStringValue(const_cast<char*>(cstr_), storage_.length_ + 1u); //+1 for null terminating character for sake of completeness but not actually necessary

}

}

void Value::CZString::swap(CZString& other) {

std::swap(cstr_, other.cstr_);

std::swap(index_, other.index_);

}

Value::CZString& Value::CZString::operator=(const CZString& other) {

cstr_ = other.cstr_;

index_ = other.index_;

return *this;

}

#if JSON_HAS_RVALUE_REFERENCES

Value::CZString& Value::CZString::operator=(CZString&& other) {

cstr_ = other.cstr_;

index_ = other.index_;

other.cstr_ = nullptr;

return *this;

}

#endif

bool Value::CZString::operator<(const CZString& other) const {

if (!cstr_) return index_ < other.index_;

//return strcmp(cstr_, other.cstr_) < 0;

// Assume both are strings.

unsigned this_len = this->storage_.length_;

unsigned other_len = other.storage_.length_;

unsigned min_len = std::min<unsigned>(this_len, other_len);

JSON_ASSERT(this->cstr_ && other.cstr_);

int comp = memcmp(this->cstr_, other.cstr_, min_len);

if (comp < 0) return true;

if (comp > 0) return false;

return (this_len < other_len);

}

bool Value::CZString::operator==(const CZString& other) const {

if (!cstr_) return index_ == other.index_;

//return strcmp(cstr_, other.cstr_) == 0;

// Assume both are strings.

unsigned this_len = this->storage_.length_;

unsigned other_len = other.storage_.length_;

if (this_len != other_len) return false;

JSON_ASSERT(this->cstr_ && other.cstr_);

int comp = memcmp(this->cstr_, other.cstr_, this_len);

return comp == 0;

}

ArrayIndex Value::CZString::index() const { return index_; }

const char* Value::CZString::data() const { return cstr_; }

unsigned Value::CZString::length() const { return storage_.length_; }

bool Value::CZString::isStaticString() const { return storage_.policy_ == noDuplication; }

Value::Value(ValueType vtype) {

}

Value::Value(Int value) {

initBasic(intValue);

value_.int_ = value;

}

Value::Value(UInt value) {

initBasic(uintValue);

value_.uint_ = value;

}

#if defined(JSON_HAS_INT64)

Value::Value(Int64 value) {

initBasic(intValue);

value_.int_ = value;

}

Value::Value(UInt64 value) {

initBasic(uintValue);

value_.uint_ = value;

}

#endif // defined(JSON_HAS_INT64)

Value::Value(double value) {

initBasic(realValue);

value_.real_ = value;

}

Value::Value(const char* value) {

}

Value::Value(const char* beginValue, const char* endValue) {

}

Value::Value(const JSONCPP_STRING& value) {

}

Value::Value(const StaticString& value) {

initBasic(stringValue);

value_.string_ = const_cast<char*>(value.c_str());

}

#ifdef JSON_USE_CPPTL

Value::Value(const CppTL::ConstString& value) {

initBasic(stringValue, true);

value_.string_ = duplicateAndPrefixStringValue(value, static_cast<unsigned>(value.length()));

}

#endif

Value::Value(bool value) {

initBasic(booleanValue);

value_.bool_ = value;

}

Value::Value(Value const& other)

}

#if JSON_HAS_RVALUE_REFERENCES

Value::Value(Value&& other) {

initBasic(nullValue);

swap(other);

}

#endif

Value::~Value() {

switch (type_) {

case nullValue:

case intValue:

case uintValue:

case realValue:

case booleanValue:

break;

case stringValue:

if (allocated_)

releasePrefixedStringValue(value_.string_);

break;

case arrayValue:

case objectValue:

delete value_.map_;

break;

default:

JSON_ASSERT_UNREACHABLE;

}

delete[] comments_;

value_.uint_ = 0;

}

Value& Value::operator=(Value other) {

swap(other);

return *this;

}

void Value::swapPayload(Value& other) {

}

void Value::copyPayload(const Value& other) {

}

void Value::swap(Value& other) {

}

void Value::copy(const Value& other) {

}

ValueType Value::type() const { return type_; }

int Value::compare(const Value& other) const {

}

bool Value::operator<(const Value& other) const {

int typeDelta = type_ - other.type_;

if (typeDelta)

return typeDelta < 0 ? true : false;

switch (type_) {

case nullValue:

return false;

case intValue:

return value_.int_ < other.value_.int_;

case uintValue:

return value_.uint_ < other.value_.uint_;

case realValue:

return value_.real_ < other.value_.real_;

case booleanValue:

return value_.bool_ < other.value_.bool_;

case stringValue:

{

if ((value_.string_ == 0) || (other.value_.string_ == 0)) {

if (other.value_.string_) return true;

else return false;

}

unsigned this_len;

unsigned other_len;

char const* this_str;

char const* other_str;

decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);

decodePrefixedString(other.allocated_, other.value_.string_, &other_len, &other_str);

unsigned min_len = std::min<unsigned>(this_len, other_len);

JSON_ASSERT(this_str && other_str);

int comp = memcmp(this_str, other_str, min_len);

if (comp < 0) return true;

if (comp > 0) return false;

return (this_len < other_len);

}

case arrayValue:

case objectValue: {

int delta = int(value_.map_->size() - other.value_.map_->size());

if (delta)

return delta < 0;

return (*value_.map_) < (*other.value_.map_);

}

default:

JSON_ASSERT_UNREACHABLE;

}

return false; // unreachable

}

bool Value::operator<=(const Value& other) const { return !(other < *this); }

bool Value::operator>=(const Value& other) const { return !(*this < other); }

bool Value::operator>(const Value& other) const { return other < *this; }

bool Value::operator==(const Value& other) const {

// if ( type_ != other.type_ )

// GCC 2.95.3 says:

// attempt to take address of bit-field structure member `Json::Value::type_'

// Beats me, but a temp solves the problem.

int temp = other.type_;

if (type_ != temp)

return false;

switch (type_) {

case nullValue:

return true;

case intValue:

return value_.int_ == other.value_.int_;

case uintValue:

return value_.uint_ == other.value_.uint_;

case realValue:

return value_.real_ == other.value_.real_;

case booleanValue:

return value_.bool_ == other.value_.bool_;

case stringValue:

{

if ((value_.string_ == 0) || (other.value_.string_ == 0)) {

return (value_.string_ == other.value_.string_);

}

unsigned this_len;

unsigned other_len;

char const* this_str;

char const* other_str;

decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);

decodePrefixedString(other.allocated_, other.value_.string_, &other_len, &other_str);

if (this_len != other_len) return false;

JSON_ASSERT(this_str && other_str);

int comp = memcmp(this_str, other_str, this_len);

return comp == 0;

}

case arrayValue:

case objectValue:

return value_.map_->size() == other.value_.map_->size() &&

(*value_.map_) == (*other.value_.map_);

default:

JSON_ASSERT_UNREACHABLE;

}

return false; // unreachable

}

bool Value::operator!=(const Value& other) const { return !(*this == other); }

const char* Value::asCString() const {

/*JSON_ASSERT_MESSAGE(type_ == stringValue,

if (type_ != stringValue) return 0;

if (value_.string_ == 0) return 0;

unsigned this_len;

char const* this_str;

decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);

return this_str;

}

#if JSONCPP_USING_SECURE_MEMORY

unsigned Value::getCStringLength() const {

}

#endif

bool Value::getString(char const** str, char const** cend) const {