Implemented some basic libc functions and a text console

libc/string/memchr.c

@@ -0,0 +1,14 @@
+#include <stddef.h>
+
+const void *memchr(const void *ptr, int value, size_t num) {
+    const unsigned char *buf = ptr;
+    unsigned char val = value;
+
+    for (size_t i = 0; i < num; i++) {
+        if (buf[i] == val) {
+            return (void *)(buf + i);
+        }
+    }
+
+    return NULL;
+}

libc/string/memcmp.c

@@ -0,0 +1,8 @@
+#include <stddef.h>
+
+int memcmp(const void *vl, const void *vr, size_t n)
+{
+    const unsigned char *l=vl, *r=vr;
+    for (; n && *l == *r; n--, l++, r++);
+    return n ? *l-*r : 0;
+}

libc/string/memcpy.c

@@ -0,0 +1,106 @@
+/*-
+ * Copyright (c) 1990, 1993
+ *  The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+#include <stddef.h>
+#include <stdint.h>
+
+typedef uintptr_t word;
+#define wsize sizeof(word)
+#define wmask (wsize - 1)
+
+void *memcpy(void *dst0, const void *src0, size_t length) {
+    char *dst       = dst0;
+    const char *src = src0;
+    size_t t;
+
+    if (length == 0 || dst == src) /* nothing to do */
+        goto done;
+
+        /*
+         * Macros: loop-t-times; and loop-t-times, t>0
+         */
+#define TLOOP(s)                                                               \
+    if (t)                                                                     \
+    TLOOP1(s)
+#define TLOOP1(s)                                                              \
+    do {                                                                       \
+        s;                                                                     \
+    } while (--t)
+
+    if ((uintptr_t)dst < (uintptr_t)src) {
+        /*
+         * Copy forward.
+         */
+        t = (uintptr_t)src; /* only need low bits */
+        if ((t | (uintptr_t)dst) & wmask) {
+            /*
+             * Try to align operands.  This cannot be done
+             * unless the low bits match.
+             */
+            if ((t ^ (uintptr_t)dst) & wmask || length < wsize)
+                t = length;
+            else
+                t = wsize - (t & wmask);
+            length -= t;
+            TLOOP1(*dst++ = *src++);
+        }
+        /*
+         * Copy whole words, then mop up any trailing bytes.
+         */
+        t = length / wsize;
+        TLOOP(*(word *)dst = *(word *)src; src += wsize; dst += wsize);
+        t = length & wmask;
+        TLOOP(*dst++ = *src++);
+    } else {
+        /*
+         * Copy backwards.  Otherwise essentially the same.
+         * Alignment works as before, except that it takes
+         * (t&wmask) bytes to align, not wsize-(t&wmask).
+         */
+        src += length;
+        dst += length;
+        t = (uintptr_t)src;
+        if ((t | (uintptr_t)dst) & wmask) {
+            if ((t ^ (uintptr_t)dst) & wmask || length <= wsize)
+                t = length;
+            else
+                t &= wmask;
+            length -= t;
+            TLOOP1(*--dst = *--src);
+        }
+        t = length / wsize;
+        TLOOP(src -= wsize; dst -= wsize; *(word *)dst = *(word *)src);
+        t = length & wmask;
+        TLOOP(*--dst = *--src);
+    }
+done:
+    return (dst0);
+}

libc/string/memmove.c

@@ -0,0 +1,24 @@
+#include <stdint.h>
+#include <socks/libc/string.h>
+
+static void *memcpy_r(void *dest, const void *src, size_t sz)
+{
+    unsigned char *d = dest;
+    const unsigned char *s = src;
+
+    for (size_t i = 0; i < sz; i++) {
+        size_t b = sz - i - 1;
+        d[b] = s[b];
+    }
+
+    return dest;
+}
+
+void *memmove(void *dest, const void *src, size_t n)
+{
+    if (dest < src) {
+        return memcpy(dest, src, n);
+    } else {
+        return memcpy_r(dest, src, n);
+    }
+}

libc/string/memset.c

@@ -0,0 +1,13 @@
+#include <stddef.h>
+
+void *memset(void *str, int c, size_t n)
+{
+    unsigned char val = (unsigned char)c;
+    unsigned char *buf = str;
+
+    for (size_t i = 0; i < n; i++) {
+        buf[i] = val;
+    }
+
+    return str;
+}

libc/string/strcat.c

@@ -0,0 +1,22 @@
+#include <socks/libc/string.h>
+
+char *strcat(char *dest, const char *src) {
+    size_t start = strlen(dest), i = 0;
+    for (i = 0; src[i] != '\0'; i++) {
+        dest[start + i] = src[i];
+    }
+
+    dest[start + i] = '\0';
+    return dest;
+}
+
+char *strncat(char *dest, const char *src, size_t num) {
+    size_t start = strlen(dest), i = 0;
+    for (i = 0; i < num; i++) {
+        dest[start + i] = src[i];
+    }
+
+    dest[start + i] = '\0';
+    return dest;
+}
+

libc/string/strcmp.c

@@ -0,0 +1,19 @@
+int strcmp(const char *s1, const char *s2)
+{
+    int i;
+    for (i = 0; s1[i] == s2[i]; i++)
+        if (s1[i] == '\0')
+            return 0;
+
+    return s1[i] - s2[i];
+}
+
+int strncmp(const char *s1, const char *s2, unsigned int n)
+{
+    for (; n > 0; s1++, s2++, --n)
+        if (*s1 != *s2)
+            return ((*(unsigned char *)s1 < *(unsigned char *)s2) ? -1 : 1);
+        else if (*s1 == '\0')
+            return 0;
+    return 0;
+}

