common.c

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#include "common.h"
#include "obj.h"
#include "number.h"
#include "boolean.h"
#include "null.h"
#include "str.h"
#include "array.h"

unsigned long hash_key(char *key, int capacity)
{
  if (capacity == 0)
  {
    return 0;
  }

  unsigned long i = 0;

  for (int j = 0; key[j]; j++)
    i += key[j];

  return i % capacity;
}

/**
 * Skip spaces, tabs and newlines
 * @param json json string
 * @param current current index in the json string
 * @param size size of the json string
 */
void skip_empty(char *json, int *current, int size)
{
  // skip spaces, tabs and newlines and index on the new character
  while (*current < size && (json[*current] == ' ' || json[*current] == '\t' || json[*current] == '\n'))
  {
    (*current)++;
  }
}

/**
 * Create a json error struct
 * @param index error location index in the json string
 * @param code error code
 */
JsonError *create_json_error(int index, char *code)
{
  JsonError *error = malloc(sizeof(JsonError));
  error->index = index;
  error->code = code;

  return error;
}

/**
 * Free a json error struct
 * @param error error struct
 */
void free_json_error(JsonError *error)
{
  if (error == NULL)
    return;

  free(error);
  error = NULL;
}

/**
 * Create an initially errored json value struct
 */
JsonValue *create_json_value()
{
  JsonValue *value = malloc(sizeof(JsonValue));

  value->end = 0;
  value->start = 0;
  value->partial = 0;
  value->error = create_json_error(0, "unknown-json-value");

  value->type = JSON_NOT_AVAILABLE;
  value->number = 0;
  value->string = NULL;
  value->array = NULL;
  value->object = NULL;

  return value;
}

/**
 * Free a json value struct
 * @param value struct
 */
void free_json_value(JsonValue *value)
{
  if (value == NULL)
    return;

  if (value->array != NULL)
  {
    free_json_array(value->array);
    value->array = NULL;
  }

  if (value->object != NULL)
  {
    free_object(value->object);
    value->object = NULL;
  }

  if (value->error != NULL)
  {
    free_json_error(value->error);
    value->error = NULL;
  }

  // all
  free(value);
}

/**
 * Create an initially empty json list (linked list).
 */
JsonLinkedNode *create_json_list()
{
  JsonLinkedNode *list = malloc(sizeof(JsonLinkedNode));

  list->value = NULL;
  list->next = NULL;
  list->key = NULL;
  list->index = 0;

  return list;
}

/**
 * Free a json list (linked list).
 * @param node list head
 */
void free_json_list(JsonLinkedNode *node)
{
  if (node == NULL)
    return;

  free_json_value(node->value);

  if (node->next != NULL)
  {
    free_json_list(node->next);
    node->next = NULL;
  }

  node->index = -1;

  free(node);
  node = NULL;
}

/**
 * Create a json key-value object item
 * @param hash hash value
 */
JsonObjectItem *create_object_item(unsigned long hash)
{
  JsonObjectItem *item = malloc(sizeof(JsonObjectItem));

  item->hash = hash;
  item->head = NULL;

  return item;
}

/**
 * Free a json key-value object item
 * @param item item
 */
void free_object_item(JsonObjectItem *item)
{
  if (item == NULL)
    return;

  free_json_list(item->head);
  free(item);
}

/**
 * Create a object to contain key-object values
 * @param size max number of items
 */
JsonObject *create_object(int size)
{
  JsonObject *object = malloc(sizeof(JsonObject));

  object->items = malloc(sizeof(JsonObjectItem *) * size);
  object->count = 0;
  object->size = size;

  for (int i = 0; i < object->size; i++)
  {
    object->items[i] = NULL;
  };

  return object;
}

/**
 * Free a object to contain key-object values
 * @param object object
 */
void free_object(JsonObject *object)
{
  if (object == NULL)
    return;

  for (int i = 0; i < object->count; i++)
  {
    free_object_item(object->items[i]);
    object->items[i] = NULL;
  }

  free(object->items);
  free(object);
  object = NULL;
}

/**
 * Insert a key-object value in the object
 * @param object parent object
 * @param key key value
 * @param item object item
 * @return int refering to insertion status
 */
