aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/alloc.h35
-rw-r--r--include/calt.h8
-rw-r--r--include/mem.h162
-rw-r--r--include/meson.build7
-rw-r--r--meson.build36
-rw-r--r--meson_options.txt2
-rw-r--r--src/alloc/alloc.c26
-rw-r--r--src/alloc/calloc.c13
-rw-r--r--src/alloc/free.c4
-rw-r--r--src/alloc/malloc.c4
-rw-r--r--src/alloc/memdup.c6
-rw-r--r--src/alloc/meson.build8
-rw-r--r--src/alloc/realloc.c22
-rw-r--r--src/mem/memccpy.c20
-rw-r--r--src/mem/memchr.c3
-rw-r--r--src/mem/memcmp.c4
-rw-r--r--src/mem/memcpy.c8
-rw-r--r--src/mem/memhash.c13
-rw-r--r--src/mem/memlen.c3
-rw-r--r--src/mem/memmem.c4
-rw-r--r--src/mem/memmove.c5
-rw-r--r--src/mem/memrchr.c3
-rw-r--r--src/mem/memrev.c4
-rw-r--r--src/mem/memset.c5
-rw-r--r--src/mem/memswap.c3
-rw-r--r--src/mem/memzero.c4
-rw-r--r--src/mem/meson.build15
-rw-r--r--src/meson.build11
-rw-r--r--test/alloc/meson.build0
-rw-r--r--test/mem/memset.c14
-rw-r--r--test/mem/memzero.c14
-rw-r--r--test/mem/meson.build9
-rw-r--r--test/meson.build9
33 files changed, 484 insertions, 0 deletions
diff --git a/include/alloc.h b/include/alloc.h
new file mode 100644
index 0000000..bc8c3d8
--- /dev/null
+++ b/include/alloc.h
@@ -0,0 +1,35 @@
+#pragma once
+#ifndef CALT_ALLOC_H
+#define CALT_ALLOC_H
+#include <stddef.h>
+
+struct calt_alloc {
+ void *(*malloc)(size_t);
+ void *(*calloc)(size_t);
+ void *(*realloc)(void *, size_t);
+ void (*free)(void *);
+};
+
+extern struct calt_alloc calt_get_alloc(void);
+extern void calt_use_custom_alloc(struct calt_alloc allocator);
+
+inline void *calt_malloc(size_t size) {
+ if (size) {
+ struct calt_alloc alloc = calt_get_alloc();
+ return alloc.malloc ? alloc.malloc(size) : NULL;
+ } else {
+ return NULL;
+ }
+}
+
+inline void calt_free(void *ptr) {
+ if (ptr) {
+ calt_get_alloc().free(ptr);
+ }
+}
+
+extern void *calt_calloc(size_t size);
+extern void *calt_realloc(void *ptr, size_t size);
+extern void *calt_memdup(void const *restrict src, size_t len);
+
+#endif
diff --git a/include/calt.h b/include/calt.h
new file mode 100644
index 0000000..4ea43b0
--- /dev/null
+++ b/include/calt.h
@@ -0,0 +1,8 @@
+#pragma once
+#ifndef CALT_CALT_H
+#define CALT_CALT_H
+
+#include <mem.h>
+#include <alloc.h>
+
+#endif
diff --git a/include/mem.h b/include/mem.h
new file mode 100644
index 0000000..3636bf3
--- /dev/null
+++ b/include/mem.h
@@ -0,0 +1,162 @@
+#pragma once
+
+#ifndef CALT_MEM_H
+#define CALT_MEM_H
+#include <stddef.h>
+
+inline void *calt_memset(void *restrict dest, unsigned char value, size_t count) {
+ unsigned char *p = dest;
+
+ while (count-- > 0) {
+ *p++ = value;
+ }
+
+ return dest;
+}
+
+inline void *calt_memset_null(void *dest, unsigned char value, size_t count) {
+ return dest ? calt_memset(dest, value, count) : NULL;
+}
+
+inline void *calt_memzero(void *dest, size_t count) {
+ return calt_memset(dest, '\0', count);
+}
+
+inline void *calt_memzero_null(void *dest, size_t count) {
+ return dest ? calt_memzero(dest, count) : NULL;
+}
+
+inline void *calt_memcpy(void *restrict dest, const void *restrict src,
+ size_t count) {
+ unsigned char *d = dest;
+ unsigned char const *s = src;
+
+ while (count-- > 0) {
+ *d++ = *s++;
+ }
+
+ return dest;
+}
+
+
+inline void *calt_memcpy_null(void *restrict dest, void const *restrict src,
+ size_t count) {
+ return dest ? calt_memcpy(dest, src, count) : NULL;
+}
+
+extern void *calt_memccpy(void *restrict dest, void const *restrict src,
+ unsigned char value, size_t count);
+inline void *calt_memccpy_null(void *restrict dest, void const *restrict src,
+ unsigned char value, size_t count) {
+ return dest ? calt_memccpy(dest, src, value, count) : NULL;
+}
+
+inline void *calt_memmove(void *dest, void const *src, size_t count) {
+ unsigned char *d = dest;
+ unsigned char const *s = src;
+
+ if (d > s) {
+ d += count;
+ s += count;
+ while (count-- > 0) {
+ *--d = *--s;
+ }
+ } else if (d < s) {
+ calt_memcpy(dest, src, count);
+ }
+
+ return dest;
+}
+
+inline void *calt_memmove_null(void *dest, void const *src, size_t count) {
+ return dest ? calt_memmove(dest, src, count) : NULL;
+}
+
+inline void *calt_memchr(void const *ptr, unsigned char value, size_t count) {
+ unsigned char const *p = ptr;
+
+ while (count-- > 0) {
+ if (*p == value) {
+ return (void *)p;
+ }
+ p++;
+ }
+
+ return NULL;
+}
+
+inline void *calt_memrchr(void const *ptr, unsigned char value, size_t count) {
+ unsigned char const *p = ptr;
+ p = p + count;
+
+ while (count > 0) {
+ if (*(--p) == value) {
+ return (void *)p;
+ }
+ }
+
+ return NULL;
+}
+
+inline int calt_memcmp(const void *ptr1, const void *ptr2, size_t count) {
+ const unsigned char *p1 = ptr1;
+ const unsigned char *p2 = ptr2;
+
+ while (count-- > 0) {
+ if (*p1 != *p2) {
+ return (*p1 < *p2) ? -1 : 1;
+ }
+ p1++;
+ p2++;
+ }
+
+ return 0;
+}
+
+inline void calt_memswap(void *restrict ptr1, void *restrict ptr2, size_t size) {
+ unsigned char *p1 = ptr1;
+ unsigned char *p2 = ptr2;
+ while (size-- > 0) {
+ unsigned char temp = *p1;
+ *p1++ = *p2;
+ *p2++ = temp;
+ }
+}
+
+inline size_t calt_memlen(void const* ptr, unsigned char value, size_t size) {
+ unsigned char const *p = ptr;
+ size_t len = 0;
+
+ while (size-- > 0 && *p != value) {
+ p++;
+ len++;
+ }
+
+ return len;
+}
+
+extern size_t calt_memhash(void const *ptr, size_t count);
+
+inline void *calt_memmem(void const *haystack, size_t haystacklen,
+ void const *needle, size_t needlelen) {
+ unsigned char const *p = haystack;
+ unsigned char const *end = p + haystacklen - needlelen;
+ while (p <= end) {
+ if (calt_memcmp(p, needle, needlelen) == 0) {
+ return (void *)p;
+ }
+ p++;
+ }
+ return NULL;
+}
+
+inline void calt_memrev(void *ptr, size_t size) {
+ unsigned char *p1 = ptr;
+ unsigned char *p2 = p1 + size - 1;
+ while (p1 < p2) {
+ unsigned char temp = *p1;
+ *p1++ = *p2;
+ *p2-- = temp;
+ }
+}
+#endif
diff --git a/include/meson.build b/include/meson.build
new file mode 100644
index 0000000..403f666
--- /dev/null
+++ b/include/meson.build
@@ -0,0 +1,7 @@
+header = files([
+ 'calt.h',
+ 'mem.h',
+ 'alloc.h'
+])
+
+install_headers(header, subdir : 'calt')
diff --git a/meson.build b/meson.build
new file mode 100644
index 0000000..6e57aa6
--- /dev/null
+++ b/meson.build
@@ -0,0 +1,36 @@
+project('calt', 'c',
+ version : '0.0.0.1',
+ default_options : [
+ 'warning_level=3',
+ 'c_std=c11',
+ 'werror=true',
+ 'b_ndebug=if-release'
+ ])
+
+inc = include_directories('include')
+
+subdir('include')
+subdir('src')
+
+lib = library(meson.project_name(), src, header,
+ install : true,
+ include_directories : inc,
+)
+
+calt = declare_dependency(
+ include_directories: inc,
+ link_with : lib)
+
+if get_option('enable_test')
+ subdir('test')
+endif
+
+pkg_mod = import('pkgconfig')
+pkg_mod.generate(
+ name : meson.project_name(),
+ filebase : meson.project_name(),
+ description : 'A C library that is to implement extend and be an alternative to the C stadard library',
+ subdirs : 'calt',
+ libraries : lib,
+ version : meson.project_version(),
+)
diff --git a/meson_options.txt b/meson_options.txt
new file mode 100644
index 0000000..24910e9
--- /dev/null
+++ b/meson_options.txt
@@ -0,0 +1,2 @@
+option('enable_test', type : 'boolean', value : true, description : 'Enables building of tests')
+
diff --git a/src/alloc/alloc.c b/src/alloc/alloc.c
new file mode 100644
index 0000000..0ff8ff4
--- /dev/null
+++ b/src/alloc/alloc.c
@@ -0,0 +1,26 @@
+#include <alloc.h>
+#include <stdlib.h>
+
+static void* stdcalloc(size_t size){
+ return calloc(1, size);
+}
+
+static void* stdmalloc(size_t size){
+ return malloc(size);
+}
+
+static void* stdrealloc(void* ptr, size_t size){
+ return realloc(ptr, size);
+}
+
+static void stdfree(void* ptr){
+ free(ptr);
+}
+
+
+static struct calt_alloc alloc = {
+ .malloc = stdmalloc, .realloc = stdrealloc, .free = stdfree, .calloc = stdcalloc};
+
+void calt_use_custom_alloc(struct calt_alloc allocator) { alloc = allocator; }
+struct calt_alloc calt_get_alloc(void) { return alloc; }
+
diff --git a/src/alloc/calloc.c b/src/alloc/calloc.c
new file mode 100644
index 0000000..666e0ba
--- /dev/null
+++ b/src/alloc/calloc.c
@@ -0,0 +1,13 @@
+#include <alloc.h>
+#include <mem.h>
+
+void *calt_calloc(size_t size) {
+ if (size) {
+ struct calt_alloc alloc = calt_get_alloc();
+ return alloc.calloc ? alloc.calloc(size)
+ : calt_memzero_null(calt_malloc(size), size);
+ } else {
+ return NULL;
+ }
+}
+
diff --git a/src/alloc/free.c b/src/alloc/free.c
new file mode 100644
index 0000000..ef2654d
--- /dev/null
+++ b/src/alloc/free.c
@@ -0,0 +1,4 @@
+#include <alloc.h>
+
+extern inline void calt_free(void *ptr);
+
diff --git a/src/alloc/malloc.c b/src/alloc/malloc.c
new file mode 100644
index 0000000..9a2e81d
--- /dev/null
+++ b/src/alloc/malloc.c
@@ -0,0 +1,4 @@
+#include <alloc.h>
+
+extern inline void *calt_malloc(size_t size);
+
diff --git a/src/alloc/memdup.c b/src/alloc/memdup.c
new file mode 100644
index 0000000..60aa35e
--- /dev/null
+++ b/src/alloc/memdup.c
@@ -0,0 +1,6 @@
+#include <alloc.h>
+#include <mem.h>
+
+void *calt_memdup(void const *restrict src, size_t len) {
+ return calt_memcpy_null(calt_malloc(len), src, len);
+}
diff --git a/src/alloc/meson.build b/src/alloc/meson.build
new file mode 100644
index 0000000..4f6ff57
--- /dev/null
+++ b/src/alloc/meson.build
@@ -0,0 +1,8 @@
+src += files([
+ 'alloc.c',
+ 'calloc.c',
+ 'free.c',
+ 'malloc.c',
+ 'memdup.c',
+ 'realloc.c',
+])
diff --git a/src/alloc/realloc.c b/src/alloc/realloc.c
new file mode 100644
index 0000000..490ba75
--- /dev/null
+++ b/src/alloc/realloc.c
@@ -0,0 +1,22 @@
+#include <alloc.h>
+#include <mem.h>
+
+void *calt_realloc(void *ptr, size_t size) {
+ if (size) {
+ struct calt_alloc alloc = calt_get_alloc();
+ if (alloc.realloc) {
+ return alloc.realloc(ptr, size);
+ } else {
+ void *new = calt_malloc(size);
+ if (new && (ptr)) {
+ calt_memcpy(new, ptr, size);
+ calt_free(ptr);
+ }
+ return new;
+ }
+ } else {
+ calt_free(ptr);
+ return NULL;
+ }
+}
+
diff --git a/src/mem/memccpy.c b/src/mem/memccpy.c
new file mode 100644
index 0000000..71b5a94
--- /dev/null
+++ b/src/mem/memccpy.c
@@ -0,0 +1,20 @@
+#include <mem.h>
+
+void *calt_memccpy(void *restrict dest, void const *restrict src, unsigned char value,
+ size_t size) {
+ unsigned char *d = dest;
+ unsigned char const *s = src;
+
+ while (size-- > 0) {
+ *d++ = *s;
+ if (*s++ == value) {
+ return d;
+ }
+ }
+
+ return NULL;
+}
+
+extern inline void *calt_memccpy_null(void *restrict dest,
+ void const *restrict src,
+ unsigned char value, size_t size);
diff --git a/src/mem/memchr.c b/src/mem/memchr.c
new file mode 100644
index 0000000..35015db
--- /dev/null
+++ b/src/mem/memchr.c
@@ -0,0 +1,3 @@
+#include <mem.h>
+
+extern inline void *calt_memchr(void const *ptr, unsigned char value, size_t count);
diff --git a/src/mem/memcmp.c b/src/mem/memcmp.c
new file mode 100644
index 0000000..829325b
--- /dev/null
+++ b/src/mem/memcmp.c
@@ -0,0 +1,4 @@
+#include <mem.h>
+
+extern inline int calt_memcmp(void const *ptr1, void const *ptr2, size_t count);
+
diff --git a/src/mem/memcpy.c b/src/mem/memcpy.c
new file mode 100644
index 0000000..3372032
--- /dev/null
+++ b/src/mem/memcpy.c
@@ -0,0 +1,8 @@
+#include <mem.h>
+
+extern inline void *calt_memcpy(void *restrict dest, void const *restrict src,
+ size_t count);
+
+
+extern inline void *calt_memcpy_null(void *restrict dest, void const *restrict src,
+ size_t count);
diff --git a/src/mem/memhash.c b/src/mem/memhash.c
new file mode 100644
index 0000000..d752fed
--- /dev/null
+++ b/src/mem/memhash.c
@@ -0,0 +1,13 @@
+#include <limits.h>
+#include <stdint.h>
+#include <mem.h>
+
+size_t calt_memhash(const void *ptr, size_t count) {
+ unsigned char const *p = ptr;
+ size_t hash = 0;
+ size_t const hash_bits = sizeof hash;
+ while (count-- > 0) {
+ hash ^= (size_t) * (p++) << count % hash_bits * CHAR_BIT;
+ }
+ return hash;
+}
diff --git a/src/mem/memlen.c b/src/mem/memlen.c
new file mode 100644
index 0000000..dfb45fb
--- /dev/null
+++ b/src/mem/memlen.c
@@ -0,0 +1,3 @@
+#include <mem.h>
+
+extern inline size_t calt_memlen(void const *ptr, unsigned char value, size_t count);
diff --git a/src/mem/memmem.c b/src/mem/memmem.c
new file mode 100644
index 0000000..8745923
--- /dev/null
+++ b/src/mem/memmem.c
@@ -0,0 +1,4 @@
+#include <mem.h>
+
+extern inline void *calt_memmem(void const *haystack, size_t haystacklen,
+ void const *needle, size_t needlelen);
diff --git a/src/mem/memmove.c b/src/mem/memmove.c
new file mode 100644
index 0000000..79a4ebb
--- /dev/null
+++ b/src/mem/memmove.c
@@ -0,0 +1,5 @@
+#include <mem.h>
+
+extern inline void *calt_memmove(void *dest, void const *src, size_t count);
+extern inline void *calt_memmove_null(void *dest, void const *src, size_t count);
+
diff --git a/src/mem/memrchr.c b/src/mem/memrchr.c
new file mode 100644
index 0000000..a8d59f2
--- /dev/null
+++ b/src/mem/memrchr.c
@@ -0,0 +1,3 @@
+#include <mem.h>
+
+extern inline void *calt_memrchr(void const *ptr, unsigned char value, size_t count);
diff --git a/src/mem/memrev.c b/src/mem/memrev.c
new file mode 100644
index 0000000..fbc7516
--- /dev/null
+++ b/src/mem/memrev.c
@@ -0,0 +1,4 @@
+#include <mem.h>
+
+extern inline void calt_memrev(void *ptr, size_t size);
+
diff --git a/src/mem/memset.c b/src/mem/memset.c
new file mode 100644
index 0000000..df4c3cd
--- /dev/null
+++ b/src/mem/memset.c
@@ -0,0 +1,5 @@
+#include <mem.h>
+
+extern inline void *calt_memset(void *dest, unsigned char value, size_t count);
+extern inline void *calt_memset_null(void *dest, unsigned char value, size_t count);
+
diff --git a/src/mem/memswap.c b/src/mem/memswap.c
new file mode 100644
index 0000000..612fde5
--- /dev/null
+++ b/src/mem/memswap.c
@@ -0,0 +1,3 @@
+#include <mem.h>
+
+extern inline void calt_memswap(void *restrict ptr1, void *restrict ptr2, size_t size);
diff --git a/src/mem/memzero.c b/src/mem/memzero.c
new file mode 100644
index 0000000..9388516
--- /dev/null
+++ b/src/mem/memzero.c
@@ -0,0 +1,4 @@
+#include <mem.h>
+
+extern inline void *calt_memzero(void *restrict dest, size_t count);
+extern inline void *calt_memzero_null(void *restrict dest, size_t count);
diff --git a/src/mem/meson.build b/src/mem/meson.build
new file mode 100644
index 0000000..0ab2bc4
--- /dev/null
+++ b/src/mem/meson.build
@@ -0,0 +1,15 @@
+src += files([
+ 'memccpy.c',
+ 'memchr.c',
+ 'memcmp.c',
+ 'memcpy.c',
+ 'memhash.c',
+ 'memlen.c',
+ 'memmem.c',
+ 'memmove.c',
+ 'memrchr.c',
+ 'memrev.c',
+ 'memset.c',
+ 'memswap.c',
+ 'memzero.c',
+])
diff --git a/src/meson.build b/src/meson.build
new file mode 100644
index 0000000..765ef7c
--- /dev/null
+++ b/src/meson.build
@@ -0,0 +1,11 @@
+src = files()
+
+dirs = [
+ 'alloc',
+ 'mem',
+]
+
+foreach dir: dirs
+ subdir(dir)
+endforeach
+
diff --git a/test/alloc/meson.build b/test/alloc/meson.build
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/alloc/meson.build
diff --git a/test/mem/memset.c b/test/mem/memset.c
new file mode 100644
index 0000000..8484b1d
--- /dev/null
+++ b/test/mem/memset.c
@@ -0,0 +1,14 @@
+#include <mem.h>
+#include <stddef.h>
+
+static char buf[100];
+
+int main(void){
+ calt_memset(buf, 'A', sizeof buf);
+ for(size_t i = 0; i < sizeof buf; i++){
+ if('A' != buf[i]){
+ return 1;
+ }
+ }
+ return 0;
+}
diff --git a/test/mem/memzero.c b/test/mem/memzero.c
new file mode 100644
index 0000000..d8bda03
--- /dev/null
+++ b/test/mem/memzero.c
@@ -0,0 +1,14 @@
+#include <calt.h>
+#include <stddef.h>
+
+static char buf[100];
+
+int main(void){
+ calt_memzero(buf, sizeof buf);
+ for(size_t i = 0; i < sizeof buf; i++){
+ if('\0' != buf[i]){
+ return 1;
+ }
+ }
+ return 0;
+}
diff --git a/test/mem/meson.build b/test/mem/meson.build
new file mode 100644
index 0000000..8cc5fc9
--- /dev/null
+++ b/test/mem/meson.build
@@ -0,0 +1,9 @@
+memset = executable('memset', 'memset.c',
+ dependencies : calt
+)
+test('memset', memset)
+
+memzero = executable('memzero', 'memzero.c',
+ dependencies : calt
+)
+test('memzero', memzero)
diff --git a/test/meson.build b/test/meson.build
new file mode 100644
index 0000000..5e7b530
--- /dev/null
+++ b/test/meson.build
@@ -0,0 +1,9 @@
+dirs = [
+ 'alloc',
+ 'mem',
+]
+
+foreach dir: dirs
+ subdir(dir)
+endforeach
+
generated by cgit v1.2.3-70-g09d2 (git 2.50.0) at 2025-06-30 22:11:59 +0000