libc/string/strcpy.c

@@ -0,0 +1,28 @@
+#include <socks/libc/string.h>
+
+char *strcpy(char *output, const char *input)
+{
+    unsigned int i;
+    for (i = 0; input[i]; i++) {
+        output[i] = input[i];
+    }
+
+    output[i] = '\0';
+    return output;
+}
+
+char *strncpy(char *output, const char *input, unsigned int count)
+{
+    unsigned int size = count;
+    unsigned int i;
+    for (i = 0; i < size; i++) {
+        output[i] = input[i];
+
+        if (input[i] == 0) {
+            break;
+        }
+    }
+
+    output[i] = '\0';
+    return output;
+}

libc/string/strdup.c

@@ -0,0 +1,6 @@
+#include <stddef.h>
+
+char *strdup(const char *src) {
+    return NULL;
+}
+

libc/string/strlen.c

@@ -0,0 +1,14 @@
+#include <socks/libc/string.h>
+
+size_t strlen(const char *str) {
+    if (!str) {
+        return 0;
+    }
+
+    size_t res = 0;
+    while (str[res]) {
+        res++;
+    }
+
+    return res;
+}

libc/string/strrchr.c

@@ -0,0 +1,13 @@
+#include <socks/libc/string.h>
+
+char *strrchr(const char *str, int c) {
+    size_t len = strlen(str);
+
+    for (int i = len - 1; i > 0; i--) {
+        if (str[i] == c) {
+            return (char *)&str[i];
+        }
+    }
+
+    return NULL;
+}

libc/string/strtok.c

@@ -0,0 +1,144 @@
+#include <limits.h>
+#include <socks/libc/string.h>
+
+#define ALIGN (sizeof(size_t))
+#define ONES ((size_t)-1 / UCHAR_MAX)
+#define HIGHS (ONES * (UCHAR_MAX / 2 + 1))
+#define HASZERO(X) (((X)-ONES) & ~(X)&HIGHS)
+#define BITOP(A, B, OP)                                                        \
+    ((A)[(size_t)(B) / (8 * sizeof *(A))] OP(size_t) 1                         \
+     << ((size_t)(B) % (8 * sizeof *(A))))
+
+char *strchrnul(const char *s, int c) {
+    size_t *w;
+    size_t k;
+
+    c = (unsigned char)c;
+    if (!c) {
+        return (char *)s + strlen(s);
+    }
+
+    for (; (uintptr_t)s % ALIGN; s++) {
+        if (!*s || *(unsigned char *)s == c) {
+            return (char *)s;
+        }
+    }
+
+    k = ONES * c;
+    for (w = (void *)s; !HASZERO(*w) && !HASZERO(*w ^ k); w++)
+        ;
+    for (s = (void *)w; *s && *(unsigned char *)s != c; s++)
+        ;
+    return (char *)s;
+}
+
+char *strchr(const char *s, int c) {
+    char *r = strchrnul(s, c);
+    return *(unsigned char *)r == (unsigned char)c ? r : 0;
+}
+
+size_t lfind(const char *str, const char accept) {
+    return (size_t)strchr(str, accept);
+}
+
+size_t strspn(const char *s, const char *c) {
+    const char *a                       = s;
+    size_t byteset[32 / sizeof(size_t)] = {0};
+
+    if (!c[0]) {
+        return 0;
+    }
+
+    if (!c[1]) {
+        for (; *s == *c; s++) {
+            return s - a;
+        }
+    }
+
+    for (; *c && BITOP(byteset, *(unsigned char *)c, |=); c++)
+        ;
+    for (; *s && BITOP(byteset, *(unsigned char *)s, &); s++)
+        ;
+    return s - a;
+}
+
+size_t strcspn(const char *s, const char *c) {
+    const char *a = s;
+
+    if (c[0] && c[1]) {
+        size_t byteset[32 / sizeof(size_t)] = {0};
+        for (; *c && BITOP(byteset, *(unsigned char *)c, |=); c++)
+            ;
+        for (; *s && !BITOP(byteset, *(unsigned char *)s, &); s++)
+            ;
+        return s - a;
+    }
+
+    return strchrnul(s, *c) - a;
+}
+
+char *strpbrk(const char *s, const char *b) {
+    s += strcspn(s, b);
+    return *s ? (char *)s : 0;
+}
+
+char *strtok_r(char *str, const char *delim, char **sp) {
+    int i   = 0;
+    int len = strlen(delim);
+
+    /* Were we given any delimiters? */
+    if (len == 0) {
+        return NULL;
+    }
+
+    /* If we weren't given a string, and save pointer is NULL, return. */
+    if (!str && !sp) {
+        return NULL;
+    }
+
+    /* If we were given a string, initialise sp for subsequent calls. */
+    if (str) {
+        *sp = str;
+    }
+
+    /* Go to the start of the substring, skipping any delimiters. */
+    char *p_start = *sp;
+    while (1) {
+        for (i = 0; i < len; i++) {
+            if (*p_start == delim[i]) {
+                p_start++;
+                break;
+            }
+        }
+
+        if (i == len) {
+            *sp = p_start;
+            break;
+        }
+    }
+
+    /* Are we at the end of the string? */
+    if (**sp == '\0') {
+        *sp = NULL;
+        return *sp;
+    }
+
+    /* Find the end of the substring, and
+       replace the delimiter with null */
+    while (**sp != '\0') {
+        for (i = 0; i < len; i++) {
+            if (**sp == delim[i]) {
+                **sp = '\0';
+                break;
+            }
+        }
+
+        (*sp)++;
+        if (i < len) {
+            break;
+        }
+    }
+
+    return p_start;
+}
+