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

5 files changed, 218 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);
+}
diff --git a/src/ipc/go_args.c b/src/ipc/go_args.c
new file mode 100644
index 0000000..50f4b72
--- /dev/null
+++ b/src/ipc/go_args.c
@@ -0,0 +1,19 @@
+#include "ipc/go_args.h"
+#include <stdio.h>
+
+bool should_continue(engine_message_t *message, go_args_t *go) {
+  int depth;
+  int nodes;
+  int mate;
+  if (go->depth && (go->depth <= message->depth)) {
+    return false;
+  }
+  if (go->nodes && (go->nodes <= message->nodes)) {
+    message->node_limit = true;
+    return false;
+  }
+  if (go->mate && message->mate && (go->mate >= message->mate)) {
+    return false;
+  }
+  return true;
+}
diff --git a/src/ipc/moves.c b/src/ipc/moves.c
new file mode 100644
index 0000000..acd7085
--- /dev/null
+++ b/src/ipc/moves.c
@@ -0,0 +1,23 @@
+#include "ipc/moves.h"
+#include <stdlib.h>
+
+void ipc_moves_init(ipc_moves_t *moves) {
+  moves->data = malloc(sizeof(ipc_move_t) * 50);
+  moves->count = 0;
+  moves->capacity = 50;
+}
+
+void ipc_moves_deinit(ipc_moves_t *moves) {
+  free(moves->data);
+}
+
+void add_ipc_move(ipc_moves_t *moves, ipc_move_t move) {
+  if (moves->count + 1 > moves->capacity) {
+    moves->capacity += 50;
+    moves->data = realloc(
+      moves->data,
+      moves->capacity * sizeof(ipc_move_t)
+    );
+  }
+  moves->data[moves->count++] = move;
+}
diff --git a/src/ipc/state.c b/src/ipc/state.c
new file mode 100644
index 0000000..02ba38b
--- /dev/null
+++ b/src/ipc/state.c
@@ -0,0 +1,41 @@
+#include <string.h>
+#include <assert.h>
+
+#define IPC_INTERNAL
+#include "ipc/state.h"
+
+void ipc_state_init(ipc_state_t *state) {
+  // done by main.c in the loop
+  // engine_messages_init(&state->engine_messages);
+  uci_state_init(&state->uci_state);
+  state->from_position = (position_t) {0};
+  ipc_moves_init(&state->moves);
+  state->uci_state.moves = &state->moves;
+  atomic_init(&state->event, EVENT_INIT);
+}
+
+void ipc_state_deinit(ipc_state_t *state) {
+  engine_messages_deinit(&state->engine_messages);
+  uci_state_deinit(&state->uci_state);
+  ipc_moves_deinit(&state->moves);
+}
+
+void ipc_state_game_reset(ipc_state_t *state) {
+  state->from_position = (position_t) {0};
+  state->moves.count = 0;
+}
+
+void ipc_state_wait_for_event(ipc_state_t *state, size_t event) {
+  assert(event < EVENTS_COUNT);
+  while (!ipc_state_is_event(state, event));
+}
+
+bool ipc_state_is_event(ipc_state_t *state, size_t event) {
+  assert(event < EVENTS_COUNT);
+  return atomic_load(&state->event) == event;
+}
+
+void ipc_state_set_event(ipc_state_t *state, size_t event) {
+  assert(event < EVENTS_COUNT);
+  atomic_store(&state->event, event);
+}
diff --git a/src/ipc/threads.c b/src/ipc/threads.c
new file mode 100644
index 0000000..9ed04de
--- /dev/null
+++ b/src/ipc/threads.c
@@ -0,0 +1,8 @@
+#include "ipc/threads.h"
+
+void threads_link(struct threads *handler, ipc_state_t *ipc_state) {
+  handler->engine_messages = &ipc_state->engine_messages;
+  handler->go_args = &ipc_state->uci_state.go_args;
+  handler->position = &ipc_state->uci_state.position;
+}
+