Added Basic Error codes, Tests and de-inliningHEADmain

Error codes needs to be ingrated with the alloc module
Tests now have great coverage in the mem module (>75%).

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:
      modified:   include/alloc.h
      new file:   include/err.h
      modified:   include/mem.h
      modified:   include/meson.build
      modified:   readme.md
      modified:   src/alloc/free.c
      modified:   src/alloc/malloc.c
      new file:   src/err/errstr.c
      new file:   src/err/meson.build
      new file:   src/err/set_err.c
      modified:   src/mem/memccpy.c
      modified:   src/mem/memchr.c
      modified:   src/mem/memcmp.c
      modified:   src/mem/memcpy.c
      modified:   src/mem/memlen.c
      modified:   src/mem/memmem.c
      modified:   src/mem/memmove.c
      modified:   src/mem/memrchr.c
      modified:   src/mem/memrev.c
      modified:   src/mem/memset.c
      modified:   src/mem/memswap.c
      modified:   src/mem/memzero.c
      modified:   src/meson.build
      new file:   test/alloc/memdup.c
      modified:   test/alloc/meson.build
      new file:   test/mem/memccpy_nullnull.c
      new file:   test/mem/memchr.c
      new file:   test/mem/memchr_notfound.c
      new file:   test/mem/memcmp_diff.c
      new file:   test/mem/memcmp_prefix.c
      new file:   test/mem/memcmp_same.c
      new file:   test/mem/memcmp_samenull.c
      new file:   test/mem/memcmp_sing.c
      new file:   test/mem/memcpy_null_prefix.c
      new file:   test/mem/memcpy_null_same.c
      new file:   test/mem/memcpy_nullnull.c
      new file:   test/mem/memcpy_prefix.c
      new file:   test/mem/memcpy_same.c
      new file:   test/mem/memlen.c
      new file:   test/mem/memlen_overflow.c
      new file:   test/mem/memmove_backward.c
      new file:   test/mem/memmove_null_backward.c
      new file:   test/mem/memmove_null_overlap.c
      new file:   test/mem/memmove_null_prefix.c
      new file:   test/mem/memmove_null_same.c
      new file:   test/mem/memmove_null_sing.c
      new file:   test/mem/memmove_nullnull.c
      new file:   test/mem/memmove_overlap.c
      new file:   test/mem/memmove_prefix.c
      new file:   test/mem/memmove_same.c
      new file:   test/mem/memmove_sing.c
      new file:   test/mem/memrchr.c
      new file:   test/mem/memrchr_notfound.c
      new file:   test/mem/memrev.c
      new file:   test/mem/memset_null.c
      new file:   test/mem/memset_nullnull.c
      new file:   test/mem/memswap.c
      new file:   test/mem/memswap_null.c
      new file:   test/mem/memswap_same.c
      new file:   test/mem/memzero_null.c
      new file:   test/mem/memzero_nullnull.c
      modified:   test/mem/meson.build
      modified:   test/meson.build

63 files changed, 721 insertions, 197 deletions

diff --git a/include/alloc.h b/include/alloc.h
index 6877f61..139b027 100644
--- a/include/alloc.h
+++ b/include/alloc.h
@@ -16,22 +16,8 @@ struct calt_alloc {
 
 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_malloc(size_t size);
+extern void calt_free(void *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);
diff --git a/include/err.h b/include/err.h
new file mode 100644
index 0000000..ba9191c
--- /dev/null
+++ b/include/err.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2023 Marc Pervaz Boocha
+ *
+ * SPDX-License-Identifier: MIT
+ */
+#ifndef CALT_ERR_H
+#define CALT_ERR_H
+
+enum calt_err {
+	CALT_OK = 0,
+	CALT_ERR_UNKNOWN = 1,
+	CALT_ERR_NULL = 2,
+	CALT_ERR_OP_NOT_IMPLEMENTED = 3,
+	CALT_ERR_OOM = 4,
+	CALT_ERR_INVALID_ARGUEMENT = 5,
+};
+
+
+extern void calt_set_err(enum calt_err *err, enum calt_err code);
+extern char* calt_errstr(enum calt_err err);
+
+#endif
diff --git a/include/mem.h b/include/mem.h
index b18822c..4136c76 100644
--- a/include/mem.h
+++ b/include/mem.h
@@ -7,159 +7,30 @@
 #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_memset(void *dest, unsigned char value, size_t count);
+extern void *calt_memset_null(void *dest, unsigned char value, size_t count);
+extern void *calt_memzero(void *restrict dest, size_t count);
+extern void *calt_memzero_null(void *restrict dest, size_t count);
+extern void *calt_memcpy(void *restrict dest, void const *restrict src,
+			      size_t count);
+extern void *calt_memcpy_null(void *restrict dest, void const *restrict src,
+			      size_t count);
 
 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 void *calt_memccpy_null(void *restrict dest, void const *restrict src,
+			     unsigned char value, size_t count);
+extern void *calt_memmove(void *dest, void const *src, size_t count);
+extern void *calt_memmove_null(void *dest, void const *src, size_t count);
+extern void *calt_memchr(void const *ptr, unsigned char value, size_t count);
+extern void *calt_memrchr(void const *ptr, unsigned char value, size_t count);
+extern void *calt_memrchr(void const *ptr, unsigned char value, size_t count);
+extern int calt_memcmp(void const *ptr1, void const *ptr2, size_t count);
+extern void calt_memswap(void *restrict ptr1, void *restrict ptr2, size_t size);
+extern size_t calt_memlen(void const *ptr, unsigned char value, size_t count);
 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;
-	}
-}
+extern void *calt_memmem(void const *haystack, size_t haystacklen,
+			      void const *needle, size_t needlelen);
+extern void *calt_memrev(void *ptr, size_t size);
 #endif
