#if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)

#define _CRT_SECURE_NO_DEPRECATE

#ifdef __GNUC__

#pragma GCC visibility push(default)

#if defined(_MSC_VER)

#pragma warning (push)

#pragma warning (disable : 4001)

#include <string.h>

#include <stdio.h>

#include <math.h>

#include <stdlib.h>

#include <limits.h>

#include <ctype.h>

#include <float.h>

#ifdef ENABLE_LOCALES

#include <locale.h>

#if defined(_MSC_VER)

#pragma warning (pop)

#ifdef __GNUC__

#pragma GCC visibility pop

#include "cJSON.h"

#ifdef true

#undef true

#define true ((cJSON_bool)1)

#ifdef false

#undef false

#define false ((cJSON_bool)0)

#ifndef isinf

#define isinf(d) (isnan((d - d)) && !isnan(d))

#ifndef isnan

#define isnan(d) (d != d)

#ifndef NAN

#ifdef _WIN32

#define NAN sqrt(-1.0)

#define NAN 0.0/0.0

typedef struct {

const unsigned char *json;

size_t position;

} error;

static error global_error = { NULL, 0 };

CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void)

{

return (const char*) (global_error.json + global_error.position);

}

CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item)

{

if (!cJSON_IsString(item))

{

return NULL;

}

return item->valuestring;

}

CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item)

{

if (!cJSON_IsNumber(item))

{

return (double) NAN;

}

return item->valuedouble;

}

#if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 15)

#error cJSON.h and cJSON.c have different versions. Make sure that both have the same.

CJSON_PUBLIC(const char*) cJSON_Version(void)

{

static char version[15];

sprintf(version, "%i.%i.%i", CJSON_VERSION_MAJOR, CJSON_VERSION_MINOR, CJSON_VERSION_PATCH);

return version;

}

static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2)

{

if ((string1 == NULL) || (string2 == NULL))

{

return 1;

}

if (string1 == string2)

{

return 0;

}

for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++)

{

if (*string1 == '\0')

{

return 0;

}

}

return tolower(*string1) - tolower(*string2);

}

typedef struct internal_hooks

} internal_hooks;

#if defined(_MSC_VER)

static void * CJSON_CDECL internal_malloc(size_t size)

{

return malloc(size);

}

static void CJSON_CDECL internal_free(void *pointer)

{

free(pointer);

}

static void * CJSON_CDECL internal_realloc(void *pointer, size_t size)

{

return realloc(pointer, size);

}

#define internal_malloc malloc

#define internal_free free

#define internal_realloc realloc

#define static_strlen(string_literal) (sizeof(string_literal) - sizeof(""))

static internal_hooks global_hooks = { internal_malloc, internal_free, internal_realloc };

static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks)

{

size_t length = 0;

unsigned char *copy = NULL;

if (string == NULL)

{

return NULL;

}

length = strlen((const char*)string) + sizeof("");

copy = (unsigned char*)hooks->allocate(length);

if (copy == NULL)

{

return NULL;

}

memcpy(copy, string, length);

return copy;

}

CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks)

{

if (hooks == NULL)

{

/* Reset hooks */

global_hooks.allocate = malloc;

global_hooks.deallocate = free;

global_hooks.reallocate = realloc;

return;

}

global_hooks.allocate = malloc;

if (hooks->malloc_fn != NULL)

{

global_hooks.allocate = hooks->malloc_fn;

}

global_hooks.deallocate = free;

if (hooks->free_fn != NULL)

{

global_hooks.deallocate = hooks->free_fn;

}

/* use realloc only if both free and malloc are used */

global_hooks.reallocate = NULL;

if ((global_hooks.allocate == malloc) && (global_hooks.deallocate == free))

{

global_hooks.reallocate = realloc;

}

}

static cJSON *cJSON_New_Item(const internal_hooks * const hooks)

{

cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON));

if (node)

{

memset(node, '\0', sizeof(cJSON));

}

return node;

}

CJSON_PUBLIC(void) cJSON_Delete(cJSON *item)

{

cJSON *next = NULL;

while (item != NULL)

{

next = item->next;

if (!(item->type & cJSON_IsReference) && (item->child != NULL))

{

cJSON_Delete(item->child);

}

if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL))

{

global_hooks.deallocate(item->valuestring);

}

if (!(item->type & cJSON_StringIsConst) && (item->string != NULL))

{

global_hooks.deallocate(item->string);

}

global_hooks.deallocate(item);

item = next;

}

}

static unsigned char get_decimal_point(void)

{

#ifdef ENABLE_LOCALES

struct lconv *lconv = localeconv();

return (unsigned char) lconv->decimal_point[0];

return '.';

}

