Added Initial Implementation of memory and allocation function

Signed-off-by: Marc Pervaz Boocha <mboocha@sudomsg.xyz>

On branch main
Your branch is up to date with 'origin/main'.

Changes to be committed:
      new file:   include/alloc.h
      new file:   include/calt.h
      new file:   include/mem.h
      new file:   include/meson.build
      new file:   meson.build
      new file:   meson_options.txt
      new file:   src/alloc/alloc.c
      new file:   src/alloc/calloc.c
      new file:   src/alloc/free.c
      new file:   src/alloc/malloc.c
      new file:   src/alloc/memdup.c
      new file:   src/alloc/meson.build
      new file:   src/alloc/realloc.c
      new file:   src/mem/memccpy.c
      new file:   src/mem/memchr.c
      new file:   src/mem/memcmp.c
      new file:   src/mem/memcpy.c
      new file:   src/mem/memhash.c
      new file:   src/mem/memlen.c
      new file:   src/mem/memmem.c
      new file:   src/mem/memmove.c
      new file:   src/mem/memrchr.c
      new file:   src/mem/memrev.c
      new file:   src/mem/memset.c
      new file:   src/mem/memswap.c
      new file:   src/mem/memzero.c
      new file:   src/mem/meson.build
      new file:   src/meson.build
      new file:   test/alloc/meson.build
      new file:   test/mem/memset.c
      new file:   test/mem/memzero.c
      new file:   test/mem/meson.build
      new file:   test/meson.build

4 files changed, 212 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')