Luna/libs/libc/src/string.cpp

#include <errno.h>
#include <stdlib.h>
#include <string.h>

extern "C"
{
    void* memcpy(void* dest, const void* src, size_t n)
    {
        for (size_t i = 0; i < n; ++i) { *((char*)dest + i) = *((const char*)src + i); }
        return dest;
    }

    void* memset(void* buf, int c, size_t n)
    {
        for (size_t i = 0; i < n; ++i) { *((char*)buf + i) = (char)c; }
        return buf;
    }

    void* memchr(const void* buf, int c, size_t n)
    {
        const char* s = (const char*)buf;
        for (; n && *s != (char)c; s++, n--)
            ;
        if (n) return (void*)(const_cast<char*>(s));
        return NULL;
    }

    int memcmp(const void* a, const void* b, size_t n)
    {
        const char* _a = (const char*)a;
        const char* _b = (const char*)b;
        for (; n && _a == _b; n--, _a++, _b++)
            ;
        if (!n) return 0;
        if (*_a > *_b) return 1;
        return -1;
    }

    void* memmove(void* dest, const void* src, size_t n)
    {
        if (dest == src) return dest;
        if (dest > src)
            for (long i = n - 1; i >= 0; i++) { *((char*)dest + i) = *((const char*)src + i); }
        else
            for (long i = 0; i < (long)n; i++) { *((char*)dest + i) = *((const char*)src + i); }
        return dest;
    }

    char* strdup(const char* str)
    {
        size_t len = strlen(str);
        char* dest = (char*)malloc(len + 1);
        if (!dest) return dest;
        return (char*)memcpy(dest, str, len + 1);
    }

    size_t strlen(const char* str)
    {
        const char* i = str;
        for (; *i; ++i)
            ;
        return (i - str);
    }

    size_t strnlen(const char* str, size_t max)
    {
        char* p = (char*)memchr(str, 0, max);
        return p ? p - str : max;
    }

    char* strcpy(char* dest, const char* src)
    {
        return (char*)memcpy(dest, src, strlen(src) + 1);
    }

    char* strncpy(char* dest, const char* src, size_t max)
    {
        size_t i;
        for (i = 0; i < max && src[i] != 0; i++) dest[i] = src[i];
        for (; i < max; i++) dest[i] = 0;
        return dest;
    }

    size_t strlcpy(char* dest, const char* src, size_t size)
    {
        size_t len = strlen(src);
        if (size == 0) return len;
        if (len < (size - 1))
        {
            memcpy(dest, src, len);
            dest[len] = 0;
        }
        else
        {
            memcpy(dest, src, size - 1);
            dest[size - 1] = 0;
        }
        return len;
    }

    int strcmp(const char* a, const char* b)
    {
        while (*a && (*a == *b))
        {
            a++;
            b++;
        }
        return *(const unsigned char*)a - *(const unsigned char*)b;
    }

    int strncmp(const char* a, const char* b, size_t max)
    {
        const char* base = a;
        while (*a && (*a == *b) && (size_t)(a - base) < (max - 1))
        {
            a++;
            b++;
        }
        return *(const unsigned char*)a - *(const unsigned char*)b;
    }

    char* strcat(char* dest, const char* src)
    {
        size_t dest_len = strlen(dest);
        size_t i;

        for (i = 0; *(src + i); i++) *(char*)(dest + dest_len + i) = *(const char*)(src + i);

        *(char*)(dest + dest_len + i) = '\0';

        return dest;
    }

    char* strncat(char* dest, const char* src, size_t max)
    {
        size_t dest_len = strlen(dest);
        size_t i;

        for (i = 0; i < max && *(src + i); i++) *(char*)(dest + dest_len + i) = *(const char*)(src + i);

        *(char*)(dest + dest_len + i) = '\0';

        return dest;
    }

    char* strchr(const char* str, int c)
    {
        while (*str && *str != (char)c) str++;
        if (*str) return const_cast<char*>(str);
        return NULL;
    }

    char* strrchr(const char* str, int c)
    {
        const char* s = str + strlen(str);
        while (s != str && *s != (char)c) s--;
        if (s != str) return const_cast<char*>(s);
        if (*s == (char)c) return const_cast<char*>(s);
        return NULL;
    }

    void* bzero(void* buf, size_t n)
    {
        return memset(buf, 0, n);
    }

    char* strstr(const char* haystack, const char* needle)
    {
        size_t needle_size = strlen(needle);
        size_t haystack_size = strlen(haystack);
        while (*haystack)
        {
            if (*haystack == *needle)
            {
                if (needle_size <= haystack_size)
                {
                    if (!strncmp(haystack, needle, needle_size)) return const_cast<char*>(haystack);
                }
                else { return NULL; }
            }
            haystack++;
            haystack_size--;
        }
        return NULL;
    }

#pragma GCC push_options
#pragma GCC diagnostic ignored "-Wwrite-strings"

    char* strerror(int err)
    {
        switch (err)
        {
        case EPERM: return "Operation not permitted";
        case EINVAL: return "Invalid argument";
        case ENOMEM: return "Cannot allocate memory";
        case ENOSYS: return "Function not implemented";
        case ENOENT: return "No such file or directory";
        case EBADF: return "Bad file descriptor";
        case EMFILE: return "Too many open files";
        case EISDIR: return "Is a directory";
        case ENOEXEC: return "Exec format error";
        case EFAULT: return "Bad address";
        case 0: return "Success";
        default: return "Unknown error";
        }
    }

#pragma GCC pop_options
}