typedef struct

{

const unsigned char *content;

size_t length;

size_t offset;

size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */

internal_hooks hooks;

} parse_buffer;

#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))

#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))

#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))

#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)

static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer)

{

double number = 0;

unsigned char *after_end = NULL;

unsigned char number_c_string[64];

unsigned char decimal_point = get_decimal_point();

size_t i = 0;

if ((input_buffer == NULL) || (input_buffer->content == NULL))

{

return false;

}

/* copy the number into a temporary buffer and replace '.' with the decimal point

for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++)

{

switch (buffer_at_offset(input_buffer)[i])

{

case '0':

case '1':

case '2':

case '3':

case '4':

case '5':

case '6':

case '7':

case '8':

case '9':

case '+':

case '-':

case 'e':

case 'E':

number_c_string[i] = buffer_at_offset(input_buffer)[i];

break;

case '.':

number_c_string[i] = decimal_point;

break;

default:

goto loop_end;

}

}

loop_end:

number_c_string[i] = '\0';

number = strtod((const char*)number_c_string, (char**)&after_end);

if (number_c_string == after_end)

{

return false; /* parse_error */

}

item->valuedouble = number;

/* use saturation in case of overflow */

if (number >= INT_MAX)

{

item->valueint = INT_MAX;

}

else if (number <= (double)INT_MIN)

{

item->valueint = INT_MIN;

}

else

{

item->valueint = (int)number;

}

item->type = cJSON_Number;

input_buffer->offset += (size_t)(after_end - number_c_string);

return true;

}

CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number)

{

if (number >= INT_MAX)

{

object->valueint = INT_MAX;

}

else if (number <= (double)INT_MIN)

{

object->valueint = INT_MIN;

}

else

{

object->valueint = (int)number;

}

return object->valuedouble = number;

}

CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring)

{

char *copy = NULL;

/* if object's type is not cJSON_String or is cJSON_IsReference, it should not set valuestring */

if (!(object->type & cJSON_String) || (object->type & cJSON_IsReference))

{

return NULL;

}

if (strlen(valuestring) <= strlen(object->valuestring))

{

strcpy(object->valuestring, valuestring);

return object->valuestring;

}

copy = (char*) cJSON_strdup((const unsigned char*)valuestring, &global_hooks);

if (copy == NULL)

{

return NULL;

}

if (object->valuestring != NULL)

{

cJSON_free(object->valuestring);

}

object->valuestring = copy;

return copy;

}

typedef struct

{

unsigned char *buffer;

size_t length;

size_t offset;

size_t depth; /* current nesting depth (for formatted printing) */

cJSON_bool noalloc;

cJSON_bool format; /* is this print a formatted print */

internal_hooks hooks;

} printbuffer;

static unsigned char* ensure(printbuffer * const p, size_t needed)

{

unsigned char *newbuffer = NULL;

size_t newsize = 0;

if ((p == NULL) || (p->buffer == NULL))

{

return NULL;

}

if ((p->length > 0) && (p->offset >= p->length))

{

/* make sure that offset is valid */

return NULL;

}

if (needed > INT_MAX)

{

/* sizes bigger than INT_MAX are currently not supported */

return NULL;

}

needed += p->offset + 1;

if (needed <= p->length)

{

return p->buffer + p->offset;

}

if (p->noalloc) {

return NULL;

}

/* calculate new buffer size */

if (needed > (INT_MAX / 2))

{

/* overflow of int, use INT_MAX if possible */

if (needed <= INT_MAX)

{

newsize = INT_MAX;

}

else

{

return NULL;

}

}

else

{

newsize = needed * 2;

}

if (p->hooks.reallocate != NULL)

{

/* reallocate with realloc if available */

newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize);

if (newbuffer == NULL)

{

p->hooks.deallocate(p->buffer);

p->length = 0;

p->buffer = NULL;

return NULL;

}

}

else

{

/* otherwise reallocate manually */

newbuffer = (unsigned char*)p->hooks.allocate(newsize);

if (!newbuffer)

{

p->hooks.deallocate(p->buffer);

p->length = 0;

p->buffer = NULL;

return NULL;

}

memcpy(newbuffer, p->buffer, p->offset + 1);

p->hooks.deallocate(p->buffer);

}

p->length = newsize;

p->buffer = newbuffer;

return newbuffer + p->offset;

}

static void update_offset(printbuffer * const buffer)

{

const unsigned char *buffer_pointer = NULL;

if ((buffer == NULL) || (buffer->buffer == NULL))

{

return;

}

buffer_pointer = buffer->buffer + buffer->offset;

buffer->offset += strlen((const char*)buffer_pointer);

}

