minor cosmetic changes

.github/workflows/cmake-single-platform.yml

@@ -20,7 +20,7 @@ jobs:
     runs-on: ubuntu-20.04
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
       with:
         submodules: true
 

program/CMakeLists.txt

@@ -4,9 +4,9 @@ find_package(GLEW REQUIRED)
 
 add_executable(${PROJECT_NAME} main.c)
 
-add_library(PROGRAM_LIBRARY "")
+add_library(program "")
 
-target_sources(PROGRAM_LIBRARY
+target_sources(program
     PRIVATE
         source/gui/graphics.c
         source/gui/input.c
@@ -22,14 +22,17 @@ target_sources(PROGRAM_LIBRARY
         source/instance/argument.c
         source/instance/settings.c
         source/instance/statistics.c
+        source/instance/expect.c
 
         source/structures/concrete/board.c
         source/structures/concrete/state.c
 
         source/slnoslav.c
 )
 
-target_include_directories(PROGRAM_LIBRARY PUBLIC include)
-target_link_libraries(PROGRAM_LIBRARY PRIVATE glfw GLEW::GLEW OpenGL::GL m nuklear)
+target_include_directories(program PUBLIC include)
 
-target_link_libraries(${PROJECT_NAME} PRIVATE PROGRAM_LIBRARY)
+target_link_libraries(program PRIVATE glfw GLEW::GLEW OpenGL::GL m nuklear)
+target_link_libraries(${PROJECT_NAME} PRIVATE program)
+
+target_compile_definitions(${PROJECT_NAME} PRIVATE ERROR_LOG_FILE_PATH=\"${CMAKE_BINARY_DIR}/slnoslav-debug.txt\")

program/include/algorithms/arc_consistency.h

@@ -6,6 +6,6 @@
 #include <structures/concrete/state.h>
 #include <structures/concrete/board.h>
 
-bool look_ahead(board_s board, SArray * current_state);
+bool look_ahead(const board_s board, state_array_s * current_state);
 
 #endif /* ALGORITHMS_ARC_CONSISTENCY_H */

program/include/algorithms/backtrack.h

@@ -6,6 +6,6 @@
 #include <structures/concrete/state.h>
 #include <structures/concrete/board.h>
 
-bool backtrack(board_s board, SArray current_state);
+bool backtrack(board_s board, state_array_s current_state);
 
 #endif /* ALGORITHMS_BACKTRACK_H */

program/include/algorithms/depth_first_search.h

@@ -4,6 +4,6 @@
 #include <structures/concrete/state.h>
 #include <structures/concrete/board.h>
 
-SArray depth_first_search(board_s board);
+state_array_s depth_first_search(board_s board);
 
 #endif /* ALGORITHMS_DEPTH_FIRST_SEARCH_H */

program/include/algorithms/forward_checking.h

@@ -6,6 +6,6 @@
 #include <structures/concrete/state.h>
 #include <structures/concrete/board.h>
 
-bool forward_checking(board_s board, SArray * current_state, ulookup_t index);
+bool forward_checking(board_s board, state_array_s * current_state, ulookup_t index);
 
 #endif /* ALGORITHMS_FORWARD_CHECKING_H */

program/include/algorithms/reduce.h

@@ -4,6 +4,6 @@
 #include <structures/concrete/state.h>
 #include <structures/concrete/board.h>
 
-void reduce(board_s board, SArray * initial_state);
+void reduce(board_s board, state_array_s * initial_state);
 
 #endif /* ALGORITHMS_REDUCE_H */

program/include/instance/argument.h

@@ -1,10 +1,6 @@
 #ifndef INSTANCE_ARGUMENT_H
 #define INSTANCE_ARGUMENT_H
 
-#include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
-
 #define FILEPATH_FLAG_STRING_SHORT "-fp"
 #define FILEPATH_FLAG_STRING_LONG  "--filepath"
 

program/include/instance/expect.h

@@ -2,29 +2,25 @@
 #define INSTANCE_EXPECT_H
 
 #include <stdio.h>
-#include <stdlib.h>
 #include <assert.h>
+#include <stdlib.h>
 
 typedef enum error_mode_type {
     DEFAULT_E, ABORT_E, ASSERT_E, EXIT_E,
 } error_mode_e;
 
-static error_mode_e error_mode = DEFAULT_E;
-static FILE *       error_log  = NULL;
+extern error_mode_e error_mode;
+extern  FILE * error_log;
 
 #define NO_ACTION (void)(0)
 
 #ifdef ERROR_LOG_FILE_PATH
 
-static FILE *       error_log  = fopen(ERROR_LOG_FILE_PATH, "a");
-
 #define expect(assertion, error_action, ...)                                   \
 {                                                                              \
     if (!(assertion)) {                                                        \
-        assert(error_log);                                                     \
         fprintf(error_log, __VA_ARGS__);                                       \
         fprintf(error_log, "\n");                                              \
-        fclose(error_log)                                                      \
         switch (error_mode) {                                                  \
             case ABORT_E  : { error_action; abort(); break;                  } \
             case ASSERT_E : { error_action; assert(0 && (assertion)); break; } \
@@ -33,14 +29,8 @@ static FILE *       error_log  = fopen(ERROR_LOG_FILE_PATH, "a");
     }                                                                          \
 }
 
-__attribute__((destructor)) static void close_error_log(void) {
-    fclose(error_log);
-}
-
 #else
 
-static FILE *       error_log;
-
 #define expect(assertion, error_action, ...)                                  \
 {                                                                             \
     if (!(assertion)) {                                                       \

program/include/instance/settings.h

@@ -1,9 +1,7 @@
 #ifndef INSTANCE_SETTINGS_H
 #define INSTANCE_SETTINGS_H
 
-#include <stdlib.h>
 #include <stdbool.h>
-#include <time.h>
 #include <stdint.h>
 
 typedef enum playstate {

program/include/instance/statistics.h

@@ -1,7 +1,6 @@
 #ifndef INSTANCE_DATA_H
 #define INSTANCE_DATA_H
 
-#include <stdlib.h>
 #include <stdbool.h>
 
 typedef struct statistics {

program/include/structures/abstract/queue.h

@@ -6,9 +6,6 @@
 #include <string.h>
 #include <assert.h>
 
-//#define FINITE_QUEUE
-//#undef FINITE_QUEUE
-
 #ifndef QUEUE_DATA_TYPE 
 
 #define QUEUE_DATA_TYPE void *
@@ -22,7 +19,7 @@
 typedef struct queue_list_array {
     QUEUE_DATA_TYPE           elements[QUEUE_LIST_ARRAY_SIZE];
     struct queue_list_array * next;
-} QLArray;
+} qlarray_s;
 
 #endif /* FINITE_QUEUE */
 
@@ -33,61 +30,61 @@ typedef struct queue {
     size_t max;
     QUEUE_DATA_TYPE * elements;
 #else
-    QLArray * head;
-    QLArray * tail;
+    qlarray_s * head;
+    qlarray_s * tail;
 #endif /* FINITE_QUEUE */
 
-} Queue;
+} queue_s;
 
 typedef enum queue_index_position {
     QI_POSITION_CURRENT = 1,
     QI_POSITION_NEXT    = 0,
-} QIPosition;
+} qip_e;
 
 #ifdef FINITE_QUEUE
 
-static Queue create_queue(size_t max);
-static bool  is_full_queue(Queue queue);
+static queue_s create_queue(size_t max);
+static bool  is_full_queue(queue_s queue);
 
 #else
 
-static Queue create_queue(void);
+static queue_s create_queue(void);
 
 #endif /* FINITE_QUEUE */
 
-static bool            is_empty_queue(Queue queue);
-static void            enqueue(Queue * queue, QUEUE_DATA_TYPE element);
-static QUEUE_DATA_TYPE dequeue(Queue * queue);
-static QUEUE_DATA_TYPE peek_queue(Queue queue);
-static Queue           copy_queue(Queue queue, QUEUE_DATA_TYPE (*copy_element)(QUEUE_DATA_TYPE));
-static void            destroy_queue(Queue * queue, void (*free_element)(QUEUE_DATA_TYPE *));
-static size_t          _get_index_queue(Queue queue, QIPosition type);
+static bool            is_empty_queue(queue_s queue);
+static void            enqueue(queue_s * queue, QUEUE_DATA_TYPE element);
+static QUEUE_DATA_TYPE dequeue(queue_s * queue);
+static QUEUE_DATA_TYPE peek_queue(queue_s queue);
+static queue_s         copy_queue(queue_s queue, QUEUE_DATA_TYPE (*copy_element)(QUEUE_DATA_TYPE));
+static void            destroy_queue(queue_s * queue, void (*free_element)(QUEUE_DATA_TYPE *));
+static size_t          _get_index_queue(queue_s queue, qip_e type);
 
 #ifdef FINITE_QUEUE
 
-static inline Queue create_queue(size_t max) {
-    Queue queue = { .elements = malloc(sizeof(QUEUE_DATA_TYPE) * max), .max = max, .size = 0, .current = 0 };
+static inline queue_s create_queue(const size_t max) {
+    queue_s queue = { .elements = malloc(sizeof(QUEUE_DATA_TYPE) * max), .max = max, .size = 0, .current = 0 };
     assert(queue.elements && "MEMORY ALLOCATION FAILED");
     return queue;
 }
 
-static inline bool is_full_queue(Queue queue) {
+static inline bool is_full_queue(const queue_s queue) {
     return queue.size == queue.max;
 }
 
 #else
 
-static inline Queue create_queue(void)  {
-    return (Queue) { 0 };
+static inline queue_s create_queue(void)  {
+    return (queue_s) { 0 };
 }
 
 #endif /* FINITE_QUEUE */
 
-static inline bool is_empty_queue(Queue queue) {
+static inline bool is_empty_queue(const queue_s queue) {
     return !queue.size;
 }
 
-static inline void enqueue(Queue * queue, QUEUE_DATA_TYPE element) {
+static inline void enqueue(queue_s * queue, QUEUE_DATA_TYPE element) {
     assert(queue && "QUEUE POINTER IS NULL");
 
 #ifdef FINITE_QUEUE
@@ -100,7 +97,7 @@ static inline void enqueue(Queue * queue, QUEUE_DATA_TYPE element) {
     queue->elements[idx] = element;
 #else
     if (!idx) {
-        QLArray * temp = malloc(sizeof(QLArray));
+        qlarray_s * temp = malloc(sizeof(qlarray_s));
         assert(temp && "MEMORY ALLOCATION FAILED");
         temp->next = NULL;
 
@@ -113,7 +110,7 @@ static inline void enqueue(Queue * queue, QUEUE_DATA_TYPE element) {
     queue->size++;
 }
 
-static inline QUEUE_DATA_TYPE dequeue(Queue * queue) {
+static inline QUEUE_DATA_TYPE dequeue(queue_s * queue) {
     assert(queue && "QUEUE POINTER IS NULL");
     assert(!is_empty_queue(*queue) && "CAN'T POP EMPTY QUEUE");
 
@@ -125,7 +122,7 @@ static inline QUEUE_DATA_TYPE dequeue(Queue * queue) {
     size_t idx = _get_index_queue(*queue, QI_POSITION_NEXT);
 
     if (idx == (QUEUE_LIST_ARRAY_SIZE - 1)) {
-        QLArray * temp = queue->head;
+        qlarray_s * temp = queue->head;
 
         queue->head = queue->head->next;
         free(temp);
@@ -145,7 +142,7 @@ static inline QUEUE_DATA_TYPE dequeue(Queue * queue) {
     return e;
 }
 
-static inline QUEUE_DATA_TYPE peek_queue(Queue queue) {
+static inline QUEUE_DATA_TYPE peek_queue(queue_s queue) {
     assert(!is_empty_queue(queue) && "CAN'T PEEK EMPTY QUEUE");
     size_t idx = _get_index_queue(queue, QI_POSITION_CURRENT);
 
@@ -157,9 +154,9 @@ static inline QUEUE_DATA_TYPE peek_queue(Queue queue) {
 
 }
 
-static inline Queue copy_queue(Queue queue, QUEUE_DATA_TYPE (*copy_element)(QUEUE_DATA_TYPE)) {
+static inline queue_s copy_queue(queue_s queue, QUEUE_DATA_TYPE (*copy_element)(QUEUE_DATA_TYPE)) {
 #ifdef FINITE_QUEUE
-    Queue copy = queue;
+    queue_s copy = queue;
     assert((copy.elements = malloc(sizeof(QUEUE_DATA_TYPE) * copy.max)) && "MEMORY ALLOCATION FAILED");
 
     size_t current_index = _get_index_queue(queue, QI_POSITION_CURRENT);
@@ -168,12 +165,12 @@ static inline Queue copy_queue(Queue queue, QUEUE_DATA_TYPE (*copy_element)(QUEU
         copy.elements[index] = copy_element ? copy_element(queue.elements[index]) : queue.elements[index];
     }
 #else
-    Queue copy = create_queue();
+    queue_s copy = create_queue();
     copy.current = queue.current;
 
-    QLArray * current_array = queue.head;
+    qlarray_s * current_array = queue.head;
     for (size_t i = _get_index_queue(queue, QI_POSITION_CURRENT); i < queue.size && current_array;) {
-        QLArray * temp = malloc(sizeof(QLArray));
+        qlarray_s * temp = malloc(sizeof(qlarray_s));
         assert(temp && "MEMORY ALLOCATION FAILED");
         temp->next = NULL;
 
@@ -192,7 +189,7 @@ static inline Queue copy_queue(Queue queue, QUEUE_DATA_TYPE (*copy_element)(QUEU
     return copy;
 }
 
-static inline void destroy_queue(Queue * queue, void (*free_element)(QUEUE_DATA_TYPE *)) {
+static inline void destroy_queue(queue_s * queue, void (*free_element)(QUEUE_DATA_TYPE *)) {
     while (!is_empty_queue(*queue)) {
         QUEUE_DATA_TYPE e = dequeue(queue);
         if (free_element) free_element(&e);
@@ -206,7 +203,7 @@ static inline void destroy_queue(Queue * queue, void (*free_element)(QUEUE_DATA_
     queue->current = 0;
 }
 
-static inline size_t _get_index_queue(Queue queue, QIPosition type) {
+static inline size_t _get_index_queue(const queue_s queue, const qip_e type) {
     assert((!is_empty_queue(queue) || type != QI_POSITION_CURRENT) && "CAN'T GET CURRENT INDEX IF EMPTY QUEUE");
     if (type == QI_POSITION_CURRENT) return queue.current;