restructed all the files + uci done now

also broke the symbol analyser in the process, i didn't help much, i had
to pull out the pen & paper, but it made a cool graph never the less

multithreading was a pain! but it got it in the end

fixed the structs naming convention, if it's used outside by other
files, it's typedeffed, otherwise it's not

fixed the recursive imports issued i had in go_args*, where i was
casting it to void* in uci to make it work

now response.c doesn't deal with ipc, really happy with that change
now every single thing has its own responsibility

1 files changed, 127 insertions, 0 deletions

diff --git a/src/ipc/engine_message.c b/src/ipc/engine_message.c
new file mode 100644
index 0000000..76814f4
--- /dev/null
+++ b/src/ipc/engine_message.c
@@ -0,0 +1,127 @@
+#include "ipc/engine_message.h"
+#include <stdio.h>
+#include <assert.h>
+
+atomic_flag handler_busy;
+
+void engine_message_handler_init(engine_message_handler_t *handle) {
+  engine_message_t *message = calloc(sizeof(*message), 1);
+
+  engine_message_init(message);
+
+  handle->oldest_valid = message;
+  handle->newest_valid = message;
+  handle->count = 1;
+  handle->pushed_count = 0;
+  handle->popped_count = 0;
+}
+
+void engine_message_handler_acquire(engine_message_handler_t *handle) {
+  while (atomic_flag_test_and_set(&handler_busy));
+}
+
+void engine_message_handler_release(engine_message_handler_t *handle) {
+  atomic_flag_clear(&handler_busy);
+}
+
+bool engine_message_handler_can_pop(engine_message_handler_t *handle) {
+  assert(handle != NULL);
+  engine_message_handler_acquire(handle);
+  if (handle->count == 0) {
+    engine_message_handler_release(handle);
+    return false;
+  }
+  if (handle->oldest_valid == NULL) {
+    printf("%d\n", handle->count);
+  }
+  bool output = engine_message_is_ready(handle->oldest_valid);
+  engine_message_handler_release(handle);
+  return output;
+}
+
+engine_message_t *engine_message_handler_pop(
+  engine_message_handler_t *handle
+) {
+  assert(handle != NULL);
+  engine_message_handler_acquire(handle);
+
+  engine_message_t *output = handle->oldest_valid;
+
+  handle->oldest_valid = handle->oldest_valid->next;
+  handle->count--;
+  handle->popped_count++;
+
+  engine_message_handler_release(handle);
+  return output;
+}
+
+engine_message_t *engine_message_handler_push(
+  engine_message_handler_t *handle
+) {
+  assert(handle != NULL);
+  engine_message_t *output = calloc(sizeof(*output), 1);
+  engine_message_init(output);
+
+  engine_message_handler_acquire(handle);
+
+  if (handle->count > 0) {
+    handle->newest_valid->next = output;
+  }
+  handle->newest_valid = output;
+  if (handle->count == 0) {
+    handle->oldest_valid = output;
+  }
+  handle->count++;
+  handle->pushed_count++;
+
+  engine_message_handler_release(handle);
+
+  return output;
+
+}
+void engine_messages_init(engine_messages_t *messages) {
+  assert(messages != NULL);
+  // idc, i don't want to exceed 10 threads anyway
+  messages->data = calloc(sizeof(*messages->data), 10);
+  for (int i = 0; i < 10; i++) {
+    messages->data[i] = malloc(sizeof(*messages->data[i]));
+    engine_message_handler_init(messages->data[i]);
+  }
+  messages->count = 0;
+  messages->capacity = 10;
+}
+
+void engine_messages_refresh(engine_messages_t *messages) {
+  assert(messages != NULL);
+  for (int i = 0; i < 10; i++) {
+    messages->data[i] = malloc(sizeof(*messages->data[i]));
+    engine_message_handler_init(messages->data[i]);
+  }
+  messages->count = 0;
+  messages->capacity = 10;
+}
+
+void engine_message_mark_ready(engine_message_t *message) {
+  atomic_store(&message->ready, 1);
+}
+
+bool engine_message_is_ready(engine_message_t *message) {
+  return atomic_load(&message->ready) == 1;
+}
+
+void engine_messages_deinit(engine_messages_t *messages) {
+  assert(messages != NULL);
+  free(messages->data);
+}
+
+void engine_message_init(engine_message_t *message) {
+  assert(message != NULL);
+  message->ready = 0;
+  ipc_moves_init(&message->pv);
+}
+
+void engine_message_deinit(engine_message_t *message) {
+  assert(message != NULL);
+  ipc_moves_deinit(&message->pv);
+  free(message);
+}