int insert_in_object(JsonObject *object, char *key, JsonValue *value)
{
  if (object->size == 0 || object->count == object->size || object->count + 1 > object->size)
  {
    return INSERT_OVERFLOW;
  }

  unsigned long hash = hash_key(key, object->size);

  JsonObjectItem *current = object->items[hash];

  if (current == NULL)
  {
    object->items[hash] = current = create_object_item(hash);
  }

  JsonLinkedNode *last = current->head;
  JsonLinkedNode *next = NULL;

  if (last == NULL)
  {
    next = last = create_json_list();
    current->head = last;
  }
  else
  {
    while (last != NULL)
    {
      if (strcmp(last->key, key) == 0)
      {
        return INSERT_EXISTS;
      }

      last = last->next;
    }

    next = create_json_list();
    last->next = next;
  };

  next->key = key;
  next->value = value;
  object->count++;

  return INSERT_OK;
}

JsonValue *get_object_value(JsonObject *object, char *key)
{
  if (object->size == 0 || object->count == object->size)
  {
    return NULL;
  }

  int index = hash_key(key, object->size);
  JsonObjectItem *item = object->items[index];

  if (!item)
    return NULL;

  JsonLinkedNode *node = item->head;

  while (item != NULL && node != NULL)
  {
    if (node->key != NULL && strcmp(node->key, key) == 0)
    {
      return node->value;
    }

    node = node->next;
  }

  return NULL;
}

JsonArray *create_json_array()
{
  JsonArray *array = malloc(sizeof(JsonArray));
  array->head = NULL;
  array->size = 0;

  return array;
}

void free_json_array(JsonArray *array)
{
  if (array == NULL)
    return;

  free_json_list(array->head);
  free(array);
}

int append_to_json_array(JsonArray *array, JsonValue *value)
{
  if (array == NULL)
  {
    return INSERT_ERROR;
  }

  JsonLinkedNode *last = array->head;

  if (last == NULL)
  {
    array->head = create_json_list();
    array->head->value = value;
    array->head->index = 0;
  }
  else
  {
    while (last->next != NULL)
    {
      last = last->next;
    }

    JsonLinkedNode *next = create_json_list();
    next->value = value;
    next->index = array->size;

    last->next = next;
  }

  array->size++;

  return INSERT_OK;
}

char *get_json_file_content(char *path)
{
  char *json = malloc(1024);

  FILE *fp = fopen(path, "r");

  if (fp == NULL)
  {
    printf("INSERT_ERROR: could not open file %s", path);
    return '\0';
  }

  int i = 0;
  char ch;
  while ((ch = fgetc(fp)) != EOF)
  {
    json[i] = ch;
    i++;
  }

  json[i] = '\0';

  // close the file
  fclose(fp);

  return json;
}

JsonValue *match_any(char *json, int *current, int size)
{
  JsonValue *value = match_boolean(json, current, size);

  if (value->error != NULL && value->partial == 0)
  {
    free_json_value(value);
    value = NULL;
    value = match_null(json, current, size);
  }

  if (value->error != NULL && value->partial == 0)
  {
    free_json_value(value);
    value = NULL;
    value = match_number(json, current, size);
  }

  if (value->error != NULL && value->partial == 0)
  {
    free_json_value(value);
    value = NULL;
    value = match_string(json, current, size);
  }

  if (value->error != NULL && value->partial == 0)
  {
    free_json_value(value);
    value = NULL;
    value = match_array(json, current, size);
  }

  if (value->error != NULL && value->partial == 0)
  {
    free_json_value(value);
    value = NULL;
    value = match_object(json, current, size);
  }

  if (value->error != NULL && value->partial == 0)
  {
    value->type = JSON_NOT_AVAILABLE;
    value->error->code = "invalid-json-type";
    value->partial = 0;
  }

  return value;
}

char *slice_string(const char *str, int start, int end)
{
  if (!str || start < 0 || end <= start || start >= (int)strlen(str))
  {
    return NULL; // Handle invalid input
  }

  int length = end - start;
  char *result = (char *)malloc(length + 1); // Allocate memory for new string

  if (!result)
  {
    return NULL; // Handle memory allocation failure
  }

  strncpy(result, str + start, length); // Copy substring
  result[length] = '\0';                // Null-terminate the string

  return result;
}