LiTHiuM List

#include <stdlib.h>

long ListCreate() {
  long list_ptr = malloc(sizeof(long) * 2);
  ((long *)list_ptr)[0] = list_ptr;

  ((long *)list_ptr)[1] = 0;
  return list_ptr;
}
long ListCount(long list_ptr) { return ((long *)list_ptr)[1]; }

long ListGetEntry(long list_ptr, long index) {
  // TODO: Get Current List Object without iterating; dynamic number of
  // dereference brackets frog code
  long current_list_entry_ptr = list_ptr;
  for (int i = 0; i <= index; ++i) {
    current_list_entry_ptr = ((long *)current_list_entry_ptr)[0];
  }
  return current_list_entry_ptr;
}

long ListRemove(long list_ptr, long index) {
  long list_count = ((long *)list_ptr)[1];

  if (index == 0) {
    long current_list_entry_ptr = ((long *)list_ptr)[0];
    ((long *)list_ptr)[0] = ((long *)current_list_entry_ptr)[0];
    --((long *)list_ptr)[1];
    free(current_list_entry_ptr);
  } else {
    long current_list_entry_ptr = ListGetEntry(list_ptr, index);

    if (index <= list_count - 1) {
      long previous_list_entry_ptr = ListGetEntry(list_ptr, index - 1);
      long next_list_entry_ptr = ListGetEntry(list_ptr, index + 1);

      ((long *)previous_list_entry_ptr)[0] = next_list_entry_ptr;
      --((long *)list_ptr)[1];
      free(current_list_entry_ptr);
    } else {
      --((long *)list_ptr)[1];
      free(current_list_entry_ptr);
    }
  }
}

void ListDelete(long list_ptr) {
  // TODO: Delete all list objects at same time with frog code
  long list_count = ((long *)list_ptr)[1];
  long next_list_entry_ptr = list_ptr;
  while (ListCount(list_ptr) > 0) {
    ListRemove(list_ptr, 0);
  }
  free(list_ptr);
}

long ListAdd(long list_ptr, long obj_ptr) {
  long list_count = ((long *)list_ptr)[1];

  long current_list_entry_ptr = malloc(sizeof(long) * 2);

  long last_list_entry_ptr = ListGetEntry(list_ptr, list_count - 1);
  ((long *)last_list_entry_ptr)[0] = current_list_entry_ptr;
  ((long *)current_list_entry_ptr)[1] = obj_ptr;
  ((long *)current_list_entry_ptr)[0] = list_ptr;

  long count = ((long *)list_ptr)[1]++;

  return count;
}

void ListInsert(long list_ptr, long obj_ptr, long index) {

  long new_list_entry_ptr = malloc(sizeof(long) * 2);

  ((long *)new_list_entry_ptr)[1] = obj_ptr;
  if (index == 0) {
    ((long *)new_list_entry_ptr)[0] = ((long *)list_ptr)[0];
    ((long *)list_ptr)[0] = new_list_entry_ptr;
  } else {
    long list_count = ((long *)list_ptr)[1];

    if (index < list_count) {
      long previous_object_entry_ptr = ListGetEntry(list_ptr, index - 1);
      long current_object_entry_ptr = ListGetEntry(list_ptr, index);

      ((long *)new_list_entry_ptr)[0] = current_object_entry_ptr;
      ((long *)new_list_entry_ptr)[1] = obj_ptr;

      ((long *)previous_object_entry_ptr)[0] = new_list_entry_ptr;

    } else {
      long last_entry_in_list_ptr = ListGetEntry(list_ptr, list_count - 1);
      long previous_entry_in_list_ptr = ListGetEntry(list_ptr, list_count - 2);
      ((long *)new_list_entry_ptr)[0] = last_entry_in_list_ptr;
      ((long *)last_entry_in_list_ptr)[0] = list_ptr;
      ((long *)previous_entry_in_list_ptr)[0] = new_list_entry_ptr;
    }
  }

  ++((long *)list_ptr)[1];
}

long ListGet(long list_ptr, long index) {
  return ((long *)ListGetEntry(list_ptr, index))[1];
}