mirror of https://github.com/grpc/grpc.git
Nicolas Noble
10 years ago
parent
85eea08ba8
commit
614c2bf99b
25 changed files with 1739 additions and 1444 deletions
@ -0,0 +1,44 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2014, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
/* The various json types. "NONE" may only used on top-level. */ |
||||
enum grpc_json_type_t { |
||||
GRPC_JSON_OBJECT, |
||||
GRPC_JSON_ARRAY, |
||||
GRPC_JSON_STRING, |
||||
GRPC_JSON_NUMBER, |
||||
GRPC_JSON_TRUE, |
||||
GRPC_JSON_FALSE, |
||||
GRPC_JSON_NULL, |
||||
GRPC_JSON_NONE |
||||
}; |
||||
@ -0,0 +1,95 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2014, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
/* the following need to be pre-defined:
|
||||
* grpc_json_reader_opaque_t // A type you can use to keep track of your
|
||||
* // own stuff.
|
||||
* grpc_json_wchar_t // A type that can hold a unicode character
|
||||
* // unsigned is good enough.
|
||||
* grpc_json_string_t // A type that can hold a growable string.
|
||||
*/ |
||||
|
||||
enum grpc_json_reader_state_t { |
||||
GRPC_JSON_STATE_OBJECT_KEY_BEGIN, |
||||
GRPC_JSON_STATE_OBJECT_KEY_STRING, |
||||
GRPC_JSON_STATE_OBJECT_KEY_END, |
||||
GRPC_JSON_STATE_VALUE_BEGIN, |
||||
GRPC_JSON_STATE_VALUE_STRING, |
||||
GRPC_JSON_STATE_STRING_ESCAPE, |
||||
GRPC_JSON_STATE_STRING_ESCAPE_U1, |
||||
GRPC_JSON_STATE_STRING_ESCAPE_U2, |
||||
GRPC_JSON_STATE_STRING_ESCAPE_U3, |
||||
GRPC_JSON_STATE_STRING_ESCAPE_U4, |
||||
GRPC_JSON_STATE_VALUE_NUMBER, |
||||
GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL, |
||||
GRPC_JSON_STATE_VALUE_NUMBER_ZERO, |
||||
GRPC_JSON_STATE_VALUE_NUMBER_DOT, |
||||
GRPC_JSON_STATE_VALUE_NUMBER_E, |
||||
GRPC_JSON_STATE_VALUE_NUMBER_EPM, |
||||
GRPC_JSON_STATE_VALUE_TRUE_R, |
||||
GRPC_JSON_STATE_VALUE_TRUE_U, |
||||
GRPC_JSON_STATE_VALUE_TRUE_E, |
||||
GRPC_JSON_STATE_VALUE_FALSE_A, |
||||
GRPC_JSON_STATE_VALUE_FALSE_L, |
||||
GRPC_JSON_STATE_VALUE_FALSE_S, |
||||
GRPC_JSON_STATE_VALUE_FALSE_E, |
||||
GRPC_JSON_STATE_VALUE_NULL_U, |
||||
GRPC_JSON_STATE_VALUE_NULL_L1, |
||||
GRPC_JSON_STATE_VALUE_NULL_L2, |
||||
GRPC_JSON_STATE_VALUE_END, |
||||
GRPC_JSON_STATE_END |
||||
}; |
||||
|
||||
struct grpc_json_reader_t { |
||||
/* You are responsible for the initialization of the following. */ |
||||
grpc_json_reader_opaque_t opaque; |
||||
|
||||
/* Everything down here is private,
|
||||
and initialized by grpc_json_reader_init. */ |
||||
int depth; |
||||
int in_object; |
||||
int in_array; |
||||
int escaped_string_was_key; |
||||
int container_just_begun; |
||||
grpc_json_wchar_t unicode; |
||||
enum grpc_json_reader_state_t state; |
||||
}; |
||||
|
||||
/* The return type of the parser. */ |
||||
typedef enum { |
||||
GRPC_JSON_DONE, /* The parser finished successfully. */ |
||||
GRPC_JSON_EAGAIN, /* The parser yields to get more data. */ |
||||
GRPC_JSON_READ_ERROR, /* The parser passes through a read error. */ |
||||
GRPC_JSON_PARSE_ERROR, /* The parser found an error in the json stream. */ |
||||
GRPC_JSON_INTERNAL_ERROR /* The parser got an internal error. */ |
||||
} grpc_json_reader_ret_t; |
||||
@ -0,0 +1,630 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2014, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
/* the following need to be pre-defined:
|
||||
* grpc_json_static_inline // A macro to declare a static inline
|
||||
* // function
|
||||
* grpc_json_eof // A macro that can be used in a switch
|
||||
* // statement, that grpc_json_read_char
|
||||
* // can return
|
||||
* grpc_json_eagain // A macro that can be used in a switch
|
||||
* // statement, that grpc_json_read_char
|
||||
* // can return
|
||||
* grpc_json_error // A macro that can be used in a switch
|
||||
* // statement, that grpc_json_read_char
|
||||
* // can return
|
||||
* |
||||
* // A macro or a function that clears your internal scratchpad.
|
||||
* grpc_json_reader_string_clear(struct grpc_json_reader_t*); |
||||
* // A macro or a function that adds a character to your internal
|
||||
* // scratchpad.
|
||||
* grpc_json_reader_string_add_char(struct grpc_json_reader_t*, int); |
||||
* // A macro or a function that adds a unicode character to your internal
|
||||
* // scratchpad.
|
||||
* grpc_json_reader_string_add_wchar(struct grpc_json_reader_t*, |
||||
* grpc_json_wchar_t); |
||||
* |
||||
* // A macro or a function that returns the next character from the input.
|
||||
* // It can return:
|
||||
* // . an actual character into an int - unicode, wchar_t, whatever, as
|
||||
* // long as it's going to work in a switch statement, and can be tested
|
||||
* // against typical json tokens, such as '{', '[', ',', '}', ']', digits
|
||||
* // and whitespaces.
|
||||
* // . grpc_json_eof, which means the end of the input has been reached.
|
||||
* // . grpc_json_eagain, which means the parser needs to yield before
|
||||
* // getting more input.
|
||||
* // . grpc_json_error, which means the parser needs to exit with an error.
|
||||
* int grpc_json_reader_read_char(struct grpc_json_reader_t*); |
||||
* |
||||
* // A macro or a function that will be called to signal the beginning of a
|
||||
* // container.
|
||||
* // The argument "type" can be either GRPC_JSON_OBJECT, or GRPC_JSON_ARRAY.
|
||||
* void grpc_json_reader_container_begins(struct grpc_json_reader_t*, |
||||
* enum *grpc_json_type_t type) |
||||
* // A macro or a function that will be called to signal the end of the
|
||||
* // current container. It must return GRPC_JSON_OBJECT or GRPC_JSON_ARRAY
|
||||
* // to signal what is the new current container, or GRPC_JSON_NONE if the
|
||||
* // stack of containers is now empty.
|
||||
* enum grpc_json_type_t |
||||
* grpc_json_reader_container_ends(struct grpc_json_reader_t*); |
||||
* |
||||
* // A macro or a function that will be called to signal that json->string
|
||||
* // contains the string of a object's key that is being added.
|
||||
* void grpc_json_reader_object_set_key(struct grpc_json_reader_t*); |
||||
* |
||||
* // A set of macro or functions that will be called to signal that the
|
||||
* // current container is getting a new value. set_string and set_number
|
||||
* // are reading their value from your internal scratchpad. set_number
|
||||
* // must return a boolean to signal if the number parsing succeeded or
|
||||
* // not. There is little reason for it not to.
|
||||
* void grpc_json_reader_container_set_string(struct grpc_json_reader_t*); |
||||
* int grpc_json_reader_container_set_number(struct grpc_json_reader_t*); |
||||
* void grpc_json_reader_container_set_true(struct grpc_json_reader_t*); |
||||
* void grpc_json_reader_container_set_false(struct grpc_json_reader_t*); |
||||
* void grpc_json_reader_container_set_null(struct grpc_json_reader_t*); |
||||
*/ |
||||
|
||||
/* Call this function to initialize the reader structure. */ |
||||
grpc_json_static_inline void grpc_json_reader_init( |
||||
struct grpc_json_reader_t* reader) { |
||||
reader->depth = 0; |
||||
reader->in_object = 0; |
||||
reader->in_array = 0; |
||||
grpc_json_reader_string_clear(reader); |
||||
reader->state = GRPC_JSON_STATE_VALUE_BEGIN; |
||||
} |
||||
|
||||
/* Call this function to start parsing the input. It will return the following:
|
||||
* . GRPC_JSON_DONE if the input got eof, and the parsing finished |
||||
* successfully. |
||||
* . GRPC_JSON_EAGAIN if the read_char function returned again. Call the |
||||
* parser again as needed. It is okay to call the parser in polling mode, |
||||
* although a bit dull. |
||||
* . GRPC_JSON_READ_ERROR if the read_char function returned an error. The |
||||
* state isn't broken however, and the function can be called again if the |
||||
* error has been corrected. But please use the EAGAIN feature instead for |
||||
* consistency. |
||||
* . GRPC_JSON_PARSE_ERROR if the input was somehow invalid. |
||||
* . GRPC_JSON_INTERNAL_ERROR if the parser somehow ended into an invalid |
||||
* internal state. |
||||
*/ |
||||
|
||||
grpc_json_static_inline grpc_json_reader_ret_t |
||||
grpc_json_reader_run(struct grpc_json_reader_t* reader) { |
||||
int c, success; |
||||
|
||||
/* This state-machine is a strict implementation of http://json.org/ */ |
||||
for (;;) { |
||||
c = grpc_json_reader_read_char(reader); |
||||
switch (c) { |
||||
/* Let's process the error cases first. */ |
||||
case grpc_json_error: |
||||
return GRPC_JSON_READ_ERROR; |
||||
|
||||
case grpc_json_eagain: |
||||
return GRPC_JSON_EAGAIN; |
||||
|
||||
case grpc_json_eof: |
||||
if ((reader->depth == 0) && |
||||
((reader->state == GRPC_JSON_STATE_END) || |
||||
(reader->state == GRPC_JSON_STATE_VALUE_END))) { |
||||
return GRPC_JSON_DONE; |
||||
} else { |
||||
return GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
/* Processing whitespaces. */ |
||||
case ' ': |
||||
case '\t': |
||||
case '\n': |
||||
case '\r': |
||||
switch (reader->state) { |
||||
case GRPC_JSON_STATE_OBJECT_KEY_BEGIN: |
||||
case GRPC_JSON_STATE_OBJECT_KEY_END: |
||||
case GRPC_JSON_STATE_VALUE_BEGIN: |
||||
case GRPC_JSON_STATE_VALUE_END: |
||||
case GRPC_JSON_STATE_END: |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_OBJECT_KEY_STRING: |
||||
case GRPC_JSON_STATE_VALUE_STRING: |
||||
grpc_json_reader_string_add_char(reader, c); |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_VALUE_NUMBER: |
||||
case GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL: |
||||
case GRPC_JSON_STATE_VALUE_NUMBER_ZERO: |
||||
case GRPC_JSON_STATE_VALUE_NUMBER_EPM: |
||||
success = grpc_json_reader_container_set_number(reader); |
||||
if (!success) return GRPC_JSON_PARSE_ERROR; |
||||
grpc_json_reader_string_clear(reader); |
||||
reader->state = GRPC_JSON_STATE_VALUE_END; |
||||
break; |
||||
|
||||
default: |
||||
return GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
/* Value, object or array terminations. */ |
||||
case ',': |
||||
case '}': |
||||
case ']': |
||||
switch (reader->state) { |
||||
case GRPC_JSON_STATE_OBJECT_KEY_STRING: |
||||
case GRPC_JSON_STATE_VALUE_STRING: |
||||
grpc_json_reader_string_add_char(reader, c); |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_VALUE_NUMBER: |
||||
case GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL: |
||||
case GRPC_JSON_STATE_VALUE_NUMBER_ZERO: |
||||
case GRPC_JSON_STATE_VALUE_NUMBER_EPM: |
||||
success = grpc_json_reader_container_set_number(reader); |
||||
if (!success) return GRPC_JSON_PARSE_ERROR; |
||||
grpc_json_reader_string_clear(reader); |
||||
reader->state = GRPC_JSON_STATE_VALUE_END; |
||||
/* The missing break here is intentional. */ |
||||
|
||||
case GRPC_JSON_STATE_VALUE_END: |
||||
case GRPC_JSON_STATE_OBJECT_KEY_BEGIN: |
||||
case GRPC_JSON_STATE_VALUE_BEGIN: |
||||
if (c == ',') { |
||||
if (reader->state != GRPC_JSON_STATE_VALUE_END) { |
||||
return GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
if (reader->in_object) { |
||||
reader->state = GRPC_JSON_STATE_OBJECT_KEY_BEGIN; |
||||
} else { |
||||
reader->state = GRPC_JSON_STATE_VALUE_BEGIN; |
||||
} |
||||
} else { |
||||
if (reader->depth-- == 0) return GRPC_JSON_PARSE_ERROR; |
||||
if ((c == '}') && !reader->in_object) { |
||||
return GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
if ((c == '}') && |
||||
(reader->state == GRPC_JSON_STATE_OBJECT_KEY_BEGIN) && |
||||
!reader->container_just_begun) { |
||||
return GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
if ((c == ']') && !reader->in_array) return GRPC_JSON_PARSE_ERROR; |
||||
if ((c == ']') && |
||||
(reader->state == GRPC_JSON_STATE_VALUE_BEGIN) && |
||||
!reader->container_just_begun) { |
||||
return GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
reader->state = GRPC_JSON_STATE_VALUE_END; |
||||
switch (grpc_json_reader_container_ends(reader)) { |
||||
case GRPC_JSON_OBJECT: |
||||
reader->in_object = 1; |
||||
reader->in_array = 0; |
||||
break; |
||||
case GRPC_JSON_ARRAY: |
||||
reader->in_object = 0; |
||||
reader->in_array = 1; |
||||
break; |
||||
case GRPC_JSON_NONE: |
||||
if (reader->depth != 0) return GRPC_JSON_INTERNAL_ERROR; |
||||
reader->in_object = 0; |
||||
reader->in_array = 0; |
||||
reader->state = GRPC_JSON_STATE_END; |
||||
break; |
||||
default: |
||||
return GRPC_JSON_INTERNAL_ERROR; |
||||
} |
||||
} |
||||
break; |
||||
|
||||
default: |
||||
return GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
/* In-string escaping. */ |
||||
case '\\': |
||||
switch (reader->state) { |
||||
case GRPC_JSON_STATE_OBJECT_KEY_STRING: |
||||
reader->escaped_string_was_key = 1; |
||||
reader->state = GRPC_JSON_STATE_STRING_ESCAPE; |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_VALUE_STRING: |
||||
reader->escaped_string_was_key = 0; |
||||
reader->state = GRPC_JSON_STATE_STRING_ESCAPE; |
||||
break; |
||||
|
||||
/* This is the \\ case. */ |
||||
case GRPC_JSON_STATE_STRING_ESCAPE: |
||||
grpc_json_reader_string_add_char(reader, '\\'); |
||||
if (reader->escaped_string_was_key) { |
||||
reader->state = GRPC_JSON_STATE_OBJECT_KEY_STRING; |
||||
} else { |
||||
reader->state = GRPC_JSON_STATE_VALUE_STRING; |
||||
} |
||||
break; |
||||
|
||||
default: |
||||
return GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
default: |
||||
reader->container_just_begun = 0; |
||||
switch (reader->state) { |
||||
case GRPC_JSON_STATE_OBJECT_KEY_BEGIN: |
||||
if (c != '"') return GRPC_JSON_PARSE_ERROR; |
||||
reader->state = GRPC_JSON_STATE_OBJECT_KEY_STRING; |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_OBJECT_KEY_STRING: |
||||
if (c == '"') { |
||||
reader->state = GRPC_JSON_STATE_OBJECT_KEY_END; |
||||
grpc_json_reader_object_set_key(reader); |
||||
grpc_json_reader_string_clear(reader); |
||||
} else { |
||||
grpc_json_reader_string_add_char(reader, c); |
||||
} |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_VALUE_STRING: |
||||
if (c == '"') { |
||||
reader->state = GRPC_JSON_STATE_VALUE_END; |
||||
grpc_json_reader_container_set_string(reader); |
||||
grpc_json_reader_string_clear(reader); |
||||
} else { |
||||
grpc_json_reader_string_add_char(reader, c); |
||||
} |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_OBJECT_KEY_END: |
||||
if (c != ':') return GRPC_JSON_PARSE_ERROR; |
||||
reader->state = GRPC_JSON_STATE_VALUE_BEGIN; |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_VALUE_BEGIN: |
||||
switch (c) { |
||||
case 't': |
||||
reader->state = GRPC_JSON_STATE_VALUE_TRUE_R; |
||||
break; |
||||
|
||||
case 'f': |
||||
reader->state = GRPC_JSON_STATE_VALUE_FALSE_A; |
||||
break; |
||||
|
||||
case 'n': |
||||
reader->state = GRPC_JSON_STATE_VALUE_NULL_U; |
||||
break; |
||||
|
||||
case '"': |
||||
reader->state = GRPC_JSON_STATE_VALUE_STRING; |
||||
break; |
||||
|
||||
case '0': |
||||
reader->state = GRPC_JSON_STATE_VALUE_NUMBER_ZERO; |
||||
break; |
||||
|
||||
case '1': |
||||
case '2': |
||||
case '3': |
||||
case '4': |
||||
case '5': |
||||
case '6': |
||||
case '7': |
||||
case '8': |
||||
case '9': |
||||
case '-': |
||||
grpc_json_reader_string_add_char(reader, c); |
||||
reader->state = GRPC_JSON_STATE_VALUE_NUMBER; |
||||
break; |
||||
|
||||
case '{': |
||||
reader->container_just_begun = 1; |
||||
grpc_json_reader_container_begins(reader, GRPC_JSON_OBJECT); |
||||
reader->depth++; |
||||
reader->state = GRPC_JSON_STATE_OBJECT_KEY_BEGIN; |
||||
reader->in_object = 1; |
||||
reader->in_array = 0; |
||||
break; |
||||
|
||||
case '[': |
||||
reader->container_just_begun = 1; |
||||
grpc_json_reader_container_begins(reader, GRPC_JSON_ARRAY); |
||||
reader->depth++; |
||||
reader->in_object = 0; |
||||
reader->in_array = 1; |
||||
break; |
||||
} |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_STRING_ESCAPE: |
||||
if (reader->escaped_string_was_key) { |
||||
reader->state = GRPC_JSON_STATE_OBJECT_KEY_STRING; |
||||
} else { |
||||
reader->state = GRPC_JSON_STATE_VALUE_STRING; |
||||
} |
||||
switch (c) { |
||||
case '"': |
||||
case '/': |
||||
grpc_json_reader_string_add_char(reader, c); |
||||
break; |
||||
case 'b': |
||||
grpc_json_reader_string_add_char(reader, '\b'); |
||||
break; |
||||
case 'f': |
||||
grpc_json_reader_string_add_char(reader, '\f'); |
||||
break; |
||||
case 'n': |
||||
grpc_json_reader_string_add_char(reader, '\n'); |
||||
break; |
||||
case 'r': |
||||
grpc_json_reader_string_add_char(reader, '\r'); |
||||
break; |
||||
case 't': |
||||
grpc_json_reader_string_add_char(reader, '\t'); |
||||
break; |
||||
case 'u': |
||||
reader->state = GRPC_JSON_STATE_STRING_ESCAPE_U1; |
||||
reader->unicode = 0; |
||||
break; |
||||
default: |
||||
return GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_STRING_ESCAPE_U1: |
||||
case GRPC_JSON_STATE_STRING_ESCAPE_U2: |
||||
case GRPC_JSON_STATE_STRING_ESCAPE_U3: |
||||
case GRPC_JSON_STATE_STRING_ESCAPE_U4: |
||||
if ((c >= '0') && (c <= '9')) { |
||||
c -= '0'; |
||||
} else if ((c >= 'A') && (c <= 'F')) { |
||||
c -= 'A' - 10; |
||||
} else if ((c >= 'a') && (c <= 'f')) { |
||||
c -= 'a' - 10; |
||||
} else { |
||||
return GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
reader->unicode <<= 4; |
||||
reader->unicode |= c; |
||||
|
||||
switch (reader->state) { |
||||
case GRPC_JSON_STATE_STRING_ESCAPE_U1: |
||||
reader->state = GRPC_JSON_STATE_STRING_ESCAPE_U2; |
||||
break; |
||||
case GRPC_JSON_STATE_STRING_ESCAPE_U2: |
||||
reader->state = GRPC_JSON_STATE_STRING_ESCAPE_U3; |
||||
break; |
||||
case GRPC_JSON_STATE_STRING_ESCAPE_U3: |
||||
reader->state = GRPC_JSON_STATE_STRING_ESCAPE_U4; |
||||
break; |
||||
case GRPC_JSON_STATE_STRING_ESCAPE_U4: |
||||
grpc_json_reader_string_add_wchar(reader, reader->unicode); |
||||
if (reader->escaped_string_was_key) { |
||||
reader->state = GRPC_JSON_STATE_OBJECT_KEY_STRING; |
||||
} else { |
||||
reader->state = GRPC_JSON_STATE_VALUE_STRING; |
||||
} |
||||
break; |
||||
default: |
||||
return GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_VALUE_NUMBER: |
||||
grpc_json_reader_string_add_char(reader, c); |
||||
switch (c) { |
||||
case '0': |
||||
case '1': |
||||
case '2': |
||||
case '3': |
||||
case '4': |
||||
case '5': |
||||
case '6': |
||||
case '7': |
||||
case '8': |
||||
case '9': |
||||
break; |
||||
case '.': |
||||
reader->state = GRPC_JSON_STATE_VALUE_NUMBER_DOT; |
||||
break; |
||||
default: |
||||
return GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL: |
||||
grpc_json_reader_string_add_char(reader, c); |
||||
switch (c) { |
||||
case '0': |
||||
case '1': |
||||
case '2': |
||||
case '3': |
||||
case '4': |
||||
case '5': |
||||
case '6': |
||||
case '7': |
||||
case '8': |
||||
case '9': |
||||
break; |
||||
case 'e': |
||||
case 'E': |
||||
reader->state = GRPC_JSON_STATE_VALUE_NUMBER_E; |
||||
break; |
||||
default: |
||||
return GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_VALUE_NUMBER_ZERO: |
||||
if (c != '.') return GRPC_JSON_PARSE_ERROR; |
||||
grpc_json_reader_string_add_char(reader, c); |
||||
reader->state = GRPC_JSON_STATE_VALUE_NUMBER_DOT; |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_VALUE_NUMBER_DOT: |
||||
grpc_json_reader_string_add_char(reader, c); |
||||
switch (c) { |
||||
case '0': |
||||
case '1': |
||||
case '2': |
||||
case '3': |
||||
case '4': |
||||
case '5': |
||||
case '6': |
||||
case '7': |
||||
case '8': |
||||
case '9': |
||||
reader->state = GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL; |
||||
break; |
||||
default: |
||||
return GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_VALUE_NUMBER_E: |
||||
grpc_json_reader_string_add_char(reader, c); |
||||
switch (c) { |
||||
case '0': |
||||
case '1': |
||||
case '2': |
||||
case '3': |
||||
case '4': |
||||
case '5': |
||||
case '6': |
||||
case '7': |
||||
case '8': |
||||
case '9': |
||||
case '+': |
||||
case '-': |
||||
reader->state = GRPC_JSON_STATE_VALUE_NUMBER_EPM; |
||||
break; |
||||
default: |
||||
return GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
|
||||
case GRPC_JSON_STATE_VALUE_NUMBER_EPM: |
||||
grpc_json_reader_string_add_char(reader, c); |
||||
switch (c) { |
||||
case '0': |
||||
case '1': |
||||
case '2': |
||||
case '3': |
||||
case '4': |
||||
case '5': |
||||
case '6': |
||||
case '7': |
||||
case '8': |
||||
case '9': |
||||
break; |
||||
default: |
||||
return GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
|
||||
case GRPC_JSON_STATE_VALUE_TRUE_R: |
||||
if (c != 'r') return GRPC_JSON_PARSE_ERROR; |
||||
reader->state = GRPC_JSON_STATE_VALUE_TRUE_U; |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_VALUE_TRUE_U: |
||||
if (c != 'u') return GRPC_JSON_PARSE_ERROR; |
||||
reader->state = GRPC_JSON_STATE_VALUE_TRUE_E; |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_VALUE_TRUE_E: |
||||
if (c != 'e') return GRPC_JSON_PARSE_ERROR; |
||||
grpc_json_reader_container_set_true(reader); |
||||
reader->state = GRPC_JSON_STATE_VALUE_END; |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_VALUE_FALSE_A: |
||||
if (c != 'a') return GRPC_JSON_PARSE_ERROR; |
||||
reader->state = GRPC_JSON_STATE_VALUE_FALSE_L; |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_VALUE_FALSE_L: |
||||
if (c != 'l') return GRPC_JSON_PARSE_ERROR; |
||||
reader->state = GRPC_JSON_STATE_VALUE_FALSE_S; |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_VALUE_FALSE_S: |
||||
if (c != 's') return GRPC_JSON_PARSE_ERROR; |
||||
reader->state = GRPC_JSON_STATE_VALUE_FALSE_E; |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_VALUE_FALSE_E: |
||||
if (c != 'e') return GRPC_JSON_PARSE_ERROR; |
||||
grpc_json_reader_container_set_false(reader); |
||||
reader->state = GRPC_JSON_STATE_VALUE_END; |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_VALUE_NULL_U: |
||||
if (c != 'u') return GRPC_JSON_PARSE_ERROR; |
||||
reader->state = GRPC_JSON_STATE_VALUE_NULL_L1; |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_VALUE_NULL_L1: |
||||
if (c != 'l') return GRPC_JSON_PARSE_ERROR; |
||||
reader->state = GRPC_JSON_STATE_VALUE_NULL_L2; |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_VALUE_NULL_L2: |
||||
if (c != 'l') return GRPC_JSON_PARSE_ERROR; |
||||
grpc_json_reader_container_set_null(reader); |
||||
reader->state = GRPC_JSON_STATE_VALUE_END; |
||||
break; |
||||
|
||||
/* All of the VALUE_END cases are handled in the specialized case
|
||||
* above. */ |
||||
case GRPC_JSON_STATE_VALUE_END: |
||||
switch (c) { |
||||
case ',': |
||||
case '}': |
||||
case ']': |
||||
return GRPC_JSON_INTERNAL_ERROR; |
||||
break; |
||||
|
||||
default: |
||||
return GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
case GRPC_JSON_STATE_END: |
||||
return GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
} |
||||
} |
||||
|
||||
return GRPC_JSON_INTERNAL_ERROR; |
||||
} |
||||
@ -0,0 +1,378 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2014, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include <string.h> |
||||
|
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
|
||||
#include "src/core/json/json.h" |
||||
|
||||
/* This json-writer will put everything in a big string.
|
||||
* The point is that we allocate that string in chunks of 256 bytes. |
||||
*/ |
||||
typedef struct { |
||||
char *output; |
||||
size_t free_space, string_len, allocated; |
||||
} grpc_json_writer_opaque_t; |
||||
|
||||
#include "src/core/json/json-writer-defs.h" |
||||
|
||||
/* The json-reader will construct a bunch of grpc_json objects and
|
||||
* link them all up together in a tree-like structure that will represent |
||||
* the json data in memory. |
||||
* |
||||
* It also uses its own input as a scratchpad to store all of the decoded, |
||||
* unescaped strings. So we need to keep track of all these pointers in |
||||
* that opaque structure the reader will carry for us. |
||||
* |
||||
* Note that this works because the act of parsing json always reduces its |
||||
* input size, and never expands it. |
||||
*/ |
||||
typedef struct { |
||||
grpc_json *top; |
||||
grpc_json *current_container; |
||||
grpc_json *current_value; |
||||
char *input; |
||||
char *key; |
||||
char *string; |
||||
char *string_ptr; |
||||
size_t remaining_input; |
||||
} grpc_json_reader_opaque_t; |
||||
|
||||
typedef unsigned grpc_json_wchar_t; |
||||
|
||||
#include "src/core/json/json-reader-defs.h" |
||||
|
||||
/* Next up, the definitions needed for the implementation. */ |
||||
#define grpc_json_static_inline static |
||||
#define grpc_json_eof -1 |
||||
#define grpc_json_eagain -2 |
||||
#define grpc_json_error -3 |
||||
|
||||
/* This functions checks if there's enough space left in the output buffer,
|
||||
* and will enlarge it if necessary. We're only allocating chunks of 256 |
||||
* bytes at a time (or multiples thereof). |
||||
*/ |
||||
static void grpc_json_writer_output_check(struct grpc_json_writer_t *writer, |
||||
size_t needed) { |
||||
if (writer->opaque.free_space >= needed) return; |
||||
needed = (needed - writer->opaque.free_space + 0xff) & ~0xff; |
||||
writer->opaque.output = (char *)gpr_realloc( |
||||
writer->opaque.output, writer->opaque.allocated + needed); |
||||
writer->opaque.free_space += needed; |
||||
writer->opaque.allocated += needed; |
||||
} |
||||
|
||||
/* These are needed by the writer's implementation. */ |
||||
static void grpc_json_writer_output_char(struct grpc_json_writer_t *writer, |
||||
char c) { |
||||
grpc_json_writer_output_check(writer, 1); |
||||
writer->opaque.output[writer->opaque.string_len++] = c; |
||||
writer->opaque.free_space--; |
||||
} |
||||
|
||||
static void grpc_json_writer_output_string_with_len( |
||||
struct grpc_json_writer_t *writer, const char *str, size_t len) { |
||||
grpc_json_writer_output_check(writer, len); |
||||
memcpy(writer->opaque.output + writer->opaque.string_len, str, len); |
||||
writer->opaque.string_len += len; |
||||
writer->opaque.free_space -= len; |
||||
} |
||||
|
||||
static void grpc_json_writer_output_string(struct grpc_json_writer_t *writer, |
||||
const char *str) { |
||||
size_t len = strlen(str); |
||||
grpc_json_writer_output_string_with_len(writer, str, len); |
||||
} |
||||
|
||||
#include "src/core/json/json-writer-impl.h" |
||||
|
||||
/* The reader asks us to clear our scratchpad. In our case, we'll simply mark
|
||||
* the end of the current string, and advance our output pointer. |
||||
*/ |
||||
static void grpc_json_reader_string_clear(struct grpc_json_reader_t *reader) { |
||||
if (reader->opaque.string) { |
||||
GPR_ASSERT(reader->opaque.string_ptr < reader->opaque.input); |
||||
*reader->opaque.string_ptr++ = 0; |
||||
} |
||||
reader->opaque.string = reader->opaque.string_ptr; |
||||
} |
||||
|
||||
static void grpc_json_reader_string_add_char(struct grpc_json_reader_t *reader, |
||||
int c) { |
||||
GPR_ASSERT(reader->opaque.string_ptr < reader->opaque.input); |
||||
*reader->opaque.string_ptr++ = (char)c; |
||||
} |
||||
|
||||
/* We are converting a unicode character into utf-8 here. */ |
||||
/* The unicode escape encoding of json can only hold 16-bits values.
|
||||
* So the the 4th case, as well as the last test aren't techically |
||||
* necessary, but I wrote them anyway for completion. |
||||
*/ |
||||
static void grpc_json_reader_string_add_wchar(struct grpc_json_reader_t *reader, |
||||
unsigned int c) { |
||||
if (c <= 0x7f) { |
||||
grpc_json_reader_string_add_char(reader, c); |
||||
} else if (c <= 0x7ff) { |
||||
int b1 = 0xc0 | ((c >> 6) & 0x1f); |
||||
int b2 = 0x80 | (c & 0x3f); |
||||
grpc_json_reader_string_add_char(reader, b1); |
||||
grpc_json_reader_string_add_char(reader, b2); |
||||
} else if (c <= 0xffff) { |
||||
int b1 = 0xe0 | ((c >> 12) & 0x0f); |
||||
int b2 = 0x80 | ((c >> 6) & 0x3f); |
||||
int b3 = 0x80 | (c & 0x3f); |
||||
grpc_json_reader_string_add_char(reader, b1); |
||||
grpc_json_reader_string_add_char(reader, b2); |
||||
grpc_json_reader_string_add_char(reader, b3); |
||||
} else if (c <= 0x1fffff) { |
||||
int b1 = 0xf0 | ((c >> 18) & 0x07); |
||||
int b2 = 0x80 | ((c >> 12) & 0x3f); |
||||
int b3 = 0x80 | ((c >> 6) & 0x3f); |
||||
int b4 = 0x80 | (c & 0x3f); |
||||
grpc_json_reader_string_add_char(reader, b1); |
||||
grpc_json_reader_string_add_char(reader, b2); |
||||
grpc_json_reader_string_add_char(reader, b3); |
||||
grpc_json_reader_string_add_char(reader, b4); |
||||
} |
||||
} |
||||
|
||||
/* We consider that the input may be a zero-terminated string. So we
|
||||
* can end up hitting eof before the end of the alleged string length. |
||||
*/ |
||||
static int grpc_json_reader_read_char(struct grpc_json_reader_t *reader) { |
||||
int r; |
||||
|
||||
if (reader->opaque.remaining_input == 0) { |
||||
return grpc_json_eof; |
||||
} |
||||
|
||||
r = *reader->opaque.input++; |
||||
reader->opaque.remaining_input--; |
||||
|
||||
if (r == 0) { |
||||
reader->opaque.remaining_input = 0; |
||||
return grpc_json_eof; |
||||
} |
||||
|
||||
return r; |
||||
} |
||||
|
||||
/* Helper function to create a new grpc_json object and link it into
|
||||
* our tree-in-progress inside our opaque structure. |
||||
*/ |
||||
static grpc_json *grpc_json_new_and_link(struct grpc_json_reader_t *reader, |
||||
enum grpc_json_type_t type) { |
||||
grpc_json *json = grpc_json_new(type); |
||||
|
||||
json->parent = reader->opaque.current_container; |
||||
json->prev = reader->opaque.current_value; |
||||
reader->opaque.current_value = json; |
||||
|
||||
if (json->prev) { |
||||
json->prev->next = json; |
||||
} |
||||
if (json->parent) { |
||||
if (!json->parent->child) { |
||||
json->parent->child = json; |
||||
} |
||||
if (json->parent->type == GRPC_JSON_OBJECT) { |
||||
json->key = reader->opaque.key; |
||||
} |
||||
} |
||||
if (!reader->opaque.top) { |
||||
reader->opaque.top = json; |
||||
} |
||||
|
||||
return json; |
||||
} |
||||
|
||||
static void grpc_json_reader_container_begins(struct grpc_json_reader_t *reader, |
||||
enum grpc_json_type_t type) { |
||||
grpc_json *container; |
||||
|
||||
GPR_ASSERT(type == GRPC_JSON_ARRAY || type == GRPC_JSON_OBJECT); |
||||
|
||||
container = grpc_json_new_and_link(reader, type); |
||||
reader->opaque.current_container = container; |
||||
reader->opaque.current_value = NULL; |
||||
} |
||||
|
||||
/* It's important to remember that the reader is mostly state-less, so it
|
||||
* isn't trying to remember what was the container prior the one that just |
||||
* ends. Since we're keeping track of these for our own purpose, we are |
||||
* able to return that information back, which is useful for it to validate |
||||
* the input json stream. |
||||
* |
||||
* Also note that if we're at the top of the tree, and the last container |
||||
* ends, we have to return GRPC_JSON_NONE. |
||||
*/ |
||||
static enum grpc_json_type_t grpc_json_reader_container_ends( |
||||
struct grpc_json_reader_t *reader) { |
||||
enum grpc_json_type_t container_type = GRPC_JSON_NONE; |
||||
|
||||
GPR_ASSERT(reader->opaque.current_container); |
||||
|
||||
reader->opaque.current_value = reader->opaque.current_container; |
||||
reader->opaque.current_container = reader->opaque.current_container->parent; |
||||
|
||||
if (reader->opaque.current_container) { |
||||
container_type = reader->opaque.current_container->type; |
||||
} |
||||
|
||||
return container_type; |
||||
} |
||||
|
||||
/* The next 3 functions basically are the reader asking us to use our string
|
||||
* scratchpad for one of these 3 purposes. |
||||
* |
||||
* Note that in the set_number case, we're not going to try interpreting it. |
||||
* We'll keep it as a string, and leave it to the caller to evaluate it. |
||||
*/ |
||||
static void grpc_json_reader_object_set_key(struct grpc_json_reader_t *reader) { |
||||
reader->opaque.key = reader->opaque.string; |
||||
} |
||||
|
||||
static void grpc_json_reader_container_set_string( |
||||
struct grpc_json_reader_t *reader) { |
||||
grpc_json *json = grpc_json_new_and_link(reader, GRPC_JSON_STRING); |
||||
json->value = reader->opaque.string; |
||||
} |
||||
|
||||
static int grpc_json_reader_container_set_number( |
||||
struct grpc_json_reader_t *reader) { |
||||
grpc_json *json = grpc_json_new_and_link(reader, GRPC_JSON_NUMBER); |
||||
json->value = reader->opaque.string; |
||||
return 1; |
||||
} |
||||
|
||||
/* The object types true, false and null are self-sufficient, and don't need
|
||||
* any more information beside their type. |
||||
*/ |
||||
static void grpc_json_reader_container_set_true( |
||||
struct grpc_json_reader_t *reader) { |
||||
grpc_json_new_and_link(reader, GRPC_JSON_TRUE); |
||||
} |
||||
|
||||
static void grpc_json_reader_container_set_false( |
||||
struct grpc_json_reader_t *reader) { |
||||
grpc_json_new_and_link(reader, GRPC_JSON_FALSE); |
||||
} |
||||
|
||||
static void grpc_json_reader_container_set_null( |
||||
struct grpc_json_reader_t *reader) { |
||||
grpc_json_new_and_link(reader, GRPC_JSON_NULL); |
||||
} |
||||
|
||||
/* Now that we've defined all that's needed for the parser's implementation,
|
||||
* let's include its file. */ |
||||
#include "json-reader-impl.h" |
||||
|
||||
/* And finally, let's define our public API. */ |
||||
grpc_json *grpc_json_parse_string_with_len(char *input, size_t size) { |
||||
struct grpc_json_reader_t reader; |
||||
grpc_json *json = NULL; |
||||
grpc_json_reader_ret_t status; |
||||
|
||||
if (!input) return NULL; |
||||
|
||||
reader.opaque.top = reader.opaque.current_container = |
||||
reader.opaque.current_value = NULL; |
||||
reader.opaque.string = reader.opaque.key = NULL; |
||||
reader.opaque.string_ptr = reader.opaque.input = input; |
||||
reader.opaque.remaining_input = size; |
||||
grpc_json_reader_init(&reader); |
||||
|
||||
status = grpc_json_reader_run(&reader); |
||||
json = reader.opaque.top; |
||||
|
||||
if ((status != GRPC_JSON_DONE) && json) { |
||||
grpc_json_delete(json); |
||||
json = NULL; |
||||
} |
||||
|
||||
return json; |
||||
} |
||||
|
||||
grpc_json *grpc_json_parse_string(char *input) { |
||||
return grpc_json_parse_string_with_len(input, 0x7fffffff); |
||||
} |
||||
|
||||
static void grpc_json_dump_recursive(struct grpc_json_writer_t *writer, |
||||
grpc_json *json, int in_object) { |
||||
while (json) { |
||||
if (in_object) grpc_json_writer_object_key(writer, json->key); |
||||
|
||||
switch (json->type) { |
||||
case GRPC_JSON_OBJECT: |
||||
case GRPC_JSON_ARRAY: |
||||
grpc_json_writer_container_begins(writer, json->type); |
||||
if (json->child) |
||||
grpc_json_dump_recursive(writer, json->child, |
||||
json->type == GRPC_JSON_OBJECT); |
||||
grpc_json_writer_container_ends(writer, json->type); |
||||
break; |
||||
case GRPC_JSON_STRING: |
||||
grpc_json_writer_value_string(writer, json->value); |
||||
break; |
||||
case GRPC_JSON_NUMBER: |
||||
grpc_json_writer_value_raw(writer, json->value); |
||||
break; |
||||
case GRPC_JSON_TRUE: |
||||
grpc_json_writer_value_raw_with_len(writer, "true", 4); |
||||
break; |
||||
case GRPC_JSON_FALSE: |
||||
grpc_json_writer_value_raw_with_len(writer, "false", 5); |
||||
break; |
||||
case GRPC_JSON_NULL: |
||||
grpc_json_writer_value_raw_with_len(writer, "null", 4); |
||||
break; |
||||
default: |
||||
abort(); |
||||
} |
||||
json = json->next; |
||||
} |
||||
} |
||||
|
||||
char *grpc_json_dump_to_string(grpc_json *json, int indent) { |
||||
struct grpc_json_writer_t writer; |
||||
writer.opaque.output = NULL; |
||||
writer.opaque.free_space = writer.opaque.string_len = |
||||
writer.opaque.allocated = 0; |
||||
grpc_json_writer_init(&writer, indent); |
||||
grpc_json_dump_recursive(&writer, json, 0); |
||||
grpc_json_writer_output_char(&writer, 0); |
||||
|
||||
return writer.opaque.output; |
||||
} |
||||
@ -0,0 +1,46 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2014, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
/* the following need to be pre-defined:
|
||||
* grpc_json_writer_opaque_t // A type you can use to keep track of your
|
||||
* // own stuff.
|
||||
*/ |
||||
|
||||
struct grpc_json_writer_t { |
||||
grpc_json_writer_opaque_t opaque; |
||||
|
||||
int indent; |
||||
int depth; |
||||
int container_empty; |
||||
int got_key; |
||||
}; |
||||
@ -0,0 +1,233 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2014, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
|
||||
/* The idea of the writer is basically symmetrical of the reader. While the
|
||||
* reader emits various calls to your code, the writer takes basically the |
||||
* same calls and emit json out of it. It doesn't try to make any check on |
||||
* the order of the calls you do on it. |
||||
* |
||||
* Also, unlike the reader, the writer expects UTF-8 encoded input strings. |
||||
* |
||||
* The following need to be defined: |
||||
* |
||||
* // Adds a character to the output stream.
|
||||
* void grpc_json_writer_output_char(struct grpc_json_writer_t *, char); |
||||
* // Adds a zero-terminated string to the output stream.
|
||||
* void grpc_json_writer_output_string( |
||||
* struct grpc_json_writer_t *writer, const char *str); |
||||
* // Adds a fixed-length string to the output stream.
|
||||
* void grpc_json_writer_output_string_with_len( |
||||
* struct grpc_json_writer_t *writer, const char *str, size_t len); |
||||
|
||||
*/ |
||||
|
||||
/* Call this function to initialize the writer structure. */ |
||||
grpc_json_static_inline void grpc_json_writer_init( |
||||
struct grpc_json_writer_t* writer, int indent) { |
||||
writer->depth = 0; |
||||
writer->container_empty = 1; |
||||
writer->got_key = 0; |
||||
writer->indent = indent; |
||||
} |
||||
|
||||
/* This function is fully private. */ |
||||
grpc_json_static_inline void grpc_json_writer_output_indent( |
||||
struct grpc_json_writer_t* writer) { |
||||
static const char spacesstr[] = |
||||
" " |
||||
" " |
||||
" " |
||||
" "; |
||||
|
||||
int spaces = writer->depth * writer->indent; |
||||
|
||||
if (writer->got_key) { |
||||
grpc_json_writer_output_char(writer, ' '); |
||||
return; |
||||
} |
||||
|
||||
while (spaces >= (sizeof(spacesstr) - 1)) { |
||||
grpc_json_writer_output_string_with_len(writer, spacesstr, |
||||
sizeof(spacesstr) - 1); |
||||
spaces -= (sizeof(spacesstr) - 1); |
||||
} |
||||
|
||||
if (!spaces) return; |
||||
|
||||
grpc_json_writer_output_string_with_len( |
||||
writer, spacesstr + sizeof(spacesstr) - 1 - spaces, spaces); |
||||
} |
||||
|
||||
/* This function is fully private. */ |
||||
grpc_json_static_inline void grpc_json_writer_value_end( |
||||
struct grpc_json_writer_t* writer) { |
||||
if (writer->container_empty) { |
||||
writer->container_empty = 0; |
||||
if (!writer->indent || !writer->depth) return; |
||||
grpc_json_writer_output_char(writer, '\n'); |
||||
} else { |
||||
grpc_json_writer_output_char(writer, ','); |
||||
if (!writer->indent) return; |
||||
grpc_json_writer_output_char(writer, '\n'); |
||||
} |
||||
} |
||||
|
||||
/* This function is fully private. */ |
||||
grpc_json_static_inline void grpc_json_writer_escape_string( |
||||
struct grpc_json_writer_t* writer, const char* string) { |
||||
static const char hex[] = "0123456789abcdef"; |
||||
grpc_json_writer_output_char(writer, '"'); |
||||
|
||||
for (;;) { |
||||
unsigned char c = (unsigned char)*string++; |
||||
if (!c) { |
||||
break; |
||||
} else if ((c >= 32) && (c <= 127)) { |
||||
if ((c == '\\') || (c == '"')) grpc_json_writer_output_char(writer, '\\'); |
||||
grpc_json_writer_output_char(writer, c); |
||||
} else if (c < 32) { |
||||
grpc_json_writer_output_char(writer, '\\'); |
||||
switch (c) { |
||||
case '\b': |
||||
grpc_json_writer_output_char(writer, 'b'); |
||||
break; |
||||
case '\f': |
||||
grpc_json_writer_output_char(writer, 'f'); |
||||
break; |
||||
case '\n': |
||||
grpc_json_writer_output_char(writer, 'n'); |
||||
break; |
||||
case '\r': |
||||
grpc_json_writer_output_char(writer, 'r'); |
||||
break; |
||||
case '\t': |
||||
grpc_json_writer_output_char(writer, 't'); |
||||
break; |
||||
default: |
||||
grpc_json_writer_output_string_with_len(writer, "u00", 3); |
||||
grpc_json_writer_output_char(writer, c >= 16 ? '1' : '0'); |
||||
grpc_json_writer_output_char(writer, hex[c & 15]); |
||||
break; |
||||
} |
||||
} else { |
||||
unsigned unicode = 0; |
||||
if ((c & 0xe0) == 0xc0) { |
||||
unicode = c & 0x1f; |
||||
unicode <<= 6; |
||||
c = *string++; |
||||
if ((c & 0xc0) != 0x80) break; |
||||
unicode |= c & 0x3f; |
||||
} else if ((c & 0xf0) == 0xe0) { |
||||
unicode = c & 0x0f; |
||||
unicode <<= 6; |
||||
c = *string++; |
||||
if ((c & 0xc0) != 0x80) break; |
||||
unicode |= c & 0x3f; |
||||
unicode <<= 6; |
||||
c = *string++; |
||||
if ((c & 0xc0) != 0x80) break; |
||||
unicode |= c & 0x3f; |
||||
} else { |
||||
break; |
||||
} |
||||
grpc_json_writer_output_string_with_len(writer, "\\u", 2); |
||||
grpc_json_writer_output_char(writer, hex[(unicode >> 12) & 0x0f]); |
||||
grpc_json_writer_output_char(writer, hex[(unicode >> 8) & 0x0f]); |
||||
grpc_json_writer_output_char(writer, hex[(unicode >> 4) & 0x0f]); |
||||
grpc_json_writer_output_char(writer, hex[(unicode) & 0x0f]); |
||||
} |
||||
} |
||||
|
||||
grpc_json_writer_output_char(writer, '"'); |
||||
} |
||||
|
||||
/* Call that function to start a new json container. */ |
||||
grpc_json_static_inline void grpc_json_writer_container_begins( |
||||
struct grpc_json_writer_t* writer, enum grpc_json_type_t type) { |
||||
if (!writer->got_key) grpc_json_writer_value_end(writer); |
||||
grpc_json_writer_output_indent(writer); |
||||
grpc_json_writer_output_char(writer, type == GRPC_JSON_OBJECT ? '{' : '['); |
||||
writer->container_empty = 1; |
||||
writer->got_key = 0; |
||||
writer->depth++; |
||||
} |
||||
|
||||
/* Call that function to end the current json container. */ |
||||
grpc_json_static_inline void grpc_json_writer_container_ends( |
||||
struct grpc_json_writer_t* writer, enum grpc_json_type_t type) { |
||||
if (writer->indent && !writer->container_empty) |
||||
grpc_json_writer_output_char(writer, '\n'); |
||||
writer->depth--; |
||||
if (!writer->container_empty) grpc_json_writer_output_indent(writer); |
||||
grpc_json_writer_output_char(writer, type == GRPC_JSON_OBJECT ? '}' : ']'); |
||||
writer->container_empty = 0; |
||||
writer->got_key = 0; |
||||
} |
||||
|
||||
/* If you are in a GRPC_JSON_OBJECT container, call this to set up a key. */ |
||||
grpc_json_static_inline void grpc_json_writer_object_key( |
||||
struct grpc_json_writer_t* writer, const char* string) { |
||||
grpc_json_writer_value_end(writer); |
||||
grpc_json_writer_output_indent(writer); |
||||
grpc_json_writer_escape_string(writer, string); |
||||
grpc_json_writer_output_char(writer, ':'); |
||||
writer->got_key = 1; |
||||
} |
||||
|
||||
/* Sets a raw value - use it for numbers. */ |
||||
grpc_json_static_inline void grpc_json_writer_value_raw( |
||||
struct grpc_json_writer_t* writer, const char* string) { |
||||
if (!writer->got_key) grpc_json_writer_value_end(writer); |
||||
grpc_json_writer_output_indent(writer); |
||||
grpc_json_writer_output_string(writer, string); |
||||
writer->got_key = 0; |
||||
} |
||||
|
||||
/* Sets a raw value with a known length - use it for true, false and null. */ |
||||
grpc_json_static_inline void grpc_json_writer_value_raw_with_len( |
||||
struct grpc_json_writer_t* writer, const char* string, unsigned len) { |
||||
if (!writer->got_key) grpc_json_writer_value_end(writer); |
||||
grpc_json_writer_output_indent(writer); |
||||
grpc_json_writer_output_string_with_len(writer, string, len); |
||||
writer->got_key = 0; |
||||
} |
||||
|
||||
/* Outputs a string value. This will add double quotes, and escape it. */ |
||||
grpc_json_static_inline void grpc_json_writer_value_string( |
||||
struct grpc_json_writer_t* writer, const char* string) { |
||||
if (!writer->got_key) grpc_json_writer_value_end(writer); |
||||
grpc_json_writer_output_indent(writer); |
||||
grpc_json_writer_escape_string(writer, string); |
||||
writer->got_key = 0; |
||||
} |
||||
@ -0,0 +1,64 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2014, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#include <grpc/support/alloc.h> |
||||
|
||||
#include "src/core/json/json.h" |
||||
|
||||
grpc_json *grpc_json_new(enum grpc_json_type_t type) { |
||||
grpc_json *json = (grpc_json *)gpr_malloc(sizeof(grpc_json)); |
||||
json->parent = json->child = json->next = json->prev = NULL; |
||||
json->type = type; |
||||
|
||||
json->value = json->key = NULL; |
||||
|
||||
return json; |
||||
} |
||||
|
||||
void grpc_json_delete(grpc_json *json) { |
||||
while (json->child) { |
||||
grpc_json_delete(json->child); |
||||
} |
||||
|
||||
if (json->next) { |
||||
json->next->prev = json->prev; |
||||
} |
||||
|
||||
if (json->prev) { |
||||
json->prev->next = json->next; |
||||
} else if (json->parent) { |
||||
json->parent->child = json->next; |
||||
} |
||||
|
||||
gpr_free(json); |
||||
} |
||||
@ -0,0 +1,78 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2014, Google Inc. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are |
||||
* met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* * Redistributions in binary form must reproduce the above |
||||
* copyright notice, this list of conditions and the following disclaimer |
||||
* in the documentation and/or other materials provided with the |
||||
* distribution. |
||||
* * Neither the name of Google Inc. nor the names of its |
||||
* contributors may be used to endorse or promote products derived from |
||||
* this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef __GRPC_SRC_CORE_JSON_JSON_H__ |
||||
#define __GRPC_SRC_CORE_JSON_JSON_H__ |
||||
|
||||
#include <stdlib.h> |
||||
|
||||
#include "src/core/json/json-defs.h" |
||||
|
||||
typedef struct grpc_json_t { |
||||
struct grpc_json_t* next, *prev, *child, *parent; |
||||
enum grpc_json_type_t type; |
||||
|
||||
const char* key; |
||||
const char* value; |
||||
} grpc_json; |
||||
|
||||
/* The next two functions are going to parse the input string, and
|
||||
* destroy it in the process, in order to use its space to store |
||||
* all of the keys and values for the returned object tree. |
||||
* |
||||
* They assume UTF-8 input stream, and will output UTF-8 encoded |
||||
* strings in the tree. |
||||
* |
||||
* Delete the allocated tree afterward using grpc_json_delete(). |
||||
*/ |
||||
grpc_json* grpc_json_parse_string_with_len(char* input, size_t size); |
||||
grpc_json* grpc_json_parse_string(char* input); |
||||
|
||||
/* This function will create a new string using gpr_realloc, and will
|
||||
* deserialize the grpc_json tree into it. It'll be zero-terminated, |
||||
* but will be allocated in chunks of 256 bytes. |
||||
* |
||||
* The indent parameter controls the way the output is formatted. |
||||
* If indent is 0, then newlines will be suppressed as well, and the |
||||
* output will be condensed at its maximum. |
||||
*/ |
||||
char* grpc_json_dump_to_string(grpc_json* json, int indent); |
||||
|
||||
/* Use these to create or delete a grpc_json object.
|
||||
* Deletion is recursive. We will not attempt to free any of the strings |
||||
* in any of the objects of that tree. |
||||
*/ |
||||
grpc_json* grpc_json_new(enum grpc_json_type_t type); |
||||
void grpc_json_delete(grpc_json* json); |
||||
|
||||
#endif /* __GRPC_SRC_CORE_JSON_JSON_H__ */ |
||||
@ -1,20 +0,0 @@ |
||||
Copyright (c) 2009 Dave Gamble |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
of this software and associated documentation files (the "Software"), to deal |
||||
in the Software without restriction, including without limitation the rights |
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
copies of the Software, and to permit persons to whom the Software is |
||||
furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in |
||||
all copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
||||
THE SOFTWARE. |
||||
|
||||
@ -1,247 +0,0 @@ |
||||
/* |
||||
Copyright (c) 2009 Dave Gamble |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
of this software and associated documentation files (the "Software"), to deal |
||||
in the Software without restriction, including without limitation the rights |
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
copies of the Software, and to permit persons to whom the Software is |
||||
furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in |
||||
all copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
||||
THE SOFTWARE. |
||||
*/ |
||||
|
||||
Welcome to cJSON. |
||||
|
||||
cJSON aims to be the dumbest possible parser that you can get your job done with. |
||||
It's a single file of C, and a single header file. |
||||
|
||||
JSON is described best here: http://www.json.org/ |
||||
It's like XML, but fat-free. You use it to move data around, store things, or just |
||||
generally represent your program's state. |
||||
|
||||
|
||||
First up, how do I build? |
||||
Add cJSON.c to your project, and put cJSON.h somewhere in the header search path. |
||||
For example, to build the test app: |
||||
|
||||
gcc cJSON.c test.c -o test -lm |
||||
./test |
||||
|
||||
|
||||
As a library, cJSON exists to take away as much legwork as it can, but not get in your way. |
||||
As a point of pragmatism (i.e. ignoring the truth), I'm going to say that you can use it |
||||
in one of two modes: Auto and Manual. Let's have a quick run-through. |
||||
|
||||
|
||||
I lifted some JSON from this page: http://www.json.org/fatfree.html |
||||
That page inspired me to write cJSON, which is a parser that tries to share the same |
||||
philosophy as JSON itself. Simple, dumb, out of the way. |
||||
|
||||
Some JSON: |
||||
{ |
||||
"name": "Jack (\"Bee\") Nimble", |
||||
"format": { |
||||
"type": "rect", |
||||
"width": 1920, |
||||
"height": 1080, |
||||
"interlace": false, |
||||
"frame rate": 24 |
||||
} |
||||
} |
||||
|
||||
Assume that you got this from a file, a webserver, or magic JSON elves, whatever, |
||||
you have a char * to it. Everything is a cJSON struct. |
||||
Get it parsed: |
||||
cJSON *root = cJSON_Parse(my_json_string); |
||||
|
||||
This is an object. We're in C. We don't have objects. But we do have structs. |
||||
What's the framerate? |
||||
|
||||
cJSON *format = cJSON_GetObjectItem(root,"format"); |
||||
int framerate = cJSON_GetObjectItem(format,"frame rate")->valueint; |
||||
|
||||
|
||||
Want to change the framerate? |
||||
cJSON_GetObjectItem(format,"frame rate")->valueint=25; |
||||
|
||||
Back to disk? |
||||
char *rendered=cJSON_Print(root); |
||||
|
||||
Finished? Delete the root (this takes care of everything else). |
||||
cJSON_Delete(root); |
||||
|
||||
That's AUTO mode. If you're going to use Auto mode, you really ought to check pointers |
||||
before you dereference them. If you want to see how you'd build this struct in code? |
||||
cJSON *root,*fmt; |
||||
root=cJSON_CreateObject(); |
||||
cJSON_AddItemToObject(root, "name", cJSON_CreateString("Jack (\"Bee\") Nimble")); |
||||
cJSON_AddItemToObject(root, "format", fmt=cJSON_CreateObject()); |
||||
cJSON_AddStringToObject(fmt,"type", "rect"); |
||||
cJSON_AddNumberToObject(fmt,"width", 1920); |
||||
cJSON_AddNumberToObject(fmt,"height", 1080); |
||||
cJSON_AddFalseToObject (fmt,"interlace"); |
||||
cJSON_AddNumberToObject(fmt,"frame rate", 24); |
||||
|
||||
Hopefully we can agree that's not a lot of code? There's no overhead, no unnecessary setup. |
||||
Look at test.c for a bunch of nice examples, mostly all ripped off the json.org site, and |
||||
a few from elsewhere. |
||||
|
||||
What about manual mode? First up you need some detail. |
||||
Let's cover how the cJSON objects represent the JSON data. |
||||
cJSON doesn't distinguish arrays from objects in handling; just type. |
||||
Each cJSON has, potentially, a child, siblings, value, a name. |
||||
|
||||
The root object has: Object Type and a Child |
||||
The Child has name "name", with value "Jack ("Bee") Nimble", and a sibling: |
||||
Sibling has type Object, name "format", and a child. |
||||
That child has type String, name "type", value "rect", and a sibling: |
||||
Sibling has type Number, name "width", value 1920, and a sibling: |
||||
Sibling has type Number, name "height", value 1080, and a sibling: |
||||
Sibling hs type False, name "interlace", and a sibling: |
||||
Sibling has type Number, name "frame rate", value 24 |
||||
|
||||
Here's the structure: |
||||
typedef struct cJSON { |
||||
struct cJSON *next,*prev; |
||||
struct cJSON *child; |
||||
|
||||
int type; |
||||
|
||||
char *valuestring; |
||||
int valueint; |
||||
double valuedouble; |
||||
|
||||
char *string; |
||||
} cJSON; |
||||
|
||||
By default all values are 0 unless set by virtue of being meaningful. |
||||
|
||||
next/prev is a doubly linked list of siblings. next takes you to your sibling, |
||||
prev takes you back from your sibling to you. |
||||
Only objects and arrays have a "child", and it's the head of the doubly linked list. |
||||
A "child" entry will have prev==0, but next potentially points on. The last sibling has next=0. |
||||
The type expresses Null/True/False/Number/String/Array/Object, all of which are #defined in |
||||
cJSON.h |
||||
|
||||
A Number has valueint and valuedouble. If you're expecting an int, read valueint, if not read |
||||
valuedouble. |
||||
|
||||
Any entry which is in the linked list which is the child of an object will have a "string" |
||||
which is the "name" of the entry. When I said "name" in the above example, that's "string". |
||||
"string" is the JSON name for the 'variable name' if you will. |
||||
|
||||
Now you can trivially walk the lists, recursively, and parse as you please. |
||||
You can invoke cJSON_Parse to get cJSON to parse for you, and then you can take |
||||
the root object, and traverse the structure (which is, formally, an N-tree), |
||||
and tokenise as you please. If you wanted to build a callback style parser, this is how |
||||
you'd do it (just an example, since these things are very specific): |
||||
|
||||
void parse_and_callback(cJSON *item,const char *prefix) |
||||
{ |
||||
while (item) |
||||
{ |
||||
char *newprefix=malloc(strlen(prefix)+strlen(item->name)+2); |
||||
sprintf(newprefix,"%s/%s",prefix,item->name); |
||||
int dorecurse=callback(newprefix, item->type, item); |
||||
if (item->child && dorecurse) parse_and_callback(item->child,newprefix); |
||||
item=item->next; |
||||
free(newprefix); |
||||
} |
||||
} |
||||
|
||||
The prefix process will build you a separated list, to simplify your callback handling. |
||||
The 'dorecurse' flag would let the callback decide to handle sub-arrays on it's own, or |
||||
let you invoke it per-item. For the item above, your callback might look like this: |
||||
|
||||
int callback(const char *name,int type,cJSON *item) |
||||
{ |
||||
if (!strcmp(name,"name")) { /* populate name */ } |
||||
else if (!strcmp(name,"format/type") { /* handle "rect" */ } |
||||
else if (!strcmp(name,"format/width") { /* 800 */ } |
||||
else if (!strcmp(name,"format/height") { /* 600 */ } |
||||
else if (!strcmp(name,"format/interlace") { /* false */ } |
||||
else if (!strcmp(name,"format/frame rate") { /* 24 */ } |
||||
return 1; |
||||
} |
||||
|
||||
Alternatively, you might like to parse iteratively. |
||||
You'd use: |
||||
|
||||
void parse_object(cJSON *item) |
||||
{ |
||||
int i; for (i=0;i<cJSON_GetArraySize(item);i++) |
||||
{ |
||||
cJSON *subitem=cJSON_GetArrayItem(item,i); |
||||
// handle subitem. |
||||
} |
||||
} |
||||
|
||||
Or, for PROPER manual mode: |
||||
|
||||
void parse_object(cJSON *item) |
||||
{ |
||||
cJSON *subitem=item->child; |
||||
while (subitem) |
||||
{ |
||||
// handle subitem |
||||
if (subitem->child) parse_object(subitem->child); |
||||
|
||||
subitem=subitem->next; |
||||
} |
||||
} |
||||
|
||||
Of course, this should look familiar, since this is just a stripped-down version |
||||
of the callback-parser. |
||||
|
||||
This should cover most uses you'll find for parsing. The rest should be possible |
||||
to infer.. and if in doubt, read the source! There's not a lot of it! ;) |
||||
|
||||
|
||||
In terms of constructing JSON data, the example code above is the right way to do it. |
||||
You can, of course, hand your sub-objects to other functions to populate. |
||||
Also, if you find a use for it, you can manually build the objects. |
||||
For instance, suppose you wanted to build an array of objects? |
||||
|
||||
cJSON *objects[24]; |
||||
|
||||
cJSON *Create_array_of_anything(cJSON **items,int num) |
||||
{ |
||||
int i;cJSON *prev, *root=cJSON_CreateArray(); |
||||
for (i=0;i<24;i++) |
||||
{ |
||||
if (!i) root->child=objects[i]; |
||||
else prev->next=objects[i], objects[i]->prev=prev; |
||||
prev=objects[i]; |
||||
} |
||||
return root; |
||||
} |
||||
|
||||
and simply: Create_array_of_anything(objects,24); |
||||
|
||||
cJSON doesn't make any assumptions about what order you create things in. |
||||
You can attach the objects, as above, and later add children to each |
||||
of those objects. |
||||
|
||||
As soon as you call cJSON_Print, it renders the structure to text. |
||||
|
||||
|
||||
|
||||
The test.c code shows how to handle a bunch of typical cases. If you uncomment |
||||
the code, it'll load, parse and print a bunch of test files, also from json.org, |
||||
which are more complex than I'd care to try and stash into a const char array[]. |
||||
|
||||
|
||||
Enjoy cJSON! |
||||
|
||||
|
||||
- Dave Gamble, Aug 2009 |
||||
@ -1,596 +0,0 @@ |
||||
/*
|
||||
Copyright (c) 2009 Dave Gamble |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
of this software and associated documentation files (the "Software"), to deal |
||||
in the Software without restriction, including without limitation the rights |
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
copies of the Software, and to permit persons to whom the Software is |
||||
furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in |
||||
all copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
||||
THE SOFTWARE. |
||||
*/ |
||||
|
||||
/* cJSON */ |
||||
/* JSON parser in C. */ |
||||
|
||||
#include <string.h> |
||||
#include <stdio.h> |
||||
#include <math.h> |
||||
#include <stdlib.h> |
||||
#include <float.h> |
||||
#include <limits.h> |
||||
#include <ctype.h> |
||||
#include "cJSON.h" |
||||
|
||||
static const char *ep; |
||||
|
||||
const char *cJSON_GetErrorPtr(void) {return ep;} |
||||
|
||||
static int cJSON_strcasecmp(const char *s1,const char *s2) |
||||
{ |
||||
if (!s1) return (s1==s2)?0:1;if (!s2) return 1; |
||||
for(; tolower(*s1) == tolower(*s2); ++s1, ++s2) if(*s1 == 0) return 0; |
||||
return tolower(*(const unsigned char *)s1) - tolower(*(const unsigned char *)s2); |
||||
} |
||||
|
||||
static void *(*cJSON_malloc)(size_t sz) = malloc; |
||||
static void (*cJSON_free)(void *ptr) = free; |
||||
|
||||
static char* cJSON_strdup(const char* str) |
||||
{ |
||||
size_t len; |
||||
char* copy; |
||||
|
||||
len = strlen(str) + 1; |
||||
if (!(copy = (char*)cJSON_malloc(len))) return 0; |
||||
memcpy(copy,str,len); |
||||
return copy; |
||||
} |
||||
|
||||
void cJSON_InitHooks(cJSON_Hooks* hooks) |
||||
{ |
||||
if (!hooks) { /* Reset hooks */ |
||||
cJSON_malloc = malloc; |
||||
cJSON_free = free; |
||||
return; |
||||
} |
||||
|
||||
cJSON_malloc = (hooks->malloc_fn)?hooks->malloc_fn:malloc; |
||||
cJSON_free = (hooks->free_fn)?hooks->free_fn:free; |
||||
} |
||||
|
||||
/* Internal constructor. */ |
||||
static cJSON *cJSON_New_Item(void) |
||||
{ |
||||
cJSON* node = (cJSON*)cJSON_malloc(sizeof(cJSON)); |
||||
if (node) memset(node,0,sizeof(cJSON)); |
||||
return node; |
||||
} |
||||
|
||||
/* Delete a cJSON structure. */ |
||||
void cJSON_Delete(cJSON *c) |
||||
{ |
||||
cJSON *next; |
||||
while (c) |
||||
{ |
||||
next=c->next; |
||||
if (!(c->type&cJSON_IsReference) && c->child) cJSON_Delete(c->child); |
||||
if (!(c->type&cJSON_IsReference) && c->valuestring) cJSON_free(c->valuestring); |
||||
if (c->string) cJSON_free(c->string); |
||||
cJSON_free(c); |
||||
c=next; |
||||
} |
||||
} |
||||
|
||||
/* Parse the input text to generate a number, and populate the result into item. */ |
||||
static const char *parse_number(cJSON *item,const char *num) |
||||
{ |
||||
double n=0,sign=1,scale=0;int subscale=0,signsubscale=1; |
||||
|
||||
if (*num=='-') sign=-1,num++; /* Has sign? */ |
||||
if (*num=='0') num++; /* is zero */ |
||||
if (*num>='1' && *num<='9') do n=(n*10.0)+(*num++ -'0'); while (*num>='0' && *num<='9'); /* Number? */ |
||||
if (*num=='.' && num[1]>='0' && num[1]<='9') {num++; do n=(n*10.0)+(*num++ -'0'),scale--; while (*num>='0' && *num<='9');} /* Fractional part? */ |
||||
if (*num=='e' || *num=='E') /* Exponent? */ |
||||
{ num++;if (*num=='+') num++; else if (*num=='-') signsubscale=-1,num++; /* With sign? */ |
||||
while (*num>='0' && *num<='9') subscale=(subscale*10)+(*num++ - '0'); /* Number? */ |
||||
} |
||||
|
||||
n=sign*n*pow(10.0,(scale+subscale*signsubscale)); /* number = +/- number.fraction * 10^+/- exponent */ |
||||
|
||||
item->valuedouble=n; |
||||
item->valueint=(int)n; |
||||
item->type=cJSON_Number; |
||||
return num; |
||||
} |
||||
|
||||
/* Render the number nicely from the given item into a string. */ |
||||
static char *print_number(cJSON *item) |
||||
{ |
||||
char *str; |
||||
double d=item->valuedouble; |
||||
if (fabs(((double)item->valueint)-d)<=DBL_EPSILON && d<=INT_MAX && d>=INT_MIN) |
||||
{ |
||||
str=(char*)cJSON_malloc(21); /* 2^64+1 can be represented in 21 chars. */ |
||||
if (str) sprintf(str,"%d",item->valueint); |
||||
} |
||||
else |
||||
{ |
||||
str=(char*)cJSON_malloc(64); /* This is a nice tradeoff. */ |
||||
if (str) |
||||
{ |
||||
if (fabs(floor(d)-d)<=DBL_EPSILON && fabs(d)<1.0e60)sprintf(str,"%.0f",d); |
||||
else if (fabs(d)<1.0e-6 || fabs(d)>1.0e9) sprintf(str,"%e",d); |
||||
else sprintf(str,"%f",d); |
||||
} |
||||
} |
||||
return str; |
||||
} |
||||
|
||||
static unsigned parse_hex4(const char *str) |
||||
{ |
||||
unsigned h=0; |
||||
if (*str>='0' && *str<='9') h+=(*str)-'0'; else if (*str>='A' && *str<='F') h+=10+(*str)-'A'; else if (*str>='a' && *str<='f') h+=10+(*str)-'a'; else return 0; |
||||
h=h<<4;str++; |
||||
if (*str>='0' && *str<='9') h+=(*str)-'0'; else if (*str>='A' && *str<='F') h+=10+(*str)-'A'; else if (*str>='a' && *str<='f') h+=10+(*str)-'a'; else return 0; |
||||
h=h<<4;str++; |
||||
if (*str>='0' && *str<='9') h+=(*str)-'0'; else if (*str>='A' && *str<='F') h+=10+(*str)-'A'; else if (*str>='a' && *str<='f') h+=10+(*str)-'a'; else return 0; |
||||
h=h<<4;str++; |
||||
if (*str>='0' && *str<='9') h+=(*str)-'0'; else if (*str>='A' && *str<='F') h+=10+(*str)-'A'; else if (*str>='a' && *str<='f') h+=10+(*str)-'a'; else return 0; |
||||
return h; |
||||
} |
||||
|
||||
/* Parse the input text into an unescaped cstring, and populate item. */ |
||||
static const unsigned char firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC }; |
||||
static const char *parse_string(cJSON *item,const char *str) |
||||
{ |
||||
const char *ptr=str+1;char *ptr2;char *out;int len=0;unsigned uc,uc2; |
||||
if (*str!='\"') {ep=str;return 0;} /* not a string! */ |
||||
|
||||
while (*ptr!='\"' && *ptr && ++len) if (*ptr++ == '\\') ptr++; /* Skip escaped quotes. */ |
||||
|
||||
out=(char*)cJSON_malloc(len+1); /* This is how long we need for the string, roughly. */ |
||||
if (!out) return 0; |
||||
|
||||
ptr=str+1;ptr2=out; |
||||
while (*ptr!='\"' && *ptr) |
||||
{ |
||||
if (*ptr!='\\') *ptr2++=*ptr++; |
||||
else |
||||
{ |
||||
ptr++; |
||||
switch (*ptr) |
||||
{ |
||||
case 'b': *ptr2++='\b'; break; |
||||
case 'f': *ptr2++='\f'; break; |
||||
case 'n': *ptr2++='\n'; break; |
||||
case 'r': *ptr2++='\r'; break; |
||||
case 't': *ptr2++='\t'; break; |
||||
case 'u': /* transcode utf16 to utf8. */ |
||||
uc=parse_hex4(ptr+1);ptr+=4; /* get the unicode char. */ |
||||
|
||||
if ((uc>=0xDC00 && uc<=0xDFFF) || uc==0) break; /* check for invalid. */ |
||||
|
||||
if (uc>=0xD800 && uc<=0xDBFF) /* UTF16 surrogate pairs. */ |
||||
{ |
||||
if (ptr[1]!='\\' || ptr[2]!='u') break; /* missing second-half of surrogate. */ |
||||
uc2=parse_hex4(ptr+3);ptr+=6; |
||||
if (uc2<0xDC00 || uc2>0xDFFF) break; /* invalid second-half of surrogate. */ |
||||
uc=0x10000 + (((uc&0x3FF)<<10) | (uc2&0x3FF)); |
||||
} |
||||
|
||||
len=4;if (uc<0x80) len=1;else if (uc<0x800) len=2;else if (uc<0x10000) len=3; ptr2+=len; |
||||
|
||||
switch (len) { |
||||
case 4: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6; |
||||
case 3: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6; |
||||
case 2: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6; |
||||
case 1: *--ptr2 =(uc | firstByteMark[len]); |
||||
} |
||||
ptr2+=len; |
||||
break; |
||||
default: *ptr2++=*ptr; break; |
||||
} |
||||
ptr++; |
||||
} |
||||
} |
||||
*ptr2=0; |
||||
if (*ptr=='\"') ptr++; |
||||
item->valuestring=out; |
||||
item->type=cJSON_String; |
||||
return ptr; |
||||
} |
||||
|
||||
/* Render the cstring provided to an escaped version that can be printed. */ |
||||
static char *print_string_ptr(const char *str) |
||||
{ |
||||
const char *ptr;char *ptr2,*out;int len=0;unsigned char token; |
||||
|
||||
if (!str) return cJSON_strdup(""); |
||||
ptr=str;while ((token=*ptr) && ++len) {if (strchr("\"\\\b\f\n\r\t",token)) len++; else if (token<32) len+=5;ptr++;} |
||||
|
||||
out=(char*)cJSON_malloc(len+3); |
||||
if (!out) return 0; |
||||
|
||||
ptr2=out;ptr=str; |
||||
*ptr2++='\"'; |
||||
while (*ptr) |
||||
{ |
||||
if ((unsigned char)*ptr>31 && *ptr!='\"' && *ptr!='\\') *ptr2++=*ptr++; |
||||
else |
||||
{ |
||||
*ptr2++='\\'; |
||||
switch (token=*ptr++) |
||||
{ |
||||
case '\\': *ptr2++='\\'; break; |
||||
case '\"': *ptr2++='\"'; break; |
||||
case '\b': *ptr2++='b'; break; |
||||
case '\f': *ptr2++='f'; break; |
||||
case '\n': *ptr2++='n'; break; |
||||
case '\r': *ptr2++='r'; break; |
||||
case '\t': *ptr2++='t'; break; |
||||
default: sprintf(ptr2,"u%04x",token);ptr2+=5; break; /* escape and print */ |
||||
} |
||||
} |
||||
} |
||||
*ptr2++='\"';*ptr2++=0; |
||||
return out; |
||||
} |
||||
/* Invote print_string_ptr (which is useful) on an item. */ |
||||
static char *print_string(cJSON *item) {return print_string_ptr(item->valuestring);} |
||||
|
||||
/* Predeclare these prototypes. */ |
||||
static const char *parse_value(cJSON *item,const char *value); |
||||
static char *print_value(cJSON *item,int depth,int fmt); |
||||
static const char *parse_array(cJSON *item,const char *value); |
||||
static char *print_array(cJSON *item,int depth,int fmt); |
||||
static const char *parse_object(cJSON *item,const char *value); |
||||
static char *print_object(cJSON *item,int depth,int fmt); |
||||
|
||||
/* Utility to jump whitespace and cr/lf */ |
||||
static const char *skip(const char *in) {while (in && *in && (unsigned char)*in<=32) in++; return in;} |
||||
|
||||
/* Parse an object - create a new root, and populate. */ |
||||
cJSON *cJSON_ParseWithOpts(const char *value,const char **return_parse_end,int require_null_terminated) |
||||
{ |
||||
const char *end=0; |
||||
cJSON *c=cJSON_New_Item(); |
||||
ep=0; |
||||
if (!c) return 0; /* memory fail */ |
||||
|
||||
end=parse_value(c,skip(value)); |
||||
if (!end) {cJSON_Delete(c);return 0;} /* parse failure. ep is set. */ |
||||
|
||||
/* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */ |
||||
if (require_null_terminated) {end=skip(end);if (*end) {cJSON_Delete(c);ep=end;return 0;}} |
||||
if (return_parse_end) *return_parse_end=end; |
||||
return c; |
||||
} |
||||
/* Default options for cJSON_Parse */ |
||||
cJSON *cJSON_Parse(const char *value) {return cJSON_ParseWithOpts(value,0,0);} |
||||
|
||||
/* Render a cJSON item/entity/structure to text. */ |
||||
char *cJSON_Print(cJSON *item) {return print_value(item,0,1);} |
||||
char *cJSON_PrintUnformatted(cJSON *item) {return print_value(item,0,0);} |
||||
|
||||
/* Parser core - when encountering text, process appropriately. */ |
||||
static const char *parse_value(cJSON *item,const char *value) |
||||
{ |
||||
if (!value) return 0; /* Fail on null. */ |
||||
if (!strncmp(value,"null",4)) { item->type=cJSON_NULL; return value+4; } |
||||
if (!strncmp(value,"false",5)) { item->type=cJSON_False; return value+5; } |
||||
if (!strncmp(value,"true",4)) { item->type=cJSON_True; item->valueint=1; return value+4; } |
||||
if (*value=='\"') { return parse_string(item,value); } |
||||
if (*value=='-' || (*value>='0' && *value<='9')) { return parse_number(item,value); } |
||||
if (*value=='[') { return parse_array(item,value); } |
||||
if (*value=='{') { return parse_object(item,value); } |
||||
|
||||
ep=value;return 0; /* failure. */ |
||||
} |
||||
|
||||
/* Render a value to text. */ |
||||
static char *print_value(cJSON *item,int depth,int fmt) |
||||
{ |
||||
char *out=0; |
||||
if (!item) return 0; |
||||
switch ((item->type)&255) |
||||
{ |
||||
case cJSON_NULL: out=cJSON_strdup("null"); break; |
||||
case cJSON_False: out=cJSON_strdup("false");break; |
||||
case cJSON_True: out=cJSON_strdup("true"); break; |
||||
case cJSON_Number: out=print_number(item);break; |
||||
case cJSON_String: out=print_string(item);break; |
||||
case cJSON_Array: out=print_array(item,depth,fmt);break; |
||||
case cJSON_Object: out=print_object(item,depth,fmt);break; |
||||
} |
||||
return out; |
||||
} |
||||
|
||||
/* Build an array from input text. */ |
||||
static const char *parse_array(cJSON *item,const char *value) |
||||
{ |
||||
cJSON *child; |
||||
if (*value!='[') {ep=value;return 0;} /* not an array! */ |
||||
|
||||
item->type=cJSON_Array; |
||||
value=skip(value+1); |
||||
if (*value==']') return value+1; /* empty array. */ |
||||
|
||||
item->child=child=cJSON_New_Item(); |
||||
if (!item->child) return 0; /* memory fail */ |
||||
value=skip(parse_value(child,skip(value))); /* skip any spacing, get the value. */ |
||||
if (!value) return 0; |
||||
|
||||
while (*value==',') |
||||
{ |
||||
cJSON *new_item; |
||||
if (!(new_item=cJSON_New_Item())) return 0; /* memory fail */ |
||||
child->next=new_item;new_item->prev=child;child=new_item; |
||||
value=skip(parse_value(child,skip(value+1))); |
||||
if (!value) return 0; /* memory fail */ |
||||
} |
||||
|
||||
if (*value==']') return value+1; /* end of array */ |
||||
ep=value;return 0; /* malformed. */ |
||||
} |
||||
|
||||
/* Render an array to text */ |
||||
static char *print_array(cJSON *item,int depth,int fmt) |
||||
{ |
||||
char **entries; |
||||
char *out=0,*ptr,*ret;int len=5; |
||||
cJSON *child=item->child; |
||||
int numentries=0,i=0,fail=0; |
||||
|
||||
/* How many entries in the array? */ |
||||
while (child) numentries++,child=child->next; |
||||
/* Explicitly handle numentries==0 */ |
||||
if (!numentries) |
||||
{ |
||||
out=(char*)cJSON_malloc(3); |
||||
if (out) strcpy(out,"[]"); |
||||
return out; |
||||
} |
||||
/* Allocate an array to hold the values for each */ |
||||
entries=(char**)cJSON_malloc(numentries*sizeof(char*)); |
||||
if (!entries) return 0; |
||||
memset(entries,0,numentries*sizeof(char*)); |
||||
/* Retrieve all the results: */ |
||||
child=item->child; |
||||
while (child && !fail) |
||||
{ |
||||
ret=print_value(child,depth+1,fmt); |
||||
entries[i++]=ret; |
||||
if (ret) len+=strlen(ret)+2+(fmt?1:0); else fail=1; |
||||
child=child->next; |
||||
} |
||||
|
||||
/* If we didn't fail, try to malloc the output string */ |
||||
if (!fail) out=(char*)cJSON_malloc(len); |
||||
/* If that fails, we fail. */ |
||||
if (!out) fail=1; |
||||
|
||||
/* Handle failure. */ |
||||
if (fail) |
||||
{ |
||||
for (i=0;i<numentries;i++) if (entries[i]) cJSON_free(entries[i]); |
||||
cJSON_free(entries); |
||||
return 0; |
||||
} |
||||
|
||||
/* Compose the output array. */ |
||||
*out='['; |
||||
ptr=out+1;*ptr=0; |
||||
for (i=0;i<numentries;i++) |
||||
{ |
||||
strcpy(ptr,entries[i]);ptr+=strlen(entries[i]); |
||||
if (i!=numentries-1) {*ptr++=',';if(fmt)*ptr++=' ';*ptr=0;} |
||||
cJSON_free(entries[i]); |
||||
} |
||||
cJSON_free(entries); |
||||
*ptr++=']';*ptr++=0; |
||||
return out;
|
||||
} |
||||
|
||||
/* Build an object from the text. */ |
||||
static const char *parse_object(cJSON *item,const char *value) |
||||
{ |
||||
cJSON *child; |
||||
if (*value!='{') {ep=value;return 0;} /* not an object! */ |
||||
|
||||
item->type=cJSON_Object; |
||||
value=skip(value+1); |
||||
if (*value=='}') return value+1; /* empty array. */ |
||||
|
||||
item->child=child=cJSON_New_Item(); |
||||
if (!item->child) return 0; |
||||
value=skip(parse_string(child,skip(value))); |
||||
if (!value) return 0; |
||||
child->string=child->valuestring;child->valuestring=0; |
||||
if (*value!=':') {ep=value;return 0;} /* fail! */ |
||||
value=skip(parse_value(child,skip(value+1))); /* skip any spacing, get the value. */ |
||||
if (!value) return 0; |
||||
|
||||
while (*value==',') |
||||
{ |
||||
cJSON *new_item; |
||||
if (!(new_item=cJSON_New_Item())) return 0; /* memory fail */ |
||||
child->next=new_item;new_item->prev=child;child=new_item; |
||||
value=skip(parse_string(child,skip(value+1))); |
||||
if (!value) return 0; |
||||
child->string=child->valuestring;child->valuestring=0; |
||||
if (*value!=':') {ep=value;return 0;} /* fail! */ |
||||
value=skip(parse_value(child,skip(value+1))); /* skip any spacing, get the value. */ |
||||
if (!value) return 0; |
||||
} |
||||
|
||||
if (*value=='}') return value+1; /* end of array */ |
||||
ep=value;return 0; /* malformed. */ |
||||
} |
||||
|
||||
/* Render an object to text. */ |
||||
static char *print_object(cJSON *item,int depth,int fmt) |
||||
{ |
||||
char **entries=0,**names=0; |
||||
char *out=0,*ptr,*ret,*str;int len=7,i=0,j; |
||||
cJSON *child=item->child; |
||||
int numentries=0,fail=0; |
||||
/* Count the number of entries. */ |
||||
while (child) numentries++,child=child->next; |
||||
/* Explicitly handle empty object case */ |
||||
if (!numentries) |
||||
{ |
||||
out=(char*)cJSON_malloc(fmt?depth+4:3); |
||||
if (!out) return 0; |
||||
ptr=out;*ptr++='{'; |
||||
if (fmt) {*ptr++='\n';for (i=0;i<depth-1;i++) *ptr++='\t';} |
||||
*ptr++='}';*ptr++=0; |
||||
return out; |
||||
} |
||||
/* Allocate space for the names and the objects */ |
||||
entries=(char**)cJSON_malloc(numentries*sizeof(char*)); |
||||
if (!entries) return 0; |
||||
names=(char**)cJSON_malloc(numentries*sizeof(char*)); |
||||
if (!names) {cJSON_free(entries);return 0;} |
||||
memset(entries,0,sizeof(char*)*numentries); |
||||
memset(names,0,sizeof(char*)*numentries); |
||||
|
||||
/* Collect all the results into our arrays: */ |
||||
child=item->child;depth++;if (fmt) len+=depth; |
||||
while (child) |
||||
{ |
||||
names[i]=str=print_string_ptr(child->string); |
||||
entries[i++]=ret=print_value(child,depth,fmt); |
||||
if (str && ret) len+=strlen(ret)+strlen(str)+2+(fmt?2+depth:0); else fail=1; |
||||
child=child->next; |
||||
} |
||||
|
||||
/* Try to allocate the output string */ |
||||
if (!fail) out=(char*)cJSON_malloc(len); |
||||
if (!out) fail=1; |
||||
|
||||
/* Handle failure */ |
||||
if (fail) |
||||
{ |
||||
for (i=0;i<numentries;i++) {if (names[i]) cJSON_free(names[i]);if (entries[i]) cJSON_free(entries[i]);} |
||||
cJSON_free(names);cJSON_free(entries); |
||||
return 0; |
||||
} |
||||
|
||||
/* Compose the output: */ |
||||
*out='{';ptr=out+1;if (fmt)*ptr++='\n';*ptr=0; |
||||
for (i=0;i<numentries;i++) |
||||
{ |
||||
if (fmt) for (j=0;j<depth;j++) *ptr++='\t'; |
||||
strcpy(ptr,names[i]);ptr+=strlen(names[i]); |
||||
*ptr++=':';if (fmt) *ptr++='\t'; |
||||
strcpy(ptr,entries[i]);ptr+=strlen(entries[i]); |
||||
if (i!=numentries-1) *ptr++=','; |
||||
if (fmt) *ptr++='\n';*ptr=0; |
||||
cJSON_free(names[i]);cJSON_free(entries[i]); |
||||
} |
||||
|
||||
cJSON_free(names);cJSON_free(entries); |
||||
if (fmt) for (i=0;i<depth-1;i++) *ptr++='\t'; |
||||
*ptr++='}';*ptr++=0; |
||||
return out;
|
||||
} |
||||
|
||||
/* Get Array size/item / object item. */ |
||||
int cJSON_GetArraySize(cJSON *array) {cJSON *c=array->child;int i=0;while(c)i++,c=c->next;return i;} |
||||
cJSON *cJSON_GetArrayItem(cJSON *array,int item) {cJSON *c=array->child; while (c && item>0) item--,c=c->next; return c;} |
||||
cJSON *cJSON_GetObjectItem(cJSON *object,const char *string) {cJSON *c=object->child; while (c && cJSON_strcasecmp(c->string,string)) c=c->next; return c;} |
||||
|
||||
/* Utility for array list handling. */ |
||||
static void suffix_object(cJSON *prev,cJSON *item) {prev->next=item;item->prev=prev;} |
||||
/* Utility for handling references. */ |
||||
static cJSON *create_reference(cJSON *item) {cJSON *ref=cJSON_New_Item();if (!ref) return 0;memcpy(ref,item,sizeof(cJSON));ref->string=0;ref->type|=cJSON_IsReference;ref->next=ref->prev=0;return ref;} |
||||
|
||||
/* Add item to array/object. */ |
||||
void cJSON_AddItemToArray(cJSON *array, cJSON *item) {cJSON *c=array->child;if (!item) return; if (!c) {array->child=item;} else {while (c && c->next) c=c->next; suffix_object(c,item);}} |
||||
void cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item) {if (!item) return; if (item->string) cJSON_free(item->string);item->string=cJSON_strdup(string);cJSON_AddItemToArray(object,item);} |
||||
void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item) {cJSON_AddItemToArray(array,create_reference(item));} |
||||
void cJSON_AddItemReferenceToObject(cJSON *object,const char *string,cJSON *item) {cJSON_AddItemToObject(object,string,create_reference(item));} |
||||
|
||||
cJSON *cJSON_DetachItemFromArray(cJSON *array,int which) {cJSON *c=array->child;while (c && which>0) c=c->next,which--;if (!c) return 0; |
||||
if (c->prev) c->prev->next=c->next;if (c->next) c->next->prev=c->prev;if (c==array->child) array->child=c->next;c->prev=c->next=0;return c;} |
||||
void cJSON_DeleteItemFromArray(cJSON *array,int which) {cJSON_Delete(cJSON_DetachItemFromArray(array,which));} |
||||
cJSON *cJSON_DetachItemFromObject(cJSON *object,const char *string) {int i=0;cJSON *c=object->child;while (c && cJSON_strcasecmp(c->string,string)) i++,c=c->next;if (c) return cJSON_DetachItemFromArray(object,i);return 0;} |
||||
void cJSON_DeleteItemFromObject(cJSON *object,const char *string) {cJSON_Delete(cJSON_DetachItemFromObject(object,string));} |
||||
|
||||
/* Replace array/object items with new ones. */ |
||||
void cJSON_ReplaceItemInArray(cJSON *array,int which,cJSON *newitem) {cJSON *c=array->child;while (c && which>0) c=c->next,which--;if (!c) return; |
||||
newitem->next=c->next;newitem->prev=c->prev;if (newitem->next) newitem->next->prev=newitem; |
||||
if (c==array->child) array->child=newitem; else newitem->prev->next=newitem;c->next=c->prev=0;cJSON_Delete(c);} |
||||
void cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem){int i=0;cJSON *c=object->child;while(c && cJSON_strcasecmp(c->string,string))i++,c=c->next;if(c){newitem->string=cJSON_strdup(string);cJSON_ReplaceItemInArray(object,i,newitem);}} |
||||
|
||||
/* Create basic types: */ |
||||
cJSON *cJSON_CreateNull(void) {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_NULL;return item;} |
||||
cJSON *cJSON_CreateTrue(void) {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_True;return item;} |
||||
cJSON *cJSON_CreateFalse(void) {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_False;return item;} |
||||
cJSON *cJSON_CreateBool(int b) {cJSON *item=cJSON_New_Item();if(item)item->type=b?cJSON_True:cJSON_False;return item;} |
||||
cJSON *cJSON_CreateNumber(double num) {cJSON *item=cJSON_New_Item();if(item){item->type=cJSON_Number;item->valuedouble=num;item->valueint=(int)num;}return item;} |
||||
cJSON *cJSON_CreateString(const char *string) {cJSON *item=cJSON_New_Item();if(item){item->type=cJSON_String;item->valuestring=cJSON_strdup(string);}return item;} |
||||
cJSON *cJSON_CreateArray(void) {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_Array;return item;} |
||||
cJSON *cJSON_CreateObject(void) {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_Object;return item;} |
||||
|
||||
/* Create Arrays: */ |
||||
cJSON *cJSON_CreateIntArray(const int *numbers,int count) {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;} |
||||
cJSON *cJSON_CreateFloatArray(const float *numbers,int count) {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;} |
||||
cJSON *cJSON_CreateDoubleArray(const double *numbers,int count) {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;} |
||||
cJSON *cJSON_CreateStringArray(const char **strings,int count) {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateString(strings[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;} |
||||
|
||||
/* Duplication */ |
||||
cJSON *cJSON_Duplicate(cJSON *item,int recurse) |
||||
{ |
||||
cJSON *newitem,*cptr,*nptr=0,*newchild; |
||||
/* Bail on bad ptr */ |
||||
if (!item) return 0; |
||||
/* Create new item */ |
||||
newitem=cJSON_New_Item(); |
||||
if (!newitem) return 0; |
||||
/* Copy over all vars */ |
||||
newitem->type=item->type&(~cJSON_IsReference),newitem->valueint=item->valueint,newitem->valuedouble=item->valuedouble; |
||||
if (item->valuestring) {newitem->valuestring=cJSON_strdup(item->valuestring); if (!newitem->valuestring) {cJSON_Delete(newitem);return 0;}} |
||||
if (item->string) {newitem->string=cJSON_strdup(item->string); if (!newitem->string) {cJSON_Delete(newitem);return 0;}} |
||||
/* If non-recursive, then we're done! */ |
||||
if (!recurse) return newitem; |
||||
/* Walk the ->next chain for the child. */ |
||||
cptr=item->child; |
||||
while (cptr) |
||||
{ |
||||
newchild=cJSON_Duplicate(cptr,1); /* Duplicate (with recurse) each item in the ->next chain */ |
||||
if (!newchild) {cJSON_Delete(newitem);return 0;} |
||||
if (nptr) {nptr->next=newchild,newchild->prev=nptr;nptr=newchild;} /* If newitem->child already set, then crosswire ->prev and ->next and move on */ |
||||
else {newitem->child=newchild;nptr=newchild;} /* Set newitem->child and move to it */ |
||||
cptr=cptr->next; |
||||
} |
||||
return newitem; |
||||
} |
||||
|
||||
void cJSON_Minify(char *json) |
||||
{ |
||||
char *into=json; |
||||
while (*json) |
||||
{ |
||||
if (*json==' ') json++; |
||||
else if (*json=='\t') json++; /* Whitespace characters. */ |
||||
else if (*json=='\r') json++; |
||||
else if (*json=='\n') json++; |
||||
else if (*json=='/' && json[1]=='/') while (*json && *json!='\n') json++; /* double-slash comments, to end of line. */ |
||||
else if (*json=='/' && json[1]=='*') {while (*json && !(*json=='*' && json[1]=='/')) json++;json+=2;} /* multiline comments. */ |
||||
else if (*json=='\"'){*into++=*json++;while (*json && *json!='\"'){if (*json=='\\') *into++=*json++;*into++=*json++;}*into++=*json++;} /* string literals, which are \" sensitive. */ |
||||
else *into++=*json++; /* All other characters. */ |
||||
} |
||||
*into=0; /* and null-terminate. */ |
||||
} |
||||
@ -1,143 +0,0 @@ |
||||
/*
|
||||
Copyright (c) 2009 Dave Gamble |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
of this software and associated documentation files (the "Software"), to deal |
||||
in the Software without restriction, including without limitation the rights |
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
copies of the Software, and to permit persons to whom the Software is |
||||
furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in |
||||
all copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
||||
THE SOFTWARE. |
||||
*/ |
||||
|
||||
#ifndef cJSON__h |
||||
#define cJSON__h |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" |
||||
{ |
||||
#endif |
||||
|
||||
/* cJSON Types: */ |
||||
#define cJSON_False 0 |
||||
#define cJSON_True 1 |
||||
#define cJSON_NULL 2 |
||||
#define cJSON_Number 3 |
||||
#define cJSON_String 4 |
||||
#define cJSON_Array 5 |
||||
#define cJSON_Object 6 |
||||
|
||||
#define cJSON_IsReference 256 |
||||
|
||||
/* The cJSON structure: */ |
||||
typedef struct cJSON { |
||||
struct cJSON *next,*prev; /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */ |
||||
struct cJSON *child; /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */ |
||||
|
||||
int type; /* The type of the item, as above. */ |
||||
|
||||
char *valuestring; /* The item's string, if type==cJSON_String */ |
||||
int valueint; /* The item's number, if type==cJSON_Number */ |
||||
double valuedouble; /* The item's number, if type==cJSON_Number */ |
||||
|
||||
char *string; /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */ |
||||
} cJSON; |
||||
|
||||
typedef struct cJSON_Hooks { |
||||
void *(*malloc_fn)(size_t sz); |
||||
void (*free_fn)(void *ptr); |
||||
} cJSON_Hooks; |
||||
|
||||
/* Supply malloc, realloc and free functions to cJSON */ |
||||
extern void cJSON_InitHooks(cJSON_Hooks* hooks); |
||||
|
||||
|
||||
/* Supply a block of JSON, and this returns a cJSON object you can interrogate. Call cJSON_Delete when finished. */ |
||||
extern cJSON *cJSON_Parse(const char *value); |
||||
/* Render a cJSON entity to text for transfer/storage. Free the char* when finished. */ |
||||
extern char *cJSON_Print(cJSON *item); |
||||
/* Render a cJSON entity to text for transfer/storage without any formatting. Free the char* when finished. */ |
||||
extern char *cJSON_PrintUnformatted(cJSON *item); |
||||
/* Delete a cJSON entity and all subentities. */ |
||||
extern void cJSON_Delete(cJSON *c); |
||||
|
||||
/* Returns the number of items in an array (or object). */ |
||||
extern int cJSON_GetArraySize(cJSON *array); |
||||
/* Retrieve item number "item" from array "array". Returns NULL if unsuccessful. */ |
||||
extern cJSON *cJSON_GetArrayItem(cJSON *array,int item); |
||||
/* Get item "string" from object. Case insensitive. */ |
||||
extern cJSON *cJSON_GetObjectItem(cJSON *object,const char *string); |
||||
|
||||
/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */ |
||||
extern const char *cJSON_GetErrorPtr(void); |
||||
|
||||
/* These calls create a cJSON item of the appropriate type. */ |
||||
extern cJSON *cJSON_CreateNull(void); |
||||
extern cJSON *cJSON_CreateTrue(void); |
||||
extern cJSON *cJSON_CreateFalse(void); |
||||
extern cJSON *cJSON_CreateBool(int b); |
||||
extern cJSON *cJSON_CreateNumber(double num); |
||||
extern cJSON *cJSON_CreateString(const char *string); |
||||
extern cJSON *cJSON_CreateArray(void); |
||||
extern cJSON *cJSON_CreateObject(void); |
||||
|
||||
/* These utilities create an Array of count items. */ |
||||
extern cJSON *cJSON_CreateIntArray(const int *numbers,int count); |
||||
extern cJSON *cJSON_CreateFloatArray(const float *numbers,int count); |
||||
extern cJSON *cJSON_CreateDoubleArray(const double *numbers,int count); |
||||
extern cJSON *cJSON_CreateStringArray(const char **strings,int count); |
||||
|
||||
/* Append item to the specified array/object. */ |
||||
extern void cJSON_AddItemToArray(cJSON *array, cJSON *item); |
||||
extern void cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item); |
||||
/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */ |
||||
extern void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item); |
||||
extern void cJSON_AddItemReferenceToObject(cJSON *object,const char *string,cJSON *item); |
||||
|
||||
/* Remove/Detatch items from Arrays/Objects. */ |
||||
extern cJSON *cJSON_DetachItemFromArray(cJSON *array,int which); |
||||
extern void cJSON_DeleteItemFromArray(cJSON *array,int which); |
||||
extern cJSON *cJSON_DetachItemFromObject(cJSON *object,const char *string); |
||||
extern void cJSON_DeleteItemFromObject(cJSON *object,const char *string); |
||||
|
||||
/* Update array items. */ |
||||
extern void cJSON_ReplaceItemInArray(cJSON *array,int which,cJSON *newitem); |
||||
extern void cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem); |
||||
|
||||
/* Duplicate a cJSON item */ |
||||
extern cJSON *cJSON_Duplicate(cJSON *item,int recurse); |
||||
/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
|
||||
need to be released. With recurse!=0, it will duplicate any children connected to the item. |
||||
The item->next and ->prev pointers are always zero on return from Duplicate. */ |
||||
|
||||
/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */ |
||||
extern cJSON *cJSON_ParseWithOpts(const char *value,const char **return_parse_end,int require_null_terminated); |
||||
|
||||
extern void cJSON_Minify(char *json); |
||||
|
||||
/* Macros for creating things quickly. */ |
||||
#define cJSON_AddNullToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateNull()) |
||||
#define cJSON_AddTrueToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateTrue()) |
||||
#define cJSON_AddFalseToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateFalse()) |
||||
#define cJSON_AddBoolToObject(object,name,b) cJSON_AddItemToObject(object, name, cJSON_CreateBool(b)) |
||||
#define cJSON_AddNumberToObject(object,name,n) cJSON_AddItemToObject(object, name, cJSON_CreateNumber(n)) |
||||
#define cJSON_AddStringToObject(object,name,s) cJSON_AddItemToObject(object, name, cJSON_CreateString(s)) |
||||
|
||||
/* When assigning an integer value, it needs to be propagated to valuedouble too. */ |
||||
#define cJSON_SetIntValue(object,val) ((object)?(object)->valueint=(object)->valuedouble=(val):(val)) |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif |
||||
@ -1,156 +0,0 @@ |
||||
/*
|
||||
Copyright (c) 2009 Dave Gamble |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
of this software and associated documentation files (the "Software"), to deal |
||||
in the Software without restriction, including without limitation the rights |
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
copies of the Software, and to permit persons to whom the Software is |
||||
furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in |
||||
all copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
||||
THE SOFTWARE. |
||||
*/ |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include "cJSON.h" |
||||
|
||||
/* Parse text to JSON, then render back to text, and print! */ |
||||
void doit(char *text) |
||||
{ |
||||
char *out;cJSON *json; |
||||
|
||||
json=cJSON_Parse(text); |
||||
if (!json) {printf("Error before: [%s]\n",cJSON_GetErrorPtr());} |
||||
else |
||||
{ |
||||
out=cJSON_Print(json); |
||||
cJSON_Delete(json); |
||||
printf("%s\n",out); |
||||
free(out); |
||||
} |
||||
} |
||||
|
||||
/* Read a file, parse, render back, etc. */ |
||||
void dofile(char *filename) |
||||
{ |
||||
FILE *f=fopen(filename,"rb");fseek(f,0,SEEK_END);long len=ftell(f);fseek(f,0,SEEK_SET); |
||||
char *data=(char*)malloc(len+1);fread(data,1,len,f);fclose(f); |
||||
doit(data); |
||||
free(data); |
||||
} |
||||
|
||||
/* Used by some code below as an example datatype. */ |
||||
struct record {const char *precision;double lat,lon;const char *address,*city,*state,*zip,*country; }; |
||||
|
||||
/* Create a bunch of objects as demonstration. */ |
||||
void create_objects() |
||||
{ |
||||
cJSON *root,*fmt,*img,*thm,*fld;char *out;int i; /* declare a few. */ |
||||
|
||||
/* Here we construct some JSON standards, from the JSON site. */ |
||||
|
||||
/* Our "Video" datatype: */ |
||||
root=cJSON_CreateObject();
|
||||
cJSON_AddItemToObject(root, "name", cJSON_CreateString("Jack (\"Bee\") Nimble")); |
||||
cJSON_AddItemToObject(root, "format", fmt=cJSON_CreateObject()); |
||||
cJSON_AddStringToObject(fmt,"type", "rect"); |
||||
cJSON_AddNumberToObject(fmt,"width", 1920); |
||||
cJSON_AddNumberToObject(fmt,"height", 1080); |
||||
cJSON_AddFalseToObject (fmt,"interlace"); |
||||
cJSON_AddNumberToObject(fmt,"frame rate", 24); |
||||
|
||||
out=cJSON_Print(root); cJSON_Delete(root); printf("%s\n",out); free(out); /* Print to text, Delete the cJSON, print it, release the string. */ |
||||
|
||||
/* Our "days of the week" array: */ |
||||
const char *strings[7]={"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"}; |
||||
root=cJSON_CreateStringArray(strings,7); |
||||
|
||||
out=cJSON_Print(root); cJSON_Delete(root); printf("%s\n",out); free(out); |
||||
|
||||
/* Our matrix: */ |
||||
int numbers[3][3]={{0,-1,0},{1,0,0},{0,0,1}}; |
||||
root=cJSON_CreateArray(); |
||||
for (i=0;i<3;i++) cJSON_AddItemToArray(root,cJSON_CreateIntArray(numbers[i],3)); |
||||
|
||||
/* cJSON_ReplaceItemInArray(root,1,cJSON_CreateString("Replacement")); */ |
||||
|
||||
out=cJSON_Print(root); cJSON_Delete(root); printf("%s\n",out); free(out); |
||||
|
||||
|
||||
/* Our "gallery" item: */ |
||||
int ids[4]={116,943,234,38793}; |
||||
root=cJSON_CreateObject(); |
||||
cJSON_AddItemToObject(root, "Image", img=cJSON_CreateObject()); |
||||
cJSON_AddNumberToObject(img,"Width",800); |
||||
cJSON_AddNumberToObject(img,"Height",600); |
||||
cJSON_AddStringToObject(img,"Title","View from 15th Floor"); |
||||
cJSON_AddItemToObject(img, "Thumbnail", thm=cJSON_CreateObject()); |
||||
cJSON_AddStringToObject(thm, "Url", "http:/*www.example.com/image/481989943"); |
||||
cJSON_AddNumberToObject(thm,"Height",125); |
||||
cJSON_AddStringToObject(thm,"Width","100"); |
||||
cJSON_AddItemToObject(img,"IDs", cJSON_CreateIntArray(ids,4)); |
||||
|
||||
out=cJSON_Print(root); cJSON_Delete(root); printf("%s\n",out); free(out); |
||||
|
||||
/* Our array of "records": */ |
||||
struct record fields[2]={ |
||||
{"zip",37.7668,-1.223959e+2,"","SAN FRANCISCO","CA","94107","US"}, |
||||
{"zip",37.371991,-1.22026e+2,"","SUNNYVALE","CA","94085","US"}}; |
||||
|
||||
root=cJSON_CreateArray(); |
||||
for (i=0;i<2;i++) |
||||
{ |
||||
cJSON_AddItemToArray(root,fld=cJSON_CreateObject()); |
||||
cJSON_AddStringToObject(fld, "precision", fields[i].precision); |
||||
cJSON_AddNumberToObject(fld, "Latitude", fields[i].lat); |
||||
cJSON_AddNumberToObject(fld, "Longitude", fields[i].lon); |
||||
cJSON_AddStringToObject(fld, "Address", fields[i].address); |
||||
cJSON_AddStringToObject(fld, "City", fields[i].city); |
||||
cJSON_AddStringToObject(fld, "State", fields[i].state); |
||||
cJSON_AddStringToObject(fld, "Zip", fields[i].zip); |
||||
cJSON_AddStringToObject(fld, "Country", fields[i].country); |
||||
} |
||||
|
||||
/* cJSON_ReplaceItemInObject(cJSON_GetArrayItem(root,1),"City",cJSON_CreateIntArray(ids,4)); */ |
||||
|
||||
out=cJSON_Print(root); cJSON_Delete(root); printf("%s\n",out); free(out); |
||||
|
||||
} |
||||
|
||||
int main (int argc, const char * argv[]) { |
||||
/* a bunch of json: */ |
||||
char text1[]="{\n\"name\": \"Jack (\\\"Bee\\\") Nimble\", \n\"format\": {\"type\": \"rect\", \n\"width\": 1920, \n\"height\": 1080, \n\"interlace\": false,\"frame rate\": 24\n}\n}";
|
||||
char text2[]="[\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"]"; |
||||
char text3[]="[\n [0, -1, 0],\n [1, 0, 0],\n [0, 0, 1]\n ]\n"; |
||||
char text4[]="{\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http:/*www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": \"100\"\n },\n \"IDs\": [116, 943, 234, 38793]\n }\n }"; |
||||
char text5[]="[\n {\n \"precision\": \"zip\",\n \"Latitude\": 37.7668,\n \"Longitude\": -122.3959,\n \"Address\": \"\",\n \"City\": \"SAN FRANCISCO\",\n \"State\": \"CA\",\n \"Zip\": \"94107\",\n \"Country\": \"US\"\n },\n {\n \"precision\": \"zip\",\n \"Latitude\": 37.371991,\n \"Longitude\": -122.026020,\n \"Address\": \"\",\n \"City\": \"SUNNYVALE\",\n \"State\": \"CA\",\n \"Zip\": \"94085\",\n \"Country\": \"US\"\n }\n ]"; |
||||
|
||||
/* Process each json textblock by parsing, then rebuilding: */ |
||||
doit(text1); |
||||
doit(text2);
|
||||
doit(text3); |
||||
doit(text4); |
||||
doit(text5); |
||||
|
||||
/* Parse standard testfiles: */ |
||||
/* dofile("../../tests/test1"); */ |
||||
/* dofile("../../tests/test2"); */ |
||||
/* dofile("../../tests/test3"); */ |
||||
/* dofile("../../tests/test4"); */ |
||||
/* dofile("../../tests/test5"); */ |
||||
|
||||
/* Now some samplecode for building objects concisely: */ |
||||
create_objects(); |
||||
|
||||
return 0; |
||||
} |
||||
@ -1,22 +0,0 @@ |
||||
{ |
||||
"glossary": { |
||||
"title": "example glossary", |
||||
"GlossDiv": { |
||||
"title": "S", |
||||
"GlossList": { |
||||
"GlossEntry": { |
||||
"ID": "SGML", |
||||
"SortAs": "SGML", |
||||
"GlossTerm": "Standard Generalized Markup Language", |
||||
"Acronym": "SGML", |
||||
"Abbrev": "ISO 8879:1986", |
||||
"GlossDef": { |
||||
"para": "A meta-markup language, used to create markup languages such as DocBook.", |
||||
"GlossSeeAlso": ["GML", "XML"] |
||||
}, |
||||
"GlossSee": "markup" |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
@ -1,11 +0,0 @@ |
||||
{"menu": { |
||||
"id": "file", |
||||
"value": "File", |
||||
"popup": { |
||||
"menuitem": [ |
||||
{"value": "New", "onclick": "CreateNewDoc()"}, |
||||
{"value": "Open", "onclick": "OpenDoc()"}, |
||||
{"value": "Close", "onclick": "CloseDoc()"} |
||||
] |
||||
} |
||||
}} |
||||
@ -1,26 +0,0 @@ |
||||
{"widget": { |
||||
"debug": "on", |
||||
"window": { |
||||
"title": "Sample Konfabulator Widget", |
||||
"name": "main_window", |
||||
"width": 500, |
||||
"height": 500 |
||||
}, |
||||
"image": { |
||||
"src": "Images/Sun.png", |
||||
"name": "sun1", |
||||
"hOffset": 250, |
||||
"vOffset": 250, |
||||
"alignment": "center" |
||||
}, |
||||
"text": { |
||||
"data": "Click Here", |
||||
"size": 36, |
||||
"style": "bold", |
||||
"name": "text1", |
||||
"hOffset": 250, |
||||
"vOffset": 100, |
||||
"alignment": "center", |
||||
"onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;" |
||||
} |
||||
}} |
||||
@ -1,88 +0,0 @@ |
||||
{"web-app": { |
||||
"servlet": [ |
||||
{ |
||||
"servlet-name": "cofaxCDS", |
||||
"servlet-class": "org.cofax.cds.CDSServlet", |
||||
"init-param": { |
||||
"configGlossary:installationAt": "Philadelphia, PA", |
||||
"configGlossary:adminEmail": "ksm@pobox.com", |
||||
"configGlossary:poweredBy": "Cofax", |
||||
"configGlossary:poweredByIcon": "/images/cofax.gif", |
||||
"configGlossary:staticPath": "/content/static", |
||||
"templateProcessorClass": "org.cofax.WysiwygTemplate", |
||||
"templateLoaderClass": "org.cofax.FilesTemplateLoader", |
||||
"templatePath": "templates", |
||||
"templateOverridePath": "", |
||||
"defaultListTemplate": "listTemplate.htm", |
||||
"defaultFileTemplate": "articleTemplate.htm", |
||||
"useJSP": false, |
||||
"jspListTemplate": "listTemplate.jsp", |
||||
"jspFileTemplate": "articleTemplate.jsp", |
||||
"cachePackageTagsTrack": 200, |
||||
"cachePackageTagsStore": 200, |
||||
"cachePackageTagsRefresh": 60, |
||||
"cacheTemplatesTrack": 100, |
||||
"cacheTemplatesStore": 50, |
||||
"cacheTemplatesRefresh": 15, |
||||
"cachePagesTrack": 200, |
||||
"cachePagesStore": 100, |
||||
"cachePagesRefresh": 10, |
||||
"cachePagesDirtyRead": 10, |
||||
"searchEngineListTemplate": "forSearchEnginesList.htm", |
||||
"searchEngineFileTemplate": "forSearchEngines.htm", |
||||
"searchEngineRobotsDb": "WEB-INF/robots.db", |
||||
"useDataStore": true, |
||||
"dataStoreClass": "org.cofax.SqlDataStore", |
||||
"redirectionClass": "org.cofax.SqlRedirection", |
||||
"dataStoreName": "cofax", |
||||
"dataStoreDriver": "com.microsoft.jdbc.sqlserver.SQLServerDriver", |
||||
"dataStoreUrl": "jdbc:microsoft:sqlserver://LOCALHOST:1433;DatabaseName=goon", |
||||
"dataStoreUser": "sa", |
||||
"dataStorePassword": "dataStoreTestQuery", |
||||
"dataStoreTestQuery": "SET NOCOUNT ON;select test='test';", |
||||
"dataStoreLogFile": "/usr/local/tomcat/logs/datastore.log", |
||||
"dataStoreInitConns": 10, |
||||
"dataStoreMaxConns": 100, |
||||
"dataStoreConnUsageLimit": 100, |
||||
"dataStoreLogLevel": "debug", |
||||
"maxUrlLength": 500}}, |
||||
{ |
||||
"servlet-name": "cofaxEmail", |
||||
"servlet-class": "org.cofax.cds.EmailServlet", |
||||
"init-param": { |
||||
"mailHost": "mail1", |
||||
"mailHostOverride": "mail2"}}, |
||||
{ |
||||
"servlet-name": "cofaxAdmin", |
||||
"servlet-class": "org.cofax.cds.AdminServlet"}, |
||||
|
||||
{ |
||||
"servlet-name": "fileServlet", |
||||
"servlet-class": "org.cofax.cds.FileServlet"}, |
||||
{ |
||||
"servlet-name": "cofaxTools", |
||||
"servlet-class": "org.cofax.cms.CofaxToolsServlet", |
||||
"init-param": { |
||||
"templatePath": "toolstemplates/", |
||||
"log": 1, |
||||
"logLocation": "/usr/local/tomcat/logs/CofaxTools.log", |
||||
"logMaxSize": "", |
||||
"dataLog": 1, |
||||
"dataLogLocation": "/usr/local/tomcat/logs/dataLog.log", |
||||
"dataLogMaxSize": "", |
||||
"removePageCache": "/content/admin/remove?cache=pages&id=", |
||||
"removeTemplateCache": "/content/admin/remove?cache=templates&id=", |
||||
"fileTransferFolder": "/usr/local/tomcat/webapps/content/fileTransferFolder", |
||||
"lookInContext": 1, |
||||
"adminGroupID": 4, |
||||
"betaServer": true}}], |
||||
"servlet-mapping": { |
||||
"cofaxCDS": "/", |
||||
"cofaxEmail": "/cofaxutil/aemail/*", |
||||
"cofaxAdmin": "/admin/*", |
||||
"fileServlet": "/static/*", |
||||
"cofaxTools": "/tools/*"}, |
||||
|
||||
"taglib": { |
||||
"taglib-uri": "cofax.tld", |
||||
"taglib-location": "/WEB-INF/tlds/cofax.tld"}}} |
||||
@ -1,27 +0,0 @@ |
||||
{"menu": { |
||||
"header": "SVG Viewer", |
||||
"items": [ |
||||
{"id": "Open"}, |
||||
{"id": "OpenNew", "label": "Open New"}, |
||||
null, |
||||
{"id": "ZoomIn", "label": "Zoom In"}, |
||||
{"id": "ZoomOut", "label": "Zoom Out"}, |
||||
{"id": "OriginalView", "label": "Original View"}, |
||||
null, |
||||
{"id": "Quality"}, |
||||
{"id": "Pause"}, |
||||
{"id": "Mute"}, |
||||
null, |
||||
{"id": "Find", "label": "Find..."}, |
||||
{"id": "FindAgain", "label": "Find Again"}, |
||||
{"id": "Copy"}, |
||||
{"id": "CopyAgain", "label": "Copy Again"}, |
||||
{"id": "CopySVG", "label": "Copy SVG"}, |
||||
{"id": "ViewSVG", "label": "View SVG"}, |
||||
{"id": "ViewSource", "label": "View Source"}, |
||||
{"id": "SaveAs", "label": "Save As"}, |
||||
null, |
||||
{"id": "Help"}, |
||||
{"id": "About", "label": "About Adobe CVG Viewer..."} |
||||
] |
||||
}} |
||||
Loading…
Reference in new issue