native_yyjson_helpers.c

Go to the documentation of this file.

/**
 * @file
 * @brief Implements small reusable yyjson wrappers with explicit ownership and type checks for Pharos native runtime callers.
 */
 
#include "native_yyjson_helpers.h"
 
#include "native_support.h"
 
#include <limits.h>
#include <stdlib.h>
#include <string.h>
 
/**
 * @brief Duplicates a JSON string value into owned storage.
 * @param value JSON string value to duplicate.
 * @return Newly allocated string, or NULL when the value is invalid.
 */
static char *native_json_string_dup(yyjson_val *value) {
  const char *text = NULL;
  size_t len = 0;
  char *copy = NULL;
  if (!yyjson_is_str(value)) {
    return NULL;
  }
  text = yyjson_get_str(value);
  len = yyjson_get_len(value);
  copy = (char *)malloc(len + 1);
  if (copy == NULL) {
    return NULL;
  }
  memcpy(copy, text, len);
  copy[len] = '\0';
  return copy;
}
 
/**
 * @brief Tests whether a numeric JSON value can be converted to long.
 * @param value Numeric JSON value.
 * @param out Output location for the converted value.
 * @return 1 when conversion succeeds, otherwise 0.
 */
static int native_json_long_from_value(yyjson_val *value, long *out) {
  int64_t signed_value = 0;
  uint64_t unsigned_value = 0;
  double real_value = 0.0;
  if (value == NULL || out == NULL || !yyjson_is_num(value)) {
    return 0;
  }
  if (yyjson_is_sint(value)) {
    signed_value = yyjson_get_sint(value);
    if (signed_value < LONG_MIN || signed_value > LONG_MAX) {
      return 0;
    }
    *out = (long)signed_value;
    return 1;
  }
  if (yyjson_is_uint(value)) {
    unsigned_value = yyjson_get_uint(value);
    if (unsigned_value > (uint64_t)LONG_MAX) {
      return 0;
    }
    *out = (long)unsigned_value;
    return 1;
  }
  if (!yyjson_is_real(value)) {
    return 0;
  }
  real_value = yyjson_get_real(value);
  if (real_value < (double)LONG_MIN || real_value > (double)LONG_MAX) {
    return 0;
  }
  if ((double)((long)real_value) != real_value) {
    return 0;
  }
  *out = (long)real_value;
  return 1;
}
 
/**
 * @brief Searches an object array for an element whose named field matches a string.
 * @param array_value Array to inspect.
 * @param field_name Object field to compare.
 * @param expected_value String value to match.
 * @return Matching object, or NULL when not found.
 */
static yyjson_val *native_json_find_object_by_string_field(
    yyjson_val *array_value,
    const char *field_name,
    const char *expected_value) {
  yyjson_arr_iter iter;
  yyjson_val *item = NULL;
  if (array_value == NULL || field_name == NULL || expected_value == NULL) {
    return NULL;
  }
  if (!yyjson_arr_iter_init(array_value, &iter)) {
    return NULL;
  }
  while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
    yyjson_val *field_value = NULL;
    if (!yyjson_is_obj(item)) {
      continue;
    }
    field_value = yyjson_obj_get(item, field_name);
    if (yyjson_is_str(field_value) &&
        yyjson_equals_str(field_value, expected_value)) {
      return item;
    }
  }
  return NULL;
}
 
yyjson_doc *native_json_doc_load_file(const char *path) {
  char *text = NULL;
  yyjson_doc *doc = NULL;
  if (path == NULL || path[0] == '\0') {
    return NULL;
  }
  text = read_file_text(path);
  if (text == NULL) {
    return NULL;
  }
  doc = native_json_doc_load_text(text);
  free(text);
  return doc;
}
 
yyjson_doc *native_json_doc_load_text(const char *text) {
  size_t len = 0;
  if (text == NULL) {
    return NULL;
  }
  len = strlen(text);
  if (len == 0) {
    return NULL;
  }
  return yyjson_read(text, len, YYJSON_READ_NOFLAG);
}
 
void native_json_doc_free(yyjson_doc *doc) {
  if (doc == NULL) {
    return;
  }
  yyjson_doc_free(doc);
}
 
yyjson_val *native_json_obj_get(yyjson_val *obj, const char *key) {
  if (obj == NULL || key == NULL || !yyjson_is_obj(obj)) {
    return NULL;
  }
  return yyjson_obj_get(obj, key);
}
 
yyjson_val *native_json_obj_get_array(yyjson_val *obj, const char *key) {
  yyjson_val *value = native_json_obj_get(obj, key);
  if (!yyjson_is_arr(value)) {
    return NULL;
  }
  return value;
}
 
char *native_json_obj_get_string_dup(yyjson_val *obj, const char *key) {
  return native_json_string_dup(native_json_obj_get(obj, key));
}
 
long native_json_obj_get_long_default(
    yyjson_val *obj,
    const char *key,
    long default_value,
    int *found_out) {
  yyjson_val *value = NULL;
  long converted = default_value;
  int found = 0;
  value = native_json_obj_get(obj, key);
  if (native_json_long_from_value(value, &converted)) {
    found = 1;
  } else {
    converted = default_value;
  }
  if (found_out != NULL) {
    *found_out = found;
  }
  return converted;
}
 
yyjson_val *native_json_find_migration_by_id(
    yyjson_val *root,
    const char *migration_id) {
  yyjson_val *migrations = native_json_obj_get_array(root, "migrations");
  return native_json_find_object_by_string_field(
      migrations,
      "migration_id",
      migration_id);
}
 
yyjson_val *native_json_find_backend_by_name(
    yyjson_val *root,
    const char *backend_name) {
  yyjson_val *backends = native_json_obj_get_array(root, "backends");
  return native_json_find_object_by_string_field(
      backends,
      "backend",
      backend_name);
}
 
char *native_json_serialize_compact_dup(yyjson_val *value) {
  if (value == NULL) {
    return NULL;
  }
  return yyjson_val_write(value, YYJSON_WRITE_NOFLAG, NULL);
}
 
char *native_json_string_array_lines_dup(yyjson_val *array_value) {
  yyjson_arr_iter iter;
  yyjson_val *item = NULL;
  Buffer buffer;
  if (array_value == NULL || !yyjson_is_arr(array_value)) {
    return NULL;
  }
  buffer_init(&buffer);
  if (!yyjson_arr_iter_init(array_value, &iter)) {
    return NULL;
  }
  while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
    const char *text = NULL;
    size_t len = 0;
    if (!yyjson_is_str(item)) {
      buffer_free(&buffer);
      return NULL;
    }
    text = yyjson_get_str(item);
    len = yyjson_get_len(item);
    if (buffer.len > 0 && buffer_append(&buffer, "\n", 1) != 0) {
      buffer_free(&buffer);
      return NULL;
    }
    if (buffer_append(&buffer, text, len) != 0) {
      buffer_free(&buffer);
      return NULL;
    }
  }
  if (buffer.data == NULL) {
    return dup_range("", 0);
  }
  return buffer.data;
}