static cJSON_bool compare_double(double a, double b)

{

double maxVal = fabs(a) > fabs(b) ? fabs(a) : fabs(b);

return (fabs(a - b) <= maxVal * DBL_EPSILON);

}

static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer)

{

unsigned char *output_pointer = NULL;

double d = item->valuedouble;

int length = 0;

size_t i = 0;

unsigned char number_buffer[26] = {0}; /* temporary buffer to print the number into */

unsigned char decimal_point = get_decimal_point();

double test = 0.0;

if (output_buffer == NULL)

{

return false;

}

/* This checks for NaN and Infinity */

if (isnan(d) || isinf(d))

{

length = sprintf((char*)number_buffer, "null");

}

else if(d == (double)item->valueint)

{

length = sprintf((char*)number_buffer, "%d", item->valueint);

}

else

{

/* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */

length = sprintf((char*)number_buffer, "%1.15g", d);

/* Check whether the original double can be recovered */

if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || !compare_double((double)test, d))

{

/* If not, print with 17 decimal places of precision */

length = sprintf((char*)number_buffer, "%1.17g", d);

}

}

/* sprintf failed or buffer overrun occurred */

if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1)))

{

return false;

}

/* reserve appropriate space in the output */

output_pointer = ensure(output_buffer, (size_t)length + sizeof(""));

if (output_pointer == NULL)

{

return false;

}

/* copy the printed number to the output and replace locale

for (i = 0; i < ((size_t)length); i++)

{

if (number_buffer[i] == decimal_point)

{

output_pointer[i] = '.';

continue;

}

output_pointer[i] = number_buffer[i];

}

output_pointer[i] = '\0';

output_buffer->offset += (size_t)length;

return true;

}

static unsigned parse_hex4(const unsigned char * const input)

{

unsigned int h = 0;

size_t i = 0;

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

{

/* parse digit */

if ((input[i] >= '0') && (input[i] <= '9'))

{

h += (unsigned int) input[i] - '0';

}

else if ((input[i] >= 'A') && (input[i] <= 'F'))

{

h += (unsigned int) 10 + input[i] - 'A';

}

else if ((input[i] >= 'a') && (input[i] <= 'f'))

{

h += (unsigned int) 10 + input[i] - 'a';

}

else /* invalid */

{

return 0;

}

if (i < 3)

{

/* shift left to make place for the next nibble */

h = h << 4;

}

}

return h;

}

static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer)

{

long unsigned int codepoint = 0;

unsigned int first_code = 0;

const unsigned char *first_sequence = input_pointer;

unsigned char utf8_length = 0;

unsigned char utf8_position = 0;

unsigned char sequence_length = 0;

unsigned char first_byte_mark = 0;

if ((input_end - first_sequence) < 6)

{

/* input ends unexpectedly */

goto fail;

}

/* get the first utf16 sequence */

first_code = parse_hex4(first_sequence + 2);

/* check that the code is valid */

if (((first_code >= 0xDC00) && (first_code <= 0xDFFF)))

{

goto fail;

}

/* UTF16 surrogate pair */

if ((first_code >= 0xD800) && (first_code <= 0xDBFF))

{

const unsigned char *second_sequence = first_sequence + 6;

unsigned int second_code = 0;

sequence_length = 12; /* \uXXXX\uXXXX */

if ((input_end - second_sequence) < 6)

{

/* input ends unexpectedly */

goto fail;

}

if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u'))

{

/* missing second half of the surrogate pair */

goto fail;

}

/* get the second utf16 sequence */

second_code = parse_hex4(second_sequence + 2);

/* check that the code is valid */

if ((second_code < 0xDC00) || (second_code > 0xDFFF))

{

/* invalid second half of the surrogate pair */

goto fail;

}

/* calculate the unicode codepoint from the surrogate pair */

codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF));

}

else

{

sequence_length = 6; /* \uXXXX */

codepoint = first_code;

}

/* encode as UTF-8

if (codepoint < 0x80)

{

/* normal ascii, encoding 0xxxxxxx */

utf8_length = 1;

}

else if (codepoint < 0x800)

{

/* two bytes, encoding 110xxxxx 10xxxxxx */

utf8_length = 2;

first_byte_mark = 0xC0; /* 11000000 */

}

else if (codepoint < 0x10000)

{

/* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */

utf8_length = 3;

first_byte_mark = 0xE0; /* 11100000 */

}

else if (codepoint <= 0x10FFFF)

{

/* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */

utf8_length = 4;

first_byte_mark = 0xF0; /* 11110000 */

}

else