diff --git a/include/meson.build b/include/meson.build
index 403f666..08f2234 100644
--- a/include/meson.build
+++ b/include/meson.build
@@ -1,5 +1,6 @@
 header = files([
   'calt.h',
+  'err.h',
   'mem.h',
   'alloc.h'
 ])
diff --git a/readme.md b/readme.md
index fbf1f49..2069106 100644
--- a/readme.md
+++ b/readme.md
@@ -7,8 +7,11 @@ A C library that is to implement extend and be an alternative to the C stdard li
 ## Build Instructions
 
 Requirements:
+
 - [Meson](https://mesonbuild.com)
+
 - [Ninja](https://ninja-build.org/)
+
 - A C compiler which supports C11 or higher.
 
 To Build:
diff --git a/src/alloc/free.c b/src/alloc/free.c
index 90d16d5..67b54bd 100644
--- a/src/alloc/free.c
+++ b/src/alloc/free.c
@@ -6,5 +6,9 @@
 
 #include <alloc.h>
 
-extern inline void calt_free(void *ptr);
+void calt_free(void *ptr) {
+	if (ptr) {
+		calt_get_alloc().free(ptr);
+	}
+}
 
diff --git a/src/alloc/malloc.c b/src/alloc/malloc.c
index 3abcf2e..3c354c0 100644
--- a/src/alloc/malloc.c
+++ b/src/alloc/malloc.c
@@ -6,5 +6,11 @@
 
 #include <alloc.h>
 
-extern inline void *calt_malloc(size_t size);
-
+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;
+	}
+}
diff --git a/src/err/errstr.c b/src/err/errstr.c
new file mode 100644
index 0000000..075b285
--- /dev/null
+++ b/src/err/errstr.c
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2023 Marc Pervaz Boocha
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <err.h>
+
+char* calt_errstr(enum calt_err err){
+	switch (err) {
+		case CALT_OK:
+			return "No Error";
+		case CALT_ERR_NULL:
+			return "Null Pointer";
+		case CALT_ERR_OOM:
+			return "Unable to Allocate Memmory(Out of Memmory)";
+		case CALT_ERR_OP_NOT_IMPLEMENTED:
+			return "Operation has not been implemented";
+		case CALT_ERR_INVALID_ARGUEMENT:
+			return "Invalid Arguement";
+		case CALT_ERR_UNKNOWN:
+		default:
+			return "Unknown Error";
+	}
+}
diff --git a/src/err/meson.build b/src/err/meson.build
new file mode 100644
index 0000000..5660eb1
--- /dev/null
+++ b/src/err/meson.build
@@ -0,0 +1,4 @@
+src += files([
+  'set_err.c',
+  'errstr.c',
+])
diff --git a/src/err/set_err.c b/src/err/set_err.c
new file mode 100644
index 0000000..3b107af
--- /dev/null
+++ b/src/err/set_err.c
@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2023 Marc Pervaz Boocha
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <err.h>
+
+void calt_set_err(enum calt_err *err, enum calt_err code) {
+	if (err) {
+		*err = code;
+	}
+}
diff --git a/src/mem/memccpy.c b/src/mem/memccpy.c
index 810b71b..82de236 100644
--- a/src/mem/memccpy.c
+++ b/src/mem/memccpy.c
@@ -21,6 +21,7 @@ void *calt_memccpy(void *restrict dest, void const *restrict src, unsigned char
 	return NULL;
 }
 
-extern inline void *calt_memccpy_null(void *restrict dest,
-				    void const *restrict src,
-				    unsigned char value, size_t size);
+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;
+}
diff --git a/src/mem/memchr.c b/src/mem/memchr.c
index b583ab3..ed1187a 100644
--- a/src/mem/memchr.c
+++ b/src/mem/memchr.c
@@ -6,4 +6,15 @@
 
 #include <mem.h>
 
