summaryrefslogtreecommitdiff
path: root/lib/libjson/json.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/libjson/json.c')
-rw-r--r--lib/libjson/json.c1607
1 files changed, 0 insertions, 1607 deletions
diff --git a/lib/libjson/json.c b/lib/libjson/json.c
deleted file mode 100644
index a50a6275..00000000
--- a/lib/libjson/json.c
+++ /dev/null
@@ -1,1607 +0,0 @@
-#include "json.h"
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-inline struct json_value *json_array_get(struct json_value *array, int index)
-{
- return index < array->array.length ? array->array.items[index] : NULL;
-}
-
-/**
- * @brief Represents a JSON parser for decoding JSON strings.
- *
- * This structure is used internally by the JSON library to parse
- * JSON-encoded strings into structured `json_value` objects.
- *
- * @note This structure is private and should not be accessed directly
- * outside of the JSON library's internal implementation.
- */
-struct json_parser {
- /**
- * @brief The input JSON string to be parsed.
- *
- * This is a pointer to the null-terminated JSON string that the parser
- * operates on.
- */
- const char *input;
-
- /**
- * @brief The length of the input JSON string.
- *
- * This value represents the total number of characters in the input
- * JSON string, excluding the null terminator.
- */
- int length;
-
- /**
- * @brief The current position in the input JSON string.
- *
- * This value indicates the index of the character currently being
- * processed by the parser.
- */
- int position;
-
-#if defined(JSON_ERROR)
- /**
- * @brief Represents error information for the JSON parser.
- *
- * This structure is used to store details about any errors encountered
- * during the parsing process.
- */
- struct {
- /**
- * @brief Enum representing the type of error encountered.
- *
- * - `JSON_ERROR_NONE`: No error occurred.
- * - `JSON_ERROR_SYNTAX`: A syntax error was encountered.
- * - `JSON_ERROR_MEMORY`: A memory allocation error occurred.
- * - `JSON_ERROR_EOF`: Unexpected end of input was encountered.
- */
- enum {
- JSON_ERROR_NONE, /**< No error occurred. */
- JSON_ERROR_SYNTAX, /**< A syntax error was encountered.
- */
- JSON_ERROR_MEMORY, /**< A memory allocation error
- occurred. */
- JSON_ERROR_EOF, /**< Unexpected end of input was
- encountered. */
- JSON_ERROR_INVALID_NUMBER, /**< Failed to parse number
- */
- } code;
-
- /**
- * @brief The line number where the error occurred.
- *
- * This value is used for debugging purposes to identify the
- * location of the error in the source code.
- */
- int line;
-
- /**
- * @brief The name of the function where the error occurred.
- *
- * This is a pointer to a string containing the name of the
- * function in which the error was detected.
- */
- const char *func;
-
- /**
- * @brief A descriptive message about the error.
- *
- * This is a pointer to a string containing a human-readable
- * description of the error.
- */
- const char *message;
- } error;
-#endif
-};
-
-/**
- * Initializes a JSON object.
- *
- * This function is responsible for setting up the internal structure
- * of a JSON object, ensuring it is ready for use. It is invoked by
- * both json_object_new() and json_object_free() to manage the lifecycle
- * of JSON objects.
- *
- * @param object A pointer to the JSON object to be initialized.
- *
- * @note This function is marked as privative and should not be used
- * directly outside of the JSON library's internal implementation.
- */
-void json_object_init(struct json_value *object);
-
-#if defined(JSON_ERROR)
-/**
- * @brief Sets an error in the JSON parser.
- *
- * This macro assigns error details to the JSON parser's error structure.
- * It captures the error code, the line number, the function name, and
- * a descriptive error message.
- *
- * @param PARSER The JSON parser where the error occurred.
- * @param CODE The error code to set.
- * @param MESSAGE A descriptive message about the error.
- */
-#define JSON_PARSER_ERROR(PARSER, CODE, MESSAGE) \
- (PARSER)->error.code = (CODE); \
- (PARSER)->error.line = __LINE__; \
- (PARSER)->error.func = __func__; \
- (PARSER)->error.message = (MESSAGE)
-#else
-/**
- * @brief No-op macro for JSON parser errors.
- *
- * When JSON_ERROR is not defined, this macro does nothing.
- *
- * @param PARSER The JSON parser (unused).
- * @param CODE The error code (unused).
- * @param MESSAGE The error message (unused).
- */
-#define JSON_PARSER_ERROR(PARSER, CODE, MESSAGE)
-#endif
-
-static int json__decode_value(struct json_parser *parser,
- struct json_value *value);
-
-static int json__strlen(const char *str)
-{
- int len = 0;
- while (*str++)
- len++;
- return len;
-}
-
-static int json__streq(const char *s1, const char *s2)
-{
- if (json__strlen(s1) != json__strlen(s2))
- return 0;
-
- while (*s1 && *s1 == *s2) {
- s1++;
- s2++;
- }
-
- if (*s1 == 0 && *s2 == 0)
- return 1;
-
- return 0;
-}
-
-static int json__streqn(const char *s1, const char *s2, int limit)
-{
- while (*s1 && *s2 && *s1 == *s2 && limit-- > 1) {
- s1++;
- s2++;
- }
-
- return *s1 == *s2 ? 1 : 0;
-}
-
-static void json__parse_whitespace(struct json_parser *parser)
-{
- const char *ptr = parser->input;
- int pos = parser->position;
- int len = parser->length;
-
- while (pos < len && (ptr[pos] == ' ' || ptr[pos] == '\t' ||
- ptr[pos] == '\n' || ptr[pos] == '\r'))
- pos++;
-
- parser->position = pos;
-}
-
-static int json__decode_string(struct json_parser *parser,
- struct json_value *value)
-{
- int start = parser->position + 1;
- int end = start;
- int buffer_size = 16;
- int buffer_length = 0;
- char *buffer = malloc(buffer_size);
-
- if (buffer == NULL) {
- JSON_PARSER_ERROR(parser, JSON_ERROR_MEMORY,
- "Memory allocation failed");
- return -1;
- }
-
- while (end < parser->length && parser->input[end] != '"') {
- if (parser->input[end] == '\\') {
- end++;
- if (end >= parser->length) {
- free(buffer);
- JSON_PARSER_ERROR(
- parser, JSON_ERROR_SYNTAX,
- "Unterminated escape sequence");
- return -1;
- }
-
- if (parser->input[end] == 'u') {
- // Handle \uXXXX Unicode escape sequences
- end++;
- if (end + 3 >= parser->length) {
- free(buffer);
- JSON_PARSER_ERROR(
- parser, JSON_ERROR_SYNTAX,
- "Incomplete Unicode escape sequence");
- return -1;
- }
-
- // Parse 4 hex digits
- unsigned int code_point = 0;
- for (int i = 0; i < 4; i++) {
- char c = parser->input[end + i];
- code_point <<= 4;
-
- if (c >= '0' && c <= '9') {
- code_point |= (c - '0');
- } else if (c >= 'a' && c <= 'f') {
- code_point |= (c - 'a' + 10);
- } else if (c >= 'A' && c <= 'F') {
- code_point |= (c - 'A' + 10);
- } else {
- free(buffer);
- JSON_PARSER_ERROR(
- parser,
- JSON_ERROR_SYNTAX,
- "Invalid hex digit in Unicode escape");
- return -1;
- }
- }
-
- // Check for surrogate pair
- if (code_point >= 0xD800 &&
- code_point <= 0xDBFF) {
- // High surrogate - need to get the low
- // surrogate
- end += 4; // Move past the first \uXXXX
-
- // Check for the sequence \uYYYY where
- // YYYY is the low surrogate
- if (end + 1 >= parser->length ||
- parser->input[end] != '\\' ||
- parser->input[end + 1] != 'u') {
- free(buffer);
- JSON_PARSER_ERROR(
- parser,
- JSON_ERROR_SYNTAX,
- "Expected low surrogate after high surrogate");
- return -1;
- }
-
- end += 2; // Move past \u
- if (end + 3 >= parser->length) {
- free(buffer);
- JSON_PARSER_ERROR(
- parser,
- JSON_ERROR_SYNTAX,
- "Incomplete Unicode escape sequence for low surrogate");
- return -1;
- }
-
- // Parse 4 hex digits for low surrogate
- unsigned int low_surrogate = 0;
- for (int i = 0; i < 4; i++) {
- char c = parser->input[end + i];
- low_surrogate <<= 4;
-
- if (c >= '0' && c <= '9') {
- low_surrogate |=
- (c - '0');
- } else if (c >= 'a' &&
- c <= 'f') {
- low_surrogate |=
- (c - 'a' + 10);
- } else if (c >= 'A' &&
- c <= 'F') {
- low_surrogate |=
- (c - 'A' + 10);
- } else {
- free(buffer);
- JSON_PARSER_ERROR(
- parser,
- JSON_ERROR_SYNTAX,
- "Invalid hex digit in low surrogate");
- return -1;
- }
- }
-
- // Validate low surrogate range
- if (low_surrogate < 0xDC00 ||
- low_surrogate > 0xDFFF) {
- free(buffer);
- JSON_PARSER_ERROR(
- parser,
- JSON_ERROR_SYNTAX,
- "Invalid low surrogate value");
- return -1;
- }
-
- // Combine surrogate pair to get actual
- // code point
- code_point =
- 0x10000 +
- ((code_point - 0xD800) << 10) +
- (low_surrogate - 0xDC00);
- end += 4; // Move past the second \uXXXX
- } else {
- end += 4; // Move past \uXXXX for
- // non-surrogate case
- }
-
- // Encode code point as UTF-8
- if (code_point < 0x80) {
- // 1-byte character
- if (buffer_length + 1 >= buffer_size) {
- buffer_size *= 2;
- char *new_buffer = realloc(
- buffer, buffer_size);
- if (new_buffer == NULL) {
- free(buffer);
- JSON_PARSER_ERROR(
- parser,
- JSON_ERROR_MEMORY,
- "Memory allocation failed");
- return -1;
- }
- buffer = new_buffer;
- }
- buffer[buffer_length++] =
- (char)code_point;
- } else if (code_point < 0x800) {
- // 2-byte character
- if (buffer_length + 2 >= buffer_size) {
- buffer_size *= 2;
- char *new_buffer = realloc(
- buffer, buffer_size);
- if (new_buffer == NULL) {
- free(buffer);
- JSON_PARSER_ERROR(
- parser,
- JSON_ERROR_MEMORY,
- "Memory allocation failed");
- return -1;
- }
- buffer = new_buffer;
- }
- buffer[buffer_length++] =
- (char)(0xC0 |
- (code_point >> 6));
- buffer[buffer_length++] =
- (char)(0x80 |
- (code_point & 0x3F));
- } else if (code_point < 0x10000) {
- // 3-byte character
- if (buffer_length + 3 >= buffer_size) {
- buffer_size *= 2;
- char *new_buffer = realloc(
- buffer, buffer_size);
- if (new_buffer == NULL) {
- free(buffer);
- JSON_PARSER_ERROR(
- parser,
- JSON_ERROR_MEMORY,
- "Memory allocation failed");
- return -1;
- }
- buffer = new_buffer;
- }
- buffer[buffer_length++] =
- (char)(0xE0 |
- (code_point >> 12));
- buffer[buffer_length++] =
- (char)(0x80 |
- ((code_point >> 6) &
- 0x3F));
- buffer[buffer_length++] =
- (char)(0x80 |
- (code_point & 0x3F));
- } else {
- // 4-byte character
- if (buffer_length + 4 >= buffer_size) {
- buffer_size *= 2;
- char *new_buffer = realloc(
- buffer, buffer_size);
- if (new_buffer == NULL) {
- free(buffer);
- JSON_PARSER_ERROR(
- parser,
- JSON_ERROR_MEMORY,
- "Memory allocation failed");
- return -1;
- }
- buffer = new_buffer;
- }
- buffer[buffer_length++] =
- (char)(0xF0 |
- (code_point >> 18));
- buffer[buffer_length++] =
- (char)(0x80 |
- ((code_point >> 12) &
- 0x3F));
- buffer[buffer_length++] =
- (char)(0x80 |
- ((code_point >> 6) &
- 0x3F));
- buffer[buffer_length++] =
- (char)(0x80 |
- (code_point & 0x3F));
- }
-
- continue; // Skip the increment at the end of
- // the loop
- } else {
- // Handle standard escape sequences
- char escaped_char;
- switch (parser->input[end]) {
- case '"':
- escaped_char = '"';
- break;
- case '\\':
- escaped_char = '\\';
- break;
- case '/':
- escaped_char = '/';
- break;
- case 'b':
- escaped_char = '\b';
- break;
- case 'f':
- escaped_char = '\f';
- break;
- case 'n':
- escaped_char = '\n';
- break;
- case 'r':
- escaped_char = '\r';
- break;
- case 't':
- escaped_char = '\t';
- break;
- default:
- free(buffer);
- JSON_PARSER_ERROR(
- parser, JSON_ERROR_SYNTAX,
- "Invalid escape character");
- return -1;
- }
-
- if (buffer_length + 1 >= buffer_size) {
- buffer_size *= 2;
- char *new_buffer =
- realloc(buffer, buffer_size);
- if (new_buffer == NULL) {
- free(buffer);
- JSON_PARSER_ERROR(
- parser,
- JSON_ERROR_MEMORY,
- "Memory allocation failed");
- return -1;
- }
- buffer = new_buffer;
- }
-
- buffer[buffer_length++] = escaped_char;
- }
- } else {
- if (buffer_length + 1 >= buffer_size) {
- buffer_size *= 2;
- char *new_buffer = realloc(buffer, buffer_size);
- if (new_buffer == NULL) {
- free(buffer);
- JSON_PARSER_ERROR(
- parser, JSON_ERROR_MEMORY,
- "Memory allocation failed");
- return -1;
- }
- buffer = new_buffer;
- }
-
- buffer[buffer_length++] = parser->input[end];
- }
- end++;
- }
-
- if (end == parser->length) {
- free(buffer);
- JSON_PARSER_ERROR(parser, JSON_ERROR_SYNTAX,
- "Unterminated string");
- return -1;
- }
-
- buffer[buffer_length] = 0;
-
- value->type = JSON_TYPE_STRING;
- value->string.value = buffer;
- value->string.length = buffer_length;
-
- parser->position = end + 1;
- return 0;
-}
-
-static void json__parser_consume_digits(struct json_parser *parser)
-{
- while (parser->position < parser->length &&
- parser->input[parser->position] >= '0' &&
- parser->input[parser->position] <= '9') {
- parser->position++;
- }
-}
-
-static int json__decode_number(struct json_parser *parser,
- struct json_value *value)
-{
- int start = parser->position;
- char *endptr;
-
- if (parser->position < parser->length &&
- parser->input[parser->position] == '-')
- parser->position++;
-
- if (parser->position < parser->length &&
- parser->input[parser->position] == '0') {
- parser->position++;
- } else if (parser->position < parser->length &&
- parser->input[parser->position] >= '1' &&
- parser->input[parser->position] <= '9') {
- json__parser_consume_digits(parser);
- } else {
- JSON_PARSER_ERROR(parser, JSON_ERROR_INVALID_NUMBER,
- "Invalid number");
- return -1;
- }
-
- if (parser->position < parser->length &&
- parser->input[parser->position] == '.') {
- parser->position++;
- if (parser->position < parser->length &&
- parser->input[parser->position] >= '0' &&
- parser->input[parser->position] <= '9') {
- json__parser_consume_digits(parser);
- } else {
- JSON_PARSER_ERROR(parser, JSON_ERROR_INVALID_NUMBER,
- "Invalid number");
- return -1;
- }
- }
-
- if (parser->position < parser->length &&
- (parser->input[parser->position] == 'e' ||
- parser->input[parser->position] == 'E')) {
- parser->position++;
- if (parser->position < parser->length &&
- (parser->input[parser->position] == '-' ||
- parser->input[parser->position] == '+')) {
- parser->position++;
- }
- if (parser->position < parser->length &&
- parser->input[parser->position] >= '0' &&
- parser->input[parser->position] <= '9') {
- json__parser_consume_digits(parser);
- } else {
- JSON_PARSER_ERROR(parser, JSON_ERROR_INVALID_NUMBER,
- "Invalid number");
- return -1;
- }
- }
-
- if (start == parser->position) {
- JSON_PARSER_ERROR(parser, JSON_ERROR_INVALID_NUMBER,
- "Invalid number");
- return -1;
- }
-
- value->type = JSON_TYPE_NUMBER;
- endptr = NULL;
- value->number = strtod(parser->input + start, &endptr);
-
- if (endptr != parser->input + parser->position) {
- JSON_PARSER_ERROR(parser, JSON_ERROR_INVALID_NUMBER,
- "Invalid number");
- return -1;
- }
-
- return 0;
-}
-
-static int json__decode_array(struct json_parser *parser,
- struct json_value *array)
-{
- if (parser->length - parser->position < 1) {
- JSON_PARSER_ERROR(parser, JSON_ERROR_EOF,
- "Unexpected end of input");
- return -1;
- }
-
- if (parser->input[parser->position] != '[') {
- JSON_PARSER_ERROR(parser, JSON_ERROR_SYNTAX, "Expected '['");
- return -1;
- }
-
- array->type = JSON_TYPE_ARRAY;
- json_array_init(array);
-
- if (parser->position + 1 < parser->length &&
- parser->input[parser->position + 1] == ']') {
- parser->position += 2;
- return 0;
- }
-
- parser->position += 1; // Skip '['
- while (parser->position < parser->length &&
- parser->input[parser->position] != ']') {
- json__parse_whitespace(parser);
-
- struct json_value *item;
- if ((item = malloc(sizeof(struct json_value))) == NULL) {
- JSON_PARSER_ERROR(parser, JSON_ERROR_MEMORY,
- "Memory allocation failed");
- json_array_free(array);
- return -1;
- }
-
- if (json__decode_value(parser, item) != 0) {
- free(item);
- json_array_free(array);
- return -1;
- }
-
- json_array_push(array, item);
- json__parse_whitespace(parser);
-
- if (parser->position < parser->length &&
- parser->input[parser->position] == ',') // Skip ','
- parser->position++;
- }
-
- if (parser->position >= parser->length ||
- parser->input[parser->position] != ']') {
- JSON_PARSER_ERROR(parser, JSON_ERROR_SYNTAX,
- "Expected closing ']' for array");
- json_array_free(array);
- return -1;
- }
-
- if (parser->position < parser->length) // Skip ']'
- parser->position++;
- return 0;
-}
-
-static int json__decode_object(struct json_parser *parser,
- struct json_value *object)
-{
- object->type = JSON_TYPE_OBJECT;
- json_object_init(object);
-
- parser->position++;
- json__parse_whitespace(parser);
-
- while (parser->position < parser->length &&
- parser->input[parser->position] != '}') {
- struct json_value key, *value;
- json__parse_whitespace(parser);
-
- if (parser->input[parser->position] != '"') {
- JSON_PARSER_ERROR(parser, JSON_ERROR_SYNTAX,
- "Expected string key");
- return -1;
- }
-
- if (json__decode_string(parser, &key) != 0) {
- JSON_PARSER_ERROR(parser, JSON_ERROR_SYNTAX,
- "Failed to parse string key");
- return -1;
- }
-
- json__parse_whitespace(parser);
- if (parser->position >= parser->length ||
- parser->input[parser->position] != ':') {
- free(key.string.value);
- JSON_PARSER_ERROR(parser, JSON_ERROR_SYNTAX,
- "Expected ':' after string key");
- return -1;
- }
- parser->position++; // Skip the colon
-
- value = malloc(sizeof(struct json_value));
- if (value == NULL) {
- free(key.string.value);
- JSON_PARSER_ERROR(
- parser, JSON_ERROR_MEMORY,
- "Failed to allocate memory for JSON item");
- return -1;
- }
-
- json__parse_whitespace(parser);
- if (json__decode_value(parser, value) != 0) {
- free(value);
- free(key.string.value);
- JSON_PARSER_ERROR(parser, JSON_ERROR_SYNTAX,
- "Failed to parse JSON value");
- return -1;
- }
-
- if (json_object_set(object, key.string.value, value) != 0) {
- free(value);
- free(key.string.value);
- JSON_PARSER_ERROR(
- parser, JSON_ERROR_MEMORY,
- "Failed to set key-value pair in object");
- return -1;
- }
-
- free(key.string.value);
- json__parse_whitespace(parser);
- if (parser->position < parser->length &&
- parser->input[parser->position] == ',')
- parser->position++; // Skip comma or closing brace
- }
-
- if (parser->position >= parser->length ||
- parser->input[parser->position] != '}') {
- JSON_PARSER_ERROR(parser, JSON_ERROR_SYNTAX,
- "Expected '}' after JSON object");
- return -1;
- }
-
- parser->position++; // Skip the closing brace
-
- return 0;
-}
-
-static int json__decode_value(struct json_parser *parser,
- struct json_value *value)
-{
- int rc;
- char c = parser->input[parser->position];
-
- if (c == '"') {
- rc = json__decode_string(parser, value);
- } else if (c == '[') {
- rc = json__decode_array(parser, value);
- } else if (c == '{') {
- rc = json__decode_object(parser, value);
- } else if (json__streqn(parser->input + parser->position, "true", 4)) {
- value->type = JSON_TYPE_BOOLEAN;
- value->number = 1;
- parser->position += 4;
- return 0;
- } else if (json__streqn(parser->input + parser->position, "false", 4)) {
- value->type = JSON_TYPE_BOOLEAN;
- value->number = 0;
- parser->position += 5;
- return 0;
- } else if (json__streqn(parser->input + parser->position, "null", 4)) {
- value->type = JSON_TYPE_NULL;
- parser->position += 4;
- return 0;
- } else {
- rc = json__decode_number(parser, value);
- }
-
-#if defined(JSON_ERROR)
- if (rc != 0 && parser->error.code == JSON_ERROR_NONE) {
- JSON_PARSER_ERROR(parser, JSON_ERROR_SYNTAX, "Expected value");
- }
-#endif
-
- return rc;
-}
-
-struct json_value *json_decode_with_length(const char *json, int length)
-{
- struct json_parser parser;
- struct json_value *value = NULL;
-
- parser.input = json;
- parser.length = length;
- parser.position = 0;
-
-#if defined(JSON_ERROR)
- parser.error.code = JSON_ERROR_NONE;
- parser.error.message = NULL;
-#endif
-
- if ((value = malloc(sizeof(struct json_value))) == NULL)
- return NULL;
-
- if (json__decode_value(&parser, value) != 0) {
-#if defined(JSON_ERROR) && !defined(JSON_ERROR_HANDLER)
- if (parser.error.code != JSON_ERROR_NONE) {
- fprintf(stderr,
- "JSON(\033[1merror\033[m): %s:%d %s at\n",
- parser.error.func, parser.error.line,
- parser.error.message);
- }
-#elif defined(JSON_ERROR) && defined(JSON_ERROR_HANDLER)
- if (parser.error.code != JSON_ERROR_NONE) {
- JSON_ERROR_HANDLER(parser.error.code,
- parser.error.message);
- }
-#endif
- free(value);
- return NULL;
- }
-
- return value;
-}
-
-struct json_value *json_decode(const char *json)
-{
- return json_decode_with_length(json, json__strlen(json));
-}
-
-static char *json__encode_array(struct json_value *value)
-{
- int length;
- int buffer_size;
- char *encoded_array;
- if (value == NULL) {
- return NULL;
- }
-
- buffer_size = 512;
- encoded_array = malloc(buffer_size);
- if (encoded_array == NULL) {
- return NULL;
- }
-
- length = 1;
- encoded_array[0] = '[';
-
- for (int i = 0; i < value->array.length; i++) {
- int needed;
- int encoded_item_len;
- char *encoded_item = json_encode(value->array.items[i]);
- if (encoded_item == NULL) {
- free(encoded_array);
- return NULL;
- }
-
- encoded_item_len = json__strlen(encoded_item);
- if (encoded_item_len < 0) {
- free(encoded_array);
- free(encoded_item);
- return NULL;
- }
-
- needed = length + encoded_item_len + (i > 0 ? 1 : 0) + 1;
- if (needed > buffer_size) {
- char *new_encoded_array = realloc(
- encoded_array, (buffer_size = needed * 2));
- if (new_encoded_array == NULL) {
- free(encoded_array);
- free(encoded_item);
- return NULL;
- }
- encoded_array = new_encoded_array;
- }
-
- if (i > 0) {
- encoded_array[length++] = ',';
- }
-
- for (int i = 0; i < encoded_item_len; i++) {
- if (encoded_item[i] == '\0')
- break;
- encoded_array[length + i] = encoded_item[i];
- }
-
- length += encoded_item_len;
-
- free(encoded_item);
- }
-
- encoded_array[length++] = ']';
- encoded_array[length] = '\0';
-
- return encoded_array;
-}
-
-static char *json__encode_object(struct json_value *object)
-{
- int length;
- int buffer_size = 256;
- char *encoded_object = malloc(buffer_size);
- if (encoded_object == NULL) {
- return NULL;
- }
-
- encoded_object[0] = '{';
- length = 1;
-
- for (int i = 0; i < object->object.n_items; i++) {
- char *new_buffer;
- char *key = object->object.items[i]->key;
- char *value = json_encode(object->object.items[i]->value);
- if (value == NULL) {
- free(encoded_object);
- return NULL;
- }
-
- int key_length = json__strlen(key);
- int value_length = json__strlen(value);
- if (value_length < 0) {
- free(encoded_object);
- free(value);
- return NULL;
- }
-
- int needed = length + key_length + value_length + 4 +
- (i < object->object.n_items - 1 ? 1 : 0);
-
- if (needed > buffer_size) {
- buffer_size = needed * 2;
- new_buffer = realloc(encoded_object, buffer_size);
- if (new_buffer == NULL) {
- free(encoded_object);
- free(value);
- return NULL;
- }
- encoded_object = new_buffer;
- }
-
- encoded_object[length++] = '"';
- for (int j = 0; j < key_length; j++)
- encoded_object[length++] = key[j];
-
- encoded_object[length++] = '"';
- encoded_object[length++] = ':';
- for (int j = 0; j < value_length; j++) {
- if (value[j] == '\0')
- break;
- encoded_object[length++] = value[j];
- }
-
- free(value);
-
- if (i < object->object.n_items - 1) {
- encoded_object[length++] = ',';
- }
- }
-
- encoded_object[length++] = '}';
- encoded_object[length] = '\0';
-
- return encoded_object;
-}
-
-static char *json__encode_string(struct json_value *value)
-{
- const char *str = value->string.value;
- int length = value->string.length;
- int buffer_size = length * 6 + 3; // Maximum possible size (all chars
- // escaped + quotes)
- char *buffer = malloc(buffer_size);
- int pos = 0;
-
- if (!buffer)
- return NULL;
-
- buffer[pos++] = '"';
-
- for (int i = 0; i < length; i++) {
- unsigned char c = (unsigned char)str[i];
-
- if (c == '"' || c == '\\' || c == '/') {
- buffer[pos++] = '\\';
- buffer[pos++] = c;
- } else if (c == '\b') {
- buffer[pos++] = '\\';
- buffer[pos++] = 'b';
- } else if (c == '\f') {
- buffer[pos++] = '\\';
- buffer[pos++] = 'f';
- } else if (c == '\n') {
- buffer[pos++] = '\\';
- buffer[pos++] = 'n';
- } else if (c == '\r') {
- buffer[pos++] = '\\';
- buffer[pos++] = 'r';
- } else if (c == '\t') {
- buffer[pos++] = '\\';
- buffer[pos++] = 't';
- } else if (c < 32) {
- // Control characters must be escaped as \uXXXX
- buffer[pos++] = '\\';
- buffer[pos++] = 'u';
- buffer[pos++] = '0';
- buffer[pos++] = '0';
- buffer[pos++] = "0123456789ABCDEF"[(c >> 4) & 0xF];
- buffer[pos++] = "0123456789ABCDEF"[c & 0xF];
- } else if (c < 128) {
- // ASCII characters
- buffer[pos++] = c;
- } else {
- // UTF-8 encoded characters
- // Check if this is a multi-byte sequence
- const unsigned char *bytes =
- (const unsigned char *)&str[i];
- if ((c & 0xE0) == 0xC0) {
- // Two-byte sequence
- if (i + 1 >= length ||
- (bytes[i + 1] & 0xC0) != 0x80) {
- // Invalid UTF-8 sequence, escape as
- // replacement character
- buffer[pos++] = '\\';
- buffer[pos++] = 'u';
- buffer[pos++] = 'F';
- buffer[pos++] = 'F';
- buffer[pos++] = 'F';
- buffer[pos++] = 'D';
- } else {
- // Valid two-byte sequence, keep as is
- buffer[pos++] = c;
- buffer[pos++] = str[++i];
- }
- } else if ((c & 0xF0) == 0xE0) {
- // Three-byte sequence
- if (i + 2 >= length ||
- (bytes[i + 1] & 0xC0) != 0x80 ||
- (bytes[i + 2] & 0xC0) != 0x80) {
- // Invalid UTF-8 sequence
- buffer[pos++] = '\\';
- buffer[pos++] = 'u';
- buffer[pos++] = 'F';
- buffer[pos++] = 'F';
- buffer[pos++] = 'F';
- buffer[pos++] = 'D';
- } else {
- // Valid three-byte sequence, keep as is
- buffer[pos++] = c;
- buffer[pos++] = str[++i];
- buffer[pos++] = str[++i];
- }
- } else if ((c & 0xF8) == 0xF0) {
- // Four-byte sequence
- if (i + 3 >= length ||
- (bytes[i + 1] & 0xC0) != 0x80 ||
- (bytes[i + 2] & 0xC0) != 0x80 ||
- (bytes[i + 3] & 0xC0) != 0x80) {
- // Invalid UTF-8 sequence
- buffer[pos++] = '\\';
- buffer[pos++] = 'u';
- buffer[pos++] = 'F';
- buffer[pos++] = 'F';
- buffer[pos++] = 'F';
- buffer[pos++] = 'D';
- } else {
- // Valid four-byte sequence, keep as is
- buffer[pos++] = c;
- buffer[pos++] = str[++i];
- buffer[pos++] = str[++i];
- buffer[pos++] = str[++i];
- }
- } else {
- // Invalid UTF-8 start byte
- buffer[pos++] = '\\';
- buffer[pos++] = 'u';
- buffer[pos++] = 'F';
- buffer[pos++] = 'F';
- buffer[pos++] = 'F';
- buffer[pos++] = 'D';
- }
- }
- }
-
- buffer[pos++] = '"';
- buffer[pos] = '\0';
-
- // Reallocate to actual size
- char *result = realloc(buffer, pos + 1);
- return result ? result : buffer;
-}
-
-char *json_encode(struct json_value *value)
-{
- switch (value->type) {
- case JSON_TYPE_STRING:
- return json__encode_string(value);
- case JSON_TYPE_NUMBER: {
- char *ptr;
- char buffer[32];
- int length = snprintf(buffer, sizeof(buffer), "%.17g",
- value->number);
-
- if ((ptr = malloc(length + 1)) == NULL)
- return NULL;
-
- for (int i = 0; i < length; i++)
- ptr[i] = buffer[i];
-
- ptr[length] = 0;
- return ptr;
- }
- case JSON_TYPE_BOOLEAN: {
- char *ptr;
- const char *boolean_str = value->number != 0.0 ? "true" :
- "false";
- int length = json__strlen(boolean_str);
-
- if ((ptr = malloc(length + 1)) == NULL)
- return NULL;
-
- for (int i = 0; i < length; i++)
- ptr[i] = boolean_str[i];
-
- ptr[length] = 0;
- return ptr;
- }
- case JSON_TYPE_NULL: {
- char *ptr;
- const char *null_str = "null";
- int length = json__strlen(null_str);
-
- if ((ptr = malloc(length + 1)) == NULL)
- return NULL;
-
- for (int i = 0; i < length; i++)
- ptr[i] = null_str[i];
-
- ptr[length] = 0;
- return ptr;
- }
- case JSON_TYPE_ARRAY:
- return json__encode_array(value);
- case JSON_TYPE_OBJECT:
- return json__encode_object(value);
- default:
- return NULL;
- }
-}
-
-void json_object_init(struct json_value *object)
-{
- object->object.n_items = 0;
- object->object.capacity = 0;
- object->object.items = NULL;
-}
-
-struct json_value *json_object_new(void)
-{
- struct json_value *object = malloc(sizeof(struct json_value));
- if (!object) {
- return NULL;
- }
-
- object->type = JSON_TYPE_OBJECT;
- json_object_init(object);
-
- return object;
-}
-
-void json_object_free(struct json_value *object)
-{
- for (int i = 0; i < object->object.n_items; i++) {
- json_free(object->object.items[i]->value);
- free(object->object.items[i]->key);
- free(object->object.items[i]);
- }
-
- free(object->object.items);
- free(object);
-}
-
-int json_object_set(struct json_value *object, const char *key,
- struct json_value *value)
-{
- if (object->object.n_items >=
- object->object.capacity * JSON_OBJECT_CAPACITY_THRESHOLD) {
- void *items;
- int capacity;
-
- if (object->object.capacity)
- capacity = object->object.capacity *
- JSON_OBJECT_CAPACITY_MULTIPLIER;
- else
- capacity = JSON_OBJECT_INITIAL_CAPACITY;
-
- if ((items = realloc(
- object->object.items,
- capacity * sizeof(*object->object.items))) == NULL)
- return -1;
-
- object->object.items = items;
- object->object.capacity = capacity;
- }
-
- for (int i = 0; i < object->object.n_items; i++) {
- if (json__streq(object->object.items[i]->key, key)) {
- json_free(object->object.items[i]->value);
- object->object.items[i]->value = value;
- return 0;
- }
- }
-
- int idx = object->object.n_items++;
- object->object.items[idx] = malloc(sizeof(*object->object.items[idx]));
-
- if (object->object.items[idx] == NULL)
- return -1;
-
- int key_len = json__strlen(key);
- object->object.items[idx]->key = malloc(key_len + 1);
- strncpy(object->object.items[idx]->key, key, key_len);
- object->object.items[idx]->key[key_len] = '\0';
- object->object.items[idx]->value = value;
-
- return 0;
-}
-
-int json_object_has(struct json_value *object, const char *key)
-{
- for (int i = 0; i < object->object.n_items; i++)
- if (json__streq(object->object.items[i]->key, key))
- return 1;
-
- return 0;
-}
-
-struct json_value *json_object_get(struct json_value *object, const char *key)
-{
- if (object == NULL || object->object.items == NULL)
- return NULL;
-
- for (int i = 0; i < object->object.n_items; i++)
- if (object->object.items[i] != NULL &&
- object->object.items[i]->key != NULL &&
- json__streq(object->object.items[i]->key, key))
- return object->object.items[i]->value;
-
- return NULL;
-}
-
-void json_object_remove(struct json_value *object, const char *key)
-{
- for (int i = 0; i < object->object.n_items; i++) {
- if (json__streq(object->object.items[i]->key, key)) {
- switch (object->object.items[i]->value->type) {
- case JSON_TYPE_ARRAY:
- json_array_free(object->object.items[i]->value);
- break;
- case JSON_TYPE_OBJECT:
- json_object_free(
- object->object.items[i]->value);
- break;
- case JSON_TYPE_STRING:
- json_string_free(
- object->object.items[i]->value);
- break;
- default:
- free(object->object.items[i]->value);
- break;
- }
-
- free(object->object.items[i]->key);
- free(object->object.items[i]);
-
- if (i < object->object.n_items - 1) {
- object->object.items[i] =
- object->object
- .items[object->object.n_items -
- 1];
- }
-
- object->object.n_items--;
- }
- }
-}
-
-int json_object_iter(const struct json_value *object, int *iter, char **key,
- struct json_value **value)
-{
- if (*iter >= object->object.n_items)
- return 0;
-
- *key = object->object.items[*iter]->key;
- *value = object->object.items[(*iter)++]->value;
-
- return 1;
-}
-
-void json_object_clear(struct json_value *object)
-{
- char *key;
- int iter = 0;
- struct json_value *value;
-
- while (json_object_iter(object, &iter, &key, &value)) {
- json_object_remove(object, key);
- iter--;
- }
-}
-
-void json_array_init(struct json_value *array)
-{
- array->array.length = 0;
- array->array.capacity = 0;
- array->array.items = NULL;
-}
-
-struct json_value *json_array_new(void)
-{
- struct json_value *value;
- if ((value = malloc(sizeof(struct json_value))) == NULL)
- return NULL;
-
- value->type = JSON_TYPE_ARRAY;
- json_array_init(value);
-
- return value;
-}
-
-void json_array_free(struct json_value *value)
-{
- for (int i = 0; i < value->array.length; i++) {
- switch (value->array.items[i]->type) {
- case JSON_TYPE_OBJECT:
- json_object_free(value->array.items[i]);
- break;
- case JSON_TYPE_ARRAY:
- json_array_free(value->array.items[i]);
- break;
- case JSON_TYPE_STRING:
- json_string_free(value->array.items[i]);
- break;
- default:
- free(value->array.items[i]);
- break;
- }
- }
- free(value->array.items);
- free(value);
-}
-
-void json_free(struct json_value *value)
-{
- switch (value->type) {
- case JSON_TYPE_OBJECT:
- json_object_free(value);
- break;
- case JSON_TYPE_ARRAY:
- json_array_free(value);
- break;
- case JSON_TYPE_STRING:
- json_string_free(value);
- break;
- default:
- free(value);
- }
-}
-
-struct json_value *json_deep_copy(struct json_value *value)
-{
- struct json_value *new_value;
- struct json_value *element;
- char *key;
- int iter;
-
- iter = 0;
-
- switch (value->type) {
- case JSON_TYPE_OBJECT:
- new_value = json_object_new();
- while (json_object_iter(value, &iter, &key, &element))
- json_object_set(new_value, key,
- json_deep_copy(element));
- return new_value;
-
- case JSON_TYPE_ARRAY:
- new_value = json_array_new();
- while (json_array_iter(value, &iter, &element))
- json_array_push(new_value, json_deep_copy(element));
- return new_value;
-
- case JSON_TYPE_STRING:
- return json_string_new(value->string.value);
-
- default:
- new_value = malloc(sizeof(struct json_value));
- memcpy(new_value, value, sizeof(*value));
- return new_value;
- }
-
- return NULL;
-}
-
-void json_array_remove(struct json_value *array, int index)
-{
- switch (array->array.items[index]->type) {
- case JSON_TYPE_OBJECT:
- json_object_free(array->array.items[index]);
- break;
- case JSON_TYPE_ARRAY:
- json_array_free(array->array.items[index]);
- break;
- case JSON_TYPE_STRING:
- json_string_free(array->array.items[index]);
- break;
- default:
- break;
- }
-
- for (int i = index; i < array->array.length - 1; i++)
- array->array.items[i] = array->array.items[i + 1];
- array->array.length--;
-}
-
-inline int json_array_length(struct json_value *array)
-{
- return array->array.length;
-}
-
-int json_array_push(struct json_value *array, struct json_value *value)
-{
- if (array == NULL) {
- return -1;
- }
-
- int index = array->array.length;
- int capacity = array->array.capacity;
- int capacity_threshold = capacity * JSON_ARRAY_CAPACITY_THRESHOLD;
-
- if (index >= capacity_threshold) {
- int capacity;
- if (array->array.capacity > 0)
- capacity = array->array.capacity *
- JSON_ARRAY_CAPACITY_MULTIPLIER;
- else
- capacity = JSON_ARRAY_INITIAL_CAPACITY;
-
- struct json_value **items;
- int size = capacity * sizeof(struct json_value *);
- if ((items = realloc(array->array.items, size)) == NULL)
- return -1;
-
- array->array.items = items;
- array->array.capacity = capacity;
- }
-
- array->array.items[array->array.length++] = value;
- return 0;
-}
-
-int json_array_iter(struct json_value *array, int *index,
- struct json_value **value)
-{
- if (*index >= array->array.length)
- return 0;
-
- *value = array->array.items[(*index)++];
- return 1;
-}
-
-void json_array_clear(struct json_value *array)
-{
- int iter = 0;
- struct json_value *value;
-
- while (json_array_iter(array, &iter, &value))
- json_array_remove(array, iter--);
-}
-
-struct json_value *json_string_new(const char *string)
-{
- struct json_value *value;
- if ((value = malloc(sizeof(struct json_value))) == NULL)
- return NULL;
-
- value->type = JSON_TYPE_STRING;
- value->string.length = json__strlen(string);
- if ((value->string.value = malloc(value->string.length + 1)) == NULL) {
- free(value);
- return NULL;
- }
-
- for (int i = 0; i < value->string.length; i++)
- value->string.value[i] = string[i];
-
- value->string.value[value->string.length] = 0;
- return value;
-}
-
-struct json_value *json_number_new(double value)
-{
- struct json_value *number;
- if ((number = malloc(sizeof(struct json_value))) == NULL)
- return NULL;
-
- number->type = JSON_TYPE_NUMBER;
- number->number = value;
-
- return number;
-}
-
-struct json_value *json_boolean_new(int value)
-{
- struct json_value *boolean;
- if ((boolean = malloc(sizeof(struct json_value))) == NULL)
- return NULL;
-
- boolean->type = JSON_TYPE_BOOLEAN;
- boolean->number = value;
-
- return boolean;
-}
-
-void json_string_free(struct json_value *string)
-{
- free(string->string.value);
- free(string);
-}
-
-static inline void json__print_indent(int indent)
-{
- for (int i = 0; i < indent; i++) {
- putchar(' ');
- }
-}
-
-static void json__print_internal(struct json_value *value, int indent)
-{
- if (value == NULL) {
- printf("null");
- return;
- }
-
- switch (value->type) {
- case JSON_TYPE_STRING:
- printf("\"%s\"", value->string.value);
- break;
- case JSON_TYPE_NUMBER:
- printf("%.17g", value->number);
- break;
- case JSON_TYPE_BOOLEAN:
- printf("%s", value->number == 0.0 ? "false" : "true");
- break;
- case JSON_TYPE_NULL:
- printf("null");
- break;
- case JSON_TYPE_ARRAY:
- printf("[\n");
- for (int i = 0; i < value->array.length; i++) {
- json__print_indent(indent + 2);
- json__print_internal(value->array.items[i], indent + 2);
- if (i < value->array.length - 1) {
- printf(",\n");
- } else {
- printf("\n");
- }
- }
- json__print_indent(indent);
- printf("]");
- break;
- case JSON_TYPE_OBJECT:
- printf("{\n");
- for (int i = 0; i < value->object.n_items; i++) {
- json__print_indent(indent + 2);
- printf("\"%s\": ", value->object.items[i]->key);
- json__print_internal(value->object.items[i]->value,
- indent + 2);
- if (i < value->object.n_items - 1) {
- printf(",\n");
- } else {
- printf("\n");
- }
- }
- json__print_indent(indent);
- printf("}");
- break;
- default:
- break;
- }
-}
-
-void json_print(struct json_value *value)
-{
- json__print_internal(value, 0);
-}
-
-void json_println(struct json_value *value)
-{
- json_print(value);
- putchar('\n');
-}
generated by cgit v1.2.3 (git 2.39.1) at 2026-04-05 13:29:08 +0000