Updated Scufeng and made a message outputting system for server

src/common/networking.c

@@ -9,7 +9,7 @@
 
 static const uint8_t fb = 0xfb;
 
-static size_t NetMsgType_to_buf_size(const NetMsgType type) {
+size_t NetMsgType_to_buf_size(const NetMsgType type) {
     switch (type) {
     case NET_MSG_PADDLE_CHANGE_DIR:
         return sizeof(PaddleChangeDirMsg);

src/common/networking.h

@@ -25,6 +25,7 @@ typedef struct [[gnu::packed]] {
     uint8_t player1; // bool
 } PaddlePosMsg;
 
+size_t NetMsgType_to_buf_size(const NetMsgType type);
 void send_msg(FILE *s, const NetMsgType type, const uint8_t *const buf);
 bool recv_msg_type(FILE *s, NetMsgType *const type);
 void recv_msg(FILE *s, const NetMsgType type, uint8_t *const buf);

src/server/server.c

@@ -11,6 +11,8 @@
 
 #include "scufeng/engine.h"
 #include "scufeng/log.h"
+#include "scufcont/DArray.h"
+
 #include "game.h"
 #include "networking.h"
 #include "GameState_net.h"
@@ -23,12 +25,74 @@ typedef enum {
     SS_GAME
 } ServerState;
 
+typedef struct {
+    NetMsgType type;
+    void *data;
+} OutgoingMsg;
+
+SCDARRAY_HEADER(OutgoingMsg, OutgoingMsg)
+
 static FILE *p1_conn = nullptr;
 static FILE *p2_conn = nullptr;
-
 static ServerState server_state = SS_LOBBY;
-
 static GameState game_state;
+static SCDArray_OutgoingMsg out_msgs;
+
+SCDARRAY_IMPL(OutgoingMsg, OutgoingMsg)
+
+static OutgoingMsg OutgoingMsg_alloc(const NetMsgType type, void *const data) {
+    const size_t data_size = NetMsgType_to_buf_size(type);
+
+    OutgoingMsg msg;
+    msg.type = type;
+    if (data != nullptr) {
+        msg.data = malloc(data_size);
+        memcpy(msg.data, data, data_size);
+    } else {
+        msg.data = nullptr;
+    }
+    return msg;
+}
+
+static void OutgoingMsg_free(OutgoingMsg *const msg) {
+    if (msg->data != nullptr) {
+        free(msg->data);
+        msg->data = nullptr;
+    }
+}
+
+static void push_out_msg(const NetMsgType type, void *const data) {
+    const OutgoingMsg msg = OutgoingMsg_alloc(type, data);
+    SCDArray_OutgoingMsg_push_back(&out_msgs, &msg);
+}
+
+static OutgoingMsg pop_out_msg() {
+    OutgoingMsg *msg = SCDArray_OutgoingMsg_at(&out_msgs, out_msgs.len - 1);
+    const OutgoingMsg ret = *msg;
+    SCDArray_OutgoingMsg_remove(&out_msgs, out_msgs.len - 1);
+    return ret;
+}
+
+static void send_out_msgs() {
+    for (size_t i = 0; i < out_msgs.len; i++) {
+        OutgoingMsg out_msg = pop_out_msg();
+        switch (out_msg.type) {
+        case NET_MSG_PADDLE_POS:
+            const PaddlePosMsg msg = {
+                .player1 = true,
+                .pos_x = game_state.paddle_l.pos[0],
+                .pos_y = game_state.paddle_l.pos[1],
+            };
+            send_msg(p1_conn, NET_MSG_PADDLE_POS, (uint8_t *) &msg);
+            break;
+        case NET_MSG_PADDLE_CHANGE_DIR:
+        case NET_MSG_GAME_STATE:
+            break;
+        }
+
+        OutgoingMsg_free(&out_msg);
+    }
+}
 
 static void send_game_state(FILE *conn) {
     GameStateMsg msg;
@@ -37,6 +101,7 @@ static void send_game_state(FILE *conn) {
 }
 
 static void server_lobby(const int sock) {
+    SCDArray_OutgoingMsg_alloc(&out_msgs);
     game_state = GameState_new(game_default_params, false);
 
     int player1 = accept(sock, nullptr, nullptr);
@@ -72,20 +137,22 @@ static void handle_paddle_change_dir_msg() {
     PaddleChangeDirMsg msg;
     recv_msg(p1_conn, NET_MSG_PADDLE_CHANGE_DIR, (uint8_t *) &msg);
     SEDirection dir = (SEDirection) msg.dir;
-    bool player1 = (bool) msg.player1;
-    if (player1) {
-        const char *dir_str = dir == SE_UP ? "UP" : (dir == SE_DOWN ? "DOWN" : (dir == SE_NONE ? "NONE" : "INVALID"));
-        printf("Player 1 moves paddle to direction: %s\n", dir_str);
-        GameState_paddle_l_change_dir(&game_state, dir);
-        PaddlePosMsg res_msg = {
-            .pos_x = game_state.paddle_l.pos[0],
-            .pos_y = game_state.paddle_l.pos[1],
-            .player1 = (uint8_t) true
-        };
-        send_msg(p1_conn, NET_MSG_PADDLE_POS, (uint8_t *) &res_msg);
-    } else {
-        printf("Message was not from player1\n");
-    }
+    GameState_paddle_l_change_dir(&game_state, dir);
+    push_out_msg(NET_MSG_PADDLE_POS, nullptr);
+    // bool player1 = (bool) msg.player1;
+    // if (player1) {
+    //     const char *dir_str = dir == SE_UP ? "UP" : (dir == SE_DOWN ? "DOWN" : (dir == SE_NONE ? "NONE" : "INVALID"));
+    //     printf("Player 1 moves paddle to direction: %s\n", dir_str);
+    //     GameState_paddle_l_change_dir(&game_state, dir);
+    //     PaddlePosMsg res_msg = {
+    //         .pos_x = game_state.paddle_l.pos[0],
+    //         .pos_y = game_state.paddle_l.pos[1],
+    //         .player1 = (uint8_t) true
+    //     };
+    //     send_msg(p1_conn, NET_MSG_PADDLE_POS, (uint8_t *) &res_msg);
+    // } else {
+    //     printf("Message was not from player1\n");
+    // }
 }
 
 static void server_game() {
@@ -97,6 +164,7 @@ static void server_game() {
     while (true) {
         const double current_time_s = se_get_time();
         const double delta = current_time_s - last_frame_time_s;
+        last_frame_time_s = current_time_s;
         se_fps_lock_frame_start_s(current_time_s);
 
         // Player input
@@ -113,9 +181,11 @@ static void server_game() {
         }
 
         // Tick
+        printf("delta: %lf\n", delta);
         GameState_update(&game_state, delta);
 
         // Player output
+        send_out_msgs();
 
         // Wait
         se_fps_lock_wait();

subprojects/scufeng/GIT_COMMIT

@@ -1 +1 @@
-c505e04113e221188440051de27fad12c0670205
+e5666a0157e6e9b651b02e2cba571a980e71b5d2

subprojects/scufeng/include/scufcont/DArray.h

@@ -25,7 +25,11 @@
     SCDARRAY_EXPANDER(SCDARRAY_PUSH_BACK, type, type_name, push_back)                   \
     SCDARRAY_EXPANDER(SCDARRAY_PUSH_BACK_MULTIPLE, type, type_name, push_back_multiple) \
     SCDARRAY_EXPANDER(SCDARRAY_AT, type, type_name, at)                                 \
-    SCDARRAY_EXPANDER(SCDARRAY_REMOVE, type, type_name, remove)
+    SCDARRAY_EXPANDER(SCDARRAY_RESIZE, type, type_name, resize)                         \
+    SCDARRAY_EXPANDER(SCDARRAY_REMOVE_NO_RESIZE, type, type_name, remove_no_resize)     \
+    SCDARRAY_EXPANDER(SCDARRAY_REMOVE, type, type_name, remove)                         \
+    SCDARRAY_EXPANDER(SCDARRAY_CLEAR_NO_RESIZE, type, type_name, clear_no_resize)       \
+    SCDARRAY_EXPANDER(SCDARRAY_CLEAR, type, type_name, clear)
 
 #define SCDARRAY_HEADER(type, type_name) \
     SCDARRAY_STRUCT(type, type_name)     \
@@ -38,41 +42,44 @@
     SCDARRAY_EXPANDER(SCDARRAY_PUSH_BACK_SIG, type, type_name, push_back);                   \
     SCDARRAY_EXPANDER(SCDARRAY_PUSH_BACK_MULTIPLE_SIG, type, type_name, push_back_multiple); \
     SCDARRAY_EXPANDER(SCDARRAY_AT_SIG, type, type_name, at);                                 \
-    SCDARRAY_EXPANDER(SCDARRAY_REMOVE_SIG, type, type_name, remove);
+    SCDARRAY_EXPANDER(SCDARRAY_RESIZE_SIG, type, type_name, resize);                         \
+    SCDARRAY_EXPANDER(SCDARRAY_REMOVE_SIG, type, type_name, remove);                         \
+    SCDARRAY_EXPANDER(SCDARRAY_CLEAR_NO_RESIZE_SIG, type, type_name, clear_no_resize);       \
+    SCDARRAY_EXPANDER(SCDARRAY_CLEAR_SIG, type, type_name, clear);
 
 // SCDARRAY_ALLOC_SIG(type, SCDArray_##type_name, SCDArray_##type_name##_alloc);
 // SCDARRAY_PUSH_BACK_SIG(type, SCDArray_##type_name, SCDArray_##type_name##_push_back);
 
 #define SCDARRAY_STRUCT(type, type_name) \
     typedef struct {                     \
-        type* data;                      \
+        type *data;                      \
         size_t len;                      \
         size_t capacity;                 \
     } SCDArray_##type_name;
 
 // SCDARRAY_STRUCT(int);
 
-#define SCDARRAY_ALLOC_SIG(type, type_name, func_name) ScufContResult func_name(type_name* darr)
-
-#define SCDARRAY_ALLOC(type, type_name, func_name)    \
-    SCDARRAY_ALLOC_SIG(type, type_name, func_name) {  \
-        darr->data = (type*) calloc(1, sizeof(type)); \
-        if (darr->data == NULL) {                     \
-            return SCUFCONT_OUT_OF_MEMORY;            \
-        }                                             \
-        darr->len = 0;                                \
-        darr->capacity = 1;                           \
-        return SCUFCONT_SUCCESS;                      \
+#define SCDARRAY_ALLOC_SIG(type, type_name, func_name) ScufContResult func_name(type_name *const darr)
+
+#define SCDARRAY_ALLOC(type, type_name, func_name)     \
+    SCDARRAY_ALLOC_SIG(type, type_name, func_name) {   \
+        darr->data = (type *) calloc(1, sizeof(type)); \
+        if (darr->data == NULL) {                      \
+            return SCUFCONT_OUT_OF_MEMORY;             \
+        }                                              \
+        darr->len = 0;                                 \
+        darr->capacity = 1;                            \
+        return SCUFCONT_SUCCESS;                       \
     }
 
-#define SCDARRAY_FREE_SIG(type, type_name, func_name) void func_name(type_name* darr)
+#define SCDARRAY_FREE_SIG(type, type_name, func_name) void func_name(type_name *const darr)
 
 #define SCDARRAY_FREE(type, type_name, func_name)   \
     SCDARRAY_FREE_SIG(type, type_name, func_name) { \
         free(darr->data);                           \
     }
 
-#define SCDARRAY_IS_NULL_SIG(type, type_name, func_name) bool func_name(const type_name* darr)
+#define SCDARRAY_IS_NULL_SIG(type, type_name, func_name) bool func_name(const type_name *const darr)
 
 #define SCDARRAY_IS_NULL(type, type_name, func_name)   \
     SCDARRAY_IS_NULL_SIG(type, type_name, func_name) { \
@@ -81,41 +88,41 @@
 
 // SCDARRAY_ALLOC(int, SCDArray_int, SCDArray_int_alloc);
 
-#define SCDARRAY_PUSH_BACK_SIG(type, type_name, func_name) ScufContResult func_name(type_name* darr, const type *const new_elem)
-
-#define SCDARRAY_PUSH_BACK(type, type_name, func_name)                                    \
-    SCDARRAY_PUSH_BACK_SIG(type, type_name, func_name) {                                  \
-        if (darr->len + 1 > darr->capacity) {                                             \
-            darr->capacity *= 2;                                                          \
-            darr->data = (type*) realloc(darr->data, darr->capacity * sizeof(*new_elem)); \
-            if (darr->data == NULL) {                                                     \
-                return SCUFCONT_OUT_OF_MEMORY;                                            \
-            }                                                                             \
-        }                                                                                 \
-        memcpy(darr->data + darr->len, new_elem, sizeof(*new_elem));                      \
-        darr->len++;                                                                      \
-        return SCUFCONT_SUCCESS;                                                          \
+#define SCDARRAY_PUSH_BACK_SIG(type, type_name, func_name) ScufContResult func_name(type_name *const darr, const type *const new_elem)
+
+#define SCDARRAY_PUSH_BACK(type, type_name, func_name)                                     \
+    SCDARRAY_PUSH_BACK_SIG(type, type_name, func_name) {                                   \
+        if (darr->len + 1 > darr->capacity) {                                              \
+            darr->capacity *= 2;                                                           \
+            darr->data = (type *) realloc(darr->data, darr->capacity * sizeof(*new_elem)); \
+            if (darr->data == NULL) {                                                      \
+                return SCUFCONT_OUT_OF_MEMORY;                                             \
+            }                                                                              \
+        }                                                                                  \
+        memcpy(darr->data + darr->len, new_elem, sizeof(*new_elem));                       \
+        darr->len++;                                                                       \
+        return SCUFCONT_SUCCESS;                                                           \
     }
 
-#define SCDARRAY_PUSH_BACK_MULTIPLE_SIG(type, type_name, func_name) ScufContResult func_name(type_name* const darr, const type* const new_elems, const size_t new_elems_n)
-
-#define SCDARRAY_PUSH_BACK_MULTIPLE(type, type_name, func_name)                                      \
-    SCDARRAY_PUSH_BACK_MULTIPLE_SIG(type, type_name, func_name) {                                    \
-        if (darr->len + new_elems_n > darr->capacity) {                                              \
-            darr->data = (type*) realloc(darr->data, (darr->capacity + new_elems_n) * sizeof(type)); \
-            if (darr->data == NULL) {                                                                \
-                return SCUFCONT_OUT_OF_MEMORY;                                                       \
-            }                                                                                        \
-            darr->capacity += new_elems_n;                                                           \
-        }                                                                                            \
-        memcpy(darr->data + darr->len, new_elems, sizeof(type) * new_elems_n);                       \
-        darr->len += new_elems_n;                                                                    \
-        return SCUFCONT_SUCCESS;                                                                     \
+#define SCDARRAY_PUSH_BACK_MULTIPLE_SIG(type, type_name, func_name) ScufContResult func_name(type_name *const darr, const type *const new_elems, const size_t new_elems_n)
+
+#define SCDARRAY_PUSH_BACK_MULTIPLE(type, type_name, func_name)                                       \
+    SCDARRAY_PUSH_BACK_MULTIPLE_SIG(type, type_name, func_name) {                                     \
+        if (darr->len + new_elems_n > darr->capacity) {                                               \
+            darr->data = (type *) realloc(darr->data, (darr->capacity + new_elems_n) * sizeof(type)); \
+            if (darr->data == NULL) {                                                                 \
+                return SCUFCONT_OUT_OF_MEMORY;                                                        \
+            }                                                                                         \
+            darr->capacity += new_elems_n;                                                            \
+        }                                                                                             \
+        memcpy(darr->data + darr->len, new_elems, sizeof(type) * new_elems_n);                        \
+        darr->len += new_elems_n;                                                                     \
+        return SCUFCONT_SUCCESS;                                                                      \
     }
 
 // SCDARRAY_PUSH_BACK_MULTIPLE(int, SCDArray_int, SCDArray_int_push_back_multiple)
 
-#define SCDARRAY_AT_SIG(type, type_name, func_name) type* func_name(const type_name* const darr, const size_t i)
+#define SCDARRAY_AT_SIG(type, type_name, func_name) type *func_name(const type_name *const darr, const size_t i)
 
 // SCDARRAY_PUSH_BACK(int, SCDArray_int, SCDArray_int_push_back);
 
@@ -142,14 +149,56 @@
 
 // SCDARRAY_AT(char*, SCDArray_charp, SCDArray_charp_at)
 
-#define SCDARRAY_REMOVE_SIG(type, type_name, func_name) void func_name(type_name* darr, const size_t i)
+#define SCDARRAY_RESIZE_SIG(type, type_name, func_name) void func_name(type_name *const darr)
+
+#define SCDARRAY_RESIZE(type, type_name, func_name)                     \
+    SCDARRAY_RESIZE_SIG(type, type_name, func_name) {                   \
+        if (darr->len == 0) {                                           \
+            darr->data = realloc(darr->data, sizeof(type));             \
+        } else {                                                        \
+            darr->data = realloc(darr->data, sizeof(type) * darr->len); \
+        }                                                               \
+    }
+
+#define SCDARRAY_REMOVE_NO_RESIZE_SIG(type, type_name, func_name) void func_name(type_name *const darr, const size_t i)
+
+#define SCDARRAY_REMOVE_NO_RESIZE(type, type_name, func_name)                                  \
+    SCDARRAY_REMOVE_SIG(type, type_name, func_name) {                                          \
+        if (i != darr->len - 1) {                                                              \
+            memmove(darr->data + i, darr->data + i + 1, (darr->len - (i + 1)) * sizeof(type)); \
+        }                                                                                      \
+        darr->len--;                                                                           \
+    }
+
+// SCDARRAY_EXPANDER(SCDARRAY_REMOVE_NO_RESIZE, char*, charp, remove_no_resize)
+
+#define SCDARRAY_REMOVE_SIG(type, type_name, func_name) void func_name(type_name *const darr, const size_t i)
+
+#define SCDARRAY_REMOVE(type, type_name, func_name)   \
+    SCDARRAY_REMOVE_SIG(type, type_name, func_name) { \
+        type_name##_remove_no_resize(darr, i);        \
+        type_name##_resize(darr);                     \
+    }
+
+// SCDARRAY_EXPANDER(SCDARRAY_REMOVE, char*, charp, remove)
+
+#define SCDARRAY_CLEAR_NO_RESIZE_SIG(type, type_name, func_name) void func_name(type_name *const darr)
+
+#define SCDARRAY_CLEAR_NO_RESIZE(type, type_name, func_name)   \
+    SCDARRAY_CLEAR_NO_RESIZE_SIG(type, type_name, func_name) { \
+        darr->len = 0;                                         \
+    }
+
+// SCDARRAY_CLEAR_NO_RESIZE(char*, SCDArray_charp, SCDArray_charp_clear_no_resize)
+
+#define SCDARRAY_CLEAR_SIG(type, type_name, func_name) void func_name(type_name *const darr)
 
-#define SCDARRAY_REMOVE(type, type_name, func_name)                                  \
-    SCDARRAY_REMOVE_SIG(type, type_name, func_name) {                                \
-        memmove(darr->data + i, darr->data + i + 1, (darr->len - i) * sizeof(type)); \
-        darr->len--;                                                                 \
+#define SCDARRAY_CLEAR(type, type_name, func_name)   \
+    SCDARRAY_CLEAR_SIG(type, type_name, func_name) { \
+        type_name##_clear_no_resize(darr);           \
+        type_name##_resize(darr);                    \
     }
 
-// SCDARRAY_REMOVE(char*, SCDArray_charp, SCDArray_charp_remove)
+// SCDARRAY_EXPANDER(SCDARRAY_CLEAR, char*, charp, clear)
 
 #endif // SCUFCONT_DARRAY_H_

subprojects/scufeng/include/scufcont/DString.h

@@ -12,40 +12,40 @@
 #define SCDString_c_str(dstr) ((dstr)->data)
 
 typedef struct {
-    char* data;
+    char *data;
     size_t len;
     size_t capacity;
 } SCDString;
 
-ScufContResult SCDString_alloc(SCDString* dstr, const char* str, const size_t len);
-ScufContResult SCDString_reserve(SCDString* dstr, const size_t new_capacity);
-void SCDString_free(SCDString* dstr);
-bool SCDString_equal(const SCDString* s1, const SCDString* s2);
-bool SCDString_equal_c_str(const SCDString* s1, const char* s2);
+ScufContResult SCDString_alloc(SCDString *const dstr, const char *str, const size_t len);
+ScufContResult SCDString_reserve(SCDString *const dstr, const size_t new_capacity);
+void SCDString_free(SCDString *const dstr);
+bool SCDString_equal(const SCDString *const s1, const SCDString *s2);
+bool SCDString_equal_c_str(const SCDString *const s1, const char *s2);
 bool SCDString_equal_next_chars_c_str(
-    const SCDString* dstr,
-    const char* str,
+    const SCDString *const dstr,
+    const char *str,
     const size_t str_len,
     const size_t s
 );
 ScufContResult SCDString_concat_c_str(
-    SCDString* dstr,
-    const char* str,
+    SCDString *const dstr,
+    const char *str,
     const size_t str_len
 );
 ScufContResult SCDString_alloc_concat_c_strs(
-    SCDString* dstr,
-    const char* s1,
+    SCDString *const dstr,
+    const char *s1,
     const size_t s1_len,
-    const char* s2,
+    const char *s2,
     const size_t s2_len
 );
 ScufContResult SCDString_split(
-    const SCDString* dstr,
-    const char* delim,
-    SCDString** split_arr,
-    size_t* arr_len
+    const SCDString *const dstr,
+    const char *delim,
+    SCDString **const split_arr,
+    size_t *const arr_len
 );
-void SCDString_split_arr_free(SCDString** arr, const size_t arr_len);
+void SCDString_split_arr_free(SCDString **const arr, const size_t arr_len);
 
 #endif // SCUFCONT_DSTRING_H_

subprojects/scufeng/include/scufcont/scufcont/DArray.h

@@ -1,155 +0,0 @@
-#ifndef SCUFCONT_DARRAY_H_
-#define SCUFCONT_DARRAY_H_
-
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdlib.h> // IWYU pragma: keep
-#include <string.h>
-
-#include "scufcont.h" // IWYU pragma: keep
-
-// #define SCUFCONT_BOUNDS_CHECK
-
-#ifdef SCUFCONT_BOUNDS_CHECK
-
-#include <stdio.h>
-
-#endif // SCUFCONT_BOUNDS_CHECK
-
-#define SCDARRAY_EXPANDER(macro, type, type_name, func_name) macro(type, SCDArray_##type_name, SCDArray_##type_name##_##func_name)
-
-#define SCDARRAY_IMPL(type, type_name)                                                  \
-    SCDARRAY_EXPANDER(SCDARRAY_ALLOC, type, type_name, alloc)                           \
-    SCDARRAY_EXPANDER(SCDARRAY_FREE, type, type_name, free)                             \
-    SCDARRAY_EXPANDER(SCDARRAY_IS_NULL, type, type_name, is_null)                       \
-    SCDARRAY_EXPANDER(SCDARRAY_PUSH_BACK, type, type_name, push_back)                   \
-    SCDARRAY_EXPANDER(SCDARRAY_PUSH_BACK_MULTIPLE, type, type_name, push_back_multiple) \
-    SCDARRAY_EXPANDER(SCDARRAY_AT, type, type_name, at)                                 \
-    SCDARRAY_EXPANDER(SCDARRAY_REMOVE, type, type_name, remove)
-
-#define SCDARRAY_HEADER(type, type_name) \
-    SCDARRAY_STRUCT(type, type_name)     \
-    SCDARRAY_SIGS(type, type_name)
-
-#define SCDARRAY_SIGS(type, type_name)                                                       \
-    SCDARRAY_EXPANDER(SCDARRAY_ALLOC_SIG, type, type_name, alloc);                           \
-    SCDARRAY_EXPANDER(SCDARRAY_FREE_SIG, type, type_name, free);                             \
-    SCDARRAY_EXPANDER(SCDARRAY_IS_NULL_SIG, type, type_name, is_null);                       \
-    SCDARRAY_EXPANDER(SCDARRAY_PUSH_BACK_SIG, type, type_name, push_back);                   \
-    SCDARRAY_EXPANDER(SCDARRAY_PUSH_BACK_MULTIPLE_SIG, type, type_name, push_back_multiple); \
-    SCDARRAY_EXPANDER(SCDARRAY_AT_SIG, type, type_name, at);                                 \
-    SCDARRAY_EXPANDER(SCDARRAY_REMOVE_SIG, type, type_name, remove);
-
-// SCDARRAY_ALLOC_SIG(type, SCDArray_##type_name, SCDArray_##type_name##_alloc);
-// SCDARRAY_PUSH_BACK_SIG(type, SCDArray_##type_name, SCDArray_##type_name##_push_back);
-
-#define SCDARRAY_STRUCT(type, type_name) \
-    typedef struct {                     \
-        type* data;                      \
-        size_t len;                      \
-        size_t capacity;                 \
-    } SCDArray_##type_name;
-
-// SCDARRAY_STRUCT(int);
-
-#define SCDARRAY_ALLOC_SIG(type, type_name, func_name) ScufContResult func_name(type_name* darr)
-
-#define SCDARRAY_ALLOC(type, type_name, func_name)    \
-    SCDARRAY_ALLOC_SIG(type, type_name, func_name) {  \
-        darr->data = (type*) calloc(1, sizeof(type)); \
-        if (darr->data == NULL) {                     \
-            return SCUFCONT_OUT_OF_MEMORY;            \
-        }                                             \
-        darr->len = 0;                                \
-        darr->capacity = 1;                           \
-        return SCUFCONT_SUCCESS;                      \
-    }
-
-#define SCDARRAY_FREE_SIG(type, type_name, func_name) void func_name(type_name* darr)
-
-#define SCDARRAY_FREE(type, type_name, func_name)   \
-    SCDARRAY_FREE_SIG(type, type_name, func_name) { \
-        free(darr->data);                           \
-    }
-
-#define SCDARRAY_IS_NULL_SIG(type, type_name, func_name) bool func_name(const type_name* darr)
-
-#define SCDARRAY_IS_NULL(type, type_name, func_name)   \
-    SCDARRAY_IS_NULL_SIG(type, type_name, func_name) { \
-        return darr->data == NULL;                     \
-    }
-
-// SCDARRAY_ALLOC(int, SCDArray_int, SCDArray_int_alloc);
-
-#define SCDARRAY_PUSH_BACK_SIG(type, type_name, func_name) ScufContResult func_name(type_name* darr, const type *const new_elem)
-
-#define SCDARRAY_PUSH_BACK(type, type_name, func_name)                                    \
-    SCDARRAY_PUSH_BACK_SIG(type, type_name, func_name) {                                  \
-        if (darr->len + 1 > darr->capacity) {                                             \
-            darr->capacity *= 2;                                                          \
-            darr->data = (type*) realloc(darr->data, darr->capacity * sizeof(*new_elem)); \
-            if (darr->data == NULL) {                                                     \
-                return SCUFCONT_OUT_OF_MEMORY;                                            \
-            }                                                                             \
-        }                                                                                 \
-        memcpy(darr->data + darr->len, new_elem, sizeof(*new_elem));                      \
-        darr->len++;                                                                      \
-        return SCUFCONT_SUCCESS;                                                          \
-    }
-
-#define SCDARRAY_PUSH_BACK_MULTIPLE_SIG(type, type_name, func_name) ScufContResult func_name(type_name* const darr, const type* const new_elems, const size_t new_elems_n)
-
-#define SCDARRAY_PUSH_BACK_MULTIPLE(type, type_name, func_name)                                      \
-    SCDARRAY_PUSH_BACK_MULTIPLE_SIG(type, type_name, func_name) {                                    \
-        if (darr->len + new_elems_n > darr->capacity) {                                              \
-            darr->data = (type*) realloc(darr->data, (darr->capacity + new_elems_n) * sizeof(type)); \
-            if (darr->data == NULL) {                                                                \
-                return SCUFCONT_OUT_OF_MEMORY;                                                       \
-            }                                                                                        \
-            darr->capacity += new_elems_n;                                                           \
-        }                                                                                            \
-        memcpy(darr->data + darr->len, new_elems, sizeof(type) * new_elems_n);                       \
-        darr->len += new_elems_n;                                                                    \
-        return SCUFCONT_SUCCESS;                                                                     \
-    }
-
-// SCDARRAY_PUSH_BACK_MULTIPLE(int, SCDArray_int, SCDArray_int_push_back_multiple)
-
-#define SCDARRAY_AT_SIG(type, type_name, func_name) type* func_name(const type_name* const darr, const size_t i)
-
-// SCDARRAY_PUSH_BACK(int, SCDArray_int, SCDArray_int_push_back);
-
-#ifdef SCUFCONT_BOUNDS_CHECK
-
-#define SCDARRAY_AT(type, type_name, func_name)                                           \
-    SCDARRAY_AT_SIG(type, type_name, func_name) {                                         \
-        if (i < 0 || i > darr->len) {                                                     \
-            fprintf(stderr, #func_name " out-of-bounds. i: %zu, len: %zu", i, darr->len); \
-            exit(1);                                                                      \
-        }                                                                                 \
-                                                                                          \
-        return darr->data + i;                                                            \
-    }
-
-#else
-
-#define SCDARRAY_AT(type, type_name, func_name)   \
-    SCDARRAY_AT_SIG(type, type_name, func_name) { \
-        return darr->data + i;                    \
-    }
-
-#endif // SCUFCONT_BOUNDS_CHECK
-
-// SCDARRAY_AT(char*, SCDArray_charp, SCDArray_charp_at)
-
-#define SCDARRAY_REMOVE_SIG(type, type_name, func_name) void func_name(type_name* darr, const size_t i)
-
-#define SCDARRAY_REMOVE(type, type_name, func_name)                                  \
-    SCDARRAY_REMOVE_SIG(type, type_name, func_name) {                                \
-        memmove(darr->data + i, darr->data + i + 1, (darr->len - i) * sizeof(type)); \
-        darr->len--;                                                                 \
-    }
-
-// SCDARRAY_REMOVE(char*, SCDArray_charp, SCDArray_charp_remove)
-
-#endif // SCUFCONT_DARRAY_H_

subprojects/scufeng/include/scufcont/scufcont/DString.h

@@ -1,51 +0,0 @@
-#ifndef SCUFCONT_DSTRING_H_
-#define SCUFCONT_DSTRING_H_
-
-#include <stdbool.h>
-#include <stddef.h>
-
-#include "scufcont.h"
-
-#define SCDSTRING_FMT(dstr) (int) (dstr).len, (dstr).data
-
-#define SCDString_is_null(dstr) ((dstr)->data == NULL)
-#define SCDString_c_str(dstr) ((dstr)->data)
-
-typedef struct {
-    char* data;
-    size_t len;
-    size_t capacity;
-} SCDString;
-
-ScufContResult SCDString_alloc(SCDString* dstr, const char* str, const size_t len);
-ScufContResult SCDString_reserve(SCDString* dstr, const size_t new_capacity);
-void SCDString_free(SCDString* dstr);
-bool SCDString_equal(const SCDString* s1, const SCDString* s2);
-bool SCDString_equal_c_str(const SCDString* s1, const char* s2);
-bool SCDString_equal_next_chars_c_str(
-    const SCDString* dstr,
-    const char* str,
-    const size_t str_len,
-    const size_t s
-);
-ScufContResult SCDString_concat_c_str(
-    SCDString* dstr,
-    const char* str,
-    const size_t str_len
-);
-ScufContResult SCDString_alloc_concat_c_strs(
-    SCDString* dstr,
-    const char* s1,
-    const size_t s1_len,
-    const char* s2,
-    const size_t s2_len
-);
-ScufContResult SCDString_split(
-    const SCDString* dstr,
-    const char* delim,
-    SCDString** split_arr,
-    size_t* arr_len
-);
-void SCDString_split_arr_free(SCDString** arr, const size_t arr_len);
-
-#endif // SCUFCONT_DSTRING_H_

subprojects/scufeng/include/scufcont/scufcont/scufcont.h

@@ -1,20 +0,0 @@
-#ifndef SCUFCONT_H_
-#define SCUFCONT_H_
-
-#define SCUFCONT_RESULT_X(X) \
-    X(SCUFCONT_SUCCESS) \
-    X(SCUFCONT_OUT_OF_MEMORY)
-
-#define X(val) val,
-
-typedef enum {
-    SCUFCONT_RESULT_X(X)
-} ScufContResult;
-
-#undef X
-
-extern const char* SCUFCONT_VERSION;
-
-const char* ScufContResult_to_str(const ScufContResult res);
-
-#endif // SCUFCONT_H_