From e29276915341a8e1da04e7c938270eb1091256c0 Mon Sep 17 00:00:00 2001 From: Marc Pervaz Boocha Date: Sat, 6 May 2023 16:50:16 +0530 Subject: Added Initial Implementation of memory and allocation function Signed-off-by: Marc Pervaz Boocha 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 --- include/alloc.h | 35 ++++++++++++ include/calt.h | 8 +++ include/mem.h | 162 ++++++++++++++++++++++++++++++++++++++++++++++++++++ include/meson.build | 7 +++ 4 files changed, 212 insertions(+) create mode 100644 include/alloc.h create mode 100644 include/calt.h create mode 100644 include/mem.h create mode 100644 include/meson.build (limited to 'include') 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 + +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 +#include + +#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 + +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') -- cgit v1.2.3-70-g09d2