3452 lines
100 KiB
C
3452 lines
100 KiB
C
/*
|
|
The latest version of this library is available on GitHub;
|
|
https://github.com/sheredom/json.h.
|
|
*/
|
|
|
|
/*
|
|
This is free and unencumbered software released into the public domain.
|
|
|
|
Anyone is free to copy, modify, publish, use, compile, sell, or
|
|
distribute this software, either in source code form or as a compiled
|
|
binary, for any purpose, commercial or non-commercial, and by any
|
|
means.
|
|
|
|
In jurisdictions that recognize copyright laws, the author or authors
|
|
of this software dedicate any and all copyright interest in the
|
|
software to the public domain. We make this dedication for the benefit
|
|
of the public at large and to the detriment of our heirs and
|
|
successors. We intend this dedication to be an overt act of
|
|
relinquishment in perpetuity of all present and future rights to this
|
|
software under copyright law.
|
|
|
|
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 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.
|
|
|
|
For more information, please refer to <http://unlicense.org/>.
|
|
*/
|
|
|
|
#ifndef SHEREDOM_JSON_H_INCLUDED
|
|
#define SHEREDOM_JSON_H_INCLUDED
|
|
|
|
#if defined(_MSC_VER)
|
|
#pragma warning(push)
|
|
|
|
/* disable warning: no function prototype given: converting '()' to '(void)' */
|
|
#pragma warning(disable : 4255)
|
|
|
|
/* disable warning: '__cplusplus' is not defined as a preprocessor macro,
|
|
* replacing with '0' for '#if/#elif' */
|
|
#pragma warning(disable : 4668)
|
|
|
|
/* disable warning: 'bytes padding added after construct' */
|
|
#pragma warning(disable : 4820)
|
|
#endif
|
|
|
|
#include <stddef.h>
|
|
#include <string.h>
|
|
|
|
#if defined(_MSC_VER) || defined(__WATCOMC__)
|
|
#define json_weak __inline
|
|
#elif defined(__clang__) || defined(__GNUC__)
|
|
#define json_weak __attribute__((weak))
|
|
#else
|
|
#error Non clang, non gcc, non MSVC, non WATCOM compiler found!
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
struct json_value_s;
|
|
struct json_parse_result_s;
|
|
|
|
enum json_parse_flags_e {
|
|
json_parse_flags_default = 0,
|
|
|
|
/* allow trailing commas in objects and arrays. For example, both [true,] and
|
|
{"a" : null,} would be allowed with this option on. */
|
|
json_parse_flags_allow_trailing_comma = 0x1,
|
|
|
|
/* allow unquoted keys for objects. For example, {a : null} would be allowed
|
|
with this option on. */
|
|
json_parse_flags_allow_unquoted_keys = 0x2,
|
|
|
|
/* allow a global unbracketed object. For example, a : null, b : true, c : {}
|
|
would be allowed with this option on. */
|
|
json_parse_flags_allow_global_object = 0x4,
|
|
|
|
/* allow objects to use '=' instead of ':' between key/value pairs. For
|
|
example, a = null, b : true would be allowed with this option on. */
|
|
json_parse_flags_allow_equals_in_object = 0x8,
|
|
|
|
/* allow that objects don't have to have comma separators between key/value
|
|
pairs. */
|
|
json_parse_flags_allow_no_commas = 0x10,
|
|
|
|
/* allow c-style comments (either variants) to be ignored in the input JSON
|
|
file. */
|
|
json_parse_flags_allow_c_style_comments = 0x20,
|
|
|
|
/* deprecated flag, unused. */
|
|
json_parse_flags_deprecated = 0x40,
|
|
|
|
/* record location information for each value. */
|
|
json_parse_flags_allow_location_information = 0x80,
|
|
|
|
/* allow strings to be 'single quoted'. */
|
|
json_parse_flags_allow_single_quoted_strings = 0x100,
|
|
|
|
/* allow numbers to be hexadecimal. */
|
|
json_parse_flags_allow_hexadecimal_numbers = 0x200,
|
|
|
|
/* allow numbers like +123 to be parsed. */
|
|
json_parse_flags_allow_leading_plus_sign = 0x400,
|
|
|
|
/* allow numbers like .0123 or 123. to be parsed. */
|
|
json_parse_flags_allow_leading_or_trailing_decimal_point = 0x800,
|
|
|
|
/* allow Infinity, -Infinity, NaN, -NaN. */
|
|
json_parse_flags_allow_inf_and_nan = 0x1000,
|
|
|
|
/* allow multi line string values. */
|
|
json_parse_flags_allow_multi_line_strings = 0x2000,
|
|
|
|
/* allow simplified JSON to be parsed. Simplified JSON is an enabling of a set
|
|
of other parsing options. */
|
|
json_parse_flags_allow_simplified_json =
|
|
(json_parse_flags_allow_trailing_comma |
|
|
json_parse_flags_allow_unquoted_keys |
|
|
json_parse_flags_allow_global_object |
|
|
json_parse_flags_allow_equals_in_object |
|
|
json_parse_flags_allow_no_commas),
|
|
|
|
/* allow JSON5 to be parsed. JSON5 is an enabling of a set of other parsing
|
|
options. */
|
|
json_parse_flags_allow_json5 =
|
|
(json_parse_flags_allow_trailing_comma |
|
|
json_parse_flags_allow_unquoted_keys |
|
|
json_parse_flags_allow_c_style_comments |
|
|
json_parse_flags_allow_single_quoted_strings |
|
|
json_parse_flags_allow_hexadecimal_numbers |
|
|
json_parse_flags_allow_leading_plus_sign |
|
|
json_parse_flags_allow_leading_or_trailing_decimal_point |
|
|
json_parse_flags_allow_inf_and_nan |
|
|
json_parse_flags_allow_multi_line_strings)
|
|
};
|
|
|
|
/* Parse a JSON text file, returning a pointer to the root of the JSON
|
|
* structure. json_parse performs 1 call to malloc for the entire encoding.
|
|
* Returns 0 if an error occurred (malformed JSON input, or malloc failed). */
|
|
json_weak struct json_value_s *json_parse(const void *src, size_t src_size);
|
|
|
|
/* Parse a JSON text file, returning a pointer to the root of the JSON
|
|
* structure. json_parse performs 1 call to alloc_func_ptr for the entire
|
|
* encoding. Returns 0 if an error occurred (malformed JSON input, or malloc
|
|
* failed). If an error occurred, the result struct (if not NULL) will explain
|
|
* the type of error, and the location in the input it occurred. If
|
|
* alloc_func_ptr is null then malloc is used. */
|
|
json_weak struct json_value_s *
|
|
json_parse_ex(const void *src, size_t src_size, size_t flags_bitset,
|
|
void *(*alloc_func_ptr)(void *, size_t), void *user_data,
|
|
struct json_parse_result_s *result);
|
|
|
|
/* Extracts a value and all the data that makes it up into a newly created
|
|
* value. json_extract_value performs 1 call to malloc for the entire encoding.
|
|
*/
|
|
json_weak struct json_value_s *
|
|
json_extract_value(const struct json_value_s *value);
|
|
|
|
/* Extracts a value and all the data that makes it up into a newly created
|
|
* value. json_extract_value performs 1 call to alloc_func_ptr for the entire
|
|
* encoding. If alloc_func_ptr is null then malloc is used. */
|
|
json_weak struct json_value_s *
|
|
json_extract_value_ex(const struct json_value_s *value,
|
|
void *(*alloc_func_ptr)(void *, size_t), void *user_data);
|
|
|
|
/* Write out a minified JSON utf-8 string. This string is an encoding of the
|
|
* minimal string characters required to still encode the same data.
|
|
* json_write_minified performs 1 call to malloc for the entire encoding. Return
|
|
* 0 if an error occurred (malformed JSON input, or malloc failed). The out_size
|
|
* parameter is optional as the utf-8 string is null terminated. */
|
|
json_weak void *json_write_minified(const struct json_value_s *value,
|
|
size_t *out_size);
|
|
|
|
/* Write out a pretty JSON utf-8 string. This string is encoded such that the
|
|
* resultant JSON is pretty in that it is easily human readable. The indent and
|
|
* newline parameters allow a user to specify what kind of indentation and
|
|
* newline they want (two spaces / three spaces / tabs? \r, \n, \r\n ?). Both
|
|
* indent and newline can be NULL, indent defaults to two spaces (" "), and
|
|
* newline defaults to linux newlines ('\n' as the newline character).
|
|
* json_write_pretty performs 1 call to malloc for the entire encoding. Return 0
|
|
* if an error occurred (malformed JSON input, or malloc failed). The out_size
|
|
* parameter is optional as the utf-8 string is null terminated. */
|
|
json_weak void *json_write_pretty(const struct json_value_s *value,
|
|
const char *indent, const char *newline,
|
|
size_t *out_size);
|
|
|
|
/* Reinterpret a JSON value as a string. Returns null is the value was not a
|
|
* string. */
|
|
json_weak struct json_string_s *
|
|
json_value_as_string(struct json_value_s *const value);
|
|
|
|
/* Reinterpret a JSON value as a number. Returns null is the value was not a
|
|
* number. */
|
|
json_weak struct json_number_s *
|
|
json_value_as_number(struct json_value_s *const value);
|
|
|
|
/* Reinterpret a JSON value as an object. Returns null is the value was not an
|
|
* object. */
|
|
json_weak struct json_object_s *
|
|
json_value_as_object(struct json_value_s *const value);
|
|
|
|
/* Reinterpret a JSON value as an array. Returns null is the value was not an
|
|
* array. */
|
|
json_weak struct json_array_s *
|
|
json_value_as_array(struct json_value_s *const value);
|
|
|
|
/* Whether the value is true. */
|
|
json_weak int json_value_is_true(const struct json_value_s *const value);
|
|
|
|
/* Whether the value is false. */
|
|
json_weak int json_value_is_false(const struct json_value_s *const value);
|
|
|
|
/* Whether the value is null. */
|
|
json_weak int json_value_is_null(const struct json_value_s *const value);
|
|
|
|
/* The various types JSON values can be. Used to identify what a value is. */
|
|
typedef enum json_type_e {
|
|
json_type_string,
|
|
json_type_number,
|
|
json_type_object,
|
|
json_type_array,
|
|
json_type_true,
|
|
json_type_false,
|
|
json_type_null
|
|
|
|
} json_type_t;
|
|
|
|
/* A JSON string value. */
|
|
typedef struct json_string_s {
|
|
/* utf-8 string */
|
|
const char *string;
|
|
/* The size (in bytes) of the string */
|
|
size_t string_size;
|
|
|
|
} json_string_t;
|
|
|
|
/* A JSON string value (extended). */
|
|
typedef struct json_string_ex_s {
|
|
/* The JSON string this extends. */
|
|
struct json_string_s string;
|
|
|
|
/* The character offset for the value in the JSON input. */
|
|
size_t offset;
|
|
|
|
/* The line number for the value in the JSON input. */
|
|
size_t line_no;
|
|
|
|
/* The row number for the value in the JSON input, in bytes. */
|
|
size_t row_no;
|
|
|
|
} json_string_ex_t;
|
|
|
|
/* A JSON number value. */
|
|
typedef struct json_number_s {
|
|
/* ASCII string containing representation of the number. */
|
|
const char *number;
|
|
/* the size (in bytes) of the number. */
|
|
size_t number_size;
|
|
|
|
} json_number_t;
|
|
|
|
/* an element of a JSON object. */
|
|
typedef struct json_object_element_s {
|
|
/* the name of this element. */
|
|
struct json_string_s *name;
|
|
/* the value of this element. */
|
|
struct json_value_s *value;
|
|
/* the next object element (can be NULL if the last element in the object). */
|
|
struct json_object_element_s *next;
|
|
|
|
} json_object_element_t;
|
|
|
|
/* a JSON object value. */
|
|
typedef struct json_object_s {
|
|
/* a linked list of the elements in the object. */
|
|
struct json_object_element_s *start;
|
|
/* the number of elements in the object. */
|
|
size_t length;
|
|
|
|
} json_object_t;
|
|
|
|
/* an element of a JSON array. */
|
|
typedef struct json_array_element_s {
|
|
/* the value of this element. */
|
|
struct json_value_s *value;
|
|
/* the next array element (can be NULL if the last element in the array). */
|
|
struct json_array_element_s *next;
|
|
|
|
} json_array_element_t;
|
|
|
|
/* a JSON array value. */
|
|
typedef struct json_array_s {
|
|
/* a linked list of the elements in the array. */
|
|
struct json_array_element_s *start;
|
|
/* the number of elements in the array. */
|
|
size_t length;
|
|
|
|
} json_array_t;
|
|
|
|
/* a JSON value. */
|
|
typedef struct json_value_s {
|
|
/* a pointer to either a json_string_s, json_number_s, json_object_s, or. */
|
|
/* json_array_s. Should be cast to the appropriate struct type based on what.
|
|
*/
|
|
/* the type of this value is. */
|
|
void *payload;
|
|
/* must be one of json_type_e. If type is json_type_true, json_type_false, or.
|
|
*/
|
|
/* json_type_null, payload will be NULL. */
|
|
size_t type;
|
|
|
|
} json_value_t;
|
|
|
|
/* a JSON value (extended). */
|
|
typedef struct json_value_ex_s {
|
|
/* the JSON value this extends. */
|
|
struct json_value_s value;
|
|
|
|
/* the character offset for the value in the JSON input. */
|
|
size_t offset;
|
|
|
|
/* the line number for the value in the JSON input. */
|
|
size_t line_no;
|
|
|
|
/* the row number for the value in the JSON input, in bytes. */
|
|
size_t row_no;
|
|
|
|
} json_value_ex_t;
|
|
|
|
/* a parsing error code. */
|
|
enum json_parse_error_e {
|
|
/* no error occurred (huzzah!). */
|
|
json_parse_error_none = 0,
|
|
|
|
/* expected either a comma or a closing '}' or ']' to close an object or. */
|
|
/* array! */
|
|
json_parse_error_expected_comma_or_closing_bracket,
|
|
|
|
/* colon separating name/value pair was missing! */
|
|
json_parse_error_expected_colon,
|
|
|
|
/* expected string to begin with '"'! */
|
|
json_parse_error_expected_opening_quote,
|
|
|
|
/* invalid escaped sequence in string! */
|
|
json_parse_error_invalid_string_escape_sequence,
|
|
|
|
/* invalid number format! */
|
|
json_parse_error_invalid_number_format,
|
|
|
|
/* invalid value! */
|
|
json_parse_error_invalid_value,
|
|
|
|
/* reached end of buffer before object/array was complete! */
|
|
json_parse_error_premature_end_of_buffer,
|
|
|
|
/* string was malformed! */
|
|
json_parse_error_invalid_string,
|
|
|
|
/* a call to malloc, or a user provider allocator, failed. */
|
|
json_parse_error_allocator_failed,
|
|
|
|
/* the JSON input had unexpected trailing characters that weren't part of the.
|
|
JSON value. */
|
|
json_parse_error_unexpected_trailing_characters,
|
|
|
|
/* catch-all error for everything else that exploded (real bad chi!). */
|
|
json_parse_error_unknown
|
|
};
|
|
|
|
/* error report from json_parse_ex(). */
|
|
typedef struct json_parse_result_s {
|
|
/* the error code (one of json_parse_error_e). */
|
|
size_t error;
|
|
|
|
/* the character offset for the error in the JSON input. */
|
|
size_t error_offset;
|
|
|
|
/* the line number for the error in the JSON input. */
|
|
size_t error_line_no;
|
|
|
|
/* the row number for the error, in bytes. */
|
|
size_t error_row_no;
|
|
|
|
} json_parse_result_t;
|
|
|
|
#ifdef __cplusplus
|
|
} /* extern "C". */
|
|
#endif
|
|
|
|
#include <stdlib.h>
|
|
|
|
#if defined(_MSC_VER)
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
#if defined(_MSC_VER) && (_MSC_VER < 1920)
|
|
#define json_uintmax_t unsigned __int64
|
|
#else
|
|
#include <inttypes.h>
|
|
#define json_uintmax_t uintmax_t
|
|
#endif
|
|
|
|
#if defined(_MSC_VER)
|
|
#define json_strtoumax _strtoui64
|
|
#else
|
|
#define json_strtoumax strtoumax
|
|
#endif
|
|
|
|
#if defined(__cplusplus) && (__cplusplus >= 201103L)
|
|
#define json_null nullptr
|
|
#else
|
|
#define json_null 0
|
|
#endif
|
|
|
|
#if defined(__clang__)
|
|
#pragma clang diagnostic push
|
|
|
|
/* we do one big allocation via malloc, then cast aligned slices of this for. */
|
|
/* our structures - we don't have a way to tell the compiler we know what we. */
|
|
/* are doing, so disable the warning instead! */
|
|
#pragma clang diagnostic ignored "-Wcast-align"
|
|
|
|
/* We use C style casts everywhere. */
|
|
#pragma clang diagnostic ignored "-Wold-style-cast"
|
|
|
|
/* We need long long for strtoull. */
|
|
#pragma clang diagnostic ignored "-Wc++11-long-long"
|
|
|
|
/* Who cares if nullptr doesn't work with C++98, we don't use it there! */
|
|
#pragma clang diagnostic ignored "-Wc++98-compat"
|
|
#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
|
|
#elif defined(_MSC_VER)
|
|
#pragma warning(push)
|
|
|
|
/* disable 'function selected for inline expansion' warning. */
|
|
#pragma warning(disable : 4711)
|
|
|
|
/* disable '#pragma warning: there is no warning number' warning. */
|
|
#pragma warning(disable : 4619)
|
|
|
|
/* disable 'warning number not a valid compiler warning' warning. */
|
|
#pragma warning(disable : 4616)
|
|
|
|
/* disable 'Compiler will insert Spectre mitigation for memory load if
|
|
* /Qspectre. */
|
|
/* switch specified' warning. */
|
|
#pragma warning(disable : 5045)
|
|
#endif
|
|
|
|
struct json_parse_state_s {
|
|
const char *src;
|
|
size_t size;
|
|
size_t offset;
|
|
size_t flags_bitset;
|
|
char *data;
|
|
char *dom;
|
|
size_t dom_size;
|
|
size_t data_size;
|
|
size_t line_no; /* line counter for error reporting. */
|
|
size_t line_offset; /* (offset-line_offset) is the character number (in
|
|
bytes). */
|
|
size_t error;
|
|
};
|
|
|
|
json_weak int json_hexadecimal_digit(const char c);
|
|
int json_hexadecimal_digit(const char c) {
|
|
if ('0' <= c && c <= '9') {
|
|
return c - '0';
|
|
}
|
|
if ('a' <= c && c <= 'f') {
|
|
return c - 'a' + 10;
|
|
}
|
|
if ('A' <= c && c <= 'F') {
|
|
return c - 'A' + 10;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
json_weak int json_hexadecimal_value(const char *c, const unsigned long size,
|
|
unsigned long *result);
|
|
int json_hexadecimal_value(const char *c, const unsigned long size,
|
|
unsigned long *result) {
|
|
const char *p;
|
|
int digit;
|
|
|
|
if (size > sizeof(unsigned long) * 2) {
|
|
return 0;
|
|
}
|
|
|
|
*result = 0;
|
|
for (p = c; (unsigned long)(p - c) < size; ++p) {
|
|
*result <<= 4;
|
|
digit = json_hexadecimal_digit(*p);
|
|
if (digit < 0 || digit > 15) {
|
|
return 0;
|
|
}
|
|
*result |= (unsigned char)digit;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
json_weak int json_skip_whitespace(struct json_parse_state_s *state);
|
|
int json_skip_whitespace(struct json_parse_state_s *state) {
|
|
size_t offset = state->offset;
|
|
const size_t size = state->size;
|
|
const char *const src = state->src;
|
|
|
|
if (offset >= state->size) {
|
|
return 0;
|
|
}
|
|
|
|
/* the only valid whitespace according to ECMA-404 is ' ', '\n', '\r' and
|
|
* '\t'. */
|
|
switch (src[offset]) {
|
|
default:
|
|
return 0;
|
|
case ' ':
|
|
case '\r':
|
|
case '\t':
|
|
case '\n':
|
|
break;
|
|
}
|
|
|
|
do {
|
|
switch (src[offset]) {
|
|
default:
|
|
/* Update offset. */
|
|
state->offset = offset;
|
|
return 1;
|
|
case ' ':
|
|
case '\r':
|
|
case '\t':
|
|
break;
|
|
case '\n':
|
|
state->line_no++;
|
|
state->line_offset = offset;
|
|
break;
|
|
}
|
|
|
|
offset++;
|
|
} while (offset < size);
|
|
|
|
/* Update offset. */
|
|
state->offset = offset;
|
|
return 1;
|
|
}
|
|
|
|
json_weak int json_skip_c_style_comments(struct json_parse_state_s *state);
|
|
int json_skip_c_style_comments(struct json_parse_state_s *state) {
|
|
/* to have a C-style comment we need at least 2 characters of space */
|
|
if ((state->offset + 2) > state->size) {
|
|
return 0;
|
|
}
|
|
|
|
/* do we have a comment? */
|
|
if ('/' == state->src[state->offset]) {
|
|
if ('/' == state->src[state->offset + 1]) {
|
|
/* we had a comment of the form // */
|
|
|
|
/* skip first '/' */
|
|
state->offset++;
|
|
|
|
/* skip second '/' */
|
|
state->offset++;
|
|
|
|
while (state->offset < state->size) {
|
|
switch (state->src[state->offset]) {
|
|
default:
|
|
/* skip the character in the comment */
|
|
state->offset++;
|
|
break;
|
|
case '\n':
|
|
/* if we have a newline, our comment has ended! Skip the newline */
|
|
state->offset++;
|
|
|
|
/* we entered a newline, so move our line info forward */
|
|
state->line_no++;
|
|
state->line_offset = state->offset;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
/* we reached the end of the JSON file! */
|
|
return 1;
|
|
} else if ('*' == state->src[state->offset + 1]) {
|
|
/* we had a comment in the C-style long form */
|
|
|
|
/* skip '/' */
|
|
state->offset++;
|
|
|
|
/* skip '*' */
|
|
state->offset++;
|
|
|
|
while (state->offset + 1 < state->size) {
|
|
if (('*' == state->src[state->offset]) &&
|
|
('/' == state->src[state->offset + 1])) {
|
|
/* we reached the end of our comment! */
|
|
state->offset += 2;
|
|
return 1;
|
|
} else if ('\n' == state->src[state->offset]) {
|
|
/* we entered a newline, so move our line info forward */
|
|
state->line_no++;
|
|
state->line_offset = state->offset;
|
|
}
|
|
|
|
/* skip character within comment */
|
|
state->offset++;
|
|
}
|
|
|
|
/* comment wasn't ended correctly which is a failure */
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
/* we didn't have any comment, which is ok too! */
|
|
return 0;
|
|
}
|
|
|
|
json_weak int json_skip_all_skippables(struct json_parse_state_s *state);
|
|
int json_skip_all_skippables(struct json_parse_state_s *state) {
|
|
/* skip all whitespace and other skippables until there are none left. note
|
|
* that the previous version suffered from read past errors should. the
|
|
* stream end on json_skip_c_style_comments eg. '{"a" ' with comments flag.
|
|
*/
|
|
|
|
int did_consume = 0;
|
|
const size_t size = state->size;
|
|
|
|
if (json_parse_flags_allow_c_style_comments & state->flags_bitset) {
|
|
do {
|
|
if (state->offset == size) {
|
|
state->error = json_parse_error_premature_end_of_buffer;
|
|
return 1;
|
|
}
|
|
|
|
did_consume = json_skip_whitespace(state);
|
|
|
|
/* This should really be checked on access, not in front of every call.
|
|
*/
|
|
if (state->offset >= size) {
|
|
state->error = json_parse_error_premature_end_of_buffer;
|
|
return 1;
|
|
}
|
|
|
|
did_consume |= json_skip_c_style_comments(state);
|
|
} while (0 != did_consume);
|
|
} else {
|
|
do {
|
|
if (state->offset == size) {
|
|
state->error = json_parse_error_premature_end_of_buffer;
|
|
return 1;
|
|
}
|
|
|
|
did_consume = json_skip_whitespace(state);
|
|
} while (0 != did_consume);
|
|
}
|
|
|
|
if (state->offset == size) {
|
|
state->error = json_parse_error_premature_end_of_buffer;
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
json_weak int json_get_value_size(struct json_parse_state_s *state,
|
|
int is_global_object);
|
|
|
|
json_weak int json_get_string_size(struct json_parse_state_s *state,
|
|
size_t is_key);
|
|
int json_get_string_size(struct json_parse_state_s *state, size_t is_key) {
|
|
size_t offset = state->offset;
|
|
const size_t size = state->size;
|
|
size_t data_size = 0;
|
|
const char *const src = state->src;
|
|
const int is_single_quote = '\'' == src[offset];
|
|
const char quote_to_use = is_single_quote ? '\'' : '"';
|
|
const size_t flags_bitset = state->flags_bitset;
|
|
unsigned long codepoint;
|
|
unsigned long high_surrogate = 0;
|
|
|
|
if ((json_parse_flags_allow_location_information & flags_bitset) != 0 &&
|
|
is_key != 0) {
|
|
state->dom_size += sizeof(struct json_string_ex_s);
|
|
} else {
|
|
state->dom_size += sizeof(struct json_string_s);
|
|
}
|
|
|
|
if ('"' != src[offset]) {
|
|
/* if we are allowed single quoted strings check for that too. */
|
|
if (!((json_parse_flags_allow_single_quoted_strings & flags_bitset) &&
|
|
is_single_quote)) {
|
|
state->error = json_parse_error_expected_opening_quote;
|
|
state->offset = offset;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
/* skip leading '"' or '\''. */
|
|
offset++;
|
|
|
|
while ((offset < size) && (quote_to_use != src[offset])) {
|
|
/* add space for the character. */
|
|
data_size++;
|
|
|
|
switch (src[offset]) {
|
|
default:
|
|
break;
|
|
case '\0':
|
|
case '\t':
|
|
state->error = json_parse_error_invalid_string;
|
|
state->offset = offset;
|
|
return 1;
|
|
}
|
|
|
|
if ('\\' == src[offset]) {
|
|
/* skip reverse solidus character. */
|
|
offset++;
|
|
|
|
if (offset == size) {
|
|
state->error = json_parse_error_premature_end_of_buffer;
|
|
state->offset = offset;
|
|
return 1;
|
|
}
|
|
|
|
switch (src[offset]) {
|
|
default:
|
|
state->error = json_parse_error_invalid_string_escape_sequence;
|
|
state->offset = offset;
|
|
return 1;
|
|
case '"':
|
|
case '\\':
|
|
case '/':
|
|
case 'b':
|
|
case 'f':
|
|
case 'n':
|
|
case 'r':
|
|
case 't':
|
|
/* all valid characters! */
|
|
offset++;
|
|
break;
|
|
case 'u':
|
|
if (!(offset + 5 < size)) {
|
|
/* invalid escaped unicode sequence! */
|
|
state->error = json_parse_error_invalid_string_escape_sequence;
|
|
state->offset = offset;
|
|
return 1;
|
|
}
|
|
|
|
codepoint = 0;
|
|
if (!json_hexadecimal_value(&src[offset + 1], 4, &codepoint)) {
|
|
/* escaped unicode sequences must contain 4 hexadecimal digits! */
|
|
state->error = json_parse_error_invalid_string_escape_sequence;
|
|
state->offset = offset;
|
|
return 1;
|
|
}
|
|
|
|
/* Valid sequence!
|
|
* see: https://en.wikipedia.org/wiki/UTF-8#Invalid_code_points.
|
|
* 1 7 U + 0000 U + 007F 0xxxxxxx.
|
|
* 2 11 U + 0080 U + 07FF 110xxxxx
|
|
* 10xxxxxx.
|
|
* 3 16 U + 0800 U + FFFF 1110xxxx
|
|
* 10xxxxxx 10xxxxxx.
|
|
* 4 21 U + 10000 U + 10FFFF 11110xxx
|
|
* 10xxxxxx 10xxxxxx 10xxxxxx.
|
|
* Note: the high and low surrogate halves used by UTF-16 (U+D800
|
|
* through U+DFFF) and code points not encodable by UTF-16 (those after
|
|
* U+10FFFF) are not legal Unicode values, and their UTF-8 encoding must
|
|
* be treated as an invalid byte sequence. */
|
|
|
|
if (high_surrogate != 0) {
|
|
/* we previously read the high half of the \uxxxx\uxxxx pair, so now
|
|
* we expect the low half. */
|
|
if (codepoint >= 0xdc00 &&
|
|
codepoint <= 0xdfff) { /* low surrogate range. */
|
|
data_size += 3;
|
|
high_surrogate = 0;
|
|
} else {
|
|
state->error = json_parse_error_invalid_string_escape_sequence;
|
|
state->offset = offset;
|
|
return 1;
|
|
}
|
|
} else if (codepoint <= 0x7f) {
|
|
data_size += 0;
|
|
} else if (codepoint <= 0x7ff) {
|
|
data_size += 1;
|
|
} else if (codepoint >= 0xd800 &&
|
|
codepoint <= 0xdbff) { /* high surrogate range. */
|
|
/* The codepoint is the first half of a "utf-16 surrogate pair". so we
|
|
* need the other half for it to be valid: \uHHHH\uLLLL. */
|
|
if (offset + 11 > size || '\\' != src[offset + 5] ||
|
|
'u' != src[offset + 6]) {
|
|
state->error = json_parse_error_invalid_string_escape_sequence;
|
|
state->offset = offset;
|
|
return 1;
|
|
}
|
|
high_surrogate = codepoint;
|
|
} else if (codepoint >= 0xd800 &&
|
|
codepoint <= 0xdfff) { /* low surrogate range. */
|
|
/* we did not read the other half before. */
|
|
state->error = json_parse_error_invalid_string_escape_sequence;
|
|
state->offset = offset;
|
|
return 1;
|
|
} else {
|
|
data_size += 2;
|
|
}
|
|
/* escaped codepoints after 0xffff are supported in json through utf-16
|
|
* surrogate pairs: \uD83D\uDD25 for U+1F525. */
|
|
|
|
offset += 5;
|
|
break;
|
|
}
|
|
} else if (('\r' == src[offset]) || ('\n' == src[offset])) {
|
|
if (!(json_parse_flags_allow_multi_line_strings & flags_bitset)) {
|
|
/* invalid escaped unicode sequence! */
|
|
state->error = json_parse_error_invalid_string_escape_sequence;
|
|
state->offset = offset;
|
|
return 1;
|
|
}
|
|
|
|
offset++;
|
|
} else {
|
|
/* skip character (valid part of sequence). */
|
|
offset++;
|
|
}
|
|
}
|
|
|
|
/* If the offset is equal to the size, we had a non-terminated string! */
|
|
if (offset == size) {
|
|
state->error = json_parse_error_premature_end_of_buffer;
|
|
state->offset = offset - 1;
|
|
return 1;
|
|
}
|
|
|
|
/* skip trailing '"' or '\''. */
|
|
offset++;
|
|
|
|
/* add enough space to store the string. */
|
|
state->data_size += data_size;
|
|
|
|
/* one more byte for null terminator ending the string! */
|
|
state->data_size++;
|
|
|
|
/* update offset. */
|
|
state->offset = offset;
|
|
|
|
return 0;
|
|
}
|
|
|
|
json_weak int is_valid_unquoted_key_char(const char c);
|
|
int is_valid_unquoted_key_char(const char c) {
|
|
return (('0' <= c && c <= '9') || ('a' <= c && c <= 'z') ||
|
|
('A' <= c && c <= 'Z') || ('_' == c));
|
|
}
|
|
|
|
json_weak int json_get_key_size(struct json_parse_state_s *state);
|
|
int json_get_key_size(struct json_parse_state_s *state) {
|
|
const size_t flags_bitset = state->flags_bitset;
|
|
|
|
if (json_parse_flags_allow_unquoted_keys & flags_bitset) {
|
|
size_t offset = state->offset;
|
|
const size_t size = state->size;
|
|
const char *const src = state->src;
|
|
size_t data_size = state->data_size;
|
|
|
|
/* if we are allowing unquoted keys, first grok for a quote... */
|
|
if ('"' == src[offset]) {
|
|
/* ... if we got a comma, just parse the key as a string as normal. */
|
|
return json_get_string_size(state, 1);
|
|
} else if ((json_parse_flags_allow_single_quoted_strings & flags_bitset) &&
|
|
('\'' == src[offset])) {
|
|
/* ... if we got a comma, just parse the key as a string as normal. */
|
|
return json_get_string_size(state, 1);
|
|
} else {
|
|
while ((offset < size) && is_valid_unquoted_key_char(src[offset])) {
|
|
offset++;
|
|
data_size++;
|
|
}
|
|
|
|
/* one more byte for null terminator ending the string! */
|
|
data_size++;
|
|
|
|
if (json_parse_flags_allow_location_information & flags_bitset) {
|
|
state->dom_size += sizeof(struct json_string_ex_s);
|
|
} else {
|
|
state->dom_size += sizeof(struct json_string_s);
|
|
}
|
|
|
|
/* update offset. */
|
|
state->offset = offset;
|
|
|
|
/* update data_size. */
|
|
state->data_size = data_size;
|
|
|
|
return 0;
|
|
}
|
|
} else {
|
|
/* we are only allowed to have quoted keys, so just parse a string! */
|
|
return json_get_string_size(state, 1);
|
|
}
|
|
}
|
|
|
|
json_weak int json_get_object_size(struct json_parse_state_s *state,
|
|
int is_global_object);
|
|
int json_get_object_size(struct json_parse_state_s *state,
|
|
int is_global_object) {
|
|
const size_t flags_bitset = state->flags_bitset;
|
|
const char *const src = state->src;
|
|
const size_t size = state->size;
|
|
size_t elements = 0;
|
|
int allow_comma = 0;
|
|
int found_closing_brace = 0;
|
|
|
|
if (is_global_object) {
|
|
/* if we found an opening '{' of an object, we actually have a normal JSON
|
|
* object at the root of the DOM... */
|
|
if (!json_skip_all_skippables(state) && '{' == state->src[state->offset]) {
|
|
/* . and we don't actually have a global object after all! */
|
|
is_global_object = 0;
|
|
}
|
|
}
|
|
|
|
if (!is_global_object) {
|
|
if ('{' != src[state->offset]) {
|
|
state->error = json_parse_error_unknown;
|
|
return 1;
|
|
}
|
|
|
|
/* skip leading '{'. */
|
|
state->offset++;
|
|
}
|
|
|
|
state->dom_size += sizeof(struct json_object_s);
|
|
|
|
if ((state->offset == size) && !is_global_object) {
|
|
state->error = json_parse_error_premature_end_of_buffer;
|
|
return 1;
|
|
}
|
|
|
|
do {
|
|
if (!is_global_object) {
|
|
if (json_skip_all_skippables(state)) {
|
|
state->error = json_parse_error_premature_end_of_buffer;
|
|
return 1;
|
|
}
|
|
|
|
if ('}' == src[state->offset]) {
|
|
/* skip trailing '}'. */
|
|
state->offset++;
|
|
|
|
found_closing_brace = 1;
|
|
|
|
/* finished the object! */
|
|
break;
|
|
}
|
|
} else {
|
|
/* we don't require brackets, so that means the object ends when the input
|
|
* stream ends! */
|
|
if (json_skip_all_skippables(state)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* if we parsed at least one element previously, grok for a comma. */
|
|
if (allow_comma) {
|
|
if (',' == src[state->offset]) {
|
|
/* skip comma. */
|
|
state->offset++;
|
|
allow_comma = 0;
|
|
} else if (json_parse_flags_allow_no_commas & flags_bitset) {
|
|
/* we don't require a comma, and we didn't find one, which is ok! */
|
|
allow_comma = 0;
|
|
} else {
|
|
/* otherwise we are required to have a comma, and we found none. */
|
|
state->error = json_parse_error_expected_comma_or_closing_bracket;
|
|
return 1;
|
|
}
|
|
|
|
if (json_parse_flags_allow_trailing_comma & flags_bitset) {
|
|
continue;
|
|
} else {
|
|
if (json_skip_all_skippables(state)) {
|
|
state->error = json_parse_error_premature_end_of_buffer;
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (json_get_key_size(state)) {
|
|
/* key parsing failed! */
|
|
state->error = json_parse_error_invalid_string;
|
|
return 1;
|
|
}
|
|
|
|
if (json_skip_all_skippables(state)) {
|
|
state->error = json_parse_error_premature_end_of_buffer;
|
|
return 1;
|
|
}
|
|
|
|
if (json_parse_flags_allow_equals_in_object & flags_bitset) {
|
|
const char current = src[state->offset];
|
|
if ((':' != current) && ('=' != current)) {
|
|
state->error = json_parse_error_expected_colon;
|
|
return 1;
|
|
}
|
|
} else {
|
|
if (':' != src[state->offset]) {
|
|
state->error = json_parse_error_expected_colon;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
/* skip colon. */
|
|
state->offset++;
|
|
|
|
if (json_skip_all_skippables(state)) {
|
|
state->error = json_parse_error_premature_end_of_buffer;
|
|
return 1;
|
|
}
|
|
|
|
if (json_get_value_size(state, /* is_global_object = */ 0)) {
|
|
/* value parsing failed! */
|
|
return 1;
|
|
}
|
|
|
|
/* successfully parsed a name/value pair! */
|
|
elements++;
|
|
allow_comma = 1;
|
|
} while (state->offset < size);
|
|
|
|
if ((state->offset == size) && !is_global_object && !found_closing_brace) {
|
|
state->error = json_parse_error_premature_end_of_buffer;
|
|
return 1;
|
|
}
|
|
|
|
state->dom_size += sizeof(struct json_object_element_s) * elements;
|
|
|
|
return 0;
|
|
}
|
|
|
|
json_weak int json_get_array_size(struct json_parse_state_s *state);
|
|
int json_get_array_size(struct json_parse_state_s *state) {
|
|
const size_t flags_bitset = state->flags_bitset;
|
|
size_t elements = 0;
|
|
int allow_comma = 0;
|
|
const char *const src = state->src;
|
|
const size_t size = state->size;
|
|
|
|
if ('[' != src[state->offset]) {
|
|
/* expected array to begin with leading '['. */
|
|
state->error = json_parse_error_unknown;
|
|
return 1;
|
|
}
|
|
|
|
/* skip leading '['. */
|
|
state->offset++;
|
|
|
|
state->dom_size += sizeof(struct json_array_s);
|
|
|
|
while (state->offset < size) {
|
|
if (json_skip_all_skippables(state)) {
|
|
state->error = json_parse_error_premature_end_of_buffer;
|
|
return 1;
|
|
}
|
|
|
|
if (']' == src[state->offset]) {
|
|
/* skip trailing ']'. */
|
|
state->offset++;
|
|
|
|
state->dom_size += sizeof(struct json_array_element_s) * elements;
|
|
|
|
/* finished the object! */
|
|
return 0;
|
|
}
|
|
|
|
/* if we parsed at least once element previously, grok for a comma. */
|
|
if (allow_comma) {
|
|
if (',' == src[state->offset]) {
|
|
/* skip comma. */
|
|
state->offset++;
|
|
allow_comma = 0;
|
|
} else if (!(json_parse_flags_allow_no_commas & flags_bitset)) {
|
|
state->error = json_parse_error_expected_comma_or_closing_bracket;
|
|
return 1;
|
|
}
|
|
|
|
if (json_parse_flags_allow_trailing_comma & flags_bitset) {
|
|
allow_comma = 0;
|
|
continue;
|
|
} else {
|
|
if (json_skip_all_skippables(state)) {
|
|
state->error = json_parse_error_premature_end_of_buffer;
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (json_get_value_size(state, /* is_global_object = */ 0)) {
|
|
/* value parsing failed! */
|
|
return 1;
|
|
}
|
|
|
|
/* successfully parsed an array element! */
|
|
elements++;
|
|
allow_comma = 1;
|
|
}
|
|
|
|
/* we consumed the entire input before finding the closing ']' of the array!
|
|
*/
|
|
state->error = json_parse_error_premature_end_of_buffer;
|
|
return 1;
|
|
}
|
|
|
|
json_weak int json_get_number_size(struct json_parse_state_s *state);
|
|
int json_get_number_size(struct json_parse_state_s *state) {
|
|
const size_t flags_bitset = state->flags_bitset;
|
|
size_t offset = state->offset;
|
|
const size_t size = state->size;
|
|
int had_leading_digits = 0;
|
|
const char *const src = state->src;
|
|
|
|
state->dom_size += sizeof(struct json_number_s);
|
|
|
|
if ((json_parse_flags_allow_hexadecimal_numbers & flags_bitset) &&
|
|
(offset + 1 < size) && ('0' == src[offset]) &&
|
|
(('x' == src[offset + 1]) || ('X' == src[offset + 1]))) {
|
|
/* skip the leading 0x that identifies a hexadecimal number. */
|
|
offset += 2;
|
|
|
|
/* consume hexadecimal digits. */
|
|
while ((offset < size) && (('0' <= src[offset] && src[offset] <= '9') ||
|
|
('a' <= src[offset] && src[offset] <= 'f') ||
|
|
('A' <= src[offset] && src[offset] <= 'F'))) {
|
|
offset++;
|
|
}
|
|
} else {
|
|
int found_sign = 0;
|
|
int inf_or_nan = 0;
|
|
|
|
if ((offset < size) &&
|
|
(('-' == src[offset]) ||
|
|
((json_parse_flags_allow_leading_plus_sign & flags_bitset) &&
|
|
('+' == src[offset])))) {
|
|
/* skip valid leading '-' or '+'. */
|
|
offset++;
|
|
|
|
found_sign = 1;
|
|
}
|
|
|
|
if (json_parse_flags_allow_inf_and_nan & flags_bitset) {
|
|
const char inf[9] = "Infinity";
|
|
const size_t inf_strlen = sizeof(inf) - 1;
|
|
const char nan[4] = "NaN";
|
|
const size_t nan_strlen = sizeof(nan) - 1;
|
|
|
|
if (offset + inf_strlen < size) {
|
|
int found = 1;
|
|
size_t i;
|
|
for (i = 0; i < inf_strlen; i++) {
|
|
if (inf[i] != src[offset + i]) {
|
|
found = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (found) {
|
|
/* We found our special 'Infinity' keyword! */
|
|
offset += inf_strlen;
|
|
|
|
inf_or_nan = 1;
|
|
}
|
|
}
|
|
|
|
if (offset + nan_strlen < size) {
|
|
int found = 1;
|
|
size_t i;
|
|
for (i = 0; i < nan_strlen; i++) {
|
|
if (nan[i] != src[offset + i]) {
|
|
found = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (found) {
|
|
/* We found our special 'NaN' keyword! */
|
|
offset += nan_strlen;
|
|
|
|
inf_or_nan = 1;
|
|
}
|
|
}
|
|
|
|
if (inf_or_nan) {
|
|
if (offset < size) {
|
|
switch (src[offset]) {
|
|
default:
|
|
break;
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
case 'e':
|
|
case 'E':
|
|
/* cannot follow an inf or nan with digits! */
|
|
state->error = json_parse_error_invalid_number_format;
|
|
state->offset = offset;
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (found_sign && !inf_or_nan && (offset < size) &&
|
|
!('0' <= src[offset] && src[offset] <= '9')) {
|
|
/* check if we are allowing leading '.'. */
|
|
if (!(json_parse_flags_allow_leading_or_trailing_decimal_point &
|
|
flags_bitset) ||
|
|
('.' != src[offset])) {
|
|
/* a leading '-' must be immediately followed by any digit! */
|
|
state->error = json_parse_error_invalid_number_format;
|
|
state->offset = offset;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if ((offset < size) && ('0' == src[offset])) {
|
|
/* skip valid '0'. */
|
|
offset++;
|
|
|
|
/* we need to record whether we had any leading digits for checks later.
|
|
*/
|
|
had_leading_digits = 1;
|
|
|
|
if ((offset < size) && ('0' <= src[offset] && src[offset] <= '9')) {
|
|
/* a leading '0' must not be immediately followed by any digit! */
|
|
state->error = json_parse_error_invalid_number_format;
|
|
state->offset = offset;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
/* the main digits of our number next. */
|
|
while ((offset < size) && ('0' <= src[offset] && src[offset] <= '9')) {
|
|
offset++;
|
|
|
|
/* we need to record whether we had any leading digits for checks later.
|
|
*/
|
|
had_leading_digits = 1;
|
|
}
|
|
|
|
if ((offset < size) && ('.' == src[offset])) {
|
|
offset++;
|
|
|
|
if ((offset >= size) || !('0' <= src[offset] && src[offset] <= '9')) {
|
|
if (!(json_parse_flags_allow_leading_or_trailing_decimal_point &
|
|
flags_bitset) ||
|
|
!had_leading_digits) {
|
|
/* a decimal point must be followed by at least one digit. */
|
|
state->error = json_parse_error_invalid_number_format;
|
|
state->offset = offset;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
/* a decimal point can be followed by more digits of course! */
|
|
while ((offset < size) && ('0' <= src[offset] && src[offset] <= '9')) {
|
|
offset++;
|
|
}
|
|
}
|
|
|
|
if ((offset < size) && ('e' == src[offset] || 'E' == src[offset])) {
|
|
/* our number has an exponent! Skip 'e' or 'E'. */
|
|
offset++;
|
|
|
|
if ((offset < size) && ('-' == src[offset] || '+' == src[offset])) {
|
|
/* skip optional '-' or '+'. */
|
|
offset++;
|
|
}
|
|
|
|
if ((offset < size) && !('0' <= src[offset] && src[offset] <= '9')) {
|
|
/* an exponent must have at least one digit! */
|
|
state->error = json_parse_error_invalid_number_format;
|
|
state->offset = offset;
|
|
return 1;
|
|
}
|
|
|
|
/* consume exponent digits. */
|
|
do {
|
|
offset++;
|
|
} while ((offset < size) && ('0' <= src[offset] && src[offset] <= '9'));
|
|
}
|
|
}
|
|
|
|
if (offset < size) {
|
|
switch (src[offset]) {
|
|
case ' ':
|
|
case '\t':
|
|
case '\r':
|
|
case '\n':
|
|
case '}':
|
|
case ',':
|
|
case ']':
|
|
/* all of the above are ok. */
|
|
break;
|
|
case '=':
|
|
if (json_parse_flags_allow_equals_in_object & flags_bitset) {
|
|
break;
|
|
}
|
|
|
|
state->error = json_parse_error_invalid_number_format;
|
|
state->offset = offset;
|
|
return 1;
|
|
default:
|
|
state->error = json_parse_error_invalid_number_format;
|
|
state->offset = offset;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
state->data_size += offset - state->offset;
|
|
|
|
/* one more byte for null terminator ending the number string! */
|
|
state->data_size++;
|
|
|
|
/* update offset. */
|
|
state->offset = offset;
|
|
|
|
return 0;
|
|
}
|
|
|
|
json_weak int json_get_value_size(struct json_parse_state_s *state,
|
|
int is_global_object);
|
|
int json_get_value_size(struct json_parse_state_s *state,
|
|
int is_global_object) {
|
|
const size_t flags_bitset = state->flags_bitset;
|
|
const char *const src = state->src;
|
|
size_t offset;
|
|
const size_t size = state->size;
|
|
|
|
if (json_parse_flags_allow_location_information & flags_bitset) {
|
|
state->dom_size += sizeof(struct json_value_ex_s);
|
|
} else {
|
|
state->dom_size += sizeof(struct json_value_s);
|
|
}
|
|
|
|
if (is_global_object) {
|
|
return json_get_object_size(state, /* is_global_object = */ 1);
|
|
} else {
|
|
if (json_skip_all_skippables(state)) {
|
|
state->error = json_parse_error_premature_end_of_buffer;
|
|
return 1;
|
|
}
|
|
|
|
/* can cache offset now. */
|
|
offset = state->offset;
|
|
|
|
switch (src[offset]) {
|
|
case '"':
|
|
return json_get_string_size(state, 0);
|
|
case '\'':
|
|
if (json_parse_flags_allow_single_quoted_strings & flags_bitset) {
|
|
return json_get_string_size(state, 0);
|
|
} else {
|
|
/* invalid value! */
|
|
state->error = json_parse_error_invalid_value;
|
|
return 1;
|
|
}
|
|
case '{':
|
|
return json_get_object_size(state, /* is_global_object = */ 0);
|
|
case '[':
|
|
return json_get_array_size(state);
|
|
case '-':
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
return json_get_number_size(state);
|
|
case '+':
|
|
if (json_parse_flags_allow_leading_plus_sign & flags_bitset) {
|
|
return json_get_number_size(state);
|
|
} else {
|
|
/* invalid value! */
|
|
state->error = json_parse_error_invalid_number_format;
|
|
return 1;
|
|
}
|
|
case '.':
|
|
if (json_parse_flags_allow_leading_or_trailing_decimal_point &
|
|
flags_bitset) {
|
|
return json_get_number_size(state);
|
|
} else {
|
|
/* invalid value! */
|
|
state->error = json_parse_error_invalid_number_format;
|
|
return 1;
|
|
}
|
|
default:
|
|
if ((offset + 4) <= size && 't' == src[offset + 0] &&
|
|
'r' == src[offset + 1] && 'u' == src[offset + 2] &&
|
|
'e' == src[offset + 3]) {
|
|
state->offset += 4;
|
|
return 0;
|
|
} else if ((offset + 5) <= size && 'f' == src[offset + 0] &&
|
|
'a' == src[offset + 1] && 'l' == src[offset + 2] &&
|
|
's' == src[offset + 3] && 'e' == src[offset + 4]) {
|
|
state->offset += 5;
|
|
return 0;
|
|
} else if ((offset + 4) <= size && 'n' == state->src[offset + 0] &&
|
|
'u' == state->src[offset + 1] &&
|
|
'l' == state->src[offset + 2] &&
|
|
'l' == state->src[offset + 3]) {
|
|
state->offset += 4;
|
|
return 0;
|
|
} else if ((json_parse_flags_allow_inf_and_nan & flags_bitset) &&
|
|
(offset + 3) <= size && 'N' == src[offset + 0] &&
|
|
'a' == src[offset + 1] && 'N' == src[offset + 2]) {
|
|
return json_get_number_size(state);
|
|
} else if ((json_parse_flags_allow_inf_and_nan & flags_bitset) &&
|
|
(offset + 8) <= size && 'I' == src[offset + 0] &&
|
|
'n' == src[offset + 1] && 'f' == src[offset + 2] &&
|
|
'i' == src[offset + 3] && 'n' == src[offset + 4] &&
|
|
'i' == src[offset + 5] && 't' == src[offset + 6] &&
|
|
'y' == src[offset + 7]) {
|
|
return json_get_number_size(state);
|
|
}
|
|
|
|
/* invalid value! */
|
|
state->error = json_parse_error_invalid_value;
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
json_weak void json_parse_value(struct json_parse_state_s *state,
|
|
int is_global_object,
|
|
struct json_value_s *value);
|
|
|
|
json_weak void json_parse_string(struct json_parse_state_s *state,
|
|
struct json_string_s *string);
|
|
void json_parse_string(struct json_parse_state_s *state,
|
|
struct json_string_s *string) {
|
|
size_t offset = state->offset;
|
|
size_t bytes_written = 0;
|
|
const char *const src = state->src;
|
|
const char quote_to_use = '\'' == src[offset] ? '\'' : '"';
|
|
char *data = state->data;
|
|
unsigned long high_surrogate = 0;
|
|
unsigned long codepoint;
|
|
|
|
string->string = data;
|
|
|
|
/* skip leading '"' or '\''. */
|
|
offset++;
|
|
|
|
while (quote_to_use != src[offset]) {
|
|
if ('\\' == src[offset]) {
|
|
/* skip the reverse solidus. */
|
|
offset++;
|
|
|
|
switch (src[offset++]) {
|
|
default:
|
|
return; /* we cannot ever reach here. */
|
|
case 'u': {
|
|
codepoint = 0;
|
|
if (!json_hexadecimal_value(&src[offset], 4, &codepoint)) {
|
|
return; /* this shouldn't happen as the value was already validated.
|
|
*/
|
|
}
|
|
|
|
offset += 4;
|
|
|
|
if (codepoint <= 0x7fu) {
|
|
data[bytes_written++] = (char)codepoint; /* 0xxxxxxx. */
|
|
} else if (codepoint <= 0x7ffu) {
|
|
data[bytes_written++] =
|
|
(char)(0xc0u | (codepoint >> 6)); /* 110xxxxx. */
|
|
data[bytes_written++] =
|
|
(char)(0x80u | (codepoint & 0x3fu)); /* 10xxxxxx. */
|
|
} else if (codepoint >= 0xd800 &&
|
|
codepoint <= 0xdbff) { /* high surrogate. */
|
|
high_surrogate = codepoint;
|
|
continue; /* we need the low half to form a complete codepoint. */
|
|
} else if (codepoint >= 0xdc00 &&
|
|
codepoint <= 0xdfff) { /* low surrogate. */
|
|
/* combine with the previously read half to obtain the complete
|
|
* codepoint. */
|
|
const unsigned long surrogate_offset =
|
|
0x10000u - (0xD800u << 10) - 0xDC00u;
|
|
codepoint = (high_surrogate << 10) + codepoint + surrogate_offset;
|
|
high_surrogate = 0;
|
|
data[bytes_written++] =
|
|
(char)(0xF0u | (codepoint >> 18)); /* 11110xxx. */
|
|
data[bytes_written++] =
|
|
(char)(0x80u | ((codepoint >> 12) & 0x3fu)); /* 10xxxxxx. */
|
|
data[bytes_written++] =
|
|
(char)(0x80u | ((codepoint >> 6) & 0x3fu)); /* 10xxxxxx. */
|
|
data[bytes_written++] =
|
|
(char)(0x80u | (codepoint & 0x3fu)); /* 10xxxxxx. */
|
|
} else {
|
|
/* we assume the value was validated and thus is within the valid
|
|
* range. */
|
|
data[bytes_written++] =
|
|
(char)(0xe0u | (codepoint >> 12)); /* 1110xxxx. */
|
|
data[bytes_written++] =
|
|
(char)(0x80u | ((codepoint >> 6) & 0x3fu)); /* 10xxxxxx. */
|
|
data[bytes_written++] =
|
|
(char)(0x80u | (codepoint & 0x3fu)); /* 10xxxxxx. */
|
|
}
|
|
} break;
|
|
case '"':
|
|
data[bytes_written++] = '"';
|
|
break;
|
|
case '\\':
|
|
data[bytes_written++] = '\\';
|
|
break;
|
|
case '/':
|
|
data[bytes_written++] = '/';
|
|
break;
|
|
case 'b':
|
|
data[bytes_written++] = '\b';
|
|
break;
|
|
case 'f':
|
|
data[bytes_written++] = '\f';
|
|
break;
|
|
case 'n':
|
|
data[bytes_written++] = '\n';
|
|
break;
|
|
case 'r':
|
|
data[bytes_written++] = '\r';
|
|
break;
|
|
case 't':
|
|
data[bytes_written++] = '\t';
|
|
break;
|
|
case '\r':
|
|
data[bytes_written++] = '\r';
|
|
|
|
/* check if we have a "\r\n" sequence. */
|
|
if ('\n' == src[offset]) {
|
|
data[bytes_written++] = '\n';
|
|
offset++;
|
|
}
|
|
|
|
break;
|
|
case '\n':
|
|
data[bytes_written++] = '\n';
|
|
break;
|
|
}
|
|
} else {
|
|
/* copy the character. */
|
|
data[bytes_written++] = src[offset++];
|
|
}
|
|
}
|
|
|
|
/* skip trailing '"' or '\''. */
|
|
offset++;
|
|
|
|
/* record the size of the string. */
|
|
string->string_size = bytes_written;
|
|
|
|
/* add null terminator to string. */
|
|
data[bytes_written++] = '\0';
|
|
|
|
/* move data along. */
|
|
state->data += bytes_written;
|
|
|
|
/* update offset. */
|
|
state->offset = offset;
|
|
}
|
|
|
|
json_weak void json_parse_key(struct json_parse_state_s *state,
|
|
struct json_string_s *string);
|
|
void json_parse_key(struct json_parse_state_s *state,
|
|
struct json_string_s *string) {
|
|
if (json_parse_flags_allow_unquoted_keys & state->flags_bitset) {
|
|
const char *const src = state->src;
|
|
char *const data = state->data;
|
|
size_t offset = state->offset;
|
|
|
|
/* if we are allowing unquoted keys, check for quoted anyway... */
|
|
if (('"' == src[offset]) || ('\'' == src[offset])) {
|
|
/* ... if we got a quote, just parse the key as a string as normal. */
|
|
json_parse_string(state, string);
|
|
} else {
|
|
size_t size = 0;
|
|
|
|
string->string = state->data;
|
|
|
|
while (is_valid_unquoted_key_char(src[offset])) {
|
|
data[size++] = src[offset++];
|
|
}
|
|
|
|
/* add null terminator to string. */
|
|
data[size] = '\0';
|
|
|
|
/* record the size of the string. */
|
|
string->string_size = size++;
|
|
|
|
/* move data along. */
|
|
state->data += size;
|
|
|
|
/* update offset. */
|
|
state->offset = offset;
|
|
}
|
|
} else {
|
|
/* we are only allowed to have quoted keys, so just parse a string! */
|
|
json_parse_string(state, string);
|
|
}
|
|
}
|
|
|
|
json_weak void json_parse_object(struct json_parse_state_s *state,
|
|
int is_global_object,
|
|
struct json_object_s *object);
|
|
void json_parse_object(struct json_parse_state_s *state, int is_global_object,
|
|
struct json_object_s *object) {
|
|
const size_t flags_bitset = state->flags_bitset;
|
|
const size_t size = state->size;
|
|
const char *const src = state->src;
|
|
size_t elements = 0;
|
|
int allow_comma = 0;
|
|
struct json_object_element_s *previous = json_null;
|
|
|
|
if (is_global_object) {
|
|
/* if we skipped some whitespace, and then found an opening '{' of an. */
|
|
/* object, we actually have a normal JSON object at the root of the DOM...
|
|
*/
|
|
if ('{' == src[state->offset]) {
|
|
/* . and we don't actually have a global object after all! */
|
|
is_global_object = 0;
|
|
}
|
|
}
|
|
|
|
if (!is_global_object) {
|
|
/* skip leading '{'. */
|
|
state->offset++;
|
|
}
|
|
|
|
(void)json_skip_all_skippables(state);
|
|
|
|
/* reset elements. */
|
|
elements = 0;
|
|
|
|
while (state->offset < size) {
|
|
struct json_object_element_s *element = json_null;
|
|
struct json_string_s *string = json_null;
|
|
struct json_value_s *value = json_null;
|
|
|
|
if (!is_global_object) {
|
|
(void)json_skip_all_skippables(state);
|
|
|
|
if ('}' == src[state->offset]) {
|
|
/* skip trailing '}'. */
|
|
state->offset++;
|
|
|
|
/* finished the object! */
|
|
break;
|
|
}
|
|
} else {
|
|
if (json_skip_all_skippables(state)) {
|
|
/* global object ends when the file ends! */
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* if we parsed at least one element previously, grok for a comma. */
|
|
if (allow_comma) {
|
|
if (',' == src[state->offset]) {
|
|
/* skip comma. */
|
|
state->offset++;
|
|
allow_comma = 0;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
element = (struct json_object_element_s *)state->dom;
|
|
|
|
state->dom += sizeof(struct json_object_element_s);
|
|
|
|
if (json_null == previous) {
|
|
/* this is our first element, so record it in our object. */
|
|
object->start = element;
|
|
} else {
|
|
previous->next = element;
|
|
}
|
|
|
|
previous = element;
|
|
|
|
if (json_parse_flags_allow_location_information & flags_bitset) {
|
|
struct json_string_ex_s *string_ex =
|
|
(struct json_string_ex_s *)state->dom;
|
|
state->dom += sizeof(struct json_string_ex_s);
|
|
|
|
string_ex->offset = state->offset;
|
|
string_ex->line_no = state->line_no;
|
|
string_ex->row_no = state->offset - state->line_offset;
|
|
|
|
string = &(string_ex->string);
|
|
} else {
|
|
string = (struct json_string_s *)state->dom;
|
|
state->dom += sizeof(struct json_string_s);
|
|
}
|
|
|
|
element->name = string;
|
|
|
|
(void)json_parse_key(state, string);
|
|
|
|
(void)json_skip_all_skippables(state);
|
|
|
|
/* skip colon or equals. */
|
|
state->offset++;
|
|
|
|
(void)json_skip_all_skippables(state);
|
|
|
|
if (json_parse_flags_allow_location_information & flags_bitset) {
|
|
struct json_value_ex_s *value_ex = (struct json_value_ex_s *)state->dom;
|
|
state->dom += sizeof(struct json_value_ex_s);
|
|
|
|
value_ex->offset = state->offset;
|
|
value_ex->line_no = state->line_no;
|
|
value_ex->row_no = state->offset - state->line_offset;
|
|
|
|
value = &(value_ex->value);
|
|
} else {
|
|
value = (struct json_value_s *)state->dom;
|
|
state->dom += sizeof(struct json_value_s);
|
|
}
|
|
|
|
element->value = value;
|
|
|
|
json_parse_value(state, /* is_global_object = */ 0, value);
|
|
|
|
/* successfully parsed a name/value pair! */
|
|
elements++;
|
|
allow_comma = 1;
|
|
}
|
|
|
|
/* if we had at least one element, end the linked list. */
|
|
if (previous) {
|
|
previous->next = json_null;
|
|
}
|
|
|
|
if (0 == elements) {
|
|
object->start = json_null;
|
|
}
|
|
|
|
object->length = elements;
|
|
}
|
|
|
|
json_weak void json_parse_array(struct json_parse_state_s *state,
|
|
struct json_array_s *array);
|
|
void json_parse_array(struct json_parse_state_s *state,
|
|
struct json_array_s *array) {
|
|
const char *const src = state->src;
|
|
const size_t size = state->size;
|
|
size_t elements = 0;
|
|
int allow_comma = 0;
|
|
struct json_array_element_s *previous = json_null;
|
|
|
|
/* skip leading '['. */
|
|
state->offset++;
|
|
|
|
(void)json_skip_all_skippables(state);
|
|
|
|
/* reset elements. */
|
|
elements = 0;
|
|
|
|
do {
|
|
struct json_array_element_s *element = json_null;
|
|
struct json_value_s *value = json_null;
|
|
|
|
(void)json_skip_all_skippables(state);
|
|
|
|
if (']' == src[state->offset]) {
|
|
/* skip trailing ']'. */
|
|
state->offset++;
|
|
|
|
/* finished the array! */
|
|
break;
|
|
}
|
|
|
|
/* if we parsed at least one element previously, grok for a comma. */
|
|
if (allow_comma) {
|
|
if (',' == src[state->offset]) {
|
|
/* skip comma. */
|
|
state->offset++;
|
|
allow_comma = 0;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
element = (struct json_array_element_s *)state->dom;
|
|
|
|
state->dom += sizeof(struct json_array_element_s);
|
|
|
|
if (json_null == previous) {
|
|
/* this is our first element, so record it in our array. */
|
|
array->start = element;
|
|
} else {
|
|
previous->next = element;
|
|
}
|
|
|
|
previous = element;
|
|
|
|
if (json_parse_flags_allow_location_information & state->flags_bitset) {
|
|
struct json_value_ex_s *value_ex = (struct json_value_ex_s *)state->dom;
|
|
state->dom += sizeof(struct json_value_ex_s);
|
|
|
|
value_ex->offset = state->offset;
|
|
value_ex->line_no = state->line_no;
|
|
value_ex->row_no = state->offset - state->line_offset;
|
|
|
|
value = &(value_ex->value);
|
|
} else {
|
|
value = (struct json_value_s *)state->dom;
|
|
state->dom += sizeof(struct json_value_s);
|
|
}
|
|
|
|
element->value = value;
|
|
|
|
json_parse_value(state, /* is_global_object = */ 0, value);
|
|
|
|
/* successfully parsed an array element! */
|
|
elements++;
|
|
allow_comma = 1;
|
|
} while (state->offset < size);
|
|
|
|
/* end the linked list. */
|
|
if (previous) {
|
|
previous->next = json_null;
|
|
}
|
|
|
|
if (0 == elements) {
|
|
array->start = json_null;
|
|
}
|
|
|
|
array->length = elements;
|
|
}
|
|
|
|
json_weak void json_parse_number(struct json_parse_state_s *state,
|
|
struct json_number_s *number);
|
|
void json_parse_number(struct json_parse_state_s *state,
|
|
struct json_number_s *number) {
|
|
const size_t flags_bitset = state->flags_bitset;
|
|
size_t offset = state->offset;
|
|
const size_t size = state->size;
|
|
size_t bytes_written = 0;
|
|
const char *const src = state->src;
|
|
char *data = state->data;
|
|
|
|
number->number = data;
|
|
|
|
if (json_parse_flags_allow_hexadecimal_numbers & flags_bitset) {
|
|
if (('0' == src[offset]) &&
|
|
(('x' == src[offset + 1]) || ('X' == src[offset + 1]))) {
|
|
/* consume hexadecimal digits. */
|
|
while ((offset < size) &&
|
|
(('0' <= src[offset] && src[offset] <= '9') ||
|
|
('a' <= src[offset] && src[offset] <= 'f') ||
|
|
('A' <= src[offset] && src[offset] <= 'F') ||
|
|
('x' == src[offset]) || ('X' == src[offset]))) {
|
|
data[bytes_written++] = src[offset++];
|
|
}
|
|
}
|
|
}
|
|
|
|
while (offset < size) {
|
|
int end = 0;
|
|
|
|
switch (src[offset]) {
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
case '.':
|
|
case 'e':
|
|
case 'E':
|
|
case '+':
|
|
case '-':
|
|
data[bytes_written++] = src[offset++];
|
|
break;
|
|
default:
|
|
end = 1;
|
|
break;
|
|
}
|
|
|
|
if (0 != end) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (json_parse_flags_allow_inf_and_nan & flags_bitset) {
|
|
const size_t inf_strlen = 8; /* = strlen("Infinity");. */
|
|
const size_t nan_strlen = 3; /* = strlen("NaN");. */
|
|
|
|
if (offset + inf_strlen < size) {
|
|
if ('I' == src[offset]) {
|
|
size_t i;
|
|
/* We found our special 'Infinity' keyword! */
|
|
for (i = 0; i < inf_strlen; i++) {
|
|
data[bytes_written++] = src[offset++];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (offset + nan_strlen < size) {
|
|
if ('N' == src[offset]) {
|
|
size_t i;
|
|
/* We found our special 'NaN' keyword! */
|
|
for (i = 0; i < nan_strlen; i++) {
|
|
data[bytes_written++] = src[offset++];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* record the size of the number. */
|
|
number->number_size = bytes_written;
|
|
/* add null terminator to number string. */
|
|
data[bytes_written++] = '\0';
|
|
/* move data along. */
|
|
state->data += bytes_written;
|
|
/* update offset. */
|
|
state->offset = offset;
|
|
}
|
|
|
|
json_weak void json_parse_value(struct json_parse_state_s *state,
|
|
int is_global_object,
|
|
struct json_value_s *value);
|
|
void json_parse_value(struct json_parse_state_s *state, int is_global_object,
|
|
struct json_value_s *value) {
|
|
const size_t flags_bitset = state->flags_bitset;
|
|
const char *const src = state->src;
|
|
const size_t size = state->size;
|
|
size_t offset;
|
|
|
|
(void)json_skip_all_skippables(state);
|
|
|
|
/* cache offset now. */
|
|
offset = state->offset;
|
|
|
|
if (is_global_object) {
|
|
value->type = json_type_object;
|
|
value->payload = state->dom;
|
|
state->dom += sizeof(struct json_object_s);
|
|
json_parse_object(state, /* is_global_object = */ 1,
|
|
(struct json_object_s *)value->payload);
|
|
} else {
|
|
switch (src[offset]) {
|
|
case '"':
|
|
case '\'':
|
|
value->type = json_type_string;
|
|
value->payload = state->dom;
|
|
state->dom += sizeof(struct json_string_s);
|
|
json_parse_string(state, (struct json_string_s *)value->payload);
|
|
break;
|
|
case '{':
|
|
value->type = json_type_object;
|
|
value->payload = state->dom;
|
|
state->dom += sizeof(struct json_object_s);
|
|
json_parse_object(state, /* is_global_object = */ 0,
|
|
(struct json_object_s *)value->payload);
|
|
break;
|
|
case '[':
|
|
value->type = json_type_array;
|
|
value->payload = state->dom;
|
|
state->dom += sizeof(struct json_array_s);
|
|
json_parse_array(state, (struct json_array_s *)value->payload);
|
|
break;
|
|
case '-':
|
|
case '+':
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
case '.':
|
|
value->type = json_type_number;
|
|
value->payload = state->dom;
|
|
state->dom += sizeof(struct json_number_s);
|
|
json_parse_number(state, (struct json_number_s *)value->payload);
|
|
break;
|
|
default:
|
|
if ((offset + 4) <= size && 't' == src[offset + 0] &&
|
|
'r' == src[offset + 1] && 'u' == src[offset + 2] &&
|
|
'e' == src[offset + 3]) {
|
|
value->type = json_type_true;
|
|
value->payload = json_null;
|
|
state->offset += 4;
|
|
} else if ((offset + 5) <= size && 'f' == src[offset + 0] &&
|
|
'a' == src[offset + 1] && 'l' == src[offset + 2] &&
|
|
's' == src[offset + 3] && 'e' == src[offset + 4]) {
|
|
value->type = json_type_false;
|
|
value->payload = json_null;
|
|
state->offset += 5;
|
|
} else if ((offset + 4) <= size && 'n' == src[offset + 0] &&
|
|
'u' == src[offset + 1] && 'l' == src[offset + 2] &&
|
|
'l' == src[offset + 3]) {
|
|
value->type = json_type_null;
|
|
value->payload = json_null;
|
|
state->offset += 4;
|
|
} else if ((json_parse_flags_allow_inf_and_nan & flags_bitset) &&
|
|
(offset + 3) <= size && 'N' == src[offset + 0] &&
|
|
'a' == src[offset + 1] && 'N' == src[offset + 2]) {
|
|
value->type = json_type_number;
|
|
value->payload = state->dom;
|
|
state->dom += sizeof(struct json_number_s);
|
|
json_parse_number(state, (struct json_number_s *)value->payload);
|
|
} else if ((json_parse_flags_allow_inf_and_nan & flags_bitset) &&
|
|
(offset + 8) <= size && 'I' == src[offset + 0] &&
|
|
'n' == src[offset + 1] && 'f' == src[offset + 2] &&
|
|
'i' == src[offset + 3] && 'n' == src[offset + 4] &&
|
|
'i' == src[offset + 5] && 't' == src[offset + 6] &&
|
|
'y' == src[offset + 7]) {
|
|
value->type = json_type_number;
|
|
value->payload = state->dom;
|
|
state->dom += sizeof(struct json_number_s);
|
|
json_parse_number(state, (struct json_number_s *)value->payload);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
struct json_value_s *
|
|
json_parse_ex(const void *src, size_t src_size, size_t flags_bitset,
|
|
void *(*alloc_func_ptr)(void *user_data, size_t size),
|
|
void *user_data, struct json_parse_result_s *result) {
|
|
struct json_parse_state_s state;
|
|
void *allocation;
|
|
struct json_value_s *value;
|
|
size_t total_size;
|
|
int input_error;
|
|
|
|
if (result) {
|
|
result->error = json_parse_error_none;
|
|
result->error_offset = 0;
|
|
result->error_line_no = 0;
|
|
result->error_row_no = 0;
|
|
}
|
|
|
|
if (json_null == src) {
|
|
/* invalid src pointer was null! */
|
|
return json_null;
|
|
}
|
|
|
|
state.src = (const char *)src;
|
|
state.size = src_size;
|
|
state.offset = 0;
|
|
state.line_no = 1;
|
|
state.line_offset = 0;
|
|
state.error = json_parse_error_none;
|
|
state.dom_size = 0;
|
|
state.data_size = 0;
|
|
state.flags_bitset = flags_bitset;
|
|
|
|
input_error = json_get_value_size(
|
|
&state, (int)(json_parse_flags_allow_global_object & state.flags_bitset));
|
|
|
|
if (0 == input_error) {
|
|
json_skip_all_skippables(&state);
|
|
|
|
if (state.offset != state.size) {
|
|
/* our parsing didn't have an error, but there are characters remaining in
|
|
* the input that weren't part of the JSON! */
|
|
|
|
state.error = json_parse_error_unexpected_trailing_characters;
|
|
input_error = 1;
|
|
}
|
|
}
|
|
|
|
if (input_error) {
|
|
/* parsing value's size failed (most likely an invalid JSON DOM!). */
|
|
if (result) {
|
|
result->error = state.error;
|
|
result->error_offset = state.offset;
|
|
result->error_line_no = state.line_no;
|
|
result->error_row_no = state.offset - state.line_offset;
|
|
}
|
|
return json_null;
|
|
}
|
|
|
|
/* our total allocation is the combination of the dom and data sizes (we. */
|
|
/* first encode the structure of the JSON, and then the data referenced by. */
|
|
/* the JSON values). */
|
|
total_size = state.dom_size + state.data_size;
|
|
|
|
if (json_null == alloc_func_ptr) {
|
|
allocation = malloc(total_size);
|
|
} else {
|
|
allocation = alloc_func_ptr(user_data, total_size);
|
|
}
|
|
|
|
if (json_null == allocation) {
|
|
/* malloc failed! */
|
|
if (result) {
|
|
result->error = json_parse_error_allocator_failed;
|
|
result->error_offset = 0;
|
|
result->error_line_no = 0;
|
|
result->error_row_no = 0;
|
|
}
|
|
|
|
return json_null;
|
|
}
|
|
|
|
/* reset offset so we can reuse it. */
|
|
state.offset = 0;
|
|
|
|
/* reset the line information so we can reuse it. */
|
|
state.line_no = 1;
|
|
state.line_offset = 0;
|
|
|
|
state.dom = (char *)allocation;
|
|
state.data = state.dom + state.dom_size;
|
|
|
|
if (json_parse_flags_allow_location_information & state.flags_bitset) {
|
|
struct json_value_ex_s *value_ex = (struct json_value_ex_s *)state.dom;
|
|
state.dom += sizeof(struct json_value_ex_s);
|
|
|
|
value_ex->offset = state.offset;
|
|
value_ex->line_no = state.line_no;
|
|
value_ex->row_no = state.offset - state.line_offset;
|
|
|
|
value = &(value_ex->value);
|
|
} else {
|
|
value = (struct json_value_s *)state.dom;
|
|
state.dom += sizeof(struct json_value_s);
|
|
}
|
|
|
|
json_parse_value(
|
|
&state, (int)(json_parse_flags_allow_global_object & state.flags_bitset),
|
|
value);
|
|
|
|
return (struct json_value_s *)allocation;
|
|
}
|
|
|
|
struct json_value_s *json_parse(const void *src, size_t src_size) {
|
|
return json_parse_ex(src, src_size, json_parse_flags_default, json_null,
|
|
json_null, json_null);
|
|
}
|
|
|
|
struct json_extract_result_s {
|
|
size_t dom_size;
|
|
size_t data_size;
|
|
};
|
|
|
|
struct json_value_s *json_extract_value(const struct json_value_s *value) {
|
|
return json_extract_value_ex(value, json_null, json_null);
|
|
}
|
|
|
|
json_weak struct json_extract_result_s
|
|
json_extract_get_number_size(const struct json_number_s *const number);
|
|
json_weak struct json_extract_result_s
|
|
json_extract_get_string_size(const struct json_string_s *const string);
|
|
json_weak struct json_extract_result_s
|
|
json_extract_get_object_size(const struct json_object_s *const object);
|
|
json_weak struct json_extract_result_s
|
|
json_extract_get_array_size(const struct json_array_s *const array);
|
|
json_weak struct json_extract_result_s
|
|
json_extract_get_value_size(const struct json_value_s *const value);
|
|
|
|
struct json_extract_result_s
|
|
json_extract_get_number_size(const struct json_number_s *const number) {
|
|
struct json_extract_result_s result;
|
|
result.dom_size = sizeof(struct json_number_s);
|
|
result.data_size = number->number_size;
|
|
return result;
|
|
}
|
|
|
|
struct json_extract_result_s
|
|
json_extract_get_string_size(const struct json_string_s *const string) {
|
|
struct json_extract_result_s result;
|
|
result.dom_size = sizeof(struct json_string_s);
|
|
result.data_size = string->string_size + 1;
|
|
return result;
|
|
}
|
|
|
|
struct json_extract_result_s
|
|
json_extract_get_object_size(const struct json_object_s *const object) {
|
|
struct json_extract_result_s result;
|
|
size_t i;
|
|
const struct json_object_element_s *element = object->start;
|
|
|
|
result.dom_size = sizeof(struct json_object_s) +
|
|
(sizeof(struct json_object_element_s) * object->length);
|
|
result.data_size = 0;
|
|
|
|
for (i = 0; i < object->length; i++) {
|
|
const struct json_extract_result_s string_result =
|
|
json_extract_get_string_size(element->name);
|
|
const struct json_extract_result_s value_result =
|
|
json_extract_get_value_size(element->value);
|
|
|
|
result.dom_size += string_result.dom_size;
|
|
result.data_size += string_result.data_size;
|
|
|
|
result.dom_size += value_result.dom_size;
|
|
result.data_size += value_result.data_size;
|
|
|
|
element = element->next;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
struct json_extract_result_s
|
|
json_extract_get_array_size(const struct json_array_s *const array) {
|
|
struct json_extract_result_s result;
|
|
size_t i;
|
|
const struct json_array_element_s *element = array->start;
|
|
|
|
result.dom_size = sizeof(struct json_array_s) +
|
|
(sizeof(struct json_array_element_s) * array->length);
|
|
result.data_size = 0;
|
|
|
|
for (i = 0; i < array->length; i++) {
|
|
const struct json_extract_result_s value_result =
|
|
json_extract_get_value_size(element->value);
|
|
|
|
result.dom_size += value_result.dom_size;
|
|
result.data_size += value_result.data_size;
|
|
|
|
element = element->next;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
struct json_extract_result_s
|
|
json_extract_get_value_size(const struct json_value_s *const value) {
|
|
struct json_extract_result_s result = {0, 0};
|
|
|
|
switch (value->type) {
|
|
default:
|
|
break;
|
|
case json_type_object:
|
|
result = json_extract_get_object_size(
|
|
(const struct json_object_s *)value->payload);
|
|
break;
|
|
case json_type_array:
|
|
result = json_extract_get_array_size(
|
|
(const struct json_array_s *)value->payload);
|
|
break;
|
|
case json_type_number:
|
|
result = json_extract_get_number_size(
|
|
(const struct json_number_s *)value->payload);
|
|
break;
|
|
case json_type_string:
|
|
result = json_extract_get_string_size(
|
|
(const struct json_string_s *)value->payload);
|
|
break;
|
|
}
|
|
|
|
result.dom_size += sizeof(struct json_value_s);
|
|
|
|
return result;
|
|
}
|
|
|
|
struct json_extract_state_s {
|
|
char *dom;
|
|
char *data;
|
|
};
|
|
|
|
json_weak void json_extract_copy_value(struct json_extract_state_s *const state,
|
|
const struct json_value_s *const value);
|
|
void json_extract_copy_value(struct json_extract_state_s *const state,
|
|
const struct json_value_s *const value) {
|
|
struct json_string_s *string;
|
|
struct json_number_s *number;
|
|
struct json_object_s *object;
|
|
struct json_array_s *array;
|
|
struct json_value_s *new_value;
|
|
|
|
memcpy(state->dom, value, sizeof(struct json_value_s));
|
|
new_value = (struct json_value_s *)state->dom;
|
|
state->dom += sizeof(struct json_value_s);
|
|
new_value->payload = state->dom;
|
|
|
|
if (json_type_string == value->type) {
|
|
memcpy(state->dom, value->payload, sizeof(struct json_string_s));
|
|
string = (struct json_string_s *)state->dom;
|
|
state->dom += sizeof(struct json_string_s);
|
|
|
|
memcpy(state->data, string->string, string->string_size + 1);
|
|
string->string = state->data;
|
|
state->data += string->string_size + 1;
|
|
} else if (json_type_number == value->type) {
|
|
memcpy(state->dom, value->payload, sizeof(struct json_number_s));
|
|
number = (struct json_number_s *)state->dom;
|
|
state->dom += sizeof(struct json_number_s);
|
|
|
|
memcpy(state->data, number->number, number->number_size);
|
|
number->number = state->data;
|
|
state->data += number->number_size;
|
|
} else if (json_type_object == value->type) {
|
|
struct json_object_element_s *element;
|
|
size_t i;
|
|
|
|
memcpy(state->dom, value->payload, sizeof(struct json_object_s));
|
|
object = (struct json_object_s *)state->dom;
|
|
state->dom += sizeof(struct json_object_s);
|
|
|
|
element = object->start;
|
|
object->start = (struct json_object_element_s *)state->dom;
|
|
|
|
for (i = 0; i < object->length; i++) {
|
|
struct json_value_s *previous_value;
|
|
struct json_object_element_s *previous_element;
|
|
|
|
memcpy(state->dom, element, sizeof(struct json_object_element_s));
|
|
element = (struct json_object_element_s *)state->dom;
|
|
state->dom += sizeof(struct json_object_element_s);
|
|
|
|
string = element->name;
|
|
memcpy(state->dom, string, sizeof(struct json_string_s));
|
|
string = (struct json_string_s *)state->dom;
|
|
state->dom += sizeof(struct json_string_s);
|
|
element->name = string;
|
|
|
|
memcpy(state->data, string->string, string->string_size + 1);
|
|
string->string = state->data;
|
|
state->data += string->string_size + 1;
|
|
|
|
previous_value = element->value;
|
|
element->value = (struct json_value_s *)state->dom;
|
|
json_extract_copy_value(state, previous_value);
|
|
|
|
previous_element = element;
|
|
element = element->next;
|
|
|
|
if (element) {
|
|
previous_element->next = (struct json_object_element_s *)state->dom;
|
|
}
|
|
}
|
|
} else if (json_type_array == value->type) {
|
|
struct json_array_element_s *element;
|
|
size_t i;
|
|
|
|
memcpy(state->dom, value->payload, sizeof(struct json_array_s));
|
|
array = (struct json_array_s *)state->dom;
|
|
state->dom += sizeof(struct json_array_s);
|
|
|
|
element = array->start;
|
|
array->start = (struct json_array_element_s *)state->dom;
|
|
|
|
for (i = 0; i < array->length; i++) {
|
|
struct json_value_s *previous_value;
|
|
struct json_array_element_s *previous_element;
|
|
|
|
memcpy(state->dom, element, sizeof(struct json_array_element_s));
|
|
element = (struct json_array_element_s *)state->dom;
|
|
state->dom += sizeof(struct json_array_element_s);
|
|
|
|
previous_value = element->value;
|
|
element->value = (struct json_value_s *)state->dom;
|
|
json_extract_copy_value(state, previous_value);
|
|
|
|
previous_element = element;
|
|
element = element->next;
|
|
|
|
if (element) {
|
|
previous_element->next = (struct json_array_element_s *)state->dom;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
struct json_value_s *json_extract_value_ex(const struct json_value_s *value,
|
|
void *(*alloc_func_ptr)(void *,
|
|
size_t),
|
|
void *user_data) {
|
|
void *allocation;
|
|
struct json_extract_result_s result;
|
|
struct json_extract_state_s state;
|
|
size_t total_size;
|
|
|
|
if (json_null == value) {
|
|
/* invalid value was null! */
|
|
return json_null;
|
|
}
|
|
|
|
result = json_extract_get_value_size(value);
|
|
total_size = result.dom_size + result.data_size;
|
|
|
|
if (json_null == alloc_func_ptr) {
|
|
allocation = malloc(total_size);
|
|
} else {
|
|
allocation = alloc_func_ptr(user_data, total_size);
|
|
}
|
|
|
|
state.dom = (char *)allocation;
|
|
state.data = state.dom + result.dom_size;
|
|
|
|
json_extract_copy_value(&state, value);
|
|
|
|
return (struct json_value_s *)allocation;
|
|
}
|
|
|
|
struct json_string_s *json_value_as_string(struct json_value_s *const value) {
|
|
if (value->type != json_type_string) {
|
|
return json_null;
|
|
}
|
|
|
|
return (struct json_string_s *)value->payload;
|
|
}
|
|
|
|
struct json_number_s *json_value_as_number(struct json_value_s *const value) {
|
|
if (value->type != json_type_number) {
|
|
return json_null;
|
|
}
|
|
|
|
return (struct json_number_s *)value->payload;
|
|
}
|
|
|
|
struct json_object_s *json_value_as_object(struct json_value_s *const value) {
|
|
if (value->type != json_type_object) {
|
|
return json_null;
|
|
}
|
|
|
|
return (struct json_object_s *)value->payload;
|
|
}
|
|
|
|
struct json_array_s *json_value_as_array(struct json_value_s *const value) {
|
|
if (value->type != json_type_array) {
|
|
return json_null;
|
|
}
|
|
|
|
return (struct json_array_s *)value->payload;
|
|
}
|
|
|
|
int json_value_is_true(const struct json_value_s *const value) {
|
|
return value->type == json_type_true;
|
|
}
|
|
|
|
int json_value_is_false(const struct json_value_s *const value) {
|
|
return value->type == json_type_false;
|
|
}
|
|
|
|
int json_value_is_null(const struct json_value_s *const value) {
|
|
return value->type == json_type_null;
|
|
}
|
|
|
|
json_weak int
|
|
json_write_minified_get_value_size(const struct json_value_s *value,
|
|
size_t *size);
|
|
|
|
json_weak int json_write_get_number_size(const struct json_number_s *number,
|
|
size_t *size);
|
|
int json_write_get_number_size(const struct json_number_s *number,
|
|
size_t *size) {
|
|
json_uintmax_t parsed_number;
|
|
size_t i;
|
|
|
|
if (number->number_size >= 2) {
|
|
switch (number->number[1]) {
|
|
default:
|
|
break;
|
|
case 'x':
|
|
case 'X':
|
|
/* the number is a json_parse_flags_allow_hexadecimal_numbers hexadecimal
|
|
* so we have to do extra work to convert it to a non-hexadecimal for JSON
|
|
* output. */
|
|
parsed_number = json_strtoumax(number->number, json_null, 0);
|
|
|
|
i = 0;
|
|
|
|
while (0 != parsed_number) {
|
|
parsed_number /= 10;
|
|
i++;
|
|
}
|
|
|
|
*size += i;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* check to see if the number has leading/trailing decimal point. */
|
|
i = 0;
|
|
|
|
/* skip any leading '+' or '-'. */
|
|
if ((i < number->number_size) &&
|
|
(('+' == number->number[i]) || ('-' == number->number[i]))) {
|
|
i++;
|
|
}
|
|
|
|
/* check if we have infinity. */
|
|
if ((i < number->number_size) && ('I' == number->number[i])) {
|
|
const char *inf = "Infinity";
|
|
size_t k;
|
|
|
|
for (k = i; k < number->number_size; k++) {
|
|
const char c = *inf++;
|
|
|
|
/* Check if we found the Infinity string! */
|
|
if ('\0' == c) {
|
|
break;
|
|
} else if (c != number->number[k]) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ('\0' == *inf) {
|
|
/* Inf becomes 1.7976931348623158e308 because JSON can't support it. */
|
|
*size += 22;
|
|
|
|
/* if we had a leading '-' we need to record it in the JSON output. */
|
|
if ('-' == number->number[0]) {
|
|
*size += 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* check if we have nan. */
|
|
if ((i < number->number_size) && ('N' == number->number[i])) {
|
|
const char *nan = "NaN";
|
|
size_t k;
|
|
|
|
for (k = i; k < number->number_size; k++) {
|
|
const char c = *nan++;
|
|
|
|
/* Check if we found the NaN string! */
|
|
if ('\0' == c) {
|
|
break;
|
|
} else if (c != number->number[k]) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ('\0' == *nan) {
|
|
/* NaN becomes 1 because JSON can't support it. */
|
|
*size += 1;
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* if we had a leading decimal point. */
|
|
if ((i < number->number_size) && ('.' == number->number[i])) {
|
|
/* 1 + because we had a leading decimal point. */
|
|
*size += 1;
|
|
goto cleanup;
|
|
}
|
|
|
|
for (; i < number->number_size; i++) {
|
|
const char c = number->number[i];
|
|
if (!('0' <= c && c <= '9')) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* if we had a trailing decimal point. */
|
|
if ((i + 1 == number->number_size) && ('.' == number->number[i])) {
|
|
/* 1 + because we had a trailing decimal point. */
|
|
*size += 1;
|
|
goto cleanup;
|
|
}
|
|
|
|
cleanup:
|
|
*size += number->number_size; /* the actual string of the number. */
|
|
|
|
/* if we had a leading '+' we don't record it in the JSON output. */
|
|
if ('+' == number->number[0]) {
|
|
*size -= 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
json_weak int json_write_get_string_size(const struct json_string_s *string,
|
|
size_t *size);
|
|
int json_write_get_string_size(const struct json_string_s *string,
|
|
size_t *size) {
|
|
size_t i;
|
|
for (i = 0; i < string->string_size; i++) {
|
|
switch (string->string[i]) {
|
|
case '"':
|
|
case '\\':
|
|
case '\b':
|
|
case '\f':
|
|
case '\n':
|
|
case '\r':
|
|
case '\t':
|
|
*size += 2;
|
|
break;
|
|
default:
|
|
*size += 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
*size += 2; /* need to encode the surrounding '"' characters. */
|
|
|
|
return 0;
|
|
}
|
|
|
|
json_weak int
|
|
json_write_minified_get_array_size(const struct json_array_s *array,
|
|
size_t *size);
|
|
int json_write_minified_get_array_size(const struct json_array_s *array,
|
|
size_t *size) {
|
|
struct json_array_element_s *element;
|
|
|
|
*size += 2; /* '[' and ']'. */
|
|
|
|
if (1 < array->length) {
|
|
*size += array->length - 1; /* ','s seperate each element. */
|
|
}
|
|
|
|
for (element = array->start; json_null != element; element = element->next) {
|
|
if (json_write_minified_get_value_size(element->value, size)) {
|
|
/* value was malformed! */
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
json_weak int
|
|
json_write_minified_get_object_size(const struct json_object_s *object,
|
|
size_t *size);
|
|
int json_write_minified_get_object_size(const struct json_object_s *object,
|
|
size_t *size) {
|
|
struct json_object_element_s *element;
|
|
|
|
*size += 2; /* '{' and '}'. */
|
|
|
|
*size += object->length; /* ':'s seperate each name/value pair. */
|
|
|
|
if (1 < object->length) {
|
|
*size += object->length - 1; /* ','s seperate each element. */
|
|
}
|
|
|
|
for (element = object->start; json_null != element; element = element->next) {
|
|
if (json_write_get_string_size(element->name, size)) {
|
|
/* string was malformed! */
|
|
return 1;
|
|
}
|
|
|
|
if (json_write_minified_get_value_size(element->value, size)) {
|
|
/* value was malformed! */
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
json_weak int
|
|
json_write_minified_get_value_size(const struct json_value_s *value,
|
|
size_t *size);
|
|
int json_write_minified_get_value_size(const struct json_value_s *value,
|
|
size_t *size) {
|
|
switch (value->type) {
|
|
default:
|
|
/* unknown value type found! */
|
|
return 1;
|
|
case json_type_number:
|
|
return json_write_get_number_size((struct json_number_s *)value->payload,
|
|
size);
|
|
case json_type_string:
|
|
return json_write_get_string_size((struct json_string_s *)value->payload,
|
|
size);
|
|
case json_type_array:
|
|
return json_write_minified_get_array_size(
|
|
(struct json_array_s *)value->payload, size);
|
|
case json_type_object:
|
|
return json_write_minified_get_object_size(
|
|
(struct json_object_s *)value->payload, size);
|
|
case json_type_true:
|
|
*size += 4; /* the string "true". */
|
|
return 0;
|
|
case json_type_false:
|
|
*size += 5; /* the string "false". */
|
|
return 0;
|
|
case json_type_null:
|
|
*size += 4; /* the string "null". */
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
json_weak char *json_write_minified_value(const struct json_value_s *value,
|
|
char *data);
|
|
|
|
json_weak char *json_write_number(const struct json_number_s *number,
|
|
char *data);
|
|
char *json_write_number(const struct json_number_s *number, char *data) {
|
|
json_uintmax_t parsed_number, backup;
|
|
size_t i;
|
|
|
|
if (number->number_size >= 2) {
|
|
switch (number->number[1]) {
|
|
default:
|
|
break;
|
|
case 'x':
|
|
case 'X':
|
|
/* The number is a json_parse_flags_allow_hexadecimal_numbers hexadecimal
|
|
* so we have to do extra work to convert it to a non-hexadecimal for JSON
|
|
* output. */
|
|
parsed_number = json_strtoumax(number->number, json_null, 0);
|
|
|
|
/* We need a copy of parsed number twice, so take a backup of it. */
|
|
backup = parsed_number;
|
|
|
|
i = 0;
|
|
|
|
while (0 != parsed_number) {
|
|
parsed_number /= 10;
|
|
i++;
|
|
}
|
|
|
|
/* Restore parsed_number to its original value stored in the backup. */
|
|
parsed_number = backup;
|
|
|
|
/* Now use backup to take a copy of i, or the length of the string. */
|
|
backup = i;
|
|
|
|
do {
|
|
*(data + i - 1) = '0' + (char)(parsed_number % 10);
|
|
parsed_number /= 10;
|
|
i--;
|
|
} while (0 != parsed_number);
|
|