Moved headers to a subdirectory.

2026-08-13 19:45:11 +03:00
parent 61301a8862
commit 07844f1f79
5 changed files with 3 additions and 3 deletions
@@ -0,0 +1,155 @@
+#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* 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* darr, const type* 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(type_name* 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_
@@ -0,0 +1,51 @@
+#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_
@@ -0,0 +1,11 @@
+#ifndef SCUFCONT_H_
+#define SCUFCONT_H_
+
+typedef enum {
+    SCUFCONT_SUCCESS,
+    SCUFCONT_OUT_OF_MEMORY
+} ScufContResult;
+
+extern const char* SCUFCONT_VERSION;
+
+#endif // SCUFCONT_H_