-extern inline void *calt_memchr(void const *ptr, unsigned char value, size_t count);
+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;
+}
diff --git a/src/mem/memcmp.c b/src/mem/memcmp.c
index bcb2fb5..70419be 100644
--- a/src/mem/memcmp.c
+++ b/src/mem/memcmp.c
@@ -11,5 +11,22 @@
  */
 #include <mem.h>
 
-extern inline int calt_memcmp(void const *ptr1, void const *ptr2, size_t count);
+int calt_memcmp(const void *ptr1, const void *ptr2, size_t count) {
+	if(ptr1 == ptr2){
+		return 0;
+	}
+
+	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;
+}
 
diff --git a/src/mem/memcpy.c b/src/mem/memcpy.c
index 7880c53..c9fbfab 100644
--- a/src/mem/memcpy.c
+++ b/src/mem/memcpy.c
@@ -5,10 +5,21 @@
  */
 
 #include <mem.h>
+void *calt_memcpy(void *restrict dest, const void *restrict src,
+		       size_t count) {
+	unsigned char *d = dest;
+	unsigned char const *s = src;
 
-extern inline void *calt_memcpy(void *restrict dest, void const *restrict src,
-			      size_t count);
+	while (count-- > 0) {
+		*d++ = *s++;
+	}
 
+	return dest;
+}
+
+
+void *calt_memcpy_null(void *restrict dest, void const *restrict src,
+			    size_t count) {
+	return dest ? calt_memcpy(dest, src, count) : NULL;
+}
 
-extern inline void *calt_memcpy_null(void *restrict dest, void const *restrict src,
-			      size_t count);
diff --git a/src/mem/memlen.c b/src/mem/memlen.c
index 6d6ddfe..83d15b1 100644
--- a/src/mem/memlen.c
+++ b/src/mem/memlen.c
@@ -6,4 +6,14 @@
 
 #include <mem.h>
 
-extern inline size_t calt_memlen(void const *ptr, unsigned char value, size_t count);
+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;
+}
diff --git a/src/mem/memmem.c b/src/mem/memmem.c
index 14be8cc..68060cd 100644
--- a/src/mem/memmem.c
+++ b/src/mem/memmem.c
@@ -6,5 +6,15 @@
 
 #include <mem.h>
 
-extern inline void *calt_memmem(void const *haystack, size_t haystacklen,
-			      void const *needle, size_t needlelen);
+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;
+}
diff --git a/src/mem/memmove.c b/src/mem/memmove.c
index b6c6b1e..abb5d41 100644
--- a/src/mem/memmove.c
+++ b/src/mem/memmove.c
@@ -6,6 +6,24 @@
 
 #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);
+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;
+}
+
+void *calt_memmove_null(void *dest, void const *src, size_t count) {
+	return dest ? calt_memmove(dest, src, count) : NULL;
+}
 
diff --git a/src/mem/memrchr.c b/src/mem/memrchr.c
index 1799d27..a6e35af 100644
--- a/src/mem/memrchr.c
+++ b/src/mem/memrchr.c
@@ -6,4 +6,15 @@
 
 #include <mem.h>
 
-extern inline void *calt_memrchr(void const *ptr, unsigned char value, size_t count);
+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;
+}
diff --git a/src/mem/memrev.c b/src/mem/memrev.c
index 472efcb..29c549c 100644
--- a/src/mem/memrev.c
+++ b/src/mem/memrev.c
@@ -6,5 +6,14 @@
 
 #include <mem.h>
 
-extern inline void calt_memrev(void *ptr, size_t size);
+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;
+	}
+	return ptr;
+}
 
diff --git a/src/mem/memset.c b/src/mem/memset.c
index 48fee61..c14cda8 100644
--- a/src/mem/memset.c
+++ b/src/mem/memset.c
@@ -6,6 +6,18 @@
 
 #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);
+void *calt_memset(void *restrict dest, unsigned char value, size_t count) {
+	unsigned char *p = dest;
+
+	while (count-- > 0) {
+		*p++ = value;
+	}
+
+	return dest;
+}
+
+void *calt_memset_null(void *dest, unsigned char value, size_t count) {
+	return dest ? calt_memset(dest, value, count) : NULL;
+}
+
 
diff --git a/src/mem/memswap.c b/src/mem/memswap.c
index 512c8c9..b6d30b1 100644
--- a/src/mem/memswap.c
+++ b/src/mem/memswap.c
@@ -6,4 +6,16 @@
 
 #include <mem.h>
 
-extern inline void calt_memswap(void *restrict ptr1, void *restrict ptr2, size_t size);
+void calt_memswap(void *restrict ptr1, void *restrict ptr2, size_t size) {
+	if(ptr1 == ptr2){
+		return;
+	}
+	unsigned char *p1 = ptr1;
+	unsigned char *p2 = ptr2;