{

/* invalid unicode codepoint */

goto fail;

}

/* encode as utf8 */

for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--)

{

/* 10xxxxxx */

(*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF);

codepoint >>= 6;

}

/* encode first byte */

if (utf8_length > 1)

{

(*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF);

}

else

{

(*output_pointer)[0] = (unsigned char)(codepoint & 0x7F);

}

*output_pointer += utf8_length;

return sequence_length;

fail:

return 0;

}

static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer)

{

const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1;

const unsigned char *input_end = buffer_at_offset(input_buffer) + 1;

unsigned char *output_pointer = NULL;

unsigned char *output = NULL;

/* not a string */

if (buffer_at_offset(input_buffer)[0] != '\"')

{

goto fail;

}

{

/* calculate approximate size of the output (overestimate) */

size_t allocation_length = 0;

size_t skipped_bytes = 0;

while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"'))

{

/* is escape sequence */

if (input_end[0] == '\\')

{

if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length)

{

/* prevent buffer overflow when last input character is a backslash */

goto fail;

}

skipped_bytes++;

input_end++;

}

input_end++;

}

if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"'))

{

goto fail; /* string ended unexpectedly */

}

/* This is at most how much we need for the output */

allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes;

output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof(""));

if (output == NULL)

{

goto fail; /* allocation failure */

}

}

output_pointer = output;

/* loop through the string literal */

while (input_pointer < input_end)

{

if (*input_pointer != '\\')

{

*output_pointer++ = *input_pointer++;

}

/* escape sequence */

else

{

unsigned char sequence_length = 2;

if ((input_end - input_pointer) < 1)

{

goto fail;

}

switch (input_pointer[1])

{

case 'b':

*output_pointer++ = '\b';

break;

case 'f':

*output_pointer++ = '\f';

break;

case 'n':

*output_pointer++ = '\n';

break;

case 'r':

*output_pointer++ = '\r';

break;

case 't':

*output_pointer++ = '\t';

break;

case '\"':

case '\\':

case '/':

*output_pointer++ = input_pointer[1];

break;

/* UTF-16 literal */

case 'u':

sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer);

if (sequence_length == 0)

{

/* failed to convert UTF16-literal to UTF-8 */

goto fail;

}

break;

default:

goto fail;

}

input_pointer += sequence_length;

}

}

/* zero terminate the output */

*output_pointer = '\0';

item->type = cJSON_String;

item->valuestring = (char*)output;

input_buffer->offset = (size_t) (input_end - input_buffer->content);

input_buffer->offset++;

return true;

fail:

if (output != NULL)

{

input_buffer->hooks.deallocate(output);

}

if (input_pointer != NULL)

{

input_buffer->offset = (size_t)(input_pointer - input_buffer->content);

}

return false;

}

static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer)

{

const unsigned char *input_pointer = NULL;

unsigned char *output = NULL;

unsigned char *output_pointer = NULL;

size_t output_length = 0;

/* numbers of additional characters needed for escaping */

size_t escape_characters = 0;

if (output_buffer == NULL)

{

return false;

}

/* empty string */

if (input == NULL)

{

output = ensure(output_buffer, sizeof("\"\""));

if (output == NULL)

{

return false;

}

strcpy((char*)output, "\"\"");

return true;

}

/* set "flag" to 1 if something needs to be escaped */

for (input_pointer = input; *input_pointer; input_pointer++)

{

switch (*input_pointer)

{

case '\"':

case '\\':

case '\b':

case '\f':

case '\n':

case '\r':

case '\t':

/* one character escape sequence */

escape_characters++;

break;

default:

if (*input_pointer < 32)

{

/* UTF-16 escape sequence uXXXX */

escape_characters += 5;

}

break;

}

}

output_length = (size_t)(input_pointer - input) + escape_characters;

output = ensure(output_buffer, output_length + sizeof("\"\""));

if (output == NULL)

{

return false;

}

/* no characters have to be escaped */

if (escape_characters == 0)

{

output[0] = '\"';

memcpy(output + 1, input, output_length);

output[output_length + 1] = '\"';

output[output_length + 2] = '\0';

return true;

}

output[0] = '\"';

output_pointer = output + 1;

/* copy the string */

for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++)

{

if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\'))

{

/* normal character, copy */

*output_pointer = *input_pointer;

}

else

{

/* character needs to be escaped */

*output_pointer++ = '\\';

switch (*input_pointer)

{

case '\\':

*output_pointer = '\\';

break;

case '\"':

*output_pointer = '\"';

break;

case '\b':

*output_pointer = 'b';

break;

case '\f':

*output_pointer = 'f';

break;